migrated ed25519 primitives from sei-v3

app/apptesting/test_suite.go

@@ -165,15 +165,15 @@ func (s *KeeperTestHelper) BuildTx(
 func CreateRandomAccounts(numAccts int) []sdk.AccAddress {
 	testAddrs := make([]sdk.AccAddress, numAccts)
 	for i := 0; i < numAccts; i++ {
-		pk := ed25519.GenPrivKey().PubKey()
+		pk := ed25519.GenerateSecretKey().Public()
 		testAddrs[i] = sdk.AccAddress(pk.Address())
 	}
 
 	return testAddrs
 }
 
 func GenerateTestAddrs() (string, string) {
-	pk1 := ed25519.GenPrivKey().PubKey()
+	pk1 := ed25519.GenerateSecretKey().Public()
 	validAddr := sdk.AccAddress(pk1.Address()).String()
 	invalidAddr := sdk.AccAddress("invalid").String()
 	return validAddr, invalidAddr

sei-cosmos/client/rpc/status.go

@@ -50,10 +50,12 @@ func StatusCommand() *cobra.Command {
 				return err
 			}
 
+			var addr cryptotypes.Address
 			var pk cryptotypes.PubKey
 			// `status` has TM pubkeys, we need to convert them to our pubkeys.
-			if status.ValidatorInfo.PubKey != nil {
-				pk, err = cryptocodec.FromTmPubKeyInterface(status.ValidatorInfo.PubKey)
+			if k, ok := status.ValidatorInfo.PubKey.Get(); ok {
+				addr = k.Address()
+				pk, err = cryptocodec.FromTmPubKeyInterface(k)
 				if err != nil {
 					return err
 				}
@@ -63,7 +65,7 @@ func StatusCommand() *cobra.Command {
 				NodeInfo: status.NodeInfo,
 				SyncInfo: status.SyncInfo,
 				ValidatorInfo: validatorInfo{
-					Address:     status.ValidatorInfo.Address,
+					Address:     addr,
 					PubKey:      pk,
 					VotingPower: status.ValidatorInfo.VotingPower,
 				},

sei-cosmos/crypto/codec/tm.go

@@ -41,19 +41,14 @@ func ToTmProtoPublicKey(pk cryptotypes.PubKey) (tmprotocrypto.PublicKey, error)
 
 // FromTmPubKeyInterface converts TM's tmcrypto.PubKey to our own PubKey.
 func FromTmPubKeyInterface(tmPk tmcrypto.PubKey) (cryptotypes.PubKey, error) {
-	tmProtoPk, err := encoding.PubKeyToProto(tmPk)
-	if err != nil {
-		return nil, err
-	}
-
-	return FromTmProtoPublicKey(tmProtoPk)
+	return FromTmProtoPublicKey(encoding.PubKeyToProto(tmPk))
 }
 
 // ToTmPubKeyInterface converts our own PubKey to TM's tmcrypto.PubKey.
 func ToTmPubKeyInterface(pk cryptotypes.PubKey) (tmcrypto.PubKey, error) {
 	tmProtoPk, err := ToTmProtoPublicKey(pk)
 	if err != nil {
-		return nil, err
+		return tmcrypto.PubKey{}, err
 	}
 
 	return encoding.PubKeyFromProto(tmProtoPk)

sei-cosmos/crypto/keys/ed25519/ed25519_test.go

@@ -139,7 +139,7 @@ func TestMarshalAmino(t *testing.T) {
 	testCases := []struct {
 		desc      string
 		msg       codec.AminoMarshaler
-		typ       interface{}
+		typ       any
 		expBinary []byte
 		expJSON   string
 	}{
@@ -187,17 +187,17 @@ func TestMarshalAmino(t *testing.T) {
 func TestMarshalAmino_BackwardsCompatibility(t *testing.T) {
 	aminoCdc := codec.NewLegacyAmino()
 	// Create Tendermint keys.
-	tmPrivKey := tmed25519.GenPrivKey()
-	tmPubKey := tmPrivKey.PubKey()
+	tmPrivKey := tmed25519.GenerateSecretKey()
+	tmPubKey := tmPrivKey.Public()
 	// Create our own keys, with the same private key as Tendermint's.
-	privKey := &ed25519.PrivKey{Key: []byte(tmPrivKey)}
+	privKey := &ed25519.PrivKey{Key: tmPrivKey.SecretBytes()}
 	pubKey := privKey.PubKey().(*ed25519.PubKey)
 
 	testCases := []struct {
 		desc      string
-		tmKey     interface{}
-		ourKey    interface{}
-		marshalFn func(o interface{}) ([]byte, error)
+		tmKey     any
+		ourKey    any
+		marshalFn func(o any) ([]byte, error)
 	}{
 		{
 			"ed25519 private key, binary",

sei-cosmos/crypto/keys/sr25519/internal/privkey.go

@@ -10,26 +10,16 @@ import (
 	"github.com/oasisprotocol/curve25519-voi/primitives/sr25519"
 )
 
-var (
-	signingCtx = sr25519.NewSigningContext([]byte{})
-)
-
-const (
-	PrivKeyName = "tendermint/PrivKeySr25519"
-	// PrivKeySize is the size of a sr25519 signature in bytes.
-	PrivKeySize = sr25519.MiniSecretKeySize
+var signingCtx = sr25519.NewSigningContext([]byte{})
 
-	KeyType = "sr25519"
-)
+const KeyType = "sr25519"
 
 // PrivKey implements crypto.PrivKey.
 type PrivKey struct {
 	msk sr25519.MiniSecretKey
 	kp  *sr25519.KeyPair
 }
 
-// TypeTag satisfies the jsontypes.Tagged interface.
-func (PrivKey) TypeTag() string      { return PrivKeyName }
 func (privKey PrivKey) Type() string { return KeyType }
 
 // Bytes returns the byte-encoded PrivKey.