Migrate BaseAccount PubKey to use Any

client/context.go

@@ -5,12 +5,12 @@ import (
 	"io"
 	"os"
 
-	"github.com/gogo/protobuf/proto"
+	"gopkg.in/yaml.v2"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/pkg/errors"
 	rpcclient "github.com/tendermint/tendermint/rpc/client"
 	rpchttp "github.com/tendermint/tendermint/rpc/client/http"
-	yaml "gopkg.in/yaml.v2"
 
 	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"

client/debug/main.go

@@ -9,10 +9,11 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/tendermint/tendermint/crypto"
-	"github.com/tendermint/tendermint/crypto/ed25519"
 
 	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/cosmos/cosmos-sdk/version"
 )
 
@@ -34,18 +35,18 @@ func Cmd() *cobra.Command {
 // to decode the pubkey string from hex, base64, and finally bech32. If all
 // encodings fail, an error is returned.
 func getPubKeyFromString(pkstr string) (crypto.PubKey, error) {
-	pubKey := make(ed25519.PubKey, ed25519.PubKeySize)
-
 	bz, err := hex.DecodeString(pkstr)
 	if err == nil {
-		copy(pubKey[:], bz)
-		return pubKey, nil
+		if len(bz) == ed25519.PubKeySize {
+			return &ed25519.PubKey{Key: bz}, nil
+		}
 	}
 
 	bz, err = base64.StdEncoding.DecodeString(pkstr)
 	if err == nil {
-		copy(pubKey[:], bz)
-		return pubKey, nil
+		if len(bz) == ed25519.PubKeySize {
+			return &ed25519.PubKey{Key: bz}, nil
+		}
 	}
 
 	pk, err := sdk.GetPubKeyFromBech32(sdk.Bech32PubKeyTypeAccPub, pkstr)
@@ -63,7 +64,7 @@ func getPubKeyFromString(pkstr string) (crypto.PubKey, error) {
 		return pk, nil
 	}
 
-	return nil, fmt.Errorf("pubkey '%s' invalid; expected hex, base64, or bech32", pubKey)
+	return nil, fmt.Errorf("pubkey '%s' invalid; expected hex, base64, or bech32 of correct size", pkstr)
 }
 
 func PubkeyCmd() *cobra.Command {
@@ -85,9 +86,9 @@ $ %s debug pubkey cosmos1e0jnq2sun3dzjh8p2xq95kk0expwmd7shwjpfg
 				return err
 			}
 
-			edPK, ok := pk.(ed25519.PubKey)
+			edPK, ok := pk.(*ed25519.PubKey)
 			if !ok {
-				return fmt.Errorf("invalid pubkey type; expected ED25519")
+				return errors.Wrapf(errors.ErrInvalidType, "invalid pubkey type; expected ED25519")
 			}
 
 			pubKeyJSONBytes, err := clientCtx.LegacyAmino.MarshalJSON(edPK)
@@ -108,7 +109,7 @@ $ %s debug pubkey cosmos1e0jnq2sun3dzjh8p2xq95kk0expwmd7shwjpfg
 			}
 
 			cmd.Println("Address:", edPK.Address())
-			cmd.Printf("Hex: %X\n", edPK[:])
+			cmd.Printf("Hex: %X\n", edPK.Key)
 			cmd.Println("JSON (base64):", string(pubKeyJSONBytes))
 			cmd.Println("Bech32 Acc:", accPub)
 			cmd.Println("Bech32 Validator Operator:", valPub)

codec/yaml.go

@@ -0,0 +1,30 @@
+package codec
+
+import (
+	"encoding/json"
+
+	"github.com/gogo/protobuf/proto"
+	"gopkg.in/yaml.v2"
+)
+
+// MarshalYAML marshals the provided toPrint content with the provided JSON marshaler
+// by encoding JSON, decoding JSON, and then encoding YAML.
+func MarshalYAML(jsonMarshaler JSONMarshaler, toPrint proto.Message) ([]byte, error) {
+	// only the JSONMarshaler has full context as to how the JSON
+	// mashalling should look (which may be different for amino & proto codecs)
+	// so we need to use it to marshal toPrint first
+	bz, err := jsonMarshaler.MarshalJSON(toPrint)
+	if err != nil {
+		return nil, err
+	}
+
+	// generate YAML by decoding and re-encoding JSON as YAML
+	var j interface{}
+
+	err = json.Unmarshal(bz, &j)
+	if err != nil {
+		return nil, err
+	}
+
+	return yaml.Marshal(j)
+}

codec/yaml_test.go

@@ -0,0 +1,49 @@
+package codec_test
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+)
+
+func TestMarshalYAML(t *testing.T) {
+	dog := &testdata.Dog{
+		Size_: "small",
+		Name:  "Spot",
+	}
+	any, err := types.NewAnyWithValue(dog)
+	require.NoError(t, err)
+	hasAnimal := &testdata.HasAnimal{
+		Animal: any,
+		X:      0,
+	}
+
+	// proto
+	protoCdc := codec.NewProtoCodec(NewTestInterfaceRegistry())
+	bz, err := codec.MarshalYAML(protoCdc, hasAnimal)
+	require.NoError(t, err)
+	require.Equal(t, `animal:
+  '@type': /testdata.Dog
+  name: Spot
+  size: small
+x: "0"
+`, string(bz))
+
+	// amino
+	aminoCdc := codec.NewAminoCodec(&codec.LegacyAmino{testdata.NewTestAmino()})
+	bz, err = codec.MarshalYAML(aminoCdc, hasAnimal)
+	require.NoError(t, err)
+	require.Equal(t, `type: testdata/HasAnimal
+value:
+  animal:
+    type: testdata/Dog
+    value:
+      name: Spot
+      size: small
+`, string(bz))
+}

crypto/codec/amino.go

@@ -2,10 +2,11 @@ package codec
 
 import (
 	"github.com/tendermint/tendermint/crypto"
-	"github.com/tendermint/tendermint/crypto/ed25519"
+	tmed25519 "github.com/tendermint/tendermint/crypto/ed25519"
 	"github.com/tendermint/tendermint/crypto/sr25519"
 
 	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	kmultisig "github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
@@ -26,20 +27,26 @@ func RegisterCrypto(cdc *codec.LegacyAmino) {
 	// first line.
 	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
 	cdc.RegisterInterface((*cryptotypes.PubKey)(nil), nil)
-	cdc.RegisterConcrete(ed25519.PubKey{},
-		ed25519.PubKeyName, nil)
 	cdc.RegisterConcrete(sr25519.PubKey{},
 		sr25519.PubKeyName, nil)
+	// TODO Same as above, for ED25519
+	cdc.RegisterConcrete(tmed25519.PubKey{},
+		tmed25519.PubKeyName, nil)
+	cdc.RegisterConcrete(&ed25519.PubKey{},
+		ed25519.PubKeyName, nil)
 	cdc.RegisterConcrete(&secp256k1.PubKey{},
 		secp256k1.PubKeyName, nil)
 	cdc.RegisterConcrete(&kmultisig.LegacyAminoPubKey{},
 		kmultisig.PubKeyAminoRoute, nil)
 
 	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
-	cdc.RegisterConcrete(ed25519.PrivKey{},
-		ed25519.PrivKeyName, nil)
 	cdc.RegisterConcrete(sr25519.PrivKey{},
 		sr25519.PrivKeyName, nil)
+	// TODO Same as above
+	cdc.RegisterConcrete(tmed25519.PrivKey{},
+		tmed25519.PrivKeyName, nil)
+	cdc.RegisterConcrete(&ed25519.PrivKey{},
+		ed25519.PrivKeyName, nil)
 	cdc.RegisterConcrete(&secp256k1.PrivKey{},
 		secp256k1.PrivKeyName, nil)
 }

crypto/codec/proto.go

@@ -4,6 +4,7 @@ import (
 	tmcrypto "github.com/tendermint/tendermint/crypto"
 
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
@@ -13,12 +14,14 @@ import (
 func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
 	// TODO We now register both Tendermint's PubKey and our own PubKey. In the
 	// long-term, we should move away from Tendermint's PubKey, and delete
-	// these lines
+	// these lines.
 	registry.RegisterInterface("tendermint.crypto.Pubkey", (*tmcrypto.PubKey)(nil))
+	registry.RegisterImplementations((*tmcrypto.PubKey)(nil), &ed25519.PubKey{})
 	registry.RegisterImplementations((*tmcrypto.PubKey)(nil), &secp256k1.PubKey{})
 	registry.RegisterImplementations((*tmcrypto.PubKey)(nil), &multisig.LegacyAminoPubKey{})
 
 	registry.RegisterInterface("cosmos.crypto.Pubkey", (*cryptotypes.PubKey)(nil))
+	registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &ed25519.PubKey{})
 	registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &secp256k1.PubKey{})
 	registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &multisig.LegacyAminoPubKey{})
 }

crypto/keyring/keyring_test.go

@@ -9,10 +9,10 @@ import (
 	bip39 "github.com/cosmos/go-bip39"
 	"github.com/stretchr/testify/require"
 	tmcrypto "github.com/tendermint/tendermint/crypto"
-	"github.com/tendermint/tendermint/crypto/ed25519"
 
 	"github.com/cosmos/cosmos-sdk/crypto"
 	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	sdk "github.com/cosmos/cosmos-sdk/types"