Merge branch 'master' into robert/api-clinetctx

CHANGELOG.md

@@ -49,6 +49,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
   * Updated gRPC dependency to v1.33.2
   * Updated iavl dependency to v0.15-rc2
 * (version) [\#7848](https://github.com/cosmos/cosmos-sdk/pull/7848) [\#7941](https://github.com/cosmos/cosmos-sdk/pull/7941) `version --long` output now shows the list of build dependencies and replaced build dependencies.
+* (x/genutil) [\#8099](https://github.com/cosmos/cosmos-sdk/pull/8099) `init` now supports a `--recover` flag to recover the private validator key from a given mnemonic
 
 ### State Machine Breaking Changes
 
@@ -58,10 +59,13 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 * (crypto) [\#7966](https://github.com/cosmos/cosmos-sdk/issues/7966) `Bip44Params` `String()` function now correctly returns the absolute HD path by adding the `m/` prefix.
 
-### Client Breaking
+### API Breaking
 
+* [\#8080](https://github.com/cosmos/cosmos-sdk/pull/8080) Updated the `codec.Marshaler` interface
+  * Moved `MarshalAny` and `UnmarshalAny` helper functions to `codec.Marshaler` and renamed to `MarshalInterface` and `UnmarshalInterface` respectively. These functions must take interface as a parameter (not a concrete type nor `Any` object). Underneath they use `Any` wrapping for correct protobuf serialization.
 * (client) [\#8107](https://github.com/cosmos/cosmos-sdk/pull/8107) Renamed `PrintOutput` and `PrintOutputLegacy` methods of the `context.Client` object to `PrintProto` and `PrintObjectLegacy`.
 
+
 ## [v0.40.0-rc3](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.40.0-rc3) - 2020-11-06
 
 ### Client Breaking
@@ -97,6 +101,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
   * All outward facing APIs will now check that capability is not nil and name is not empty before performing any state-machine changes
   * `SetIndex` has been renamed to `InitializeIndex`
 
+
 ### Features
 
 * (tx) [\#7688](https://github.com/cosmos/cosmos-sdk/pull/7688) Add a new Tx gRPC service with methods `Simulate` and `GetTx` (by hash).

codec/amino_codec.go

@@ -1,6 +1,8 @@
 package codec
 
-import "github.com/gogo/protobuf/proto"
+import (
+	"github.com/gogo/protobuf/proto"
+)
 
 // AminoCodec defines a codec that utilizes Codec for both binary and JSON
 // encoding.
@@ -78,3 +80,45 @@ func (ac *AminoCodec) UnmarshalJSON(bz []byte, ptr proto.Message) error {
 func (ac *AminoCodec) MustUnmarshalJSON(bz []byte, ptr proto.Message) {
 	ac.LegacyAmino.MustUnmarshalJSON(bz, ptr)
 }
+
+// MarshalInterface is a convenience function for amino marshaling interfaces.
+// The `i` must be an interface.
+// NOTE: to marshal a concrete type, you should use MarshalBinaryBare instead
+func (ac *AminoCodec) MarshalInterface(i proto.Message) ([]byte, error) {
+	if err := assertNotNil(i); err != nil {
+		return nil, err
+	}
+	return ac.LegacyAmino.MarshalBinaryBare(i)
+}
+
+// UnmarshalInterface is a convenience function for amino unmarshaling interfaces.
+// `ptr` must be a pointer to an interface.
+// NOTE: to unmarshal a concrete type, you should use UnmarshalBinaryBare instead
+//
+// Example:
+//   var x MyInterface
+//   err := cdc.UnmarshalInterface(bz, &x)
+func (ac *AminoCodec) UnmarshalInterface(bz []byte, ptr interface{}) error {
+	return ac.LegacyAmino.UnmarshalBinaryBare(bz, ptr)
+}
+
+// MarshalInterfaceJSON is a convenience function for amino marshaling interfaces.
+// The `i` must be an interface.
+// NOTE: to marshal a concrete type, you should use MarshalJSON instead
+func (ac *AminoCodec) MarshalInterfaceJSON(i proto.Message) ([]byte, error) {
+	if err := assertNotNil(i); err != nil {
+		return nil, err
+	}
+	return ac.LegacyAmino.MarshalJSON(i)
+}
+
+// UnmarshalInterfaceJSON is a convenience function for amino unmarshaling interfaces.
+// `ptr` must be a pointer to an interface.
+// NOTE: to unmarshal a concrete type, you should use UnmarshalJSON instead
+//
+// Example:
+//   var x MyInterface
+//   err := cdc.UnmarshalInterfaceJSON(bz, &x)
+func (ac *AminoCodec) UnmarshalInterfaceJSON(bz []byte, ptr interface{}) error {
+	return ac.LegacyAmino.UnmarshalJSON(bz, ptr)
+}

codec/amino_codec_test.go

@@ -15,121 +15,26 @@ import (
 
 func createTestCodec() *codec.LegacyAmino {
 	cdc := codec.NewLegacyAmino()
-
 	cdc.RegisterInterface((*testdata.Animal)(nil), nil)
-	cdc.RegisterConcrete(testdata.Dog{}, "testdata/Dog", nil)
-	cdc.RegisterConcrete(testdata.Cat{}, "testdata/Cat", nil)
+	// NOTE: since we unmarshal interface using pointers, we need to register a pointer
+	// types here.
+	cdc.RegisterConcrete(&testdata.Dog{}, "testdata/Dog", nil)
+	cdc.RegisterConcrete(&testdata.Cat{}, "testdata/Cat", nil)
 
 	return cdc
 }
 
-func TestAminoCodec(t *testing.T) {
-	any, err := types.NewAnyWithValue(&testdata.Dog{Name: "rufus"})
-	require.NoError(t, err)
-
-	testCases := []struct {
-		name         string
-		codec        *codec.AminoCodec
-		input        codec.ProtoMarshaler
-		recv         codec.ProtoMarshaler
-		marshalErr   bool
-		unmarshalErr bool
-	}{
-		{
-			"valid encoding and decoding",
-			codec.NewAminoCodec(createTestCodec()),
-			&testdata.Dog{Name: "rufus"},
-			&testdata.Dog{},
-			false,
-			false,
-		},
-		{
-			"invalid decode type",
-			codec.NewAminoCodec(createTestCodec()),
-			&testdata.Dog{Name: "rufus"},
-			&testdata.Cat{},
-			false,
-			true,
-		},
-		{
-			"any marshaling",
-			codec.NewAminoCodec(createTestCodec()),
-			&testdata.HasAnimal{Animal: any},
-			&testdata.HasAnimal{Animal: any},
-			false,
-			false,
-		},
-	}
-
-	for _, tc := range testCases {
-		tc := tc
-
-		t.Run(tc.name, func(t *testing.T) {
-			bz, err := tc.codec.MarshalBinaryBare(tc.input)
-
-			if tc.marshalErr {
-				require.Error(t, err)
-				require.Panics(t, func() { tc.codec.MustMarshalBinaryBare(tc.input) })
-			} else {
-				var bz2 []byte
-				require.NoError(t, err)
-				require.NotPanics(t, func() { bz2 = tc.codec.MustMarshalBinaryBare(tc.input) })
-				require.Equal(t, bz, bz2)
-
-				err := tc.codec.UnmarshalBinaryBare(bz, tc.recv)
-				if tc.unmarshalErr {
-					require.Error(t, err)
-					require.Panics(t, func() { tc.codec.MustUnmarshalBinaryBare(bz, tc.recv) })
-				} else {
-					require.NoError(t, err)
-					require.NotPanics(t, func() { tc.codec.MustUnmarshalBinaryBare(bz, tc.recv) })
-					require.Equal(t, tc.input, tc.recv)
-				}
-			}
+func TestAminoMarsharlInterface(t *testing.T) {
+	cdc := codec.NewAminoCodec(createTestCodec())
+	m := interfaceMarshaler{cdc.MarshalInterface, cdc.UnmarshalInterface}
+	testInterfaceMarshaling(require.New(t), m, true)
 
-			bz, err = tc.codec.MarshalBinaryLengthPrefixed(tc.input)
-			if tc.marshalErr {
-				require.Error(t, err)
-				require.Panics(t, func() { tc.codec.MustMarshalBinaryLengthPrefixed(tc.input) })
-			} else {
-				var bz2 []byte
-				require.NoError(t, err)
-				require.NotPanics(t, func() { bz2 = tc.codec.MustMarshalBinaryLengthPrefixed(tc.input) })
-				require.Equal(t, bz, bz2)
-
-				err := tc.codec.UnmarshalBinaryLengthPrefixed(bz, tc.recv)
-				if tc.unmarshalErr {
-					require.Error(t, err)
-					require.Panics(t, func() { tc.codec.MustUnmarshalBinaryLengthPrefixed(bz, tc.recv) })
-				} else {
-					require.NoError(t, err)
-					require.NotPanics(t, func() { tc.codec.MustUnmarshalBinaryLengthPrefixed(bz, tc.recv) })
-					require.Equal(t, tc.input, tc.recv)
-				}
-			}
+	m = interfaceMarshaler{cdc.MarshalInterfaceJSON, cdc.UnmarshalInterfaceJSON}
+	testInterfaceMarshaling(require.New(t), m, false)
+}
 
-			bz, err = tc.codec.MarshalJSON(tc.input)
-			if tc.marshalErr {
-				require.Error(t, err)
-				require.Panics(t, func() { tc.codec.MustMarshalJSON(tc.input) })
-			} else {
-				var bz2 []byte
-				require.NoError(t, err)
-				require.NotPanics(t, func() { bz2 = tc.codec.MustMarshalJSON(tc.input) })
-				require.Equal(t, bz, bz2)
-
-				err := tc.codec.UnmarshalJSON(bz, tc.recv)
-				if tc.unmarshalErr {
-					require.Error(t, err)
-					require.Panics(t, func() { tc.codec.MustUnmarshalJSON(bz, tc.recv) })
-				} else {
-					require.NoError(t, err)
-					require.NotPanics(t, func() { tc.codec.MustUnmarshalJSON(bz, tc.recv) })
-					require.Equal(t, tc.input, tc.recv)
-				}
-			}
-		})
-	}
+func TestAminoCodec(t *testing.T) {
+	testMarshaling(t, codec.NewAminoCodec(createTestCodec()))
 }
 
 func TestAminoCodecMarshalJSONIndent(t *testing.T) {

codec/any_test.go

@@ -1,7 +1,6 @@
 package codec_test
 
 import (
-	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -28,38 +27,29 @@ func TestMarshalAny(t *testing.T) {
 	cdc := codec.NewProtoCodec(registry)
 
 	kitty := &testdata.Cat{Moniker: "Kitty"}
-	bz, err := codec.MarshalAny(cdc, kitty)
+	bz, err := cdc.MarshalInterface(kitty)
 	require.NoError(t, err)
 
 	var animal testdata.Animal
 
 	// empty registry should fail
-	err = codec.UnmarshalAny(cdc, &animal, bz)
+	err = cdc.UnmarshalInterface(bz, &animal)
 	require.Error(t, err)
 
 	// wrong type registration should fail
 	registry.RegisterImplementations((*testdata.Animal)(nil), &testdata.Dog{})
-	err = codec.UnmarshalAny(cdc, &animal, bz)
+	err = cdc.UnmarshalInterface(bz, &animal)
 	require.Error(t, err)
 
 	// should pass
 	registry = NewTestInterfaceRegistry()
 	cdc = codec.NewProtoCodec(registry)
-	err = codec.UnmarshalAny(cdc, &animal, bz)
+	err = cdc.UnmarshalInterface(bz, &animal)
 	require.NoError(t, err)
 	require.Equal(t, kitty, animal)
 
 	// nil should fail
 	registry = NewTestInterfaceRegistry()
-	err = codec.UnmarshalAny(cdc, nil, bz)
+	err = cdc.UnmarshalInterface(bz, nil)
 	require.Error(t, err)
 }
-
-func TestMarshalAnyNonProtoErrors(t *testing.T) {
-	registry := types.NewInterfaceRegistry()
-	cdc := codec.NewProtoCodec(registry)
-
-	_, err := codec.MarshalAny(cdc, 29)
-	require.Error(t, err)
-	require.Equal(t, err, errors.New("can't proto marshal int"))
-}

codec/codec.go

@@ -32,12 +32,17 @@ type (
 		UnmarshalBinaryLengthPrefixed(bz []byte, ptr ProtoMarshaler) error
 		MustUnmarshalBinaryLengthPrefixed(bz []byte, ptr ProtoMarshaler)
 
+		MarshalInterface(i proto.Message) ([]byte, error)
+		UnmarshalInterface(bz []byte, ptr interface{}) error
+
 		types.AnyUnpacker
 	}
 
 	JSONMarshaler interface {
 		MarshalJSON(o proto.Message) ([]byte, error)
 		MustMarshalJSON(o proto.Message) []byte
+		MarshalInterfaceJSON(i proto.Message) ([]byte, error)
+		UnmarshalInterfaceJSON(bz []byte, ptr interface{}) error
 
 		UnmarshalJSON(bz []byte, ptr proto.Message) error
 		MustUnmarshalJSON(bz []byte, ptr proto.Message)