Proto Any init + evidence

Makefile

@@ -258,6 +258,9 @@ proto-all: proto-gen proto-lint proto-check-breaking
 proto-gen:
 	@./scripts/protocgen.sh
 
+proto-gen-any:
+	@./scripts/protocgen-any.sh
+
 proto-lint:
 	@buf check lint --error-format=json
 

buf.yaml

@@ -1,6 +1,8 @@
 build:
   roots:
     - .
+  excludes:
+    - third_party/proto/google
 lint:
   use:
     - DEFAULT

codec/amino_codec_test.go

@@ -3,6 +3,8 @@ package codec_test
 import (
 	"testing"
 
+	"github.com/cosmos/cosmos-sdk/codec/types"
+
 	"github.com/stretchr/testify/require"
 	amino "github.com/tendermint/go-amino"
 
@@ -17,9 +19,27 @@ func createTestCodec() *amino.Codec {
 	cdc.RegisterConcrete(testdata.Dog{}, "testdata/Dog", nil)
 	cdc.RegisterConcrete(testdata.Cat{}, "testdata/Cat", nil)
 
+	interfaceRegistry := types.NewInterfaceRegistry()
+	interfaceRegistry.RegisterInterface("testdata.Animal",
+		(*testdata.Animal)(nil),
+		&testdata.Dog{},
+		&testdata.Cat{},
+	)
+
 	return cdc
 }
 
+func createTestIntefaceRegistry() types.InterfaceRegistry {
+	interfaceRegistry := types.NewInterfaceRegistry()
+	interfaceRegistry.RegisterInterface("testdata.Animal",
+		(*testdata.Animal)(nil),
+		&testdata.Dog{},
+		&testdata.Cat{},
+	)
+
+	return interfaceRegistry
+}
+
 func TestAminoCodec(t *testing.T) {
 	testCases := []struct {
 		name         string

codec/hybrid_codec.go

@@ -1,15 +1,17 @@
 package codec
 
+import "github.com/cosmos/cosmos-sdk/codec/types"
+
 // HybridCodec defines a codec that utilizes Protobuf for binary encoding
 // and Amino for JSON encoding.
 type HybridCodec struct {
 	proto Marshaler
 	amino Marshaler
 }
 
-func NewHybridCodec(amino *Codec) Marshaler {
+func NewHybridCodec(amino *Codec, unpacker types.AnyUnpacker) Marshaler {
 	return &HybridCodec{
-		proto: NewProtoCodec(),
+		proto: NewProtoCodec(unpacker),
 		amino: NewAminoCodec(amino),
 	}
 }

codec/hybrid_codec_test.go

@@ -20,15 +20,15 @@ func TestHybridCodec(t *testing.T) {
 	}{
 		{
 			"valid encoding and decoding",
-			codec.NewHybridCodec(createTestCodec()),
+			codec.NewHybridCodec(createTestCodec(), createTestIntefaceRegistry()),
 			&testdata.Dog{Name: "rufus"},
 			&testdata.Dog{},
 			false,
 			false,
 		},
 		{
 			"invalid decode type",
-			codec.NewHybridCodec(createTestCodec()),
+			codec.NewHybridCodec(createTestCodec(), createTestIntefaceRegistry()),
 			&testdata.Dog{Name: "rufus"},
 			&testdata.Cat{},
 			false,

codec/proto_codec.go

@@ -6,15 +6,19 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/cosmos/cosmos-sdk/codec/types"
+
 	"github.com/gogo/protobuf/jsonpb"
 )
 
 // ProtoCodec defines a codec that utilizes Protobuf for both binary and JSON
 // encoding.
-type ProtoCodec struct{}
+type ProtoCodec struct {
+	anyUnpacker types.AnyUnpacker
+}
 
-func NewProtoCodec() Marshaler {
-	return &ProtoCodec{}
+func NewProtoCodec(anyUnpacker types.AnyUnpacker) Marshaler {
+	return &ProtoCodec{anyUnpacker: anyUnpacker}
 }
 
 func (pc *ProtoCodec) MarshalBinaryBare(o ProtoMarshaler) ([]byte, error) {
@@ -58,7 +62,15 @@ func (pc *ProtoCodec) MustMarshalBinaryLengthPrefixed(o ProtoMarshaler) []byte {
 }
 
 func (pc *ProtoCodec) UnmarshalBinaryBare(bz []byte, ptr ProtoMarshaler) error {
-	return ptr.Unmarshal(bz)
+	err := ptr.Unmarshal(bz)
+	if err != nil {
+		return err
+	}
+	err = types.UnpackInterfaces(ptr, pc.anyUnpacker)
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
 func (pc *ProtoCodec) MustUnmarshalBinaryBare(bz []byte, ptr ProtoMarshaler) {
@@ -80,7 +92,7 @@ func (pc *ProtoCodec) UnmarshalBinaryLengthPrefixed(bz []byte, ptr ProtoMarshale
 	}
 
 	bz = bz[n:]
-	return ptr.Unmarshal(bz)
+	return pc.UnmarshalBinaryBare(bz, ptr)
 }
 
 func (pc *ProtoCodec) MustUnmarshalBinaryLengthPrefixed(bz []byte, ptr ProtoMarshaler) {

codec/proto_codec_test.go

@@ -20,15 +20,15 @@ func TestProtoCodec(t *testing.T) {
 	}{
 		{
 			"valid encoding and decoding",
-			codec.NewProtoCodec(),
+			codec.NewProtoCodec(createTestIntefaceRegistry()),
 			&testdata.Dog{Name: "rufus"},
 			&testdata.Dog{},
 			false,
 			false,
 		},
 		{
 			"invalid decode type",
-			codec.NewProtoCodec(),
+			codec.NewProtoCodec(createTestIntefaceRegistry()),
 			&testdata.Dog{Name: "rufus"},
 			&testdata.Cat{},
 			false,

codec/types/any.go

@@ -0,0 +1,104 @@
+package types
+
+import (
+	"fmt"
+
+	"github.com/gogo/protobuf/proto"
+)
+
+type Any struct {
+	// A URL/resource name that uniquely identifies the type of the serialized
+	// protocol buffer message. This string must contain at least
+	// one "/" character. The last segment of the URL's path must represent
+	// the fully qualified name of the type (as in
+	// `path/google.protobuf.Duration`). The name should be in a canonical form
+	// (e.g., leading "." is not accepted).
+	//
+	// In practice, teams usually precompile into the binary all types that they
+	// expect it to use in the context of Any. However, for URLs which use the
+	// scheme `http`, `https`, or no scheme, one can optionally set up a type
+	// server that maps type URLs to message definitions as follows:
+	//
+	// * If no scheme is provided, `https` is assumed.
+	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+	//   value in binary format, or produce an error.
+	// * Applications are allowed to cache lookup results based on the
+	//   URL, or have them precompiled into a binary to avoid any
+	//   lookup. Therefore, binary compatibility needs to be preserved
+	//   on changes to types. (Use versioned type names to manage
+	//   breaking changes.)
+	//
+	// Note: this functionality is not currently available in the official
+	// protobuf release, and it is not used for type URLs beginning with
+	// type.googleapis.com.
+	//
+	// Schemes other than `http`, `https` (or the empty scheme) might be
+	// used with implementation specific semantics.
+	//
+
+	// nolint
+	TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"`
+	// Must be a valid serialized protocol buffer of the above specified type.
+	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+
+	// nolint
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+
+	// nolint
+	XXX_unrecognized []byte `json:"-"`
+
+	// nolint
+	XXX_sizecache int32 `json:"-"`
+
+	cachedValue interface{}
+}
+
+func NewAnyWithValue(value interface{}) (*Any, error) {
+	any := &Any{}
+	msg, ok := value.(proto.Message)
+	if !ok {
+		return nil, fmt.Errorf("can't pack %T", msg)
+	}
+	err := any.Pack(msg)
+	if err != nil {
+		return nil, err
+	}
+	return any, nil
+}
+
+func (any *Any) Pack(x proto.Message) error {
+	any.TypeUrl = "/" + proto.MessageName(x)
+	bz, err := proto.Marshal(x)
+	if err != nil {
+		return err
+	}
+	any.Value = bz
+	any.cachedValue = x
+	return nil
+}
+
+func (any *Any) CachedValue() interface{} {
+	return any.cachedValue
+}
+
+func MarshalAny(x interface{}) ([]byte, error) {
+	msg, ok := x.(proto.Message)
+	if !ok {
+		return nil, fmt.Errorf("can't proto marshal %T", x)
+	}
+	any := &Any{}
+	err := any.Pack(msg)
+	if err != nil {
+		return nil, err
+	}
+	return any.Marshal()
+}
+
+func UnmarshalAny(ctx AnyUnpacker, iface interface{}, bz []byte) error {
+	any := &Any{}
+	err := any.Unmarshal(bz)
+	if err != nil {
+		return err
+	}
+	return ctx.UnpackAny(any, iface)
+}