Rebase peppermint branch to v0.38.5

abci/types/messages.go

@@ -124,8 +124,6 @@ func ToRequestFinalizeBlock(req *RequestFinalizeBlock) *Request {
 	}
 }
 
-//----------------------------------------
-
 func ToResponseException(errStr string) *Response {
 	return &Response{
 		Value: &Response_Exception{&ResponseException{Error: errStr}},

crypto/encoding/codec.go

@@ -32,6 +32,12 @@ func PubKeyToProto(k crypto.PubKey) (pc.PublicKey, error) {
 				Secp256K1: k,
 			},
 		}
+	case secp256k1.PubKeyOld:
+		kp = pc.PublicKey{
+			Sum: &pc.PublicKey_Secp256K1{
+				Secp256K1: k,
+			},
+		}
 	default:
 		return kp, fmt.Errorf("toproto: key type %v is not supported", k)
 	}

crypto/secp256k1/secp256k1.go

@@ -9,17 +9,18 @@ import (
 	"math/big"
 
 	secp256k1 "github.com/btcsuite/btcd/btcec/v2"
-	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
-	"golang.org/x/crypto/ripemd160" //nolint: staticcheck // necessary for Bitcoin address format
+	ethCrypto "github.com/ethereum/go-ethereum/crypto" //nolint:depguard
 
 	"github.com/cometbft/cometbft/crypto"
 	cmtjson "github.com/cometbft/cometbft/libs/json"
 )
 
 // -------------------------------------
 const (
-	PrivKeyName = "tendermint/PrivKeySecp256k1"
-	PubKeyName  = "tendermint/PubKeySecp256k1"
+	PrivKeyNameOld = "tendermint/PrivKeySecp256k1"
+	PubKeyNameOld  = "tendermint/PubKeySecp256k1"
+	PrivKeyName    = "comet/PrivKeySecp256k1Uncompressed"
+	PubKeyName     = "comet/PubKeySecp256k1Uncompressed"
 
 	KeyType     = "secp256k1"
 	PrivKeySize = 32
@@ -28,13 +29,34 @@ const (
 func init() {
 	cmtjson.RegisterType(PubKey{}, PubKeyName)
 	cmtjson.RegisterType(PrivKey{}, PrivKeyName)
+	cmtjson.RegisterType(PubKeyOld{}, PubKeyNameOld)
+	cmtjson.RegisterType(PrivKeyOld{}, PrivKeyNameOld)
 }
 
 var _ crypto.PrivKey = PrivKey{}
+var _ crypto.PrivKey = PrivKeyOld{}
 
 // PrivKey implements PrivKey.
 type PrivKey []byte
 
+type PrivKeyOld []byte
+
+func (privKey PrivKeyOld) Bytes() []byte {
+	return PrivKey(privKey).Bytes()
+}
+func (privKey PrivKeyOld) PubKey() crypto.PubKey {
+	return PrivKey(privKey).PubKey()
+}
+func (privKey PrivKeyOld) Equals(other crypto.PrivKey) bool {
+	return PrivKey(privKey).Equals(other)
+}
+func (privKey PrivKeyOld) Type() string {
+	return PrivKey(privKey).Type()
+}
+func (privKey PrivKeyOld) Sign(msg []byte) ([]byte, error) {
+	return PrivKey(privKey).Sign(msg)
+}
+
 // Bytes marshalls the private key using amino encoding.
 func (privKey PrivKey) Bytes() []byte {
 	return []byte(privKey)
@@ -43,11 +65,14 @@ func (privKey PrivKey) Bytes() []byte {
 // PubKey performs the point-scalar multiplication from the privKey on the
 // generator point to get the pubkey.
 func (privKey PrivKey) PubKey() crypto.PubKey {
-	_, pubkeyObject := secp256k1.PrivKeyFromBytes(privKey)
-
-	pk := pubkeyObject.SerializeCompressed()
+	privateObject, err := ethCrypto.ToECDSA(privKey)
+	if err != nil {
+		panic(err)
+	}
 
+	pk := ethCrypto.FromECDSAPub(&privateObject.PublicKey)
 	return PubKey(pk)
+
 }
 
 // Equals - you probably don't need to use this.
@@ -75,20 +100,21 @@ func genPrivKey(rand io.Reader) PrivKey {
 	d := new(big.Int)
 
 	for {
-		privKeyBytes = [PrivKeySize]byte{}
 		_, err := io.ReadFull(rand, privKeyBytes[:])
 		if err != nil {
 			panic(err)
 		}
 
 		d.SetBytes(privKeyBytes[:])
-		// break if we found a valid point (i.e. > 0 and < N == curverOrder)
+		// break if we found a valid point (i.e. > 0 and < N == curveOrder)
 		isValidFieldElement := 0 < d.Sign() && d.Cmp(secp256k1.S256().N) < 0
 		if isValidFieldElement {
 			break
 		}
 	}
 
+	// crypto.CRandBytes is guaranteed to be 32 bytes long, so it can be
+	// casted to PrivKey.
 	return PrivKey(privKeyBytes[:])
 }
 
@@ -124,47 +150,64 @@ func GenPrivKeySecp256k1(secret []byte) PrivKey {
 }
 
 // Sign creates an ECDSA signature on curve Secp256k1, using SHA256 on the msg.
-// The returned signature will be of the form R || S (in lower-S form).
+// The returned signature will be of the form R || S || V (in lower-S form).
 func (privKey PrivKey) Sign(msg []byte) ([]byte, error) {
-	priv, _ := secp256k1.PrivKeyFromBytes(privKey)
-
-	sig, err := ecdsa.SignCompact(priv, crypto.Sha256(msg), false)
+	privateObject, err := ethCrypto.ToECDSA(privKey)
 	if err != nil {
 		return nil, err
 	}
 
-	// remove the first byte which is compactSigRecoveryCode
-	return sig[1:], nil
+	return ethCrypto.Sign(ethCrypto.Keccak256(msg), privateObject)
 }
 
 //-------------------------------------
 
 var _ crypto.PubKey = PubKey{}
+var _ crypto.PubKey = PubKeyOld{}
+
+// PubKeySize (uncompressed) is comprised of 65 bytes for two field elements (x and y)
+// and a prefix byte (0x04) to indicate that it is uncompressed.
+const PubKeySize = 65
 
-// PubKeySize is comprised of 32 bytes for one field element
-// (the x-coordinate), plus one byte for the parity of the y-coordinate.
-const PubKeySize = 33
+// SigSize is the size of the ECDSA signature.
+const SigSize = 65
 
 // PubKey implements crypto.PubKey.
-// It is the compressed form of the pubkey. The first byte depends is a 0x02 byte
-// if the y-coordinate is the lexicographically largest of the two associated with
-// the x-coordinate. Otherwise the first byte is a 0x03.
-// This prefix is followed with the x-coordinate.
+// It is the uncompressed form of the pubkey. The first byte is prefixed with 0x04.
+// This prefix is followed with the (x,y)-coordinates.
 type PubKey []byte
+type PubKeyOld []byte
+
+func (pubKey PubKeyOld) Address() crypto.Address {
+	return PubKey(pubKey).Address()
+}
+
+func (pubKey PubKeyOld) Bytes() []byte {
+	return PubKey(pubKey).Bytes()
+}
+
+func (pubKey PubKeyOld) String() string {
+	return PubKey(pubKey).String()
+}
 
-// Address returns a Bitcoin style addresses: RIPEMD160(SHA256(pubkey))
+func (pubKey PubKeyOld) Equals(other crypto.PubKey) bool {
+	return PubKey(pubKey).Equals(other)
+}
+
+func (pubKey PubKeyOld) Type() string {
+	return PubKey(pubKey).Type()
+}
+
+func (pubKey PubKeyOld) VerifySignature(msg []byte, sigStr []byte) bool {
+	return PubKey(pubKey).VerifySignature(msg, sigStr)
+}
+
+// Address returns a Ethereym style addresses: Last_20_Bytes(KECCAK256(pubkey))
 func (pubKey PubKey) Address() crypto.Address {
 	if len(pubKey) != PubKeySize {
-		panic("length of pubkey is incorrect")
+		panic(fmt.Sprintf("length of pubkey is incorrect %d != %d", len(pubKey), PubKeySize))
 	}
-	hasherSHA256 := sha256.New()
-	_, _ = hasherSHA256.Write(pubKey) // does not error
-	sha := hasherSHA256.Sum(nil)
-
-	hasherRIPEMD160 := ripemd160.New()
-	_, _ = hasherRIPEMD160.Write(sha) // does not error
-
-	return crypto.Address(hasherRIPEMD160.Sum(nil))
+	return crypto.Address(ethCrypto.Keccak256(pubKey[1:])[12:])
 }
 
 // Bytes returns the pubkey marshaled with amino encoding.
@@ -187,41 +230,13 @@ func (pubKey PubKey) Type() string {
 	return KeyType
 }
 
-// VerifySignature verifies a signature of the form R || S.
+// VerifySignature verifies a signature of the form R || S || V.
 // It rejects signatures which are not in lower-S form.
 func (pubKey PubKey) VerifySignature(msg []byte, sigStr []byte) bool {
-	if len(sigStr) != 64 {
+	if len(sigStr) != SigSize {
 		return false
 	}
 
-	pub, err := secp256k1.ParsePubKey(pubKey)
-	if err != nil {
-		return false
-	}
-
-	// parse the signature:
-	signature := signatureFromBytes(sigStr)
-	// Reject malleable signatures. libsecp256k1 does this check but btcec doesn't.
-	// see: https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
-	// Serialize() would negate S value if it is over half order.
-	// Hence, if the signature is different after Serialize() if should be rejected.
-	var modifiedSignature, parseErr = ecdsa.ParseDERSignature(signature.Serialize())
-	if parseErr != nil {
-		return false
-	}
-	if !signature.IsEqual(modifiedSignature) {
-		return false
-	}
-
-	return signature.Verify(crypto.Sha256(msg), pub)
-}
-
-// Read Signature struct from R || S. Caller needs to ensure
-// that len(sigStr) == 64.
-func signatureFromBytes(sigStr []byte) *ecdsa.Signature {
-	var r secp256k1.ModNScalar
-	r.SetByteSlice(sigStr[:32])
-	var s secp256k1.ModNScalar
-	s.SetByteSlice(sigStr[32:64])
-	return ecdsa.NewSignature(&r, &s)
+	hash := ethCrypto.Keccak256(msg)
+	return ethCrypto.VerifySignature(pubKey, hash, sigStr[:64])
 }

crypto/secp256k1/secp256k1_internal_test.go

@@ -5,13 +5,11 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/stretchr/testify/require"
-
 	secp256k1 "github.com/btcsuite/btcd/btcec/v2"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_genPrivKey(t *testing.T) {
-
 	empty := make([]byte, 32)
 	oneB := big.NewInt(1).Bytes()
 	onePadded := make([]byte, 32)
@@ -82,3 +80,16 @@ func TestSignatureVerificationAndRejectUpperS(t *testing.T) {
 		)
 	}
 }
+
+func TestGenEthPrivKey(t *testing.T) {
+	msg := []byte("We have lingered long enough on the shores of the cosmic ocean.")
+	priv := GenPrivKey()
+	t.Log("privkey ", priv)
+	sigStr, err := priv.Sign(msg)
+	require.NoError(t, err)
+	pub := priv.PubKey()
+	addr := pub.Address()
+	t.Log("address ", addr)
+	t.Log("pub ", pub)
+	t.Log("SigStr ", sigStr)
+}

crypto/secp256k1/secp256k1_test.go

@@ -24,8 +24,8 @@ type keyData struct {
 var secpDataTable = []keyData{
 	{
 		priv: "a96e62ed3955e65be32703f12d87b6b5cf26039ecfa948dc5107a495418e5330",
-		pub:  "02950e1cdfcb133d6024109fd489f734eeb4502418e538c28481f22bce276f248c",
-		addr: "1CKZ9Nx4zgds8tU7nJHotKSDr4a9bYJCa3",
+		pub:  "04950e1cdfcb133d6024109fd489f734eeb4502418e538c28481f22bce276f248ca0ca66092c9fe8adfbb8424bd92f26e170234c42df756075278ead79a8f5c4ae",
+		addr: "1PrkgVnuHLGZu4EUQGmXkGVuhTfn7t8DJK",
 	},
 }
 

evidence/pool_test.go

@@ -82,7 +82,7 @@ func TestEvidencePoolBasic(t *testing.T) {
 	next := pool.EvidenceFront()
 	assert.Equal(t, ev, next.Value.(types.Evidence))
 
-	const evidenceBytes int64 = 372
+	const evidenceBytes int64 = 374
 	evs, size = pool.PendingEvidence(evidenceBytes)
 	assert.Equal(t, 1, len(evs))
 	assert.Equal(t, evidenceBytes, size) // check that the size of the single evidence in bytes is correct

go.mod

@@ -46,6 +46,7 @@ require (
 	github.com/btcsuite/btcd/btcutil v1.1.3
 	github.com/cometbft/cometbft-db v0.7.0
 	github.com/cosmos/gogoproto v1.4.11
+	github.com/ethereum/go-ethereum v1.13.4
 	github.com/go-git/go-git/v5 v5.11.0
 	github.com/gofrs/uuid v4.4.0+incompatible
 	github.com/google/uuid v1.4.0
@@ -103,7 +104,7 @@ require (
 	github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 // indirect
 	github.com/docker/cli v23.0.1+incompatible // indirect
 	github.com/docker/distribution v2.8.1+incompatible // indirect
-	github.com/docker/docker v23.0.1+incompatible // indirect
+	github.com/docker/docker v24.0.5+incompatible // indirect
 	github.com/docker/docker-credential-helpers v0.7.0 // indirect
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.5.0 // indirect
@@ -140,7 +141,7 @@ require (
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v1.1.2 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/snappy v0.0.4 // indirect
+	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
 	github.com/golangci/check v0.0.0-20180506172741-cfe4005ccda2 // indirect
 	github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a // indirect
 	github.com/golangci/go-misc v0.0.0-20220329215616-d24fe342adfe // indirect
@@ -165,6 +166,7 @@ require (
 	github.com/hashicorp/go-version v1.6.0 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/hexops/gotextdiff v1.0.3 // indirect
+	github.com/holiman/uint256 v1.2.3 // indirect
 	github.com/iancoleman/strcase v0.2.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
@@ -287,19 +289,11 @@ require (
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	gotest.tools v2.2.0+incompatible // indirect
 	honnef.co/go/tools v0.4.3 // indirect
 	mvdan.cc/gofumpt v0.4.0 // indirect
 	mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed // indirect
 	mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b // indirect
 	mvdan.cc/unparam v0.0.0-20221223090309-7455f1af531d // indirect
 )
 
-retract (
-	// a regression was introduced
-	v0.38.4
-	// a breaking change was introduced
-	v0.38.3
-	// superseeded by v0.38.3 because of ASA-2024-001
-	[v0.38.0, v0.38.2]
-)
+replace github.com/ethereum/go-ethereum => github.com/maticnetwork/bor v1.0.4