certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge PR #6076: Proto Any init + evidence

This commit is contained in:
Aaron Craelius 2020-05-05 10:28:20 -04:00 committed by GitHub
parent 7e72e5b8a6
commit 386217209d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
82 changed files with 2145 additions and 1304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -251,6 +251,10 @@ proto-all: proto-tools proto-gen proto-lint proto-check-breaking
proto-gen:
@./scripts/protocgen.sh
# This generates the SDK's custom wrapper for google.protobuf.Any. It should only be run manually when needed
proto-gen-any:
@./scripts/protocgen-any.sh
proto-lint:
@buf check lint --error-format=json

2
buf.yaml
View File

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

10
codec/amino_codec.go
View File

@ -1,5 +1,11 @@
package codec
import (
"fmt"
"github.com/cosmos/cosmos-sdk/codec/types"
)
// AminoCodec defines a codec that utilizes Amino for both binary and JSON
// encoding.
type AminoCodec struct {
@ -57,3 +63,7 @@ func (ac *AminoCodec) UnmarshalJSON(bz []byte, ptr interface{}) error {
func (ac *AminoCodec) MustUnmarshalJSON(bz []byte, ptr interface{}) {
ac.amino.MustUnmarshalJSON(bz, ptr)
}
func (*AminoCodec) UnpackAny(*types.Any, interface{}) error {
return fmt.Errorf("AminoCodec can't handle unpack protobuf Any's")
}

3
codec/codec.go
View File

@ -4,6 +4,8 @@ import (
"encoding/binary"
"io"
"github.com/cosmos/cosmos-sdk/codec/types"
"github.com/gogo/protobuf/proto"
)
@ -31,6 +33,7 @@ type (
MustUnmarshalBinaryLengthPrefixed(bz []byte, ptr ProtoMarshaler)
JSONMarshaler
types.AnyUnpacker
}
JSONMarshaler interface {

10
codec/hybrid_codec.go
View File

@ -1,5 +1,7 @@
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 {
@ -7,9 +9,9 @@ type HybridCodec struct {
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),
}
}
@ -61,3 +63,7 @@ func (hc *HybridCodec) UnmarshalJSON(bz []byte, ptr interface{}) error {
func (hc *HybridCodec) MustUnmarshalJSON(bz []byte, ptr interface{}) {
hc.amino.MustUnmarshalJSON(bz, ptr)
}
func (hc *HybridCodec) UnpackAny(any *types.Any, iface interface{}) error {
return hc.proto.UnpackAny(any, iface)
}

4
codec/hybrid_codec_test.go
View File

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

26
codec/proto_codec.go
View File

@ -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) {
@ -121,3 +133,7 @@ func (pc *ProtoCodec) MustUnmarshalJSON(bz []byte, ptr interface{}) {
panic(err)
}
}
func (pc *ProtoCodec) UnpackAny(any *types.Any, iface interface{}) error {
return pc.anyUnpacker.UnpackAny(any, iface)
}

16
codec/proto_codec_test.go
View File

@ -7,8 +7,20 @@ import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/testdata"
"github.com/cosmos/cosmos-sdk/codec/types"
)
func createTestInterfaceRegistry() types.InterfaceRegistry {
interfaceRegistry := types.NewInterfaceRegistry()
interfaceRegistry.RegisterInterface("testdata.Animal",
(*testdata.Animal)(nil),
&testdata.Dog{},
&testdata.Cat{},
)
return interfaceRegistry
}
func TestProtoCodec(t *testing.T) {
testCases := []struct {
name string
@ -20,7 +32,7 @@ func TestProtoCodec(t *testing.T) {
}{
{
"valid encoding and decoding",
codec.NewProtoCodec(),
codec.NewProtoCodec(createTestInterfaceRegistry()),
&testdata.Dog{Name: "rufus"},
&testdata.Dog{},
false,
@ -28,7 +40,7 @@ func TestProtoCodec(t *testing.T) {
},
{
"invalid decode type",
codec.NewProtoCodec(),
codec.NewProtoCodec(createTestInterfaceRegistry()),
&testdata.Dog{Name: "rufus"},
&testdata.Cat{},
false,

9
codec/testdata/animal.go vendored
View File

@ -5,6 +5,8 @@ package testdata
import (
"fmt"
"github.com/cosmos/cosmos-sdk/codec/types"
)
type Animal interface {
@ -18,3 +20,10 @@ func (c Cat) Greet() string {
func (d Dog) Greet() string {
return fmt.Sprintf("Roof, my name is %s", d.Name)
}
var _ types.UnpackInterfacesMessage = HasAnimal{}
func (m HasAnimal) UnpackInterfaces(unpacker types.AnyUnpacker) error {
var animal Animal
return unpacker.UnpackAny(m.Animal, &animal)
}

250
codec/testdata/proto.pb.go vendored
View File

@ -5,6 +5,7 @@ package testdata
import (
fmt "fmt"
types "github.com/cosmos/cosmos-sdk/codec/types"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
@ -126,28 +127,85 @@ func (m *Cat) GetLives() int32 {
return 0
}
type HasAnimal struct {
Animal *types.Any `protobuf:"bytes,1,opt,name=animal,proto3" json:"animal,omitempty"`
X int64 `protobuf:"varint,2,opt,name=x,proto3" json:"x,omitempty"`
}
func (m *HasAnimal) Reset() { *m = HasAnimal{} }
func (m *HasAnimal) String() string { return proto.CompactTextString(m) }
func (*HasAnimal) ProtoMessage() {}
func (*HasAnimal) Descriptor() ([]byte, []int) {
return fileDescriptor_ae1353846770e6e2, []int{2}
}
func (m *HasAnimal) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *HasAnimal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_HasAnimal.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *HasAnimal) XXX_Merge(src proto.Message) {
xxx_messageInfo_HasAnimal.Merge(m, src)
}
func (m *HasAnimal) XXX_Size() int {
return m.Size()
}
func (m *HasAnimal) XXX_DiscardUnknown() {
xxx_messageInfo_HasAnimal.DiscardUnknown(m)
}
var xxx_messageInfo_HasAnimal proto.InternalMessageInfo
func (m *HasAnimal) GetAnimal() *types.Any {
if m != nil {
return m.Animal
}
return nil
}
func (m *HasAnimal) GetX() int64 {
if m != nil {
return m.X
}
return 0
}
func init() {
proto.RegisterType((*Dog)(nil), "cosmos_sdk.codec.v1.Dog")
proto.RegisterType((*Cat)(nil), "cosmos_sdk.codec.v1.Cat")
proto.RegisterType((*HasAnimal)(nil), "cosmos_sdk.codec.v1.HasAnimal")
}
func init() { proto.RegisterFile("codec/testdata/proto.proto", fileDescriptor_ae1353846770e6e2) }
var fileDescriptor_ae1353846770e6e2 = []byte{
// 195 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0xce, 0x4f, 0x49,
0x4d, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x49, 0x49, 0x2c, 0x49, 0xd4, 0x2f, 0x28, 0xca, 0x2f, 0xc9,
0xd7, 0x03, 0x93, 0x42, 0xc2, 0xc9, 0xf9, 0xc5, 0xb9, 0xf9, 0xc5, 0xf1, 0xc5, 0x29, 0xd9, 0x7a,
0x60, 0x65, 0x7a, 0x65, 0x86, 0x4a, 0xba, 0x5c, 0xcc, 0x2e, 0xf9, 0xe9, 0x42, 0x42, 0x5c, 0x2c,
0xc5, 0x99, 0x55, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x60, 0x36, 0x48, 0x2c, 0x2f,
0x31, 0x37, 0x55, 0x82, 0x09, 0x22, 0x06, 0x62, 0x2b, 0x99, 0x72, 0x31, 0x3b, 0x27, 0x96, 0x08,
0x49, 0x70, 0xb1, 0xe7, 0xe6, 0xe7, 0x65, 0x66, 0xa7, 0x16, 0x41, 0x75, 0xc0, 0xb8, 0x42, 0x22,
0x5c, 0xac, 0x39, 0x99, 0x65, 0xa9, 0xc5, 0x60, 0x5d, 0xac, 0x41, 0x10, 0x8e, 0x93, 0xeb, 0x89,
0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3,
0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x69, 0xa7, 0x67, 0x96, 0x64, 0x94, 0x26,
0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x43, 0xdc, 0x07, 0xa5, 0x74, 0x8b, 0x53, 0xb2, 0xf5, 0x51, 0x7d,
0x93, 0xc4, 0x06, 0xf6, 0x88, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x64, 0x25, 0x07, 0xc7, 0xe6,
0x00, 0x00, 0x00,
// 264 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xbd, 0x4e, 0xc3, 0x30,
0x14, 0x85, 0x63, 0x42, 0x8b, 0x6a, 0x98, 0x4c, 0x87, 0xd0, 0xc1, 0x42, 0x99, 0x90, 0xa0, 0xb6,
0x00, 0xf1, 0x00, 0xe5, 0x47, 0x30, 0x67, 0x64, 0x41, 0x4e, 0x62, 0x82, 0x95, 0xd8, 0x17, 0xd5,
0x6e, 0xd5, 0xf2, 0x14, 0x3c, 0x16, 0x63, 0x47, 0x46, 0x94, 0xbc, 0x08, 0xaa, 0x9d, 0x0e, 0x5d,
0xec, 0x73, 0xaf, 0xbe, 0x63, 0x1f, 0x1d, 0x3c, 0x29, 0xa0, 0x94, 0x05, 0x77, 0xd2, 0xba, 0x52,
0x38, 0xc1, 0x3f, 0xe7, 0xe0, 0x80, 0xf9, 0x93, 0x9c, 0x16, 0x60, 0x35, 0xd8, 0x37, 0x5b, 0xd6,
0xcc, 0x63, 0x6c, 0x79, 0x3d, 0x39, 0xab, 0x00, 0xaa, 0x46, 0x06, 0x30, 0x5f, 0xbc, 0x73, 0x61,
0xd6, 0x81, 0x4f, 0xa7, 0x38, 0x7e, 0x84, 0x8a, 0x10, 0x7c, 0x68, 0xd5, 0x97, 0x4c, 0xd0, 0x39,
0xba, 0x18, 0x65, 0x5e, 0x6f, 0x77, 0x46, 0x68, 0x99, 0x1c, 0x84, 0xdd, 0x56, 0xa7, 0x77, 0x38,
0x7e, 0x10, 0x8e, 0x24, 0xf8, 0x48, 0x83, 0x51, 0xb5, 0x9c, 0xf7, 0x8e, 0xdd, 0x48, 0xc6, 0x78,
0xd0, 0xa8, 0xa5, 0xb4, 0xde, 0x35, 0xc8, 0xc2, 0x90, 0x3e, 0xe3, 0xd1, 0x8b, 0xb0, 0x33, 0xa3,
0xb4, 0x68, 0xc8, 0x15, 0x1e, 0x0a, 0xaf, 0xbc, 0xf7, 0xf8, 0x66, 0xcc, 0x42, 0x3c, 0xb6, 0x8b,
0xc7, 0x66, 0x66, 0x9d, 0xf5, 0x0c, 0x39, 0xc1, 0x68, 0xe5, 0x1f, 0x8b, 0x33, 0xb4, 0xba, 0x7f,
0xfa, 0x69, 0x29, 0xda, 0xb4, 0x14, 0xfd, 0xb5, 0x14, 0x7d, 0x77, 0x34, 0xda, 0x74, 0x34, 0xfa,
0xed, 0x68, 0xf4, 0x7a, 0x59, 0x29, 0xf7, 0xb1, 0xc8, 0x59, 0x01, 0x9a, 0x87, 0x0e, 0xfa, 0x6b,
0x6a, 0xcb, 0x9a, 0xef, 0x37, 0x96, 0x0f, 0xfd, 0x57, 0xb7, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff,
0x75, 0xe8, 0x4c, 0xa3, 0x4a, 0x01, 0x00, 0x00,
}
func (m *Dog) Marshal() (dAtA []byte, err error) {
@ -222,6 +280,46 @@ func (m *Cat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *HasAnimal) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *HasAnimal) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *HasAnimal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.X != 0 {
i = encodeVarintProto(dAtA, i, uint64(m.X))
i--
dAtA[i] = 0x10
}
if m.Animal != nil {
{
size, err := m.Animal.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintProto(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintProto(dAtA []byte, offset int, v uint64) int {
offset -= sovProto(v)
base := offset
@ -266,6 +364,22 @@ func (m *Cat) Size() (n int) {
return n
}
func (m *HasAnimal) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Animal != nil {
l = m.Animal.Size()
n += 1 + l + sovProto(uint64(l))
}
if m.X != 0 {
n += 1 + sovProto(uint64(m.X))
}
return n
}
func sovProto(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@ -493,6 +607,114 @@ func (m *Cat) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *HasAnimal) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowProto
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: HasAnimal: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: HasAnimal: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Animal", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowProto
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthProto
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthProto
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Animal == nil {
m.Animal = &types.Any{}
}
if err := m.Animal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
}
m.X = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowProto
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.X |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipProto(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthProto
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthProto
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipProto(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0

7
codec/testdata/proto.proto vendored
View File

@ -1,6 +1,8 @@
syntax = "proto3";
package cosmos_sdk.codec.v1;
import "google/protobuf/any.proto";
option go_package = "github.com/cosmos/cosmos-sdk/codec/testdata";
message Dog {
@ -12,3 +14,8 @@ message Cat {
string moniker = 1;
int32 lives = 2;
}
message HasAnimal {
google.protobuf.Any animal = 1;
int64 x = 2;
}

129
codec/types/any.go Normal file
View File

@ -0,0 +1,129 @@
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{}
}
// NewAnyWithValue constructs a new Any packed with the value provided or
// returns an error if that value couldn't be packed. This also caches
// the packed value so that it can be retrieved from GetCachedValue without
// unmarshaling
func NewAnyWithValue(value proto.Message) (*Any, error) {
any := &Any{}
err := any.Pack(value)
if err != nil {
return nil, err
}
return any, nil
}
// Pack packs the value x in the Any or returns an error. This also caches
// the packed value so that it can be retrieved from GetCachedValue without
// unmarshaling
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
}
// GetCachedValue returns the cached value from the Any if present
func (any *Any) GetCachedValue() interface{} {
return any.cachedValue
}
// ClearCachedValue clears the cached value from the Any
func (any *Any) ClearCachedValue() {
any.cachedValue = nil
}
// MarshalAny is a convenience function for packing the provided value in an
// Any and then proto marshaling it to bytes
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()
}
// UnmarshalAny is a convenience function for proto unmarshaling an Any from
// bz and then unpacking it to the interface pointer passed in as iface using
// the provided AnyUnpacker or returning an error
//
// Ex:
// var x MyInterface
// err := UnmarshalAny(unpacker, &x, bz)
func UnmarshalAny(unpacker AnyUnpacker, iface interface{}, bz []byte) error {
any := &Any{}
err := any.Unmarshal(bz)
if err != nil {
return err
}
return unpacker.UnpackAny(any, iface)
}

584
codec/types/any.pb.go Normal file
View File

@ -0,0 +1,584 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: third_party/proto/google/protobuf/any.proto
package types
import (
bytes "bytes"
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
math_bits "math/bits"
reflect "reflect"
strings "strings"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
func (m *Any) Reset() { *m = Any{} }
func (*Any) ProtoMessage() {}
func (*Any) Descriptor() ([]byte, []int) {
return fileDescriptor_cb68f365a8e2bcdc, []int{0}
}
func (*Any) XXX_WellKnownType() string { return "Any" }
func (m *Any) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Any.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Any) XXX_Merge(src proto.Message) {
xxx_messageInfo_Any.Merge(m, src)
}
func (m *Any) XXX_Size() int {
return m.Size()
}
func (m *Any) XXX_DiscardUnknown() {
xxx_messageInfo_Any.DiscardUnknown(m)
}
var xxx_messageInfo_Any proto.InternalMessageInfo
func (m *Any) GetTypeUrl() string {
if m != nil {
return m.TypeUrl
}
return ""
}
func (m *Any) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func (*Any) XXX_MessageName() string {
return "google.protobuf.Any"
}
func init() {
}
func init() {
proto.RegisterFile("third_party/proto/google/protobuf/any.proto", fileDescriptor_cb68f365a8e2bcdc)
}
var fileDescriptor_cb68f365a8e2bcdc = []byte{
// 246 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2e, 0xc9, 0xc8, 0x2c,
0x4a, 0x89, 0x2f, 0x48, 0x2c, 0x2a, 0xa9, 0xd4, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0xd7, 0x4f, 0xcf,
0xcf, 0x4f, 0xcf, 0x49, 0x85, 0x70, 0x92, 0x4a, 0xd3, 0xf4, 0x13, 0xf3, 0x2a, 0xf5, 0xc0, 0x1c,
0x21, 0x7e, 0x88, 0x94, 0x1e, 0x4c, 0x4a, 0x4a, 0x0d, 0x9b, 0xee, 0xf4, 0x7c, 0x04, 0x0b, 0xa2,
0x54, 0xc9, 0x86, 0x8b, 0xd9, 0x31, 0xaf, 0x52, 0x48, 0x92, 0x8b, 0xa3, 0xa4, 0xb2, 0x20, 0x35,
0xbe, 0xb4, 0x28, 0x47, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x88, 0x1d, 0xc4, 0x0f, 0x2d, 0xca,
0x11, 0x12, 0xe1, 0x62, 0x2d, 0x4b, 0xcc, 0x29, 0x4d, 0x95, 0x60, 0x52, 0x60, 0xd4, 0xe0, 0x09,
0x82, 0x70, 0xac, 0x58, 0x3e, 0x2c, 0x94, 0x67, 0x70, 0x6a, 0x66, 0xbc, 0xf1, 0x50, 0x8e, 0xe1,
0xc3, 0x43, 0x39, 0xc6, 0x1f, 0x0f, 0xe5, 0x18, 0x1b, 0x1e, 0xc9, 0x31, 0xae, 0x78, 0x24, 0xc7,
0x78, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0xbe, 0x78, 0x24,
0xc7, 0xf0, 0x01, 0x24, 0xfe, 0x58, 0x8e, 0xf1, 0xc0, 0x63, 0x39, 0x86, 0x13, 0x8f, 0xe5, 0x18,
0xb9, 0x84, 0x93, 0xf3, 0x73, 0xf5, 0xd0, 0x5c, 0xec, 0xc4, 0xe1, 0x98, 0x57, 0x19, 0x00, 0xe2,
0x04, 0x30, 0x46, 0xb1, 0x82, 0x2c, 0x2f, 0x5e, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49,
0xce, 0x1d, 0xa2, 0x34, 0x00, 0xaa, 0x54, 0x2f, 0x3c, 0x35, 0x27, 0xc7, 0x3b, 0x2f, 0xbf, 0x3c,
0x2f, 0x04, 0xa4, 0x2c, 0x89, 0x0d, 0x6c, 0x86, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x16, 0xc3,
0x46, 0x5f, 0x32, 0x01, 0x00, 0x00,
}
func (this *Any) Compare(that interface{}) int {
if that == nil {
if this == nil {
return 0
}
return 1
}
that1, ok := that.(*Any)
if !ok {
that2, ok := that.(Any)
if ok {
that1 = &that2
} else {
return 1
}
}
if that1 == nil {
if this == nil {
return 0
}
return 1
} else if this == nil {
return -1
}
if this.TypeUrl != that1.TypeUrl {
if this.TypeUrl < that1.TypeUrl {
return -1
}
return 1
}
if c := bytes.Compare(this.Value, that1.Value); c != 0 {
return c
}
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
return c
}
return 0
}
func (this *Any) Equal(that interface{}) bool {
if that == nil {
return this == nil
}
that1, ok := that.(*Any)
if !ok {
that2, ok := that.(Any)
if ok {
that1 = &that2
} else {
return false
}
}
if that1 == nil {
return this == nil
} else if this == nil {
return false
}
if this.TypeUrl != that1.TypeUrl {
return false
}
if !bytes.Equal(this.Value, that1.Value) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Any) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 6)
s = append(s, "&types.Any{")
s = append(s, "TypeUrl: "+fmt.Sprintf("%#v", this.TypeUrl)+",\n")
s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func valueToGoStringAny(v interface{}, typ string) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
return "nil"
}
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Any) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Any) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Any) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Value) > 0 {
i -= len(m.Value)
copy(dAtA[i:], m.Value)
i = encodeVarintAny(dAtA, i, uint64(len(m.Value)))
i--
dAtA[i] = 0x12
}
if len(m.TypeUrl) > 0 {
i -= len(m.TypeUrl)
copy(dAtA[i:], m.TypeUrl)
i = encodeVarintAny(dAtA, i, uint64(len(m.TypeUrl)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintAny(dAtA []byte, offset int, v uint64) int {
offset -= sovAny(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func NewPopulatedAny(r randyAny, easy bool) *Any {
this := &Any{}
this.TypeUrl = string(randStringAny(r))
v1 := r.Intn(100)
this.Value = make([]byte, v1)
for i := 0; i < v1; i++ {
this.Value[i] = byte(r.Intn(256))
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedAny(r, 3)
}
return this
}
type randyAny interface {
Float32() float32
Float64() float64
Int63() int64
Int31() int32
Uint32() uint32
Intn(n int) int
}
func randUTF8RuneAny(r randyAny) rune {
ru := r.Intn(62)
if ru < 10 {
return rune(ru + 48)
} else if ru < 36 {
return rune(ru + 55)
}
return rune(ru + 61)
}
func randStringAny(r randyAny) string {
v2 := r.Intn(100)
tmps := make([]rune, v2)
for i := 0; i < v2; i++ {
tmps[i] = randUTF8RuneAny(r)
}
return string(tmps)
}
func randUnrecognizedAny(r randyAny, maxFieldNumber int) (dAtA []byte) {
l := r.Intn(5)
for i := 0; i < l; i++ {
wire := r.Intn(4)
if wire == 3 {
wire = 5
}
fieldNumber := maxFieldNumber + r.Intn(100)
dAtA = randFieldAny(dAtA, r, fieldNumber, wire)
}
return dAtA
}
func randFieldAny(dAtA []byte, r randyAny, fieldNumber int, wire int) []byte {
key := uint32(fieldNumber)<<3 | uint32(wire)
switch wire {
case 0:
dAtA = encodeVarintPopulateAny(dAtA, uint64(key))
v3 := r.Int63()
if r.Intn(2) == 0 {
v3 *= -1
}
dAtA = encodeVarintPopulateAny(dAtA, uint64(v3))
case 1:
dAtA = encodeVarintPopulateAny(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
case 2:
dAtA = encodeVarintPopulateAny(dAtA, uint64(key))
ll := r.Intn(100)
dAtA = encodeVarintPopulateAny(dAtA, uint64(ll))
for j := 0; j < ll; j++ {
dAtA = append(dAtA, byte(r.Intn(256)))
}
default:
dAtA = encodeVarintPopulateAny(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
}
return dAtA
}
func encodeVarintPopulateAny(dAtA []byte, v uint64) []byte {
for v >= 1<<7 {
dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
v >>= 7
}
dAtA = append(dAtA, uint8(v))
return dAtA
}
func (m *Any) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.TypeUrl)
if l > 0 {
n += 1 + l + sovAny(uint64(l))
}
l = len(m.Value)
if l > 0 {
n += 1 + l + sovAny(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovAny(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozAny(x uint64) (n int) {
return sovAny(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Any) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Any{`,
`TypeUrl:` + fmt.Sprintf("%v", this.TypeUrl) + `,`,
`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func valueToStringAny(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
return "nil"
}
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv)
}
func (m *Any) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAny
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Any: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Any: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TypeUrl", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAny
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthAny
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthAny
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.TypeUrl = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAny
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthAny
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthAny
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
if m.Value == nil {
m.Value = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipAny(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthAny
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthAny
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipAny(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowAny
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowAny
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowAny
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthAny
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupAny
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthAny
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthAny = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowAny = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupAny = fmt.Errorf("proto: unexpected end of group")
)

6
codec/types/doc.go Normal file
View File

@ -0,0 +1,6 @@
/*
Package types defines a custom wrapper for google.protobuf.Any which supports
cached values as well as InterfaceRegistry which keeps track of types which can
be used with Any for both security and introspection
*/
package types

165
codec/types/interface_registry.go Normal file
View File

@ -0,0 +1,165 @@
package types
import (
"fmt"
"reflect"
"github.com/gogo/protobuf/proto"
)
// AnyUnpacker is an interface which allows safely unpacking types packed
// in Any's against a whitelist of registered types
type AnyUnpacker interface {
// UnpackAny unpacks the value in any to the interface pointer passed in as
// iface. Note that the type in any must have been registered in the
// underlying whitelist registry as a concrete type for that interface
// Ex:
// var msg sdk.Msg
// err := cdc.UnpackAny(any, &msg)
// ...
UnpackAny(any *Any, iface interface{}) error
}
// InterfaceRegistry provides a mechanism for registering interfaces and
// implementations that can be safely unpacked from Any
type InterfaceRegistry interface {
AnyUnpacker
// RegisterInterface associates protoName as the public name for the
// interface passed in as iface. This is to be used primarily to create
// a public facing registry of interface implementations for clients.
// protoName should be a well-chosen public facing name that remains stable.
// RegisterInterface takes an optional list of impls to be registered
// as implementations of iface.
//
// Ex:
// registry.RegisterInterface("cosmos_sdk.Msg", (*sdk.Msg)(nil))
RegisterInterface(protoName string, iface interface{}, impls ...proto.Message)
// RegisterImplementations registers impls as concrete implementations of
// the interface iface.
//
// Ex:
// registry.RegisterImplementations((*sdk.Msg)(nil), &MsgSend{}, &MsgMultiSend{})
RegisterImplementations(iface interface{}, impls ...proto.Message)
}
// UnpackInterfacesMessage is meant to extend protobuf types (which implement
// proto.Message) to support a post-deserialization phase which unpacks
// types packed within Any's using the whitelist provided by AnyUnpacker
type UnpackInterfacesMessage interface {
// UnpackInterfaces is implemented in order to unpack values packed within
// Any's using the AnyUnpacker. It should generally be implemented as
// follows:
// func (s *MyStruct) UnpackInterfaces(unpacker AnyUnpacker) error {
// var x AnInterface
// // where X is an Any field on MyStruct
// err := unpacker.UnpackAny(s.X, &x)
// if err != nil {
// return nil
// }
// // where Y is a field on MyStruct that implements UnpackInterfacesMessage itself
// err = s.Y.UnpackInterfaces(unpacker)
// if err != nil {
// return nil
// }
// return nil
// }
UnpackInterfaces(unpacker AnyUnpacker) error
}
type interfaceRegistry struct {
interfaceNames map[string]reflect.Type
interfaceImpls map[reflect.Type]interfaceMap
}
type interfaceMap = map[string]reflect.Type
// NewInterfaceRegistry returns a new InterfaceRegistry
func NewInterfaceRegistry() InterfaceRegistry {
return &interfaceRegistry{
interfaceNames: map[string]reflect.Type{},
interfaceImpls: map[reflect.Type]interfaceMap{},
}
}
func (registry *interfaceRegistry) RegisterInterface(protoName string, iface interface{}, impls ...proto.Message) {
registry.interfaceNames[protoName] = reflect.TypeOf(iface)
registry.RegisterImplementations(iface, impls...)
}
func (registry *interfaceRegistry) RegisterImplementations(iface interface{}, impls ...proto.Message) {
ityp := reflect.TypeOf(iface).Elem()
imap, found := registry.interfaceImpls[ityp]
if !found {
imap = map[string]reflect.Type{}
}
for _, impl := range impls {
implType := reflect.TypeOf(impl)
if !implType.AssignableTo(ityp) {
panic(fmt.Errorf("type %T doesn't actually implement interface %T", implType, ityp))
}
imap["/"+proto.MessageName(impl)] = implType
}
registry.interfaceImpls[ityp] = imap
}
func (registry *interfaceRegistry) UnpackAny(any *Any, iface interface{}) error {
rv := reflect.ValueOf(iface)
if rv.Kind() != reflect.Ptr {
return fmt.Errorf("UnpackAny expects a pointer")
}
rt := rv.Elem().Type()
cachedValue := any.cachedValue
if cachedValue != nil {
if reflect.TypeOf(cachedValue).AssignableTo(rt) {
rv.Elem().Set(reflect.ValueOf(cachedValue))
return nil
}
}
imap, found := registry.interfaceImpls[rt]
if !found {
return fmt.Errorf("no registered implementations of interface type %T", iface)
}
typ, found := imap[any.TypeUrl]
if !found {
return fmt.Errorf("no concrete type registered for type URL %s against interface %T", any.TypeUrl, iface)
}
msg, ok := reflect.New(typ.Elem()).Interface().(proto.Message)
if !ok {
return fmt.Errorf("can't proto unmarshal %T", msg)
}
err := proto.Unmarshal(any.Value, msg)
if err != nil {
return err
}
err = UnpackInterfaces(msg, registry)
if err != nil {
return err
}
rv.Elem().Set(reflect.ValueOf(msg))
any.cachedValue = msg
return nil
}
// UnpackInterfaces is a convenience function that calls UnpackInterfaces
// on x if x implements UnpackInterfacesMessage
func UnpackInterfaces(x interface{}, unpacker AnyUnpacker) error {
if msg, ok := x.(UnpackInterfacesMessage); ok {
return msg.UnpackInterfaces(unpacker)
}
return nil
}

120
codec/types/types_test.go Normal file
View File

@ -0,0 +1,120 @@
package types_test
import (
"testing"
"github.com/cosmos/cosmos-sdk/codec/types"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/codec/testdata"
)
func NewTestInterfaceRegistry() types.InterfaceRegistry {
registry := types.NewInterfaceRegistry()
registry.RegisterInterface("Animal", (*testdata.Animal)(nil))
registry.RegisterImplementations(
(*testdata.Animal)(nil),
&testdata.Dog{},
&testdata.Cat{},
)
return registry
}
func TestPackUnpack(t *testing.T) {
registry := NewTestInterfaceRegistry()
spot := &testdata.Dog{Name: "Spot"}
any := types.Any{}
err := any.Pack(spot)
require.NoError(t, err)
require.Equal(t, spot, any.GetCachedValue())
// without cache
any.ClearCachedValue()
var animal testdata.Animal
err = registry.UnpackAny(&any, &animal)
require.NoError(t, err)
require.Equal(t, spot, animal)
// with cache
err = any.Pack(spot)
require.Equal(t, spot, any.GetCachedValue())
require.NoError(t, err)
err = registry.UnpackAny(&any, &animal)
require.NoError(t, err)
require.Equal(t, spot, animal)
}
func TestMarshalAny(t *testing.T) {
registry := types.NewInterfaceRegistry()
kitty := &testdata.Cat{Moniker: "Kitty"}
bz, err := types.MarshalAny(kitty)
require.NoError(t, err)
var animal testdata.Animal
// empty registry should fail
err = types.UnmarshalAny(registry, &animal, bz)
require.Error(t, err)
// wrong type registration should fail
registry.RegisterImplementations((*testdata.Animal)(nil), &testdata.Dog{})
err = types.UnmarshalAny(registry, &animal, bz)
require.Error(t, err)
// should pass
registry = NewTestInterfaceRegistry()
err = types.UnmarshalAny(registry, &animal, bz)
require.NoError(t, err)
require.Equal(t, kitty, animal)
// nil should fail
registry = NewTestInterfaceRegistry()
err = types.UnmarshalAny(registry, nil, bz)
}
type TestI interface {
DoSomething()
}
func TestRegister(t *testing.T) {
registry := types.NewInterfaceRegistry()
registry.RegisterInterface("Animal", (*testdata.Animal)(nil))
registry.RegisterInterface("TestI", (*TestI)(nil))
require.NotPanics(t, func() {
registry.RegisterImplementations((*testdata.Animal)(nil), &testdata.Dog{})
})
require.Panics(t, func() {
registry.RegisterImplementations((*TestI)(nil), &testdata.Dog{})
})
require.Panics(t, func() {
registry.RegisterImplementations((*TestI)(nil), nil)
})
}
func TestUnpackInterfaces(t *testing.T) {
registry := NewTestInterfaceRegistry()
spot := &testdata.Dog{Name: "Spot"}
any, err := types.NewAnyWithValue(spot)
require.NoError(t, err)
hasAny := testdata.HasAnimal{
Animal: any,
X: 1,
}
bz, err := hasAny.Marshal()
require.NoError(t, err)
var hasAny2 testdata.HasAnimal
err = hasAny2.Unmarshal(bz)
require.NoError(t, err)
err = types.UnpackInterfaces(hasAny2, registry)
require.NoError(t, err)
require.Equal(t, spot, hasAny2.Animal.GetCachedValue())
}

6
docs/architecture/adr-019-protobuf-state-encoding.md
View File

@ -262,13 +262,13 @@ To implement the `UnpackInterfaces` phase of deserialization which unpacks
interfaces wrapped in `Any` before they're needed, we create an interface
that `sdk.Msg`s and other types can implement:
```go
type UnpackInterfacesMsg interface {
type UnpackInterfacesMessage interface {
UnpackInterfaces(InterfaceUnpacker) error
}
```
We also introduce a private `cachedValue interface{}` field onto the `Any`
struct itself with a public getter `GetUnpackedValue() interface{}`.
struct itself with a public getter `GetCachedValue() interface{}`.
The `UnpackInterfaces` method is to be invoked during message deserialization right
after `Unmarshal` and any interface values packed in `Any`s will be decoded
@ -295,7 +295,7 @@ func (msg MsgSubmitEvidence) UnpackInterfaces(ctx sdk.InterfaceRegistry) error {
}
func (msg MsgSubmitEvidence) GetEvidence() eviexported.Evidence {
return msg.Evidence.GetUnpackedValue().(eviexported.Evidence)
return msg.Evidence.GetCachedValue().(eviexported.Evidence)
}
```

18
scripts/protocgen-any.sh Executable file
View File

@ -0,0 +1,18 @@
#!/usr/bin/env bash
# This script generates a custom wrapper for google.protobuf.Any in
# codec/types/any.pb.go with a custom generated struct that lives in
# codec/types/any.go
set -eo pipefail
go install github.com/gogo/protobuf/protoc-gen-gogotypes
protoc -I. --gogotypes_out=./codec/types third_party/proto/google/protobuf/any.proto
mv codec/types/third_party/proto/google/protobuf/any.pb.go codec/types
rm -rf codec/types/third_party
# This removes the call to RegisterType in the custom generated Any wrapper
# so that only the Any type provided by gogo protobuf is registered in the
# global gogo protobuf type registry, which we aren't actually using
sed '/proto\.RegisterType/d' codec/types/any.pb.go > tmp && mv tmp codec/types/any.pb.go

3
scripts/protocgen.sh
View File

@ -6,6 +6,7 @@ proto_dirs=$(find . -path ./third_party -prune -o -name '*.proto' -print0 | xarg
for dir in $proto_dirs; do
protoc \
-I. \
--gocosmos_out=plugins=interfacetype,paths=source_relative:. \
--gocosmos_out=plugins=interfacetype,paths=source_relative,\
Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \
$(find "${dir}" -name '*.proto')
done

35
simapp/app.go
View File

@ -4,6 +4,8 @@ import (
"io"
"os"
"github.com/cosmos/cosmos-sdk/codec/types"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/libs/log"
tmos "github.com/tendermint/tendermint/libs/os"
@ -94,7 +96,8 @@ var _ App = (*SimApp)(nil)
// capabilities aren't needed for testing.
type SimApp struct {
*baseapp.BaseApp
cdc *codec.Codec
cdc *codec.Codec
appCodec *std.Codec
invCheckPeriod uint
@ -140,8 +143,7 @@ func NewSimApp(
) *SimApp {
// TODO: Remove cdc in favor of appCodec once all modules are migrated.
cdc := std.MakeCodec(ModuleBasics)
appCodec := std.NewAppCodec(cdc)
appCodec, cdc := MakeCodecs()
bApp := baseapp.NewBaseApp(appName, logger, db, auth.DefaultTxDecoder(cdc), baseAppOptions...)
bApp.SetCommitMultiStoreTracer(traceStore)
@ -159,6 +161,7 @@ func NewSimApp(
app := &SimApp{
BaseApp: bApp,
cdc: cdc,
appCodec: appCodec,
invCheckPeriod: invCheckPeriod,
keys: keys,
tkeys: tkeys,
@ -248,7 +251,7 @@ func NewSimApp(
// create evidence keeper with router
evidenceKeeper := evidence.NewKeeper(
appCodec, keys[evidence.StoreKey], &app.StakingKeeper, app.SlashingKeeper,
evidence.NewAnyCodec(appCodec), keys[evidence.StoreKey], &app.StakingKeeper, app.SlashingKeeper,
)
evidenceRouter := evidence.NewRouter().
AddRoute(ibcclient.RouterKey, ibcclient.HandlerClientMisbehaviour(app.IBCKeeper.ClientKeeper))
@ -270,7 +273,7 @@ func NewSimApp(
distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper),
staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper),
upgrade.NewAppModule(app.UpgradeKeeper),
evidence.NewAppModule(appCodec, app.EvidenceKeeper),
evidence.NewAppModule(app.EvidenceKeeper),
ibc.NewAppModule(app.IBCKeeper),
params.NewAppModule(app.ParamsKeeper),
transferModule,
@ -314,7 +317,7 @@ func NewSimApp(
distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper),
slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper),
params.NewAppModule(app.ParamsKeeper),
evidence.NewAppModule(appCodec, app.EvidenceKeeper),
evidence.NewAppModule(app.EvidenceKeeper),
)
app.sm.RegisterStoreDecoders()
@ -354,6 +357,18 @@ func NewSimApp(
return app
}
// MakeCodecs constructs the *std.Codec and *codec.Codec instances used by
// simapp. It is useful for tests and clients who do not want to construct the
// full simapp
func MakeCodecs() (*std.Codec, *codec.Codec) {
cdc := std.MakeCodec(ModuleBasics)
interfaceRegistry := types.NewInterfaceRegistry()
sdk.RegisterInterfaces(interfaceRegistry)
ModuleBasics.RegisterInterfaceModules(interfaceRegistry)
appCodec := std.NewAppCodec(cdc, interfaceRegistry)
return appCodec, cdc
}
// Name returns the name of the App
func (app *SimApp) Name() string { return app.BaseApp.Name() }
@ -407,6 +422,14 @@ func (app *SimApp) Codec() *codec.Codec {
return app.cdc
}
// AppCodec returns SimApp's app codec.
//
// NOTE: This is solely to be used for testing purposes as it may be desirable
// for modules to register their own custom testing types.
func (app *SimApp) AppCodec() *std.Codec {
return app.appCodec
}
// GetKey returns the KVStoreKey for the provided store key.
//
// NOTE: This is solely to be used for testing purposes.

5
simapp/cmd/simcli/main.go
View File

@ -5,8 +5,6 @@ import (
"os"
"path"
"github.com/cosmos/cosmos-sdk/std"
"github.com/spf13/cobra"
"github.com/spf13/viper"
"github.com/tendermint/go-amino"
@ -26,8 +24,7 @@ import (
)
var (
cdc = std.MakeCodec(simapp.ModuleBasics)
appCodec = std.NewAppCodec(cdc)
appCodec, cdc = simapp.MakeCodecs()
)
func init() {

5
simapp/cmd/simd/main.go
View File

@ -4,8 +4,6 @@ import (
"encoding/json"
"io"
"github.com/cosmos/cosmos-sdk/std"
"github.com/spf13/cobra"
"github.com/spf13/viper"
abci "github.com/tendermint/tendermint/abci/types"
@ -31,8 +29,7 @@ const flagInvCheckPeriod = "inv-check-period"
var invCheckPeriod uint
func main() {
cdc := std.MakeCodec(simapp.ModuleBasics)
appCodec := std.NewAppCodec(cdc)
appCodec, cdc := simapp.MakeCodecs()
config := sdk.GetConfig()
config.SetBech32PrefixForAccount(sdk.Bech32PrefixAccAddr, sdk.Bech32PrefixAccPub)

56
std/codec.go
View File

@ -2,6 +2,7 @@ package std
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/module"
"github.com/cosmos/cosmos-sdk/x/auth"
@ -9,16 +10,13 @@ import (
"github.com/cosmos/cosmos-sdk/x/auth/vesting"
"github.com/cosmos/cosmos-sdk/x/bank"
bankexported "github.com/cosmos/cosmos-sdk/x/bank/exported"
"github.com/cosmos/cosmos-sdk/x/evidence"
eviexported "github.com/cosmos/cosmos-sdk/x/evidence/exported"
gov "github.com/cosmos/cosmos-sdk/x/gov/types"
)
var (
_ auth.Codec = (*Codec)(nil)
_ bank.Codec = (*Codec)(nil)
_ evidence.Codec = (*Codec)(nil)
_ gov.Codec = (*Codec)(nil)
_ auth.Codec = (*Codec)(nil)
_ bank.Codec = (*Codec)(nil)
_ gov.Codec = (*Codec)(nil)
)
// Codec defines the application-level codec. This codec contains all the
@ -29,10 +27,12 @@ type Codec struct {
// Keep reference to the amino codec to allow backwards compatibility along
// with type, and interface registration.
amino *codec.Codec
anyUnpacker types.AnyUnpacker
}
func NewAppCodec(amino *codec.Codec) *Codec {
return &Codec{Marshaler: codec.NewHybridCodec(amino), amino: amino}
func NewAppCodec(amino *codec.Codec, anyUnpacker types.AnyUnpacker) *Codec {
return &Codec{Marshaler: codec.NewHybridCodec(amino, anyUnpacker), amino: amino, anyUnpacker: anyUnpacker}
}
// MarshalAccount marshals an Account interface. If the given type implements
@ -113,46 +113,6 @@ func (c *Codec) UnmarshalSupplyJSON(bz []byte) (bankexported.SupplyI, error) {
return supply.GetSupplyI(), nil
}
// MarshalEvidence marshals an Evidence interface. If the given type implements
// the Marshaler interface, it is treated as a Proto-defined message and
// serialized that way. Otherwise, it falls back on the internal Amino codec.
func (c *Codec) MarshalEvidence(evidenceI eviexported.Evidence) ([]byte, error) {
evidence := &Evidence{}
if err := evidence.SetEvidence(evidenceI); err != nil {
return nil, err
}
return c.Marshaler.MarshalBinaryBare(evidence)
}
// UnmarshalEvidence returns an Evidence interface from raw encoded evidence
// bytes of a Proto-based Evidence type. An error is returned upon decoding
// failure.
func (c *Codec) UnmarshalEvidence(bz []byte) (eviexported.Evidence, error) {
evidence := &Evidence{}
if err := c.Marshaler.UnmarshalBinaryBare(bz, evidence); err != nil {
return nil, err
}
return evidence.GetEvidence(), nil
}
// MarshalEvidenceJSON JSON encodes an evidence object implementing the Evidence
// interface.
func (c *Codec) MarshalEvidenceJSON(evidence eviexported.Evidence) ([]byte, error) {
return c.Marshaler.MarshalJSON(evidence)
}
// UnmarshalEvidenceJSON returns an Evidence from JSON encoded bytes
func (c *Codec) UnmarshalEvidenceJSON(bz []byte) (eviexported.Evidence, error) {
evidence := &Evidence{}
if err := c.Marshaler.UnmarshalJSON(bz, evidence); err != nil {
return nil, err
}
return evidence.GetEvidence(), nil
}
// MarshalProposal marshals a Proposal. It accepts a Proposal defined by the x/gov
// module and uses the application-level Proposal type which has the concrete
// Content implementation to serialize.

1079
std/codec.pb.go
View File

File diff suppressed because it is too large Load Diff

24
std/codec.proto
View File

@ -9,7 +9,6 @@ import "x/auth/vesting/types/types.proto";
import "x/bank/types/types.proto";
import "x/crisis/types/types.proto";
import "x/distribution/types/types.proto";
import "x/evidence/types/types.proto";
import "x/gov/types/types.proto";
import "x/slashing/types/types.proto";
import "x/staking/types/types.proto";
@ -43,28 +42,6 @@ message Supply {
}
}
// Evidence defines the application-level allowed Evidence to be submitted via a
// MsgSubmitEvidence message.
message Evidence {
option (gogoproto.equal) = true;
option (cosmos_proto.interface_type) = "github.com/cosmos/cosmos-sdk/x/evidence/exported.Evidence";
// sum defines a set of all acceptable concrete Evidence implementations.
oneof sum {
cosmos_sdk.x.evidence.v1.Equivocation equivocation = 1;
}
}
// MsgSubmitEvidence defines the application-level message type for handling
// evidence submission.
message MsgSubmitEvidence {
option (gogoproto.equal) = true;
option (gogoproto.goproto_getters) = false;
cosmos_sdk.x.evidence.v1.MsgSubmitEvidenceBase base = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true];
Evidence evidence = 2;
}
// MsgSubmitProposal defines the application-level message type for handling
// governance proposals.
message MsgSubmitProposal {
@ -124,7 +101,6 @@ message Message {
cosmos_sdk.x.distribution.v1.MsgWithdrawDelegatorReward msg_withdraw_delegator_reward = 5;
cosmos_sdk.x.distribution.v1.MsgWithdrawValidatorCommission msg_withdraw_validator_commission = 6;
cosmos_sdk.x.distribution.v1.MsgFundCommunityPool msg_fund_community_pool = 7;
MsgSubmitEvidence msg_submit_evidence = 8;
MsgSubmitProposal msg_submit_proposal = 9;
cosmos_sdk.x.gov.v1.MsgVote msg_vote = 10;
cosmos_sdk.x.gov.v1.MsgDeposit msg_deposit = 11;

38
std/msgs.go
View File

@ -3,49 +3,13 @@ package std
import (
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/x/evidence"
eviexported "github.com/cosmos/cosmos-sdk/x/evidence/exported"
gov "github.com/cosmos/cosmos-sdk/x/gov/types"
)
var (
_ eviexported.MsgSubmitEvidence = MsgSubmitEvidence{}
_ gov.MsgSubmitProposalI = &MsgSubmitProposal{}
_ gov.MsgSubmitProposalI = &MsgSubmitProposal{}
)
// NewMsgSubmitEvidence returns a new MsgSubmitEvidence.
func NewMsgSubmitEvidence(evidenceI eviexported.Evidence, s sdk.AccAddress) (MsgSubmitEvidence, error) {
e := &Evidence{}
if err := e.SetEvidence(evidenceI); err != nil {
return MsgSubmitEvidence{}, err
}
return MsgSubmitEvidence{
Evidence: e,
MsgSubmitEvidenceBase: evidence.NewMsgSubmitEvidenceBase(s),
}, nil
}
// ValidateBasic performs basic (non-state-dependant) validation on a
// MsgSubmitEvidence.
func (msg MsgSubmitEvidence) ValidateBasic() error {
if err := msg.MsgSubmitEvidenceBase.ValidateBasic(); err != nil {
return nil
}
if msg.Evidence == nil {
return sdkerrors.Wrap(evidence.ErrInvalidEvidence, "missing evidence")
}
if err := msg.Evidence.GetEvidence().ValidateBasic(); err != nil {
return err
}
return nil
}
// nolint
func (msg MsgSubmitEvidence) GetEvidence() eviexported.Evidence { return msg.Evidence.GetEvidence() }
func (msg MsgSubmitEvidence) GetSubmitter() sdk.AccAddress { return msg.Submitter }
// NewMsgSubmitProposal returns a new MsgSubmitProposal.
func NewMsgSubmitProposal(c gov.Content, d sdk.Coins, p sdk.AccAddress) (gov.MsgSubmitProposalI, error) {
content := &Content{}

18
std/msgs_test.go
View File

@ -2,7 +2,6 @@ package std_test
import (
"testing"
"time"
gov "github.com/cosmos/cosmos-sdk/x/gov/types"
@ -10,25 +9,8 @@ import (
"github.com/cosmos/cosmos-sdk/std"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/evidence"
)
func TestNewMsgSubmitEvidence(t *testing.T) {
s := sdk.AccAddress("foo")
e := evidence.Equivocation{
Height: 100,
Time: time.Now().UTC(),
Power: 40000000000,
ConsensusAddress: sdk.ConsAddress("test"),
}
msg, err := std.NewMsgSubmitEvidence(e, s)
require.NoError(t, err)
require.Equal(t, msg.GetEvidence(), &e)
require.Equal(t, msg.GetSubmitter(), s)
require.NoError(t, msg.ValidateBasic())
}
type invalidProposal struct {
*gov.TextProposal
}

4
tests/cli/simd_test.go
View File

@ -11,6 +11,7 @@ import (
"github.com/stretchr/testify/require"
tmtypes "github.com/tendermint/tendermint/types"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/std"
"github.com/cosmos/cosmos-sdk/tests/cli"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -98,7 +99,8 @@ func TestCLISimdAddGenesisAccount(t *testing.T) {
genesisState := f.GenesisState()
appCodec := std.NewAppCodec(f.Cdc)
interfaceRegistry := codectypes.NewInterfaceRegistry()
appCodec := std.NewAppCodec(f.Cdc, interfaceRegistry)
accounts := auth.GetGenesisStateFromAppState(appCodec, genesisState).Accounts
balances := bank.GetGenesisStateFromAppState(f.Cdc, genesisState).Balances

161
third_party/proto/google/protobuf/any.proto vendored Normal file
View File

@ -0,0 +1,161 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
import "third_party/proto/gogoproto/gogo.proto";
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option go_package = "types";
option java_package = "com.google.protobuf";
option java_outer_classname = "AnyProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// `Any` contains an arbitrary serialized protocol buffer message along with a
// URL that describes the type of the serialized message.
//
// Protobuf library provides support to pack/unpack Any values in the form
// of utility functions or additional generated methods of the Any type.
//
// Example 1: Pack and unpack a message in C++.
//
// Foo foo = ...;
// Any any;
// any.PackFrom(foo);
// ...
// if (any.UnpackTo(&foo)) {
// ...
// }
//
// Example 2: Pack and unpack a message in Java.
//
// Foo foo = ...;
// Any any = Any.pack(foo);
// ...
// if (any.is(Foo.class)) {
// foo = any.unpack(Foo.class);
// }
//
// Example 3: Pack and unpack a message in Python.
//
// foo = Foo(...)
// any = Any()
// any.Pack(foo)
// ...
// if any.Is(Foo.DESCRIPTOR):
// any.Unpack(foo)
// ...
//
// Example 4: Pack and unpack a message in Go
//
// foo := &pb.Foo{...}
// any, err := ptypes.MarshalAny(foo)
// ...
// foo := &pb.Foo{}
// if err := ptypes.UnmarshalAny(any, foo); err != nil {
// ...
// }
//
// The pack methods provided by protobuf library will by default use
// 'type.googleapis.com/full.type.name' as the type URL and the unpack
// methods only use the fully qualified type name after the last '/'
// in the type URL, for example "foo.bar.com/x/y.z" will yield type
// name "y.z".
//
//
// JSON
// ====
// The JSON representation of an `Any` value uses the regular
// representation of the deserialized, embedded message, with an
// additional field `@type` which contains the type URL. Example:
//
// package google.profile;
// message Person {
// string first_name = 1;
// string last_name = 2;
// }
//
// {
// "@type": "type.googleapis.com/google.profile.Person",
// "firstName": <string>,
// "lastName": <string>
// }
//
// If the embedded message type is well-known and has a custom JSON
// representation, that representation will be embedded adding a field
// `value` which holds the custom JSON in addition to the `@type`
// field. Example (for message [google.protobuf.Duration][]):
//
// {
// "@type": "type.googleapis.com/google.protobuf.Duration",
// "value": "1.212s"
// }
//
message Any {
// 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.
//
string type_url = 1;
// Must be a valid serialized protocol buffer of the above specified type.
bytes value = 2;
option (gogoproto.typedecl) = false;
}
option (gogoproto.goproto_registration) = false;

7
types/codec.go
View File

@ -3,6 +3,8 @@ package types
import (
jsonc "github.com/gibson042/canonicaljson-go"
"github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/codec"
)
@ -12,6 +14,11 @@ func RegisterCodec(cdc *codec.Codec) {
cdc.RegisterInterface((*Tx)(nil), nil)
}
// Register the sdk message type
func RegisterInterfaces(registry types.InterfaceRegistry) {
registry.RegisterInterface("cosmos_sdk.v1.Msg", (*Msg)(nil))
}
// CanonicalSignBytes returns a canonical JSON encoding of a Proto message that
// can be signed over. The JSON encoding ensures all field names adhere to their
// Proto definition, default values are omitted, and follows the JSON Canonical

21
types/module/interface_module.go Normal file
View File

@ -0,0 +1,21 @@
package module
import "github.com/cosmos/cosmos-sdk/codec/types"
// InterfaceModule is an interface that modules can implement in order to
// register their interfaces and implementations in an InterfaceRegistry
type InterfaceModule interface {
RegisterInterfaceTypes(registry types.InterfaceRegistry)
}
// RegisterInterfaceModules calls RegisterInterfaceTypes with the registry
// parameter on all of the modules which implement InterfaceModule in the manager
func (bm BasicManager) RegisterInterfaceModules(registry types.InterfaceRegistry) {
for _, m := range bm {
im, ok := m.(InterfaceModule)
if !ok {
continue
}
im.RegisterInterfaceTypes(registry)
}
}

1
x/auth/alias.go
View File

@ -68,7 +68,6 @@ var (
NewModuleAccount = types.NewModuleAccount
// variable aliases
ModuleCdc = types.ModuleCdc
AddressStoreKeyPrefix = types.AddressStoreKeyPrefix
GlobalAccountNumberKey = types.GlobalAccountNumberKey
KeyMaxMemoCharacters = types.KeyMaxMemoCharacters

6
x/auth/keeper/keeper_test.go
View File

@ -3,11 +3,11 @@ package keeper_test
import (
"testing"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/std"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/auth/types"
@ -108,7 +108,7 @@ func TestSupply_ValidatePermissions(t *testing.T) {
maccPerms[multiPerm] = []string{types.Burner, types.Minter, types.Staking}
maccPerms[randomPerm] = []string{"random"}
appCodec := std.NewAppCodec(app.Codec())
appCodec := std.NewAppCodec(app.Codec(), codectypes.NewInterfaceRegistry())
keeper := auth.NewAccountKeeper(
appCodec, app.GetKey(types.StoreKey), app.GetSubspace(types.ModuleName),
types.ProtoBaseAccount, maccPerms,

4
x/auth/simulation/decoder_test.go
View File

@ -4,8 +4,6 @@ import (
"fmt"
"testing"
"github.com/cosmos/cosmos-sdk/std"
gogotypes "github.com/gogo/protobuf/types"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
@ -23,7 +21,7 @@ var (
)
func TestDecodeStore(t *testing.T) {
cdc := std.NewAppCodec(std.MakeCodec(simapp.ModuleBasics))
cdc, _ := simapp.MakeCodecs()
acc := types.NewBaseAccountWithAddress(delAddr1)
dec := simulation.NewDecodeStore(cdc)

9
x/auth/types/codec.go
View File

@ -32,19 +32,10 @@ func RegisterCodec(cdc *codec.Codec) {
// another module for the internal ModuleCdc.
func RegisterKeyTypeCodec(o interface{}, name string) {
amino.RegisterConcrete(o, name, nil)
ModuleCdc = codec.NewHybridCodec(amino)
}
var (
amino = codec.New()
// ModuleCdc references the global x/auth module codec. Note, the codec should
// ONLY be used in certain instances of tests and for JSON encoding as Amino is
// still used for that purpose.
//
// The actual codec used for serialization should be provided to x/auth and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
)
func init() {

5
x/auth/types/common_test.go
View File

@ -2,10 +2,9 @@ package types_test
import (
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/std"
)
var (
app = simapp.Setup(false)
appCodec = std.NewAppCodec(app.Codec())
app = simapp.Setup(false)
appCodec, _ = simapp.MakeCodecs()
)

5
x/auth/vesting/types/common_test.go
View File

@ -2,10 +2,9 @@ package types_test
import (
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/std"
)
var (
app = simapp.Setup(false)
appCodec = std.NewAppCodec(app.Codec())
app = simapp.Setup(false)
appCodec, _ = simapp.MakeCodecs()
)

8
x/bank/keeper/keeper_test.go
View File

@ -4,8 +4,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
tmkv "github.com/tendermint/tendermint/libs/kv"
@ -92,7 +90,7 @@ func (suite *IntegrationTestSuite) TestSupply() {
func (suite *IntegrationTestSuite) TestSupply_SendCoins() {
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{Height: 1})
appCodec := std.NewAppCodec(app.Codec())
appCodec := app.AppCodec()
// add module accounts to supply keeper
maccPerms := simapp.GetMaccPerms()
@ -155,7 +153,7 @@ func (suite *IntegrationTestSuite) TestSupply_SendCoins() {
func (suite *IntegrationTestSuite) TestSupply_MintCoins() {
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{Height: 1})
appCodec := std.NewAppCodec(app.Codec())
appCodec := app.AppCodec()
// add module accounts to supply keeper
maccPerms := simapp.GetMaccPerms()
@ -209,7 +207,7 @@ func (suite *IntegrationTestSuite) TestSupply_MintCoins() {
func (suite *IntegrationTestSuite) TestSupply_BurnCoins() {
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{Height: 1})
appCodec := std.NewAppCodec(app.Codec())
appCodec, _ := simapp.MakeCodecs()
// add module accounts to supply keeper
maccPerms := simapp.GetMaccPerms()

4
x/bank/simulation/decoder_test.go
View File

@ -4,8 +4,6 @@ import (
"fmt"
"testing"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
@ -16,7 +14,7 @@ import (
)
func TestDecodeStore(t *testing.T) {
cdc := std.NewAppCodec(std.MakeCodec(simapp.ModuleBasics))
cdc, _ := simapp.MakeCodecs()
dec := simulation.NewDecodeStore(cdc)
totalSupply := types.NewSupply(sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000)))

3
x/bank/types/codec.go
View File

@ -2,6 +2,7 @@ package types
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/x/bank/exported"
)
@ -35,7 +36,7 @@ var (
//
// The actual codec used for serialization should be provided to x/staking and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
ModuleCdc = codec.NewHybridCodec(amino, types.NewInterfaceRegistry())
)
func init() {

1
x/capability/alias.go
View File

@ -26,7 +26,6 @@ var (
ErrOwnerClaimed = types.ErrOwnerClaimed
ErrCapabilityNotOwned = types.ErrCapabilityNotOwned
RegisterCodec = types.RegisterCodec
ModuleCdc = types.ModuleCdc
NewOwner = types.NewOwner
NewCapabilityOwners = types.NewCapabilityOwners
)

3
x/capability/keeper/keeper_test.go
View File

@ -7,7 +7,6 @@ import (
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/bank"
@ -28,7 +27,7 @@ type KeeperTestSuite struct {
func (suite *KeeperTestSuite) SetupTest() {
checkTx := false
app := simapp.Setup(checkTx)
cdc := codec.NewHybridCodec(app.Codec())
cdc := app.AppCodec()
// create new keeper so we can define custom scoping before init and seal
keeper := keeper.NewKeeper(cdc, app.GetKey(capability.StoreKey), app.GetMemKey(capability.MemStoreKey))

3
x/capability/simulation/decoder_test.go
View File

@ -8,14 +8,13 @@ import (
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
codecstd "github.com/cosmos/cosmos-sdk/std"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/capability/simulation"
"github.com/cosmos/cosmos-sdk/x/capability/types"
)
func TestDecodeStore(t *testing.T) {
cdc := codecstd.NewAppCodec(codecstd.MakeCodec(simapp.ModuleBasics))
cdc, _ := simapp.MakeCodecs()
dec := simulation.NewDecodeStore(cdc)
capOwners := types.CapabilityOwners{

8
x/capability/types/codec.go
View File

@ -14,14 +14,6 @@ func RegisterCodec(cdc *codec.Codec) {
var (
amino = codec.New()
// ModuleCdc references the global x/capability module codec. Note, the codec should
// ONLY be used in certain instances of tests and for JSON encoding as Amino is
// still used for that purpose.
//
// The actual codec used for serialization should be provided to x/capability and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
)
func init() {

3
x/crisis/types/codec.go
View File

@ -2,6 +2,7 @@ package types
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
)
// RegisterCodec registers the necessary x/crisis interfaces and concrete types
@ -19,7 +20,7 @@ var (
//
// The actual codec used for serialization should be provided to x/crisis and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
ModuleCdc = codec.NewHybridCodec(amino, types.NewInterfaceRegistry())
)
func init() {

4
x/distribution/simulation/decoder_test.go
View File

@ -4,8 +4,6 @@ import (
"fmt"
"testing"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
@ -25,7 +23,7 @@ var (
)
func TestDecodeDistributionStore(t *testing.T) {
cdc := std.NewAppCodec(std.MakeCodec(simapp.ModuleBasics))
cdc, _ := simapp.MakeCodecs()
dec := simulation.NewDecodeStore(cdc)
decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, sdk.OneDec())}

3
x/distribution/types/codec.go
View File

@ -2,6 +2,7 @@ package types
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
)
// RegisterCodec registers the necessary x/distribution interfaces and concrete types
@ -22,7 +23,7 @@ var (
//
// The actual codec used for serialization should be provided to x/distribution and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
ModuleCdc = codec.NewHybridCodec(amino, types.NewInterfaceRegistry())
)
func init() {

2
x/evidence/abci.go
View File

@ -16,7 +16,7 @@ func BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock, k Keeper) {
switch tmEvidence.Type {
case tmtypes.ABCIEvidenceTypeDuplicateVote:
evidence := ConvertDuplicateVoteEvidence(tmEvidence)
k.HandleDoubleSign(ctx, evidence.(Equivocation))
k.HandleDoubleSign(ctx, evidence.(*Equivocation))
default:
k.Logger(ctx).Error(fmt.Sprintf("ignored unknown evidence type: %s", tmEvidence.Type))

17
x/evidence/alias.go
View File

@ -24,11 +24,13 @@ var (
NewKeeper = keeper.NewKeeper
NewQuerier = keeper.NewQuerier
NewMsgSubmitEvidenceBase = types.NewMsgSubmitEvidenceBase
NewMsgSubmitEvidence = types.NewMsgSubmitEvidence
NewRouter = types.NewRouter
NewQueryEvidenceParams = types.NewQueryEvidenceParams
NewQueryAllEvidenceParams = types.NewQueryAllEvidenceParams
NewAnyCodec = types.NewAnyCodec
RegisterCodec = types.RegisterCodec
RegisterInterfaces = types.RegisterInterfaces
ModuleCdc = types.ModuleCdc
NewGenesisState = types.NewGenesisState
DefaultGenesisState = types.DefaultGenesisState
@ -43,10 +45,11 @@ var (
type (
Keeper = keeper.Keeper
GenesisState = types.GenesisState
MsgSubmitEvidenceBase = types.MsgSubmitEvidenceBase
Handler = types.Handler
Router = types.Router
Equivocation = types.Equivocation
Codec = types.Codec
GenesisState = types.GenesisState
MsgSubmitEvidence = types.MsgSubmitEvidence
Handler = types.Handler
Router = types.Router
Equivocation = types.Equivocation
Codec = types.Codec
AnyCodec = types.AnyCodec
)

4
x/evidence/genesis_test.go
View File

@ -35,7 +35,7 @@ func (suite *GenesisTestSuite) TestInitGenesis_Valid() {
testEvidence := make([]exported.Evidence, 100)
for i := 0; i < 100; i++ {
testEvidence[i] = types.Equivocation{
testEvidence[i] = &types.Equivocation{
Height: int64(i + 1),
Power: 100,
Time: time.Now().UTC(),
@ -58,7 +58,7 @@ func (suite *GenesisTestSuite) TestInitGenesis_Invalid() {
testEvidence := make([]exported.Evidence, 100)
for i := 0; i < 100; i++ {
testEvidence[i] = types.Equivocation{
testEvidence[i] = &types.Equivocation{
Power: 100,
Time: time.Now().UTC(),
ConsensusAddress: pk.PubKey().Address().Bytes(),

8
x/evidence/handler.go
View File

@ -11,14 +11,10 @@ func NewHandler(k Keeper) sdk.Handler {
ctx = ctx.WithEventManager(sdk.NewEventManager())
switch msg := msg.(type) {
case MsgSubmitEvidenceBase:
return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "%T must be extended to support evidence", msg)
case exported.MsgSubmitEvidence:
return handleMsgSubmitEvidence(ctx, k, msg)
default:
msgSubEv, ok := msg.(exported.MsgSubmitEvidence)
if ok {
return handleMsgSubmitEvidence(ctx, k, msgSubEv)
}
return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized %s message type: %T", ModuleName, msg)
}

14
x/evidence/handler_test.go
View File

@ -5,8 +5,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
@ -26,8 +24,8 @@ type HandlerTestSuite struct {
app *simapp.SimApp
}
func testMsgSubmitEvidence(r *require.Assertions, e exported.Evidence, s sdk.AccAddress) std.MsgSubmitEvidence {
msg, err := std.NewMsgSubmitEvidence(e, s)
func testMsgSubmitEvidence(r *require.Assertions, e exported.Evidence, s sdk.AccAddress) exported.MsgSubmitEvidence {
msg, err := evidence.NewMsgSubmitEvidence(s, e)
r.NoError(err)
return msg
}
@ -56,7 +54,7 @@ func (suite *HandlerTestSuite) SetupTest() {
// recreate keeper in order to use custom testing types
evidenceKeeper := evidence.NewKeeper(
std.NewAppCodec(app.Codec()), app.GetKey(evidence.StoreKey),
evidence.NewAnyCodec(app.AppCodec()), app.GetKey(evidence.StoreKey),
app.StakingKeeper, app.SlashingKeeper,
)
router := evidence.NewRouter()
@ -103,10 +101,6 @@ func (suite *HandlerTestSuite) TestMsgSubmitEvidence() {
),
true,
},
{
types.NewMsgSubmitEvidenceBase(s),
true,
},
}
for i, tc := range testCases {
@ -119,7 +113,7 @@ func (suite *HandlerTestSuite) TestMsgSubmitEvidence() {
suite.Require().NoError(err, "unexpected error; tc #%d", i)
suite.Require().NotNil(res, "expected non-nil result; tc #%d", i)
msg := tc.msg.(std.MsgSubmitEvidence)
msg := tc.msg.(exported.MsgSubmitEvidence)
suite.Require().Equal(msg.GetEvidence().Hash().Bytes(), res.Data, "invalid hash; tc #%d", i)
}
}

2
x/evidence/keeper/infraction.go
View File

@ -22,7 +22,7 @@ import (
//
// TODO: Some of the invalid constraints listed above may need to be reconsidered
// in the case of a lunatic attack.
func (k Keeper) HandleDoubleSign(ctx sdk.Context, evidence types.Equivocation) {
func (k Keeper) HandleDoubleSign(ctx sdk.Context, evidence *types.Equivocation) {
logger := k.Logger(ctx)
consAddr := evidence.GetConsensusAddress()

4
x/evidence/keeper/infraction_test.go
View File

@ -45,7 +45,7 @@ func (suite *KeeperTestSuite) TestHandleDoubleSign() {
// double sign less than max age
oldTokens := suite.app.StakingKeeper.Validator(ctx, operatorAddr).GetTokens()
evidence := types.Equivocation{
evidence := &types.Equivocation{
Height: 0,
Time: time.Unix(0, 0),
Power: power,
@ -106,7 +106,7 @@ func (suite *KeeperTestSuite) TestHandleDoubleSign_TooOld() {
)
suite.Equal(amt, suite.app.StakingKeeper.Validator(ctx, operatorAddr).GetBondedTokens())
evidence := types.Equivocation{
evidence := &types.Equivocation{
Height: 0,
Time: ctx.BlockTime(),
Power: power,

4
x/evidence/keeper/keeper.go
View File

@ -165,3 +165,7 @@ func (k Keeper) MustMarshalEvidence(evidence exported.Evidence) []byte {
return bz
}
func (k Keeper) UnmarshalEvidence(bz []byte) (exported.Evidence, error) {
return k.cdc.UnmarshalEvidence(bz)
}

20
x/evidence/keeper/keeper_test.go
View File

@ -6,8 +6,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
@ -58,7 +56,7 @@ func testEquivocationHandler(k interface{}) types.Handler {
return err
}
ee, ok := e.(types.Equivocation)
ee, ok := e.(*types.Equivocation)
if !ok {
return fmt.Errorf("unexpected evidence type: %T", e)
}
@ -84,7 +82,7 @@ func (suite *KeeperTestSuite) SetupTest() {
// recreate keeper in order to use custom testing types
evidenceKeeper := evidence.NewKeeper(
std.NewAppCodec(app.Codec()), app.GetKey(evidence.StoreKey),
evidence.NewAnyCodec(app.AppCodec()), app.GetKey(evidence.StoreKey),
app.StakingKeeper, app.SlashingKeeper,
)
router := evidence.NewRouter()
@ -109,7 +107,7 @@ func (suite *KeeperTestSuite) populateEvidence(ctx sdk.Context, numEvidence int)
for i := 0; i < numEvidence; i++ {
pk := ed25519.GenPrivKey()
evidence[i] = types.Equivocation{
evidence[i] = &types.Equivocation{
Height: 11,
Power: 100,
Time: time.Now().UTC(),
@ -138,7 +136,7 @@ func (suite *KeeperTestSuite) TestSubmitValidEvidence() {
ctx := suite.ctx.WithIsCheckTx(false)
pk := ed25519.GenPrivKey()
e := types.Equivocation{
e := &types.Equivocation{
Height: 1,
Power: 100,
Time: time.Now().UTC(),
@ -149,14 +147,14 @@ func (suite *KeeperTestSuite) TestSubmitValidEvidence() {
res, ok := suite.app.EvidenceKeeper.GetEvidence(ctx, e.Hash())
suite.True(ok)
suite.Equal(&e, res)
suite.Equal(e, res)
}
func (suite *KeeperTestSuite) TestSubmitValidEvidence_Duplicate() {
ctx := suite.ctx.WithIsCheckTx(false)
pk := ed25519.GenPrivKey()
e := types.Equivocation{
e := &types.Equivocation{
Height: 1,
Power: 100,
Time: time.Now().UTC(),
@ -168,13 +166,13 @@ func (suite *KeeperTestSuite) TestSubmitValidEvidence_Duplicate() {
res, ok := suite.app.EvidenceKeeper.GetEvidence(ctx, e.Hash())
suite.True(ok)
suite.Equal(&e, res)
suite.Equal(e, res)
}
func (suite *KeeperTestSuite) TestSubmitInvalidEvidence() {
ctx := suite.ctx.WithIsCheckTx(false)
pk := ed25519.GenPrivKey()
e := types.Equivocation{
e := &types.Equivocation{
Height: 0,
Power: 100,
Time: time.Now().UTC(),
@ -198,7 +196,7 @@ func (suite *KeeperTestSuite) TestIterateEvidence() {
}
func (suite *KeeperTestSuite) TestGetEvidenceHandler() {
handler, err := suite.app.EvidenceKeeper.GetEvidenceHandler(types.Equivocation{}.Route())
handler, err := suite.app.EvidenceKeeper.GetEvidenceHandler((&types.Equivocation{}).Route())
suite.NoError(err)
suite.NotNil(handler)

10
x/evidence/keeper/querier_test.go
View File

@ -3,6 +3,8 @@ package keeper_test
import (
"strings"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/std"
"github.com/cosmos/cosmos-sdk/x/evidence/exported"
@ -18,7 +20,7 @@ const (
func (suite *KeeperTestSuite) TestQueryEvidence_Existing() {
ctx := suite.ctx.WithIsCheckTx(false)
numEvidence := 100
cdc := std.NewAppCodec(suite.app.Codec())
cdc := std.NewAppCodec(suite.app.Codec(), codectypes.NewInterfaceRegistry())
evidence := suite.populateEvidence(ctx, numEvidence)
query := abci.RequestQuery{
@ -37,7 +39,7 @@ func (suite *KeeperTestSuite) TestQueryEvidence_Existing() {
func (suite *KeeperTestSuite) TestQueryEvidence_NonExisting() {
ctx := suite.ctx.WithIsCheckTx(false)
cdc := std.NewAppCodec(suite.app.Codec())
cdc := std.NewAppCodec(suite.app.Codec(), codectypes.NewInterfaceRegistry())
numEvidence := 100
suite.populateEvidence(ctx, numEvidence)
@ -53,7 +55,7 @@ func (suite *KeeperTestSuite) TestQueryEvidence_NonExisting() {
func (suite *KeeperTestSuite) TestQueryAllEvidence() {
ctx := suite.ctx.WithIsCheckTx(false)
cdc := std.NewAppCodec(suite.app.Codec())
cdc := std.NewAppCodec(suite.app.Codec(), codectypes.NewInterfaceRegistry())
numEvidence := 100
suite.populateEvidence(ctx, numEvidence)
@ -73,7 +75,7 @@ func (suite *KeeperTestSuite) TestQueryAllEvidence() {
func (suite *KeeperTestSuite) TestQueryAllEvidence_InvalidPagination() {
ctx := suite.ctx.WithIsCheckTx(false)
cdc := std.NewAppCodec(suite.app.Codec())
cdc := std.NewAppCodec(suite.app.Codec(), codectypes.NewInterfaceRegistry())
numEvidence := 100
suite.populateEvidence(ctx, numEvidence)

14
x/evidence/module.go
View File

@ -5,6 +5,8 @@ import (
"fmt"
"math/rand"
"github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/client/context"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -24,6 +26,7 @@ var (
_ module.AppModule = AppModule{}
_ module.AppModuleBasic = AppModuleBasic{}
_ module.AppModuleSimulation = AppModule{}
_ module.InterfaceModule = AppModuleBasic{}
)
// ----------------------------------------------------------------------------
@ -32,7 +35,6 @@ var (
// AppModuleBasic implements the AppModuleBasic interface for the evidence module.
type AppModuleBasic struct {
cdc Codec
evidenceHandlers []client.EvidenceHandler // client evidence submission handlers
}
@ -95,6 +97,10 @@ func (AppModuleBasic) GetQueryCmd(cdc *codec.Codec) *cobra.Command {
return cli.GetQueryCmd(StoreKey, cdc)
}
func (AppModuleBasic) RegisterInterfaceTypes(registry types.InterfaceRegistry) {
RegisterInterfaces(registry)
}
// ----------------------------------------------------------------------------
// AppModule
// ----------------------------------------------------------------------------
@ -106,9 +112,9 @@ type AppModule struct {
keeper Keeper
}
func NewAppModule(cdc Codec, keeper Keeper) AppModule {
func NewAppModule(keeper Keeper) AppModule {
return AppModule{
AppModuleBasic: AppModuleBasic{cdc: cdc},
AppModuleBasic: AppModuleBasic{},
keeper: keeper,
}
}
@ -192,7 +198,7 @@ func (AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange {
// RegisterStoreDecoder registers a decoder for evidence module's types
func (am AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry) {
sdr[StoreKey] = simulation.NewDecodeStore(am.cdc)
sdr[StoreKey] = simulation.NewDecodeStore(am.keeper)
}
// WeightedOperations returns the all the gov module operations with their respective weights.

8
x/evidence/simulation/decoder.go
View File

@ -4,14 +4,20 @@ import (
"bytes"
"fmt"
"github.com/cosmos/cosmos-sdk/x/evidence/exported"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/x/evidence/types"
)
type EvidenceUnmarshaler interface {
UnmarshalEvidence([]byte) (exported.Evidence, error)
}
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding evidence type.
func NewDecodeStore(cdc types.Codec) func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc EvidenceUnmarshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
switch {
case bytes.Equal(kvA.Key[:1], types.KeyPrefixEvidence):

9
x/evidence/simulation/decoder_test.go
View File

@ -5,8 +5,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
tmkv "github.com/tendermint/tendermint/libs/kv"
@ -18,19 +16,20 @@ import (
)
func TestDecodeStore(t *testing.T) {
cdc := std.NewAppCodec(std.MakeCodec(simapp.ModuleBasics))
m, _ := simapp.MakeCodecs()
cdc := types.NewAnyCodec(m)
dec := simulation.NewDecodeStore(cdc)
delPk1 := ed25519.GenPrivKey().PubKey()
ev := types.Equivocation{
ev := &types.Equivocation{
Height: 10,
Time: time.Now().UTC(),
Power: 1000,
ConsensusAddress: sdk.ConsAddress(delPk1.Address()),
}
evBz, err := cdc.MarshalEvidence(&ev)
evBz, err := cdc.MarshalEvidence(ev)
require.NoError(t, err)
kvPairs := tmkv.Pairs{

78
x/evidence/types/codec.go
View File

@ -1,7 +1,13 @@
package types
import (
"fmt"
"github.com/gogo/protobuf/proto"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/evidence/exported"
)
@ -19,8 +25,17 @@ type Codec interface {
// evidence module.
func RegisterCodec(cdc *codec.Codec) {
cdc.RegisterInterface((*exported.Evidence)(nil), nil)
cdc.RegisterConcrete(MsgSubmitEvidenceBase{}, "cosmos-sdk/MsgSubmitEvidenceBase", nil)
cdc.RegisterConcrete(Equivocation{}, "cosmos-sdk/Equivocation", nil)
cdc.RegisterConcrete(MsgSubmitEvidence{}, "cosmos-sdk/MsgSubmitEvidence", nil)
cdc.RegisterConcrete(&Equivocation{}, "cosmos-sdk/Equivocation", nil)
}
func RegisterInterfaces(registry types.InterfaceRegistry) {
registry.RegisterImplementations((*sdk.Msg)(nil), &MsgSubmitEvidence{})
registry.RegisterInterface(
"cosmos_sdk.evidence.v1.Evidence",
(*exported.Evidence)(nil),
&Equivocation{},
)
}
var (
@ -32,7 +47,7 @@ var (
//
// The actual codec used for serialization should be provided to x/evidence and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
ModuleCdc = codec.NewHybridCodec(amino, types.NewInterfaceRegistry())
)
func init() {
@ -40,3 +55,60 @@ func init() {
codec.RegisterCrypto(amino)
amino.Seal()
}
// AnyCodec is an evidence Codec that marshals evidence using google.protobuf.Any
type AnyCodec struct {
codec.Marshaler
}
// NewAnyCodec returns a new AnyCodec
func NewAnyCodec(marshaler codec.Marshaler) Codec {
return AnyCodec{Marshaler: marshaler}
}
// MarshalEvidence marshals an Evidence interface. If the given type implements
// the Marshaler interface, it is treated as a Proto-defined message and
// serialized that way. Otherwise, it falls back on the internal Amino codec.
func (c AnyCodec) MarshalEvidence(evidenceI exported.Evidence) ([]byte, error) {
return types.MarshalAny(evidenceI)
}
// UnmarshalEvidence returns an Evidence interface from raw encoded evidence
// bytes of a Proto-based Evidence type. An error is returned upon decoding
// failure.
func (c AnyCodec) UnmarshalEvidence(bz []byte) (exported.Evidence, error) {
var evi exported.Evidence
err := types.UnmarshalAny(c, &evi, bz)
if err != nil {
return nil, err
}
return evi, nil
}
// MarshalEvidenceJSON JSON encodes an evidence object implementing the Evidence
// interface.
func (c AnyCodec) MarshalEvidenceJSON(evidence exported.Evidence) ([]byte, error) {
msg, ok := evidence.(proto.Message)
if !ok {
return nil, fmt.Errorf("cannot proto marshal %T", evidence)
}
any, err := types.NewAnyWithValue(msg)
if err != nil {
return nil, err
}
return c.MarshalJSON(any)
}
// UnmarshalEvidenceJSON returns an Evidence from JSON encoded bytes
func (c AnyCodec) UnmarshalEvidenceJSON(bz []byte) (exported.Evidence, error) {
var any types.Any
if err := c.UnmarshalJSON(bz, &any); err != nil {
return nil, err
}
var evi exported.Evidence
if err := c.UnpackAny(&any, &evi); err != nil {
return nil, err
}
return evi, nil
}

8
x/evidence/types/codec_test.go
View File

@ -4,8 +4,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
@ -16,7 +14,7 @@ import (
func TestCodec(t *testing.T) {
app := simapp.Setup(false)
appCodec := std.NewAppCodec(app.Codec())
evidenceCodec := types.NewAnyCodec(app.AppCodec())
pk := ed25519.GenPrivKey()
var e exported.Evidence = &types.Equivocation{
@ -25,10 +23,10 @@ func TestCodec(t *testing.T) {
Power: 100000,
ConsensusAddress: pk.PubKey().Address().Bytes(),
}
bz, err := appCodec.MarshalEvidence(e)
bz, err := evidenceCodec.MarshalEvidence(e)
require.NoError(t, err)
other, err := appCodec.UnmarshalEvidence(bz)
other, err := evidenceCodec.UnmarshalEvidence(bz)
require.NoError(t, err)
require.Equal(t, e, other)
}

16
x/evidence/types/evidence.go
View File

@ -19,26 +19,26 @@ const (
TypeEquivocation = "equivocation"
)
var _ exported.Evidence = (*Equivocation)(nil)
var _ exported.Evidence = &Equivocation{}
// Route returns the Evidence Handler route for an Equivocation type.
func (e Equivocation) Route() string { return RouteEquivocation }
func (e *Equivocation) Route() string { return RouteEquivocation }
// Type returns the Evidence Handler type for an Equivocation type.
func (e Equivocation) Type() string { return TypeEquivocation }
func (e *Equivocation) Type() string { return TypeEquivocation }
func (e Equivocation) String() string {
func (e *Equivocation) String() string {
bz, _ := yaml.Marshal(e)
return string(bz)
}
// Hash returns the hash of an Equivocation object.
func (e Equivocation) Hash() tmbytes.HexBytes {
return tmhash.Sum(ModuleCdc.MustMarshalBinaryBare(&e))
func (e *Equivocation) Hash() tmbytes.HexBytes {
return tmhash.Sum(ModuleCdc.MustMarshalBinaryBare(e))
}
// ValidateBasic performs basic stateless validation checks on an Equivocation object.
func (e Equivocation) ValidateBasic() error {
func (e *Equivocation) ValidateBasic() error {
if e.Time.IsZero() {
return fmt.Errorf("invalid equivocation time: %s", e.Time)
}
@ -83,7 +83,7 @@ func (e Equivocation) GetTotalPower() int64 { return 0 }
// ConvertDuplicateVoteEvidence converts a Tendermint concrete Evidence type to
// SDK Evidence using Equivocation as the concrete type.
func ConvertDuplicateVoteEvidence(dupVote abci.Evidence) exported.Evidence {
return Equivocation{
return &Equivocation{
Height: dupVote.Height,
Power: dupVote.Validator.Power,
ConsensusAddress: sdk.ConsAddress(dupVote.Validator.Address),

4
x/evidence/types/genesis_test.go
View File

@ -22,7 +22,7 @@ func TestGenesisStateValidate_Valid(t *testing.T) {
evidence := make([]exported.Evidence, 100)
for i := 0; i < 100; i++ {
evidence[i] = types.Equivocation{
evidence[i] = &types.Equivocation{
Height: int64(i) + 1,
Power: 100,
Time: time.Now().UTC(),
@ -39,7 +39,7 @@ func TestGenesisStateValidate_Invalid(t *testing.T) {
evidence := make([]exported.Evidence, 100)
for i := 0; i < 100; i++ {
evidence[i] = types.Equivocation{
evidence[i] = &types.Equivocation{
Height: int64(i),
Power: 100,
Time: time.Now().UTC(),

71
x/evidence/types/msgs.go
View File

@ -1,8 +1,14 @@
package types
import (
"fmt"
"github.com/gogo/protobuf/proto"
"github.com/cosmos/cosmos-sdk/codec/types"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/x/evidence/exported"
)
// Message types for the evidence module
@ -11,38 +17,71 @@ const (
)
var (
_ sdk.Msg = MsgSubmitEvidenceBase{}
_ sdk.Msg = MsgSubmitEvidence{}
_ types.UnpackInterfacesMessage = MsgSubmitEvidence{}
_ exported.MsgSubmitEvidence = MsgSubmitEvidence{}
)
// NewMsgSubmitEvidenceBase returns a new MsgSubmitEvidenceBase with a signer/submitter.
// Note, the MsgSubmitEvidenceBase is not to be used as an actual message, but
// rather to be extended with Evidence.
func NewMsgSubmitEvidenceBase(s sdk.AccAddress) MsgSubmitEvidenceBase {
return MsgSubmitEvidenceBase{Submitter: s}
// NewMsgSubmitEvidence returns a new MsgSubmitEvidence with a signer/submitter.
func NewMsgSubmitEvidence(s sdk.AccAddress, evi exported.Evidence) (MsgSubmitEvidence, error) {
msg, ok := evi.(proto.Message)
if !ok {
return MsgSubmitEvidence{}, fmt.Errorf("cannot proto marshal %T", evi)
}
any, err := types.NewAnyWithValue(msg)
if err != nil {
return MsgSubmitEvidence{Submitter: s}, err
}
return MsgSubmitEvidence{Submitter: s, Evidence: any}, nil
}
// Route returns the MsgSubmitEvidenceBase's route.
func (m MsgSubmitEvidenceBase) Route() string { return RouterKey }
// Route returns the MsgSubmitEvidence's route.
func (m MsgSubmitEvidence) Route() string { return RouterKey }
// Type returns the MsgSubmitEvidenceBase's type.
func (m MsgSubmitEvidenceBase) Type() string { return TypeMsgSubmitEvidence }
// Type returns the MsgSubmitEvidence's type.
func (m MsgSubmitEvidence) Type() string { return TypeMsgSubmitEvidence }
// ValidateBasic performs basic (non-state-dependant) validation on a MsgSubmitEvidenceBase.
func (m MsgSubmitEvidenceBase) ValidateBasic() error {
// ValidateBasic performs basic (non-state-dependant) validation on a MsgSubmitEvidence.
func (m MsgSubmitEvidence) ValidateBasic() error {
if m.Submitter.Empty() {
return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, m.Submitter.String())
}
evi := m.GetEvidence()
if evi == nil {
return sdkerrors.Wrap(ErrInvalidEvidence, "missing evidence")
}
if err := evi.ValidateBasic(); err != nil {
return err
}
return nil
}
// GetSignBytes returns the raw bytes a signer is expected to sign when submitting
// a MsgSubmitEvidenceBase message.
func (m MsgSubmitEvidenceBase) GetSignBytes() []byte {
// a MsgSubmitEvidence message.
func (m MsgSubmitEvidence) GetSignBytes() []byte {
return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(m))
}
// GetSigners returns the single expected signer for a MsgSubmitEvidenceBase.
func (m MsgSubmitEvidenceBase) GetSigners() []sdk.AccAddress {
// GetSigners returns the single expected signer for a MsgSubmitEvidence.
func (m MsgSubmitEvidence) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{m.Submitter}
}
func (m MsgSubmitEvidence) GetEvidence() exported.Evidence {
evi, ok := m.Evidence.GetCachedValue().(exported.Evidence)
if !ok {
return nil
}
return evi
}
func (m MsgSubmitEvidence) GetSubmitter() sdk.AccAddress {
return m.Submitter
}
func (m MsgSubmitEvidence) UnpackInterfaces(ctx types.AnyUnpacker) error {
var evi exported.Evidence
return ctx.UnpackAny(m.Evidence, &evi)
}

11
x/evidence/types/msgs_test.go
View File

@ -4,8 +4,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/evidence/exported"
"github.com/cosmos/cosmos-sdk/x/evidence/types"
@ -14,8 +12,8 @@ import (
"github.com/tendermint/tendermint/crypto/ed25519"
)
func testMsgSubmitEvidence(t *testing.T, e exported.Evidence, s sdk.AccAddress) std.MsgSubmitEvidence {
msg, err := std.NewMsgSubmitEvidence(e, s)
func testMsgSubmitEvidence(t *testing.T, e exported.Evidence, s sdk.AccAddress) exported.MsgSubmitEvidence {
msg, err := types.NewMsgSubmitEvidence(s, e)
require.NoError(t, err)
return msg
}
@ -29,11 +27,6 @@ func TestMsgSubmitEvidence(t *testing.T) {
submitter sdk.AccAddress
expectErr bool
}{
{
types.NewMsgSubmitEvidenceBase(submitter),
submitter,
false,
},
{
testMsgSubmitEvidence(t, &types.Equivocation{
Height: 0,

184
x/evidence/types/types.pb.go
View File

@ -6,6 +6,7 @@ package types
import (
bytes "bytes"
fmt "fmt"
types "github.com/cosmos/cosmos-sdk/codec/types"
github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
@ -29,29 +30,25 @@ var _ = time.Kitchen
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// MsgSubmitEvidenceBase defines an sdk.Msg type that supports submitting arbitrary
// MsgSubmitEvidence defines an sdk.Msg type that supports submitting arbitrary
// Evidence.
//
// Note, this message type provides the basis for which a true MsgSubmitEvidence
// can be constructed. Since the evidence submitted in the message can be arbitrary,
// assuming it fulfills the Evidence interface, it must be defined at the
// application-level and extend MsgSubmitEvidenceBase.
type MsgSubmitEvidenceBase struct {
type MsgSubmitEvidence struct {
Submitter github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=submitter,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"submitter,omitempty"`
Evidence *types.Any `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"`
}
func (m *MsgSubmitEvidenceBase) Reset() { *m = MsgSubmitEvidenceBase{} }
func (m *MsgSubmitEvidenceBase) String() string { return proto.CompactTextString(m) }
func (*MsgSubmitEvidenceBase) ProtoMessage() {}
func (*MsgSubmitEvidenceBase) Descriptor() ([]byte, []int) {
func (m *MsgSubmitEvidence) Reset() { *m = MsgSubmitEvidence{} }
func (m *MsgSubmitEvidence) String() string { return proto.CompactTextString(m) }
func (*MsgSubmitEvidence) ProtoMessage() {}
func (*MsgSubmitEvidence) Descriptor() ([]byte, []int) {
return fileDescriptor_72113e6a7b2536ae, []int{0}
}
func (m *MsgSubmitEvidenceBase) XXX_Unmarshal(b []byte) error {
func (m *MsgSubmitEvidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgSubmitEvidenceBase) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *MsgSubmitEvidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgSubmitEvidenceBase.Marshal(b, m, deterministic)
return xxx_messageInfo_MsgSubmitEvidence.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@ -61,24 +58,17 @@ func (m *MsgSubmitEvidenceBase) XXX_Marshal(b []byte, deterministic bool) ([]byt
return b[:n], nil
}
}
func (m *MsgSubmitEvidenceBase) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgSubmitEvidenceBase.Merge(m, src)
func (m *MsgSubmitEvidence) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgSubmitEvidence.Merge(m, src)
}
func (m *MsgSubmitEvidenceBase) XXX_Size() int {
func (m *MsgSubmitEvidence) XXX_Size() int {
return m.Size()
}
func (m *MsgSubmitEvidenceBase) XXX_DiscardUnknown() {
xxx_messageInfo_MsgSubmitEvidenceBase.DiscardUnknown(m)
func (m *MsgSubmitEvidence) XXX_DiscardUnknown() {
xxx_messageInfo_MsgSubmitEvidence.DiscardUnknown(m)
}
var xxx_messageInfo_MsgSubmitEvidenceBase proto.InternalMessageInfo
func (m *MsgSubmitEvidenceBase) GetSubmitter() github_com_cosmos_cosmos_sdk_types.AccAddress {
if m != nil {
return m.Submitter
}
return nil
}
var xxx_messageInfo_MsgSubmitEvidence proto.InternalMessageInfo
// Equivocation implements the Evidence interface and defines evidence of double
// signing misbehavior.
@ -122,49 +112,50 @@ func (m *Equivocation) XXX_DiscardUnknown() {
var xxx_messageInfo_Equivocation proto.InternalMessageInfo
func init() {
proto.RegisterType((*MsgSubmitEvidenceBase)(nil), "cosmos_sdk.x.evidence.v1.MsgSubmitEvidenceBase")
proto.RegisterType((*MsgSubmitEvidence)(nil), "cosmos_sdk.x.evidence.v1.MsgSubmitEvidence")
proto.RegisterType((*Equivocation)(nil), "cosmos_sdk.x.evidence.v1.Equivocation")
}
func init() { proto.RegisterFile("x/evidence/types/types.proto", fileDescriptor_72113e6a7b2536ae) }
var fileDescriptor_72113e6a7b2536ae = []byte{
// 390 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xa9, 0xd0, 0x4f, 0x2d,
0xcb, 0x4c, 0x49, 0xcd, 0x4b, 0x4e, 0xd5, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0x86, 0x90, 0x7a, 0x05,
0x45, 0xf9, 0x25, 0xf9, 0x42, 0x12, 0xc9, 0xf9, 0xc5, 0xb9, 0xf9, 0xc5, 0xf1, 0xc5, 0x29, 0xd9,
0x7a, 0x15, 0x7a, 0x30, 0x85, 0x7a, 0x65, 0x86, 0x52, 0x6a, 0x25, 0x19, 0x99, 0x45, 0x29, 0xf1,
0x05, 0x89, 0x45, 0x25, 0x95, 0xfa, 0x60, 0xc5, 0xfa, 0xe9, 0xf9, 0xe9, 0xf9, 0x08, 0x16, 0xc4,
0x04, 0x29, 0xf9, 0xf4, 0xfc, 0xfc, 0xf4, 0x9c, 0x54, 0x88, 0x92, 0xa4, 0xd2, 0x34, 0xfd, 0x92,
0xcc, 0xdc, 0xd4, 0xe2, 0x92, 0xc4, 0xdc, 0x02, 0x88, 0x02, 0xa5, 0x0c, 0x2e, 0x51, 0xdf, 0xe2,
0xf4, 0xe0, 0xd2, 0xa4, 0xdc, 0xcc, 0x12, 0x57, 0xa8, 0x05, 0x4e, 0x89, 0xc5, 0xa9, 0x42, 0xfe,
0x5c, 0x9c, 0xc5, 0x60, 0xd1, 0x92, 0xd4, 0x22, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x1e, 0x27, 0xc3,
0x5f, 0xf7, 0xe4, 0x75, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x21,
0xae, 0x83, 0x52, 0xba, 0xc5, 0x29, 0xd9, 0x50, 0xc7, 0x3b, 0x26, 0x27, 0x3b, 0xa6, 0xa4, 0x14,
0xa5, 0x16, 0x17, 0x07, 0x21, 0xcc, 0x50, 0xfa, 0xcb, 0xc8, 0xc5, 0xe3, 0x5a, 0x58, 0x9a, 0x59,
0x96, 0x9f, 0x9c, 0x58, 0x92, 0x99, 0x9f, 0x27, 0x24, 0xc6, 0xc5, 0x96, 0x91, 0x9a, 0x99, 0x9e,
0x51, 0x02, 0x36, 0x9e, 0x39, 0x08, 0xca, 0x13, 0xb2, 0xe0, 0x62, 0x01, 0xb9, 0x52, 0x82, 0x49,
0x81, 0x51, 0x83, 0xdb, 0x48, 0x4a, 0x0f, 0xe2, 0x05, 0x3d, 0x98, 0x17, 0xf4, 0x42, 0x60, 0x5e,
0x70, 0xe2, 0x38, 0x71, 0x4f, 0x9e, 0x61, 0xc2, 0x7d, 0x79, 0xc6, 0x20, 0xb0, 0x0e, 0x21, 0x11,
0x2e, 0xd6, 0x82, 0xfc, 0xf2, 0xd4, 0x22, 0x09, 0x66, 0xb0, 0x81, 0x10, 0x8e, 0x50, 0x35, 0x97,
0x60, 0x72, 0x7e, 0x5e, 0x71, 0x6a, 0x5e, 0x71, 0x69, 0x71, 0x7c, 0x22, 0xc4, 0x61, 0x12, 0x2c,
0x60, 0x1f, 0xf9, 0x7d, 0xba, 0x27, 0x2f, 0x51, 0x99, 0x98, 0x9b, 0x63, 0xa5, 0x84, 0xa1, 0x44,
0xe9, 0xd7, 0x3d, 0x79, 0x3d, 0x22, 0x7c, 0xeb, 0x9c, 0x9f, 0x57, 0x0c, 0xf3, 0xae, 0x00, 0xdc,
0x14, 0xa8, 0x88, 0x15, 0x47, 0xc7, 0x02, 0x79, 0x86, 0x19, 0x0b, 0xe4, 0x19, 0x9c, 0xbc, 0x57,
0x3c, 0x92, 0x63, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18,
0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xfc, 0xe1,
0x8a, 0x9e, 0x4a, 0x92, 0xd8, 0xc0, 0xa1, 0x61, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xce, 0x16,
0xee, 0xfa, 0x40, 0x02, 0x00, 0x00,
// 414 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0xbd, 0xae, 0xd3, 0x30,
0x18, 0x8d, 0xb9, 0xe5, 0xaa, 0x98, 0x3b, 0xd0, 0xa8, 0x42, 0xa1, 0x42, 0x71, 0x95, 0x01, 0x75,
0xa9, 0x43, 0x61, 0x41, 0xdd, 0x5a, 0xd4, 0x09, 0x01, 0x52, 0x60, 0x62, 0xa9, 0xf2, 0x63, 0x12,
0xab, 0x4d, 0x1c, 0x62, 0xa7, 0x34, 0xe2, 0x05, 0x18, 0x3b, 0x32, 0x30, 0x74, 0xe4, 0x51, 0x3a,
0x76, 0x64, 0x0a, 0x28, 0x7d, 0x03, 0xc6, 0x4a, 0x48, 0xa8, 0x71, 0xd2, 0x4a, 0xad, 0x84, 0xee,
0x62, 0xfb, 0xfb, 0x7c, 0x7c, 0x7c, 0xce, 0xb1, 0xe1, 0xe3, 0xa5, 0x49, 0x16, 0xd4, 0x23, 0x91,
0x4b, 0x4c, 0x91, 0xc5, 0x84, 0xcb, 0x11, 0xc7, 0x09, 0x13, 0x4c, 0xd5, 0x5c, 0xc6, 0x43, 0xc6,
0xa7, 0xdc, 0x9b, 0xe1, 0x25, 0xae, 0x81, 0x78, 0x31, 0xe8, 0x3c, 0x11, 0x01, 0x4d, 0xbc, 0x69,
0x6c, 0x27, 0x22, 0x33, 0x4b, 0xb0, 0xe9, 0x33, 0x9f, 0x9d, 0x56, 0x92, 0xa1, 0x83, 0x7c, 0xc6,
0xfc, 0x39, 0x91, 0x10, 0x27, 0xfd, 0x68, 0x0a, 0x1a, 0x12, 0x2e, 0xec, 0x30, 0xae, 0x00, 0x8f,
0xce, 0x01, 0x76, 0x94, 0xc9, 0x2d, 0xe3, 0x3b, 0x80, 0xad, 0xd7, 0xdc, 0x7f, 0x97, 0x3a, 0x21,
0x15, 0x93, 0xea, 0x72, 0xf5, 0x2d, 0xbc, 0xc7, 0xcb, 0x8e, 0x20, 0x89, 0x06, 0xba, 0xa0, 0x77,
0x33, 0x1e, 0xec, 0x73, 0xd4, 0xf7, 0xa9, 0x08, 0x52, 0x07, 0xbb, 0x2c, 0x34, 0xa5, 0xea, 0x6a,
0xea, 0x73, 0x6f, 0x56, 0x99, 0x1a, 0xb9, 0xee, 0xc8, 0xf3, 0x12, 0xc2, 0xb9, 0x75, 0xe2, 0x50,
0x9f, 0xc2, 0x66, 0xed, 0x4c, 0xbb, 0xd3, 0x05, 0xbd, 0xfb, 0xcf, 0xda, 0x58, 0x8a, 0xc2, 0xb5,
0x28, 0x3c, 0x8a, 0x32, 0xeb, 0x88, 0x1a, 0x36, 0xbe, 0xae, 0x91, 0x62, 0xfc, 0x05, 0xf0, 0x66,
0xf2, 0x29, 0xa5, 0x0b, 0xe6, 0xda, 0x82, 0xb2, 0x48, 0x7d, 0x08, 0xaf, 0x03, 0x42, 0xfd, 0x40,
0x94, 0xb2, 0xae, 0xac, 0xaa, 0x52, 0x5f, 0xc0, 0xc6, 0xc1, 0x75, 0x45, 0xde, 0xb9, 0x20, 0x7f,
0x5f, 0x47, 0x32, 0x6e, 0x6e, 0x72, 0xa4, 0xac, 0x7e, 0x21, 0x60, 0x95, 0x27, 0xd4, 0x36, 0xbc,
0x1b, 0xb3, 0xcf, 0x24, 0xd1, 0xae, 0x4a, 0x42, 0x59, 0xa8, 0x5f, 0x60, 0xcb, 0x65, 0x11, 0x27,
0x11, 0x4f, 0xf9, 0xd4, 0x96, 0x86, 0xb4, 0x46, 0x99, 0xc4, 0x9b, 0x3f, 0x39, 0xd2, 0x32, 0x3b,
0x9c, 0x0f, 0x8d, 0x0b, 0x88, 0xb1, 0xcf, 0x11, 0xbe, 0x45, 0x4a, 0x2f, 0x59, 0xc4, 0xeb, 0x98,
0x1e, 0x1c, 0x59, 0xaa, 0xce, 0xb0, 0x79, 0xf0, 0xfe, 0x6d, 0x8d, 0x94, 0xf1, 0xab, 0x1f, 0x85,
0x0e, 0x36, 0x85, 0x0e, 0xb6, 0x85, 0x0e, 0x7e, 0x17, 0x3a, 0x58, 0xed, 0x74, 0x65, 0xbb, 0xd3,
0x95, 0x9f, 0x3b, 0x5d, 0xf9, 0xf0, 0xff, 0xf7, 0x38, 0xff, 0x75, 0xce, 0x75, 0x99, 0xc6, 0xf3,
0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x2c, 0xbe, 0x1a, 0x9c, 0x90, 0x02, 0x00, 0x00,
}
func (this *MsgSubmitEvidenceBase) Equal(that interface{}) bool {
func (this *MsgSubmitEvidence) Equal(that interface{}) bool {
if that == nil {
return this == nil
}
that1, ok := that.(*MsgSubmitEvidenceBase)
that1, ok := that.(*MsgSubmitEvidence)
if !ok {
that2, ok := that.(MsgSubmitEvidenceBase)
that2, ok := that.(MsgSubmitEvidence)
if ok {
that1 = &that2
} else {
@ -179,6 +170,9 @@ func (this *MsgSubmitEvidenceBase) Equal(that interface{}) bool {
if !bytes.Equal(this.Submitter, that1.Submitter) {
return false
}
if !this.Evidence.Equal(that1.Evidence) {
return false
}
return true
}
func (this *Equivocation) Equal(that interface{}) bool {
@ -214,7 +208,7 @@ func (this *Equivocation) Equal(that interface{}) bool {
}
return true
}
func (m *MsgSubmitEvidenceBase) Marshal() (dAtA []byte, err error) {
func (m *MsgSubmitEvidence) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -224,16 +218,28 @@ func (m *MsgSubmitEvidenceBase) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *MsgSubmitEvidenceBase) MarshalTo(dAtA []byte) (int, error) {
func (m *MsgSubmitEvidence) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgSubmitEvidenceBase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
func (m *MsgSubmitEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Evidence != nil {
{
size, err := m.Evidence.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
if len(m.Submitter) > 0 {
i -= len(m.Submitter)
copy(dAtA[i:], m.Submitter)
@ -276,12 +282,12 @@ func (m *Equivocation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x18
}
n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
if err1 != nil {
return 0, err1
n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
if err2 != nil {
return 0, err2
}
i -= n1
i = encodeVarintTypes(dAtA, i, uint64(n1))
i -= n2
i = encodeVarintTypes(dAtA, i, uint64(n2))
i--
dAtA[i] = 0x12
if m.Height != 0 {
@ -303,7 +309,7 @@ func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func (m *MsgSubmitEvidenceBase) Size() (n int) {
func (m *MsgSubmitEvidence) Size() (n int) {
if m == nil {
return 0
}
@ -313,6 +319,10 @@ func (m *MsgSubmitEvidenceBase) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.Evidence != nil {
l = m.Evidence.Size()
n += 1 + l + sovTypes(uint64(l))
}
return n
}
@ -343,7 +353,7 @@ func sovTypes(x uint64) (n int) {
func sozTypes(x uint64) (n int) {
return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgSubmitEvidenceBase) Unmarshal(dAtA []byte) error {
func (m *MsgSubmitEvidence) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -366,10 +376,10 @@ func (m *MsgSubmitEvidenceBase) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MsgSubmitEvidenceBase: wiretype end group for non-group")
return fmt.Errorf("proto: MsgSubmitEvidence: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgSubmitEvidenceBase: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: MsgSubmitEvidence: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@ -406,6 +416,42 @@ func (m *MsgSubmitEvidenceBase) Unmarshal(dAtA []byte) error {
m.Submitter = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Evidence", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Evidence == nil {
m.Evidence = &types.Any{}
}
if err := m.Evidence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])

12
x/evidence/types/types.proto
View File

@ -6,16 +6,14 @@ option (gogoproto.equal_all) = true;
import "third_party/proto/gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto";
import "google/protobuf/any.proto";
// MsgSubmitEvidenceBase defines an sdk.Msg type that supports submitting arbitrary
// MsgSubmitEvidence defines an sdk.Msg type that supports submitting arbitrary
// Evidence.
//
// Note, this message type provides the basis for which a true MsgSubmitEvidence
// can be constructed. Since the evidence submitted in the message can be arbitrary,
// assuming it fulfills the Evidence interface, it must be defined at the
// application-level and extend MsgSubmitEvidenceBase.
message MsgSubmitEvidenceBase {
message MsgSubmitEvidence {
option (gogoproto.goproto_getters) = false;
bytes submitter = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
google.protobuf.Any evidence = 2;
}
// Equivocation implements the Evidence interface and defines evidence of double

3
x/gov/keeper/common_test.go
View File

@ -2,7 +2,6 @@ package keeper_test
import (
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/std"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/gov/types"
"github.com/cosmos/cosmos-sdk/x/staking"
@ -17,7 +16,7 @@ func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sd
valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
pks := simapp.CreateTestPubKeys(5)
appCodec := std.NewAppCodec(app.Codec())
appCodec, _ := simapp.MakeCodecs()
app.StakingKeeper = staking.NewKeeper(
appCodec,
app.GetKey(staking.StoreKey),

6
x/gov/keeper/querier_test.go
View File

@ -6,8 +6,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
abci "github.com/tendermint/tendermint/abci/types"
@ -148,7 +146,7 @@ func getQueriedVotes(t *testing.T, ctx sdk.Context, cdc codec.JSONMarshaler, que
func TestQueries(t *testing.T) {
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
appCodec := std.NewAppCodec(app.Codec())
appCodec := app.AppCodec()
querier := keeper.NewQuerier(app.GovKeeper)
@ -296,7 +294,7 @@ func TestQueries(t *testing.T) {
func TestPaginatedVotesQuery(t *testing.T) {
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
appCodec := std.NewAppCodec(app.Codec())
appCodec := app.AppCodec()
proposal := types.Proposal{
ProposalBase: types.ProposalBase{

4
x/gov/simulation/decoder_test.go
View File

@ -6,8 +6,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
@ -25,7 +23,7 @@ var (
)
func TestDecodeStore(t *testing.T) {
cdc := std.NewAppCodec(std.MakeCodec(simapp.ModuleBasics))
cdc, _ := simapp.MakeCodecs()
dec := simulation.NewDecodeStore(cdc)
endTime := time.Now().UTC()

3
x/gov/types/codec.go
View File

@ -2,6 +2,7 @@ package types
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
)
// Codec defines the interface required to serialize custom x/gov types.
@ -42,7 +43,7 @@ var (
//
// The actual codec used for serialization should be provided to x/gov and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
ModuleCdc = codec.NewHybridCodec(amino, types.NewInterfaceRegistry())
)
func init() {

1
x/mint/alias.go
View File

@ -33,7 +33,6 @@ var (
DefaultParams = types.DefaultParams
// variable aliases
ModuleCdc = types.ModuleCdc
MinterKey = types.MinterKey
KeyMintDenom = types.KeyMintDenom
KeyInflationRateChange = types.KeyInflationRateChange

4
x/mint/simulation/decoder_test.go
View File

@ -4,8 +4,6 @@ import (
"fmt"
"testing"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
@ -17,7 +15,7 @@ import (
)
func TestDecodeStore(t *testing.T) {
cdc := std.NewAppCodec(std.MakeCodec(simapp.ModuleBasics))
cdc, _ := simapp.MakeCodecs()
dec := simulation.NewDecodeStore(cdc)
minter := types.NewMinter(sdk.OneDec(), sdk.NewDec(15))

8
x/mint/types/codec.go
View File

@ -6,14 +6,6 @@ import (
var (
amino = codec.New()
// ModuleCdc references the global x/mint module codec. Note, the codec
// should ONLY be used in certain instances of tests and for JSON encoding as
// Amino is still used for that purpose.
//
// The actual codec used for serialization should be provided to x/mint and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
)
func init() {

3
x/params/types/proposal/codec.go
View File

@ -2,6 +2,7 @@ package proposal
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
)
type Codec struct {
@ -13,7 +14,7 @@ type Codec struct {
}
func NewCodec(amino *codec.Codec) *Codec {
return &Codec{Marshaler: codec.NewHybridCodec(amino), amino: amino}
return &Codec{Marshaler: codec.NewHybridCodec(amino, types.NewInterfaceRegistry()), amino: amino}
}
// ModuleCdc is the module codec.

4
x/slashing/simulation/decoder_test.go
View File

@ -5,8 +5,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
gogotypes "github.com/gogo/protobuf/types"
"github.com/stretchr/testify/require"
@ -29,7 +27,7 @@ var (
)
func TestDecodeStore(t *testing.T) {
cdc := std.NewAppCodec(std.MakeCodec(simapp.ModuleBasics))
cdc, _ := simapp.MakeCodecs()
dec := simulation.NewDecodeStore(cdc)
info := types.NewValidatorSigningInfo(consAddr1, 0, 1, time.Now().UTC(), false, 0)

3
x/slashing/types/codec.go
View File

@ -2,6 +2,7 @@ package types
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
)
// RegisterCodec registers concrete types on codec
@ -18,7 +19,7 @@ var (
//
// The actual codec used for serialization should be provided to x/slashing and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
ModuleCdc = codec.NewHybridCodec(amino, types.NewInterfaceRegistry())
)
func init() {

4
x/staking/common_test.go
View File

@ -5,8 +5,6 @@ import (
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/secp256k1"
"github.com/cosmos/cosmos-sdk/std"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -44,7 +42,7 @@ func getBaseSimappWithCustomKeeper() (*codec.Codec, *simapp.SimApp, sdk.Context)
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
appCodec := std.NewAppCodec(codec.New())
appCodec := app.AppCodec()
app.StakingKeeper = keeper.NewKeeper(
appCodec,

4
x/staking/keeper/common_test.go
View File

@ -3,8 +3,6 @@ package keeper_test
import (
"testing"
"github.com/cosmos/cosmos-sdk/std"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/cosmos/cosmos-sdk/codec"
@ -25,7 +23,7 @@ func createTestInput() (*codec.Codec, *simapp.SimApp, sdk.Context) {
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
appCodec := std.NewAppCodec(codec.New())
appCodec := app.AppCodec()
app.StakingKeeper = keeper.NewKeeper(
appCodec,

4
x/staking/simulation/decoder_test.go
View File

@ -5,8 +5,6 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
@ -34,7 +32,7 @@ func makeTestCodec() (cdc *codec.Codec) {
}
func TestDecodeStore(t *testing.T) {
cdc := std.NewAppCodec(std.MakeCodec(simapp.ModuleBasics))
cdc, _ := simapp.MakeCodecs()
dec := simulation.NewDecodeStore(cdc)
bondTime := time.Now().UTC()

3
x/staking/types/codec.go
View File

@ -2,6 +2,7 @@ package types
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
)
// RegisterCodec registers the necessary x/staking interfaces and concrete types
@ -23,7 +24,7 @@ var (
//
// The actual codec used for serialization should be provided to x/staking and
// defined at the application level.
ModuleCdc = codec.NewHybridCodec(amino)
ModuleCdc = codec.NewHybridCodec(amino, types.NewInterfaceRegistry())
)
func init() {