Audit / Refactor proto packages layout (#6905)

* create base proto package, move ValAddresses to staking

* move tx, crypto, query proto packages into base; mark module level packages as beta

* new cosmos/base/abci.proto file, refactor some message names

* add comments to TxResponse

* refactor RegisterInterface calls to new proto package names

* fix bug in merge commit

* move missing module proto packages to beta, move cosmos.kv to cosmos.base.kv

* add tx.proto files, holding proto messages for module Msgs

* rm old generated pb.go files

* cosmos/base/base.proto -> cosmos/base/coin.proto

* mark genutil proto package as beta

* Fix conflicts

* Restructure proto files

* Re put signing

* Fix test

* Update slashing genesis

* Ignore confio proto files

* Fix interface register

* Make proto-gen

* Fix lint

* Put tx service into tx.v1beta1

* Use v1beta1 in interface registry

* Remove to cosmos.base.store

* Remove extra confio in buf

Co-authored-by: Amaury Martiny <amaury.martiny@protonmail.com>
Co-authored-by: Alexander Bezobchuk <alexanderbez@users.noreply.github.com>
Co-authored-by: Federico Kunze <31522760+fedekunze@users.noreply.github.com>

types/codec.go

@@ -6,13 +6,13 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 )
 
-// Register the sdk message type
+// RegisterCodec registers the sdk message type.
 func RegisterCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterInterface((*Msg)(nil), nil)
 	cdc.RegisterInterface((*Tx)(nil), nil)
 }
 
-// Register the sdk message type
+// RegisterInterfaces registers the sdk message type.
 func RegisterInterfaces(registry types.InterfaceRegistry) {
-	registry.RegisterInterface("cosmos_sdk.v1.Msg", (*Msg)(nil))
+	registry.RegisterInterface("cosmos.v1beta1.Msg", (*Msg)(nil))
 }

types/coin.pb.go

@@ -0,0 +1,990 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: cosmos/base/v1beta1/coin.proto
+
+package types
+
+import (
+	fmt "fmt"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// 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
+
+// Coin defines a token with a denomination and an amount.
+//
+// NOTE: The amount field is an Int which implements the custom method
+// signatures required by gogoproto.
+type Coin struct {
+	Denom  string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
+	Amount Int    `protobuf:"bytes,2,opt,name=amount,proto3,customtype=Int" json:"amount"`
+}
+
+func (m *Coin) Reset()      { *m = Coin{} }
+func (*Coin) ProtoMessage() {}
+func (*Coin) Descriptor() ([]byte, []int) {
+	return fileDescriptor_189a96714eafc2df, []int{0}
+}
+func (m *Coin) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Coin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Coin.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 *Coin) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Coin.Merge(m, src)
+}
+func (m *Coin) XXX_Size() int {
+	return m.Size()
+}
+func (m *Coin) XXX_DiscardUnknown() {
+	xxx_messageInfo_Coin.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Coin proto.InternalMessageInfo
+
+func (m *Coin) GetDenom() string {
+	if m != nil {
+		return m.Denom
+	}
+	return ""
+}
+
+// DecCoin defines a token with a denomination and a decimal amount.
+//
+// NOTE: The amount field is an Dec which implements the custom method
+// signatures required by gogoproto.
+type DecCoin struct {
+	Denom  string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
+	Amount Dec    `protobuf:"bytes,2,opt,name=amount,proto3,customtype=Dec" json:"amount"`
+}
+
+func (m *DecCoin) Reset()      { *m = DecCoin{} }
+func (*DecCoin) ProtoMessage() {}
+func (*DecCoin) Descriptor() ([]byte, []int) {
+	return fileDescriptor_189a96714eafc2df, []int{1}
+}
+func (m *DecCoin) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DecCoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DecCoin.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 *DecCoin) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DecCoin.Merge(m, src)
+}
+func (m *DecCoin) XXX_Size() int {
+	return m.Size()
+}
+func (m *DecCoin) XXX_DiscardUnknown() {
+	xxx_messageInfo_DecCoin.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DecCoin proto.InternalMessageInfo
+
+func (m *DecCoin) GetDenom() string {
+	if m != nil {
+		return m.Denom
+	}
+	return ""
+}
+
+// IntProto defines a Protobuf wrapper around an Int object.
+type IntProto struct {
+	Int Int `protobuf:"bytes,1,opt,name=int,proto3,customtype=Int" json:"int"`
+}
+
+func (m *IntProto) Reset()      { *m = IntProto{} }
+func (*IntProto) ProtoMessage() {}
+func (*IntProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_189a96714eafc2df, []int{2}
+}
+func (m *IntProto) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *IntProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_IntProto.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 *IntProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IntProto.Merge(m, src)
+}
+func (m *IntProto) XXX_Size() int {
+	return m.Size()
+}
+func (m *IntProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_IntProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IntProto proto.InternalMessageInfo
+
+// DecProto defines a Protobuf wrapper around a Dec object.
+type DecProto struct {
+	Dec Dec `protobuf:"bytes,1,opt,name=dec,proto3,customtype=Dec" json:"dec"`
+}
+
+func (m *DecProto) Reset()      { *m = DecProto{} }
+func (*DecProto) ProtoMessage() {}
+func (*DecProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_189a96714eafc2df, []int{3}
+}
+func (m *DecProto) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DecProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DecProto.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 *DecProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DecProto.Merge(m, src)
+}
+func (m *DecProto) XXX_Size() int {
+	return m.Size()
+}
+func (m *DecProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_DecProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DecProto proto.InternalMessageInfo
+
+func init() {
+	proto.RegisterType((*Coin)(nil), "cosmos.base.v1beta1.Coin")
+	proto.RegisterType((*DecCoin)(nil), "cosmos.base.v1beta1.DecCoin")
+	proto.RegisterType((*IntProto)(nil), "cosmos.base.v1beta1.IntProto")
+	proto.RegisterType((*DecProto)(nil), "cosmos.base.v1beta1.DecProto")
+}
+
+func init() { proto.RegisterFile("cosmos/base/v1beta1/coin.proto", fileDescriptor_189a96714eafc2df) }
+
+var fileDescriptor_189a96714eafc2df = []byte{
+	// 261 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xce, 0x2f, 0xce,
+	0xcd, 0x2f, 0xd6, 0x4f, 0x4a, 0x2c, 0x4e, 0xd5, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4,
+	0x4f, 0xce, 0xcf, 0xcc, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, 0xc8, 0xeb, 0x81,
+	0xe4, 0xf5, 0xa0, 0xf2, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x79, 0x7d, 0x10, 0x0b, 0xa2,
+	0x54, 0xc9, 0x9d, 0x8b, 0xc5, 0x39, 0x3f, 0x33, 0x4f, 0x48, 0x84, 0x8b, 0x35, 0x25, 0x35, 0x2f,
+	0x3f, 0x57, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x08, 0xc2, 0x11, 0x52, 0xe6, 0x62, 0x4b, 0xcc,
+	0xcd, 0x2f, 0xcd, 0x2b, 0x91, 0x60, 0x02, 0x09, 0x3b, 0x71, 0x9f, 0xb8, 0x27, 0xcf, 0x70, 0xeb,
+	0x9e, 0x3c, 0xb3, 0x67, 0x5e, 0x49, 0x10, 0x54, 0xca, 0x8a, 0xe5, 0xc5, 0x02, 0x79, 0x46, 0x25,
+	0x2f, 0x2e, 0x76, 0x97, 0xd4, 0x64, 0x72, 0xcc, 0x72, 0x49, 0x4d, 0x46, 0x33, 0x4b, 0x93, 0x8b,
+	0xc3, 0x33, 0xaf, 0x24, 0x00, 0xec, 0x17, 0x59, 0x2e, 0xe6, 0xcc, 0xbc, 0x12, 0x88, 0x51, 0xa8,
+	0xf6, 0x83, 0xc4, 0x41, 0x4a, 0x5d, 0x52, 0x93, 0xe1, 0x4a, 0x53, 0x52, 0x93, 0xd1, 0x95, 0x82,
+	0x8c, 0x07, 0x89, 0x3b, 0xb9, 0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48, 0x8e, 0xe1, 0xc4, 0x23,
+	0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2,
+	0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2, 0x94, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4,
+	0x92, 0xf3, 0x73, 0xf5, 0xa1, 0x41, 0x0c, 0xa1, 0x74, 0x8b, 0x53, 0xb2, 0xf5, 0x4b, 0x2a, 0x0b,
+	0x52, 0x8b, 0x93, 0xd8, 0xc0, 0xe1, 0x66, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x57, 0xb3, 0x7a,
+	0x93, 0x84, 0x01, 0x00, 0x00,
+}
+
+func (this *Coin) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*Coin)
+	if !ok {
+		that2, ok := that.(Coin)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.Denom != that1.Denom {
+		return false
+	}
+	if !this.Amount.Equal(that1.Amount) {
+		return false
+	}
+	return true
+}
+func (this *DecCoin) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*DecCoin)
+	if !ok {
+		that2, ok := that.(DecCoin)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.Denom != that1.Denom {
+		return false
+	}
+	if !this.Amount.Equal(that1.Amount) {
+		return false
+	}
+	return true
+}
+func (m *Coin) 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 *Coin) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Coin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Amount.Size()
+		i -= size
+		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintCoin(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	if len(m.Denom) > 0 {
+		i -= len(m.Denom)
+		copy(dAtA[i:], m.Denom)
+		i = encodeVarintCoin(dAtA, i, uint64(len(m.Denom)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DecCoin) 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 *DecCoin) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DecCoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Amount.Size()
+		i -= size
+		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintCoin(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	if len(m.Denom) > 0 {
+		i -= len(m.Denom)
+		copy(dAtA[i:], m.Denom)
+		i = encodeVarintCoin(dAtA, i, uint64(len(m.Denom)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *IntProto) 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 *IntProto) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *IntProto) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Int.Size()
+		i -= size
+		if _, err := m.Int.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintCoin(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *DecProto) 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 *DecProto) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DecProto) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Dec.Size()
+		i -= size
+		if _, err := m.Dec.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintCoin(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintCoin(dAtA []byte, offset int, v uint64) int {
+	offset -= sovCoin(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *Coin) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Denom)
+	if l > 0 {
+		n += 1 + l + sovCoin(uint64(l))
+	}
+	l = m.Amount.Size()
+	n += 1 + l + sovCoin(uint64(l))
+	return n
+}
+
+func (m *DecCoin) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Denom)
+	if l > 0 {
+		n += 1 + l + sovCoin(uint64(l))
+	}
+	l = m.Amount.Size()
+	n += 1 + l + sovCoin(uint64(l))
+	return n
+}
+
+func (m *IntProto) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Int.Size()
+	n += 1 + l + sovCoin(uint64(l))
+	return n
+}
+
+func (m *DecProto) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Dec.Size()
+	n += 1 + l + sovCoin(uint64(l))
+	return n
+}
+
+func sovCoin(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozCoin(x uint64) (n int) {
+	return sovCoin(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Coin) 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 ErrIntOverflowCoin
+			}
+			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: Coin: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Coin: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCoin
+				}
+				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 ErrInvalidLengthCoin
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Denom = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCoin
+				}
+				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 ErrInvalidLengthCoin
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipCoin(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DecCoin) 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 ErrIntOverflowCoin
+			}
+			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: DecCoin: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DecCoin: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCoin
+				}
+				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 ErrInvalidLengthCoin
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Denom = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCoin
+				}
+				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 ErrInvalidLengthCoin
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipCoin(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *IntProto) 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 ErrIntOverflowCoin
+			}
+			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: IntProto: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: IntProto: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCoin
+				}
+				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 ErrInvalidLengthCoin
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Int.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipCoin(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DecProto) 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 ErrIntOverflowCoin
+			}
+			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: DecProto: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DecProto: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Dec", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCoin
+				}
+				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 ErrInvalidLengthCoin
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Dec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipCoin(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthCoin
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipCoin(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, ErrIntOverflowCoin
+			}
+			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, ErrIntOverflowCoin
+				}
+				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, ErrIntOverflowCoin
+				}
+				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, ErrInvalidLengthCoin
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupCoin
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthCoin
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthCoin        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowCoin          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupCoin = fmt.Errorf("proto: unexpected end of group")
+)

types/kv/kv.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: cosmos/kv/kv.proto
+// source: cosmos/base/kv/v1beta1/kv.proto
 
 package kv
 
@@ -32,7 +32,7 @@ func (m *Pairs) Reset()         { *m = Pairs{} }
 func (m *Pairs) String() string { return proto.CompactTextString(m) }
 func (*Pairs) ProtoMessage()    {}
 func (*Pairs) Descriptor() ([]byte, []int) {
-	return fileDescriptor_23371bd43b515c6e, []int{0}
+	return fileDescriptor_a44e87fe7182bb73, []int{0}
 }
 func (m *Pairs) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -78,7 +78,7 @@ func (m *Pair) Reset()         { *m = Pair{} }
 func (m *Pair) String() string { return proto.CompactTextString(m) }
 func (*Pair) ProtoMessage()    {}
 func (*Pair) Descriptor() ([]byte, []int) {
-	return fileDescriptor_23371bd43b515c6e, []int{1}
+	return fileDescriptor_a44e87fe7182bb73, []int{1}
 }
 func (m *Pair) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -122,27 +122,28 @@ func (m *Pair) GetValue() []byte {
 }
 
 func init() {
-	proto.RegisterType((*Pairs)(nil), "cosmos.kv.Pairs")
-	proto.RegisterType((*Pair)(nil), "cosmos.kv.Pair")
+	proto.RegisterType((*Pairs)(nil), "cosmos.base.kv.v1beta1.Pairs")
+	proto.RegisterType((*Pair)(nil), "cosmos.base.kv.v1beta1.Pair")
 }
 
-func init() { proto.RegisterFile("cosmos/kv/kv.proto", fileDescriptor_23371bd43b515c6e) }
+func init() { proto.RegisterFile("cosmos/base/kv/v1beta1/kv.proto", fileDescriptor_a44e87fe7182bb73) }
 
-var fileDescriptor_23371bd43b515c6e = []byte{
-	// 200 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4a, 0xce, 0x2f, 0xce,
-	0xcd, 0x2f, 0xd6, 0xcf, 0x2e, 0xd3, 0xcf, 0x2e, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2,
-	0x84, 0x88, 0xe9, 0x65, 0x97, 0x49, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x45, 0xf5, 0x41, 0x2c,
-	0x88, 0x02, 0x25, 0x13, 0x2e, 0xd6, 0x80, 0xc4, 0xcc, 0xa2, 0x62, 0x21, 0x6d, 0x2e, 0xd6, 0x02,
-	0x10, 0x43, 0x82, 0x51, 0x81, 0x59, 0x83, 0xdb, 0x88, 0x5f, 0x0f, 0xae, 0x53, 0x0f, 0xa4, 0xc0,
-	0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0x88, 0x1a, 0x25, 0x3d, 0x2e, 0x16, 0x90, 0xa0, 0x90,
-	0x00, 0x17, 0x73, 0x76, 0x6a, 0xa5, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x4f, 0x10, 0x88, 0x29, 0x24,
-	0xc2, 0xc5, 0x5a, 0x96, 0x98, 0x53, 0x9a, 0x2a, 0xc1, 0x04, 0x16, 0x83, 0x70, 0x9c, 0xec, 0x4f,
-	0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18,
-	0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x35, 0x3d, 0xb3, 0x24, 0xa3, 0x34,
-	0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0xea, 0x7e, 0x08, 0xa5, 0x5b, 0x9c, 0x92, 0xad, 0x5f, 0x52,
-	0x59, 0x90, 0x0a, 0xf2, 0x50, 0x12, 0x1b, 0xd8, 0xb5, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0xce, 0x49, 0x74, 0x20, 0xe4, 0x00, 0x00, 0x00,
+var fileDescriptor_a44e87fe7182bb73 = []byte{
+	// 221 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xce, 0x2f, 0xce,
+	0xcd, 0x2f, 0xd6, 0x4f, 0x4a, 0x2c, 0x4e, 0xd5, 0xcf, 0x2e, 0xd3, 0x2f, 0x33, 0x4c, 0x4a, 0x2d,
+	0x49, 0x34, 0xd4, 0xcf, 0x2e, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x83, 0x28, 0xd0,
+	0x03, 0x29, 0xd0, 0xcb, 0x2e, 0xd3, 0x83, 0x2a, 0x90, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x2b,
+	0xd1, 0x07, 0xb1, 0x20, 0xaa, 0x95, 0x1c, 0xb9, 0x58, 0x03, 0x12, 0x33, 0x8b, 0x8a, 0x85, 0x2c,
+	0xb8, 0x58, 0x0b, 0x40, 0x0c, 0x09, 0x46, 0x05, 0x66, 0x0d, 0x6e, 0x23, 0x19, 0x3d, 0xec, 0xc6,
+	0xe8, 0x81, 0x54, 0x3b, 0xb1, 0x9c, 0xb8, 0x27, 0xcf, 0x10, 0x04, 0xd1, 0xa0, 0xa4, 0xc7, 0xc5,
+	0x02, 0x12, 0x14, 0x12, 0xe0, 0x62, 0xce, 0x4e, 0xad, 0x94, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x09,
+	0x02, 0x31, 0x85, 0x44, 0xb8, 0x58, 0xcb, 0x12, 0x73, 0x4a, 0x53, 0x25, 0x98, 0xc0, 0x62, 0x10,
+	0x8e, 0x93, 0xfd, 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, 0xa9, 0xa6, 0x67,
+	0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x43, 0xbd, 0x09, 0xa1, 0x74, 0x8b, 0x53,
+	0xb2, 0xf5, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0xf5, 0xb3, 0xcb, 0x92, 0xd8, 0xc0, 0x4e, 0x37, 0x06,
+	0x04, 0x00, 0x00, 0xff, 0xff, 0x15, 0x18, 0x16, 0xcf, 0x0b, 0x01, 0x00, 0x00,
 }
 
 func (m *Pairs) Marshal() (dAtA []byte, err error) {

types/query/pagination.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: cosmos/query/pagination.proto
+// source: cosmos/base/query/v1beta1/pagination.proto
 
 package query
 
@@ -51,7 +51,7 @@ func (m *PageRequest) Reset()         { *m = PageRequest{} }
 func (m *PageRequest) String() string { return proto.CompactTextString(m) }
 func (*PageRequest) ProtoMessage()    {}
 func (*PageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4353dcf7b0208338, []int{0}
+	return fileDescriptor_53d6d609fe6828af, []int{0}
 }
 func (m *PageRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -128,7 +128,7 @@ func (m *PageResponse) Reset()         { *m = PageResponse{} }
 func (m *PageResponse) String() string { return proto.CompactTextString(m) }
 func (*PageResponse) ProtoMessage()    {}
 func (*PageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4353dcf7b0208338, []int{1}
+	return fileDescriptor_53d6d609fe6828af, []int{1}
 }
 func (m *PageResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -172,30 +172,33 @@ func (m *PageResponse) GetTotal() uint64 {
 }
 
 func init() {
-	proto.RegisterType((*PageRequest)(nil), "cosmos.query.PageRequest")
-	proto.RegisterType((*PageResponse)(nil), "cosmos.query.PageResponse")
+	proto.RegisterType((*PageRequest)(nil), "cosmos.base.query.v1beta1.PageRequest")
+	proto.RegisterType((*PageResponse)(nil), "cosmos.base.query.v1beta1.PageResponse")
 }
 
-func init() { proto.RegisterFile("cosmos/query/pagination.proto", fileDescriptor_4353dcf7b0208338) }
+func init() {
+	proto.RegisterFile("cosmos/base/query/v1beta1/pagination.proto", fileDescriptor_53d6d609fe6828af)
+}
 
-var fileDescriptor_4353dcf7b0208338 = []byte{
-	// 251 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_53d6d609fe6828af = []byte{
+	// 266 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x90, 0xc1, 0x4a, 0xc3, 0x40,
-	0x10, 0x86, 0xb3, 0xb6, 0xd6, 0x32, 0xcd, 0x41, 0x16, 0x91, 0x78, 0x70, 0x0d, 0x3d, 0xe5, 0x62,
-	0x72, 0xf0, 0x01, 0x84, 0x5e, 0xbd, 0x48, 0xf0, 0xe4, 0xa5, 0xa4, 0x71, 0x1a, 0x97, 0x36, 0x3b,
-	0x69, 0x77, 0x02, 0xe6, 0x2d, 0x7c, 0x2c, 0x8f, 0x3d, 0x7a, 0x94, 0xe4, 0x45, 0x24, 0xd9, 0x40,
-	0x4f, 0xbb, 0xdf, 0xff, 0xc3, 0x7c, 0xf0, 0xc3, 0x7d, 0x4e, 0xb6, 0x24, 0x9b, 0x1c, 0x6a, 0x3c,
-	0x36, 0x49, 0x95, 0x15, 0xda, 0x64, 0xac, 0xc9, 0xc4, 0xd5, 0x91, 0x98, 0xa4, 0xef, 0xea, 0x78,
-	0xa8, 0x97, 0x06, 0x16, 0xaf, 0x59, 0x81, 0x29, 0x1e, 0x6a, 0xb4, 0x2c, 0xaf, 0x61, 0xb2, 0xc3,
-	0x26, 0x10, 0xa1, 0x88, 0xfc, 0xb4, 0xff, 0xca, 0x5b, 0x98, 0xd1, 0x76, 0x6b, 0x91, 0x83, 0x8b,
-	0x50, 0x44, 0xd3, 0x74, 0x24, 0x79, 0x03, 0x97, 0x7b, 0x5d, 0x6a, 0x0e, 0x26, 0x43, 0xec, 0x40,
-	0x3e, 0xc0, 0x22, 0xa7, 0xda, 0xf0, 0x9a, 0x89, 0xb3, 0x7d, 0x30, 0x0d, 0x45, 0x34, 0x4f, 0x61,
-	0x88, 0xde, 0xfa, 0x64, 0xf9, 0x0c, 0xbe, 0xf3, 0xd9, 0x8a, 0x8c, 0x45, 0x79, 0x07, 0x73, 0x83,
-	0x5f, 0xbc, 0x3e, 0x5b, 0xaf, 0x7a, 0x7e, 0xc1, 0xa6, 0x37, 0xb8, 0x2b, 0x4e, 0xec, 0x60, 0xb5,
-	0xfa, 0x69, 0x95, 0x38, 0xb5, 0x4a, 0xfc, 0xb5, 0x4a, 0x7c, 0x77, 0xca, 0x3b, 0x75, 0xca, 0xfb,
-	0xed, 0x94, 0xf7, 0x1e, 0x15, 0x9a, 0x3f, 0xeb, 0x4d, 0x9c, 0x53, 0x99, 0x8c, 0x13, 0xb8, 0xe7,
-	0xd1, 0x7e, 0xec, 0x12, 0x6e, 0x2a, 0x1c, 0x37, 0xd9, 0xcc, 0x86, 0x25, 0x9e, 0xfe, 0x03, 0x00,
-	0x00, 0xff, 0xff, 0xe5, 0x66, 0x0a, 0x76, 0x2a, 0x01, 0x00, 0x00,
+	0x14, 0x45, 0x33, 0xb6, 0xd6, 0x32, 0xed, 0x42, 0x06, 0x91, 0x74, 0x33, 0x86, 0xae, 0x82, 0x60,
+	0x86, 0xe2, 0x07, 0x08, 0xdd, 0xba, 0x91, 0xe0, 0xca, 0x4d, 0x99, 0xc4, 0xd7, 0x18, 0xda, 0xcc,
+	0x4b, 0x3b, 0x2f, 0x62, 0xfe, 0xc2, 0xcf, 0x72, 0xd9, 0xa5, 0x4b, 0x49, 0x7e, 0x44, 0x92, 0x09,
+	0x74, 0x35, 0x73, 0x2f, 0x87, 0x77, 0xe0, 0xf2, 0xfb, 0x14, 0x6d, 0x81, 0x56, 0x25, 0xda, 0x82,
+	0x3a, 0x54, 0x70, 0xac, 0xd5, 0xe7, 0x2a, 0x01, 0xd2, 0x2b, 0x55, 0xea, 0x2c, 0x37, 0x9a, 0x72,
+	0x34, 0x51, 0x79, 0x44, 0x42, 0xb1, 0x70, 0x6c, 0xd4, 0xb1, 0x51, 0xcf, 0x46, 0x03, 0xbb, 0x34,
+	0x7c, 0xf6, 0xa2, 0x33, 0x88, 0xe1, 0x50, 0x81, 0x25, 0x71, 0xcd, 0x47, 0x3b, 0xa8, 0x7d, 0x16,
+	0xb0, 0x70, 0x1e, 0x77, 0x5f, 0x71, 0xcb, 0x27, 0xb8, 0xdd, 0x5a, 0x20, 0xff, 0x22, 0x60, 0xe1,
+	0x38, 0x1e, 0x92, 0xb8, 0xe1, 0x97, 0xfb, 0xbc, 0xc8, 0xc9, 0x1f, 0xf5, 0xb5, 0x0b, 0xe2, 0x8e,
+	0xcf, 0x52, 0xac, 0x0c, 0x6d, 0x08, 0x49, 0xef, 0xfd, 0x71, 0xc0, 0xc2, 0x69, 0xcc, 0xfb, 0xea,
+	0xb5, 0x6b, 0x96, 0x4f, 0x7c, 0xee, 0x7c, 0xb6, 0x44, 0x63, 0x41, 0x2c, 0xf8, 0xd4, 0xc0, 0x17,
+	0x6d, 0xce, 0xd6, 0xab, 0x2e, 0x3f, 0x43, 0xdd, 0x19, 0xdc, 0x15, 0x27, 0x76, 0x61, 0xbd, 0xfe,
+	0x69, 0x24, 0x3b, 0x35, 0x92, 0xfd, 0x35, 0x92, 0x7d, 0xb7, 0xd2, 0x3b, 0xb5, 0xd2, 0xfb, 0x6d,
+	0xa5, 0xf7, 0x16, 0x66, 0x39, 0x7d, 0x54, 0x49, 0x94, 0x62, 0xa1, 0x86, 0x71, 0xdc, 0xf3, 0x60,
+	0xdf, 0x77, 0x8a, 0xea, 0x12, 0xac, 0x1b, 0x2a, 0x99, 0xf4, 0xb3, 0x3c, 0xfe, 0x07, 0x00, 0x00,
+	0xff, 0xff, 0xb5, 0x65, 0x82, 0x18, 0x44, 0x01, 0x00, 0x00,
 }
 
 func (m *PageRequest) Marshal() (dAtA []byte, err error) {

types/tx/service.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: cosmos/tx/service.proto
+// source: cosmos/tx/v1beta1/service.proto
 
 package tx
 
@@ -37,7 +37,7 @@ func (m *SimulateRequest) Reset()         { *m = SimulateRequest{} }
 func (m *SimulateRequest) String() string { return proto.CompactTextString(m) }
 func (*SimulateRequest) ProtoMessage()    {}
 func (*SimulateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3815655f4ee03b11, []int{0}
+	return fileDescriptor_e0b00a618705eca7, []int{0}
 }
 func (m *SimulateRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -83,7 +83,7 @@ func (m *SimulateResponse) Reset()         { *m = SimulateResponse{} }
 func (m *SimulateResponse) String() string { return proto.CompactTextString(m) }
 func (*SimulateResponse) ProtoMessage()    {}
 func (*SimulateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3815655f4ee03b11, []int{1}
+	return fileDescriptor_e0b00a618705eca7, []int{1}
 }
 func (m *SimulateResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -127,31 +127,33 @@ func (m *SimulateResponse) GetResult() *types.Result {
 }
 
 func init() {
-	proto.RegisterType((*SimulateRequest)(nil), "cosmos.tx.SimulateRequest")
-	proto.RegisterType((*SimulateResponse)(nil), "cosmos.tx.SimulateResponse")
+	proto.RegisterType((*SimulateRequest)(nil), "cosmos.tx.v1beta1.SimulateRequest")
+	proto.RegisterType((*SimulateResponse)(nil), "cosmos.tx.v1beta1.SimulateResponse")
 }
 
-func init() { proto.RegisterFile("cosmos/tx/service.proto", fileDescriptor_3815655f4ee03b11) }
+func init() { proto.RegisterFile("cosmos/tx/v1beta1/service.proto", fileDescriptor_e0b00a618705eca7) }
 
-var fileDescriptor_3815655f4ee03b11 = []byte{
-	// 266 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4f, 0xce, 0x2f, 0xce,
-	0xcd, 0x2f, 0xd6, 0x2f, 0xa9, 0xd0, 0x2f, 0x4e, 0x2d, 0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b, 0x28,
-	0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0x48, 0xe8, 0x95, 0x54, 0x48, 0x09, 0x43, 0xd5, 0x40, 0x45,
-	0xc0, 0xf2, 0x52, 0x42, 0x08, 0x8d, 0x25, 0x15, 0x10, 0x31, 0x25, 0x03, 0x2e, 0xfe, 0xe0, 0xcc,
-	0xdc, 0xd2, 0x9c, 0xc4, 0x92, 0xd4, 0xa0, 0xd4, 0xc2, 0xd2, 0xd4, 0xe2, 0x12, 0x21, 0x59, 0x2e,
-	0xa6, 0x92, 0x0a, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x6e, 0x23, 0x5e, 0x3d, 0xb8, 0x99, 0x7a, 0x21,
-	0x15, 0x41, 0x4c, 0x25, 0x15, 0x4a, 0x69, 0x5c, 0x02, 0x08, 0x1d, 0xc5, 0x05, 0xf9, 0x79, 0xc5,
-	0xa9, 0x42, 0x5a, 0x5c, 0x1c, 0xe9, 0x89, 0xc5, 0xf1, 0x99, 0x79, 0x69, 0xf9, 0x50, 0x8d, 0xfc,
-	0x30, 0x8d, 0xee, 0x89, 0xc5, 0x9e, 0x79, 0x69, 0xf9, 0x41, 0xec, 0xe9, 0x10, 0x86, 0x90, 0x1a,
-	0x17, 0x5b, 0x51, 0x6a, 0x71, 0x69, 0x4e, 0x89, 0x04, 0x13, 0x58, 0x25, 0x1f, 0x4c, 0x65, 0x10,
-	0x58, 0x34, 0x08, 0x2a, 0x6b, 0x14, 0xc0, 0xc5, 0x1e, 0x0c, 0xf1, 0x9e, 0x90, 0x2b, 0x17, 0x07,
-	0xcc, 0x4a, 0x21, 0x29, 0x24, 0x17, 0xa1, 0xb9, 0x5c, 0x4a, 0x1a, 0xab, 0x1c, 0xc4, 0x8d, 0x4a,
-	0x0c, 0x4e, 0xf6, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3,
-	0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x9a, 0x9e,
-	0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0x12, 0x72, 0xba, 0xc5, 0x29, 0xd9,
-	0xfa, 0x25, 0x95, 0x05, 0xa9, 0xa0, 0x50, 0x4b, 0x62, 0x03, 0x87, 0x99, 0x31, 0x20, 0x00, 0x00,
-	0xff, 0xff, 0x1f, 0x22, 0x57, 0x5f, 0x82, 0x01, 0x00, 0x00,
+var fileDescriptor_e0b00a618705eca7 = []byte{
+	// 300 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xce, 0x2f, 0xce,
+	0xcd, 0x2f, 0xd6, 0x2f, 0xa9, 0xd0, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x2f, 0x4e,
+	0x2d, 0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0x28, 0xd0,
+	0x2b, 0xa9, 0xd0, 0x83, 0x2a, 0x90, 0x52, 0x86, 0xea, 0x49, 0x4a, 0x2c, 0x4e, 0xd5, 0x4f, 0x4c,
+	0x4a, 0xce, 0x84, 0x6b, 0x05, 0x71, 0x20, 0xfa, 0xa4, 0xa4, 0x30, 0x0d, 0x2e, 0xa9, 0x80, 0xc8,
+	0x29, 0x59, 0x70, 0xf1, 0x07, 0x67, 0xe6, 0x96, 0xe6, 0x24, 0x96, 0xa4, 0x06, 0xa5, 0x16, 0x96,
+	0xa6, 0x16, 0x97, 0x08, 0xa9, 0x72, 0x31, 0x95, 0x54, 0x48, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b,
+	0x89, 0xea, 0x61, 0xd8, 0xa9, 0x17, 0x52, 0x11, 0xc4, 0x54, 0x52, 0xa1, 0xd4, 0xc5, 0xc8, 0x25,
+	0x80, 0xd0, 0x5a, 0x5c, 0x90, 0x9f, 0x57, 0x9c, 0x2a, 0x64, 0xc3, 0xc5, 0x91, 0x9e, 0x58, 0x1c,
+	0x9f, 0x99, 0x97, 0x96, 0x0f, 0x35, 0x41, 0x11, 0x66, 0x02, 0xc8, 0x89, 0x7a, 0x60, 0x57, 0xc1,
+	0x0c, 0x72, 0x4f, 0x2c, 0xf6, 0xcc, 0x4b, 0xcb, 0x0f, 0x62, 0x4f, 0x87, 0x30, 0x84, 0x2c, 0xb8,
+	0xd8, 0x8a, 0x52, 0x8b, 0x4b, 0x73, 0x4a, 0x24, 0x98, 0xc0, 0x7a, 0x15, 0x70, 0xeb, 0x0d, 0x02,
+	0xab, 0x0b, 0x82, 0xaa, 0x37, 0x4a, 0xe0, 0x62, 0x0f, 0x86, 0x84, 0x95, 0x50, 0x28, 0x17, 0x07,
+	0xcc, 0x59, 0x42, 0x4a, 0x58, 0x9c, 0x8f, 0xe6, 0x5d, 0x29, 0x65, 0xbc, 0x6a, 0x20, 0xfe, 0x52,
+	0x62, 0x70, 0xb2, 0x3f, 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, 0xd5, 0xf4,
+	0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x68, 0x48, 0x43, 0x28, 0xdd, 0xe2,
+	0x94, 0x6c, 0xfd, 0x92, 0xca, 0x82, 0x54, 0x50, 0xd0, 0x27, 0xb1, 0x81, 0x03, 0xdc, 0x18, 0x10,
+	0x00, 0x00, 0xff, 0xff, 0x16, 0x0a, 0x0d, 0x78, 0xe7, 0x01, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -180,7 +182,7 @@ func NewServiceClient(cc grpc1.ClientConn) ServiceClient {
 
 func (c *serviceClient) Simulate(ctx context.Context, in *SimulateRequest, opts ...grpc.CallOption) (*SimulateResponse, error) {
 	out := new(SimulateResponse)
-	err := c.cc.Invoke(ctx, "/cosmos.tx.Service/Simulate", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/cosmos.tx.v1beta1.Service/Simulate", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -215,7 +217,7 @@ func _Service_Simulate_Handler(srv interface{}, ctx context.Context, dec func(in
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/cosmos.tx.Service/Simulate",
+		FullMethod: "/cosmos.tx.v1beta1.Service/Simulate",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ServiceServer).Simulate(ctx, req.(*SimulateRequest))
@@ -224,7 +226,7 @@ func _Service_Simulate_Handler(srv interface{}, ctx context.Context, dec func(in
 }
 
 var _Service_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "cosmos.tx.Service",
+	ServiceName: "cosmos.tx.v1beta1.Service",
 	HandlerType: (*ServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -233,7 +235,7 @@ var _Service_serviceDesc = grpc.ServiceDesc{
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
-	Metadata: "cosmos/tx/service.proto",
+	Metadata: "cosmos/tx/v1beta1/service.proto",
 }
 
 func (m *SimulateRequest) Marshal() (dAtA []byte, err error) {

types/tx/sig_desc.pb.go

@@ -1,37 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: cosmos/tx/sig_desc.proto
-
-package tx
-
-import (
-	fmt "fmt"
-	_ "github.com/cosmos/cosmos-sdk/types/tx/signing"
-	proto "github.com/gogo/protobuf/proto"
-	math "math"
-)
-
-// 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 init() { proto.RegisterFile("cosmos/tx/sig_desc.proto", fileDescriptor_d560eb6bd3d62ef7) }
-
-var fileDescriptor_d560eb6bd3d62ef7 = []byte{
-	// 129 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x48, 0xce, 0x2f, 0xce,
-	0xcd, 0x2f, 0xd6, 0x2f, 0xa9, 0xd0, 0x2f, 0xce, 0x4c, 0x8f, 0x4f, 0x49, 0x2d, 0x4e, 0xd6, 0x2b,
-	0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0xc8, 0xe8, 0x95, 0x54, 0x48, 0xc9, 0xa3, 0x28, 0xca,
-	0xcb, 0xcc, 0x4b, 0x87, 0xd1, 0x10, 0xb5, 0x4e, 0xf6, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24,
-	0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78,
-	0x2c, 0xc7, 0x10, 0xa5, 0x9a, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x0f,
-	0x35, 0x05, 0x42, 0xe9, 0x16, 0xa7, 0x64, 0xeb, 0x97, 0x54, 0x16, 0xa4, 0x82, 0x8c, 0x4d, 0x62,
-	0x03, 0x9b, 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x86, 0x8a, 0xa4, 0x8a, 0x8f, 0x00, 0x00,
-	0x00,
-}

types/tx/signing/signing.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: cosmos/tx/signing/signing.proto
+// source: cosmos/tx/signing/v1beta1/signing.proto
 
 package signing
 
@@ -59,7 +59,7 @@ func (x SignMode) String() string {
 }
 
 func (SignMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_8a04324e5f3729bf, []int{0}
+	return fileDescriptor_9a54958ff3d0b1b9, []int{0}
 }
 
 // SignatureDescriptors wraps multiple SignatureDescriptor's.
@@ -72,7 +72,7 @@ func (m *SignatureDescriptors) Reset()         { *m = SignatureDescriptors{} }
 func (m *SignatureDescriptors) String() string { return proto.CompactTextString(m) }
 func (*SignatureDescriptors) ProtoMessage()    {}
 func (*SignatureDescriptors) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8a04324e5f3729bf, []int{0}
+	return fileDescriptor_9a54958ff3d0b1b9, []int{0}
 }
 func (m *SignatureDescriptors) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -121,7 +121,7 @@ func (m *SignatureDescriptor) Reset()         { *m = SignatureDescriptor{} }
 func (m *SignatureDescriptor) String() string { return proto.CompactTextString(m) }
 func (*SignatureDescriptor) ProtoMessage()    {}
 func (*SignatureDescriptor) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8a04324e5f3729bf, []int{1}
+	return fileDescriptor_9a54958ff3d0b1b9, []int{1}
 }
 func (m *SignatureDescriptor) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -178,7 +178,7 @@ func (m *SignatureDescriptor_Data) Reset()         { *m = SignatureDescriptor_Da
 func (m *SignatureDescriptor_Data) String() string { return proto.CompactTextString(m) }
 func (*SignatureDescriptor_Data) ProtoMessage()    {}
 func (*SignatureDescriptor_Data) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8a04324e5f3729bf, []int{1, 0}
+	return fileDescriptor_9a54958ff3d0b1b9, []int{1, 0}
 }
 func (m *SignatureDescriptor_Data) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -255,7 +255,7 @@ func (*SignatureDescriptor_Data) XXX_OneofWrappers() []interface{} {
 // Single is the signature data for a single signer
 type SignatureDescriptor_Data_Single struct {
 	// mode is the signing mode of the single signer
-	Mode SignMode `protobuf:"varint,1,opt,name=mode,proto3,enum=cosmos.tx.signing.SignMode" json:"mode,omitempty"`
+	Mode SignMode `protobuf:"varint,1,opt,name=mode,proto3,enum=cosmos.tx.signing.v1beta1.SignMode" json:"mode,omitempty"`
 	// signature is the raw signature bytes
 	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
 }
@@ -264,7 +264,7 @@ func (m *SignatureDescriptor_Data_Single) Reset()         { *m = SignatureDescri
 func (m *SignatureDescriptor_Data_Single) String() string { return proto.CompactTextString(m) }
 func (*SignatureDescriptor_Data_Single) ProtoMessage()    {}
 func (*SignatureDescriptor_Data_Single) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8a04324e5f3729bf, []int{1, 0, 0}
+	return fileDescriptor_9a54958ff3d0b1b9, []int{1, 0, 0}
 }
 func (m *SignatureDescriptor_Data_Single) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -319,7 +319,7 @@ func (m *SignatureDescriptor_Data_Multi) Reset()         { *m = SignatureDescrip
 func (m *SignatureDescriptor_Data_Multi) String() string { return proto.CompactTextString(m) }
 func (*SignatureDescriptor_Data_Multi) ProtoMessage()    {}
 func (*SignatureDescriptor_Data_Multi) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8a04324e5f3729bf, []int{1, 0, 1}
+	return fileDescriptor_9a54958ff3d0b1b9, []int{1, 0, 1}
 }
 func (m *SignatureDescriptor_Data_Multi) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -363,49 +363,52 @@ func (m *SignatureDescriptor_Data_Multi) GetSignatures() []*SignatureDescriptor_
 }
 
 func init() {
-	proto.RegisterEnum("cosmos.tx.signing.SignMode", SignMode_name, SignMode_value)
-	proto.RegisterType((*SignatureDescriptors)(nil), "cosmos.tx.signing.SignatureDescriptors")
-	proto.RegisterType((*SignatureDescriptor)(nil), "cosmos.tx.signing.SignatureDescriptor")
-	proto.RegisterType((*SignatureDescriptor_Data)(nil), "cosmos.tx.signing.SignatureDescriptor.Data")
-	proto.RegisterType((*SignatureDescriptor_Data_Single)(nil), "cosmos.tx.signing.SignatureDescriptor.Data.Single")
-	proto.RegisterType((*SignatureDescriptor_Data_Multi)(nil), "cosmos.tx.signing.SignatureDescriptor.Data.Multi")
+	proto.RegisterEnum("cosmos.tx.signing.v1beta1.SignMode", SignMode_name, SignMode_value)
+	proto.RegisterType((*SignatureDescriptors)(nil), "cosmos.tx.signing.v1beta1.SignatureDescriptors")
+	proto.RegisterType((*SignatureDescriptor)(nil), "cosmos.tx.signing.v1beta1.SignatureDescriptor")
+	proto.RegisterType((*SignatureDescriptor_Data)(nil), "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data")
+	proto.RegisterType((*SignatureDescriptor_Data_Single)(nil), "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Single")
+	proto.RegisterType((*SignatureDescriptor_Data_Multi)(nil), "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Multi")
 }
 
-func init() { proto.RegisterFile("cosmos/tx/signing/signing.proto", fileDescriptor_8a04324e5f3729bf) }
+func init() {
+	proto.RegisterFile("cosmos/tx/signing/v1beta1/signing.proto", fileDescriptor_9a54958ff3d0b1b9)
+}
 
-var fileDescriptor_8a04324e5f3729bf = []byte{
-	// 487 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xcb, 0x6e, 0xd3, 0x40,
-	0x14, 0xb5, 0x9b, 0x87, 0xda, 0x5b, 0x84, 0xdc, 0xa1, 0x95, 0x82, 0x8b, 0xdc, 0xaa, 0x0b, 0x54,
-	0x81, 0x6a, 0x8b, 0xb0, 0x40, 0x62, 0x83, 0x92, 0xd8, 0x4d, 0x4d, 0xf3, 0xa8, 0xc6, 0xa9, 0x78,
-	0x2c, 0xb0, 0x1c, 0xc7, 0x32, 0xa3, 0xc6, 0x19, 0xcb, 0x33, 0x96, 0x9a, 0x15, 0xbf, 0x50, 0xf1,
-	0x0d, 0x7c, 0x0c, 0xcb, 0x2e, 0x59, 0xa2, 0xe4, 0x47, 0x50, 0xc6, 0x76, 0x13, 0xa0, 0x48, 0x64,
-	0x75, 0xed, 0x33, 0xe7, 0x9c, 0x39, 0xbe, 0xbe, 0x17, 0x0e, 0x7c, 0xca, 0x22, 0xca, 0x0c, 0x7e,
-	0x6d, 0x30, 0x12, 0x4e, 0xc8, 0x24, 0x2c, 0xaa, 0x1e, 0x27, 0x94, 0x53, 0xb4, 0x93, 0x11, 0x74,
-	0x7e, 0xad, 0xe7, 0x07, 0xaa, 0x9a, 0x6b, 0xfc, 0x64, 0x1a, 0x73, 0x9a, 0x97, 0x8c, 0x7e, 0xf4,
-	0x09, 0x76, 0x1d, 0x12, 0x4e, 0x3c, 0x9e, 0x26, 0x81, 0x19, 0x30, 0x3f, 0x21, 0x31, 0xa7, 0x09,
-	0x43, 0xa7, 0x00, 0xac, 0xc0, 0x59, 0x4d, 0x3e, 0x2c, 0x1d, 0x6f, 0xd7, 0x9f, 0xea, 0x7f, 0x79,
-	0xeb, 0xf7, 0x88, 0xf1, 0x8a, 0xf2, 0xe8, 0x5b, 0x19, 0x1e, 0xdd, 0xc3, 0x41, 0xaf, 0x00, 0xe2,
-	0x74, 0x38, 0x26, 0xbe, 0x7b, 0x15, 0x4c, 0x6b, 0xf2, 0xa1, 0x7c, 0xbc, 0x5d, 0xaf, 0x15, 0xfe,
-	0x79, 0xc2, 0x0b, 0x41, 0x38, 0x0f, 0xa6, 0x78, 0x2b, 0x2e, 0x1e, 0xd1, 0x1b, 0x28, 0x8f, 0x3c,
-	0xee, 0xd5, 0x36, 0x84, 0xe4, 0xf9, 0xff, 0x45, 0xd2, 0x4d, 0x8f, 0x7b, 0x58, 0x08, 0xd5, 0xaf,
-	0x25, 0x28, 0x2f, 0x5e, 0x51, 0x07, 0xaa, 0x8c, 0x4c, 0xc2, 0x71, 0x90, 0x5f, 0x5f, 0x5f, 0xc3,
-	0x4b, 0x77, 0x84, 0xf2, 0x4c, 0xc2, 0xb9, 0x07, 0xb2, 0xa1, 0x12, 0xa5, 0x63, 0x4e, 0xf2, 0x60,
-	0x2f, 0xd6, 0x31, 0xeb, 0x2e, 0x84, 0x67, 0x12, 0xce, 0x1c, 0xd4, 0x77, 0x50, 0xcd, 0xec, 0x91,
-	0x01, 0xe5, 0x88, 0x8e, 0xb2, 0x80, 0x0f, 0xeb, 0xfb, 0xff, 0xf0, 0xec, 0xd2, 0x51, 0x80, 0x05,
-	0x11, 0x3d, 0x81, 0xad, 0xbb, 0xe6, 0x8b, 0x24, 0x0f, 0xf0, 0x12, 0x50, 0x6f, 0x64, 0xa8, 0x88,
-	0xbb, 0xd0, 0x6b, 0xd8, 0x1c, 0x12, 0xee, 0x25, 0x89, 0x57, 0x34, 0x5f, 0xfb, 0xa3, 0xf9, 0x2d,
-	0x1a, 0xc5, 0x9e, 0xcf, 0x9b, 0x84, 0x37, 0x16, 0x2c, 0x7c, 0xc7, 0x47, 0xe7, 0xbf, 0x8d, 0xc6,
-	0x86, 0x18, 0x8d, 0xb5, 0xfe, 0xc3, 0x8a, 0xbc, 0x59, 0x81, 0x12, 0x4b, 0xa3, 0x67, 0x0c, 0x36,
-	0x8b, 0x2f, 0x41, 0x8f, 0x61, 0xcf, 0xb1, 0xdb, 0x3d, 0xb7, 0xdb, 0x37, 0x2d, 0xf7, 0xb2, 0xe7,
-	0x5c, 0x58, 0x2d, 0xfb, 0xd4, 0xb6, 0x4c, 0x45, 0x42, 0xbb, 0xa0, 0x2c, 0x8f, 0x4c, 0x1b, 0x5b,
-	0xad, 0x81, 0x22, 0xa3, 0x3d, 0xd8, 0x59, 0xa2, 0x03, 0xeb, 0xfd, 0xe0, 0xb2, 0xd1, 0x51, 0x36,
-	0xd0, 0x01, 0xec, 0x2f, 0xe1, 0x8e, 0xd5, 0x6e, 0xb4, 0x3e, 0xb8, 0x8d, 0xae, 0xdd, 0xeb, 0xbb,
-	0x6f, 0x9d, 0x7e, 0x4f, 0xf9, 0xd2, 0x6c, 0x7f, 0x9f, 0x69, 0xf2, 0xed, 0x4c, 0x93, 0x7f, 0xce,
-	0x34, 0xf9, 0x66, 0xae, 0x49, 0xb7, 0x73, 0x4d, 0xfa, 0x31, 0xd7, 0xa4, 0x8f, 0x27, 0x21, 0xe1,
-	0x9f, 0xd3, 0xa1, 0xee, 0xd3, 0xc8, 0x28, 0x96, 0x47, 0x94, 0x13, 0x36, 0xba, 0x32, 0xf8, 0x34,
-	0x0e, 0x56, 0x37, 0x70, 0x58, 0x15, 0xbb, 0xf4, 0xf2, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x82,
-	0x8c, 0xaa, 0x54, 0x9d, 0x03, 0x00, 0x00,
+var fileDescriptor_9a54958ff3d0b1b9 = []byte{
+	// 506 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0xcd, 0x6e, 0xd3, 0x40,
+	0x10, 0xc7, 0xed, 0x7c, 0xa9, 0x9d, 0x22, 0x14, 0x96, 0x56, 0x4a, 0x03, 0x32, 0x55, 0x11, 0xa2,
+	0x02, 0x75, 0xad, 0xa6, 0x07, 0x04, 0xb7, 0x24, 0x36, 0x69, 0xa0, 0x71, 0x8a, 0x9d, 0x4a, 0xc0,
+	0xc5, 0x5a, 0x3b, 0xc6, 0xac, 0x1a, 0x67, 0x2d, 0xef, 0x1a, 0x35, 0x27, 0x5e, 0x81, 0x97, 0xe0,
+	0x39, 0xb8, 0x72, 0xec, 0x91, 0x23, 0x4a, 0x24, 0x9e, 0x03, 0xc5, 0x1f, 0x49, 0x90, 0x0a, 0xa8,
+	0x39, 0xd9, 0x33, 0x3b, 0xf3, 0xfb, 0xff, 0x57, 0xb3, 0x03, 0x8f, 0x5d, 0xc6, 0x03, 0xc6, 0x55,
+	0x71, 0xa9, 0x72, 0xea, 0x8f, 0xe9, 0xd8, 0x57, 0x3f, 0x1d, 0x39, 0x9e, 0x20, 0x47, 0x79, 0x8c,
+	0xc3, 0x88, 0x09, 0x86, 0x76, 0xd3, 0x42, 0x2c, 0x2e, 0x71, 0x7e, 0x90, 0x15, 0xd6, 0x73, 0x86,
+	0x43, 0xb8, 0xa7, 0xba, 0xd1, 0x24, 0x14, 0x6c, 0x01, 0x49, 0xc3, 0x94, 0xb1, 0xff, 0x01, 0xb6,
+	0x2d, 0xea, 0x8f, 0x89, 0x88, 0x23, 0x4f, 0xf3, 0xb8, 0x1b, 0xd1, 0x50, 0xb0, 0x88, 0x23, 0x03,
+	0x80, 0xe7, 0x79, 0x5e, 0x93, 0xf7, 0x8a, 0x07, 0x5b, 0x0d, 0x8c, 0xff, 0x2a, 0x88, 0xaf, 0x81,
+	0x98, 0x2b, 0x84, 0xfd, 0x5f, 0x25, 0xb8, 0x7b, 0x4d, 0x0d, 0xd2, 0x00, 0xc2, 0xd8, 0x19, 0x51,
+	0xd7, 0xbe, 0xf0, 0x26, 0x35, 0x79, 0x4f, 0x3e, 0xd8, 0x6a, 0x3c, 0xca, 0x75, 0xe6, 0xee, 0x71,
+	0x66, 0x37, 0x17, 0x3a, 0x4b, 0xaa, 0x5f, 0x7b, 0x13, 0x73, 0x33, 0xcc, 0x7f, 0x51, 0x07, 0x4a,
+	0x43, 0x22, 0x48, 0xad, 0x90, 0xf4, 0x1f, 0xdf, 0xcc, 0x27, 0xd6, 0x88, 0x20, 0x66, 0x02, 0xa8,
+	0x7f, 0x2b, 0x42, 0x69, 0x1e, 0xa2, 0x01, 0x54, 0x38, 0x1d, 0xfb, 0x23, 0x2f, 0xf3, 0xf4, 0x62,
+	0x0d, 0x26, 0xb6, 0x12, 0xc2, 0x89, 0x64, 0x66, 0x2c, 0xf4, 0x06, 0xca, 0x41, 0x3c, 0x12, 0x34,
+	0x33, 0xfa, 0x7c, 0x1d, 0x68, 0x6f, 0x0e, 0x38, 0x91, 0xcc, 0x94, 0x54, 0xb7, 0xa1, 0x92, 0xca,
+	0xa0, 0x67, 0x50, 0x0a, 0xd8, 0x30, 0x35, 0x7c, 0xbb, 0xf1, 0xf0, 0x3f, 0xec, 0x1e, 0x1b, 0x7a,
+	0x66, 0xd2, 0x80, 0xee, 0xc3, 0xe6, 0x62, 0x52, 0x89, 0xb3, 0x5b, 0xe6, 0x32, 0x51, 0xff, 0x2a,
+	0x43, 0x39, 0xd1, 0x44, 0x1d, 0xd8, 0x70, 0xa8, 0x20, 0x51, 0x44, 0xf2, 0x49, 0x3d, 0xfd, 0xd7,
+	0xa4, 0xda, 0x2c, 0x08, 0x89, 0x2b, 0x5a, 0x54, 0x34, 0xe7, 0x2d, 0xe6, 0xa2, 0x19, 0x59, 0x7f,
+	0x3c, 0xae, 0x42, 0xf2, 0xb8, 0xd6, 0x1a, 0xda, 0x0a, 0xa6, 0x55, 0x86, 0x22, 0x8f, 0x83, 0x27,
+	0x1c, 0x36, 0xf2, 0xeb, 0xa1, 0x5d, 0xd8, 0xb1, 0xba, 0x1d, 0xc3, 0xee, 0xf5, 0x35, 0xdd, 0x3e,
+	0x37, 0xac, 0x33, 0xbd, 0xdd, 0x7d, 0xd9, 0xd5, 0xb5, 0xaa, 0x84, 0xb6, 0xa1, 0xba, 0x3c, 0xd2,
+	0xba, 0xa6, 0xde, 0x1e, 0x54, 0x65, 0xb4, 0x03, 0x77, 0x96, 0xd9, 0x81, 0xfe, 0x76, 0x70, 0xde,
+	0x3c, 0xad, 0x16, 0xd0, 0x03, 0xb8, 0xb7, 0x4c, 0x9f, 0xea, 0x9d, 0x66, 0xfb, 0x9d, 0xdd, 0xec,
+	0x75, 0x8d, 0xbe, 0xfd, 0xca, 0xea, 0x1b, 0xd5, 0xcf, 0xad, 0xce, 0xf7, 0xa9, 0x22, 0x5f, 0x4d,
+	0x15, 0xf9, 0xe7, 0x54, 0x91, 0xbf, 0xcc, 0x14, 0xe9, 0x6a, 0xa6, 0x48, 0x3f, 0x66, 0x8a, 0xf4,
+	0xfe, 0xd0, 0xa7, 0xe2, 0x63, 0xec, 0x60, 0x97, 0x05, 0x6a, 0xb6, 0x93, 0xe9, 0xe7, 0x90, 0x0f,
+	0x2f, 0x54, 0x31, 0x09, 0xbd, 0xd5, 0x45, 0x77, 0x2a, 0xc9, 0x56, 0x1e, 0xff, 0x0e, 0x00, 0x00,
+	0xff, 0xff, 0x63, 0x6d, 0x8a, 0xc7, 0x04, 0x04, 0x00, 0x00,
 }
 
 func (m *SignatureDescriptors) Marshal() (dAtA []byte, err error) {

types/tx/tx.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: cosmos/tx/tx.proto
+// source: cosmos/tx/v1beta1/tx.proto
 
 package tx
 
@@ -44,7 +44,7 @@ func (m *Tx) Reset()         { *m = Tx{} }
 func (m *Tx) String() string { return proto.CompactTextString(m) }
 func (*Tx) ProtoMessage()    {}
 func (*Tx) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{0}
+	return fileDescriptor_96d1575ffde80842, []int{0}
 }
 func (m *Tx) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -112,7 +112,7 @@ func (m *TxRaw) Reset()         { *m = TxRaw{} }
 func (m *TxRaw) String() string { return proto.CompactTextString(m) }
 func (*TxRaw) ProtoMessage()    {}
 func (*TxRaw) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{1}
+	return fileDescriptor_96d1575ffde80842, []int{1}
 }
 func (m *TxRaw) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -183,7 +183,7 @@ func (m *SignDoc) Reset()         { *m = SignDoc{} }
 func (m *SignDoc) String() string { return proto.CompactTextString(m) }
 func (*SignDoc) ProtoMessage()    {}
 func (*SignDoc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{2}
+	return fileDescriptor_96d1575ffde80842, []int{2}
 }
 func (m *SignDoc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -275,7 +275,7 @@ func (m *TxBody) Reset()         { *m = TxBody{} }
 func (m *TxBody) String() string { return proto.CompactTextString(m) }
 func (*TxBody) ProtoMessage()    {}
 func (*TxBody) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{3}
+	return fileDescriptor_96d1575ffde80842, []int{3}
 }
 func (m *TxBody) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -356,7 +356,7 @@ func (m *AuthInfo) Reset()         { *m = AuthInfo{} }
 func (m *AuthInfo) String() string { return proto.CompactTextString(m) }
 func (*AuthInfo) ProtoMessage()    {}
 func (*AuthInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{4}
+	return fileDescriptor_96d1575ffde80842, []int{4}
 }
 func (m *AuthInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -414,7 +414,7 @@ func (m *SignerInfo) Reset()         { *m = SignerInfo{} }
 func (m *SignerInfo) String() string { return proto.CompactTextString(m) }
 func (*SignerInfo) ProtoMessage()    {}
 func (*SignerInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{5}
+	return fileDescriptor_96d1575ffde80842, []int{5}
 }
 func (m *SignerInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -472,7 +472,7 @@ func (m *ModeInfo) Reset()         { *m = ModeInfo{} }
 func (m *ModeInfo) String() string { return proto.CompactTextString(m) }
 func (*ModeInfo) ProtoMessage()    {}
 func (*ModeInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{6}
+	return fileDescriptor_96d1575ffde80842, []int{6}
 }
 func (m *ModeInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -550,14 +550,14 @@ func (*ModeInfo) XXX_OneofWrappers() []interface{} {
 // to allow for additional fields such as locale for SIGN_MODE_TEXTUAL in the future
 type ModeInfo_Single struct {
 	// mode is the signing mode of the single signer
-	Mode signing.SignMode `protobuf:"varint,1,opt,name=mode,proto3,enum=cosmos.tx.signing.SignMode" json:"mode,omitempty"`
+	Mode signing.SignMode `protobuf:"varint,1,opt,name=mode,proto3,enum=cosmos.tx.signing.v1beta1.SignMode" json:"mode,omitempty"`
 }
 
 func (m *ModeInfo_Single) Reset()         { *m = ModeInfo_Single{} }
 func (m *ModeInfo_Single) String() string { return proto.CompactTextString(m) }
 func (*ModeInfo_Single) ProtoMessage()    {}
 func (*ModeInfo_Single) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{6, 0}
+	return fileDescriptor_96d1575ffde80842, []int{6, 0}
 }
 func (m *ModeInfo_Single) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -606,7 +606,7 @@ func (m *ModeInfo_Multi) Reset()         { *m = ModeInfo_Multi{} }
 func (m *ModeInfo_Multi) String() string { return proto.CompactTextString(m) }
 func (*ModeInfo_Multi) ProtoMessage()    {}
 func (*ModeInfo_Multi) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{6, 1}
+	return fileDescriptor_96d1575ffde80842, []int{6, 1}
 }
 func (m *ModeInfo_Multi) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -664,7 +664,7 @@ func (m *Fee) Reset()         { *m = Fee{} }
 func (m *Fee) String() string { return proto.CompactTextString(m) }
 func (*Fee) ProtoMessage()    {}
 func (*Fee) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9b35c9d5d6b7bce8, []int{7}
+	return fileDescriptor_96d1575ffde80842, []int{7}
 }
 func (m *Fee) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -708,72 +708,74 @@ func (m *Fee) GetGasLimit() uint64 {
 }
 
 func init() {
-	proto.RegisterType((*Tx)(nil), "cosmos.tx.Tx")
-	proto.RegisterType((*TxRaw)(nil), "cosmos.tx.TxRaw")
-	proto.RegisterType((*SignDoc)(nil), "cosmos.tx.SignDoc")
-	proto.RegisterType((*TxBody)(nil), "cosmos.tx.TxBody")
-	proto.RegisterType((*AuthInfo)(nil), "cosmos.tx.AuthInfo")
-	proto.RegisterType((*SignerInfo)(nil), "cosmos.tx.SignerInfo")
-	proto.RegisterType((*ModeInfo)(nil), "cosmos.tx.ModeInfo")
-	proto.RegisterType((*ModeInfo_Single)(nil), "cosmos.tx.ModeInfo.Single")
-	proto.RegisterType((*ModeInfo_Multi)(nil), "cosmos.tx.ModeInfo.Multi")
-	proto.RegisterType((*Fee)(nil), "cosmos.tx.Fee")
+	proto.RegisterType((*Tx)(nil), "cosmos.tx.v1beta1.Tx")
+	proto.RegisterType((*TxRaw)(nil), "cosmos.tx.v1beta1.TxRaw")
+	proto.RegisterType((*SignDoc)(nil), "cosmos.tx.v1beta1.SignDoc")
+	proto.RegisterType((*TxBody)(nil), "cosmos.tx.v1beta1.TxBody")
+	proto.RegisterType((*AuthInfo)(nil), "cosmos.tx.v1beta1.AuthInfo")
+	proto.RegisterType((*SignerInfo)(nil), "cosmos.tx.v1beta1.SignerInfo")
+	proto.RegisterType((*ModeInfo)(nil), "cosmos.tx.v1beta1.ModeInfo")
+	proto.RegisterType((*ModeInfo_Single)(nil), "cosmos.tx.v1beta1.ModeInfo.Single")
+	proto.RegisterType((*ModeInfo_Multi)(nil), "cosmos.tx.v1beta1.ModeInfo.Multi")
+	proto.RegisterType((*Fee)(nil), "cosmos.tx.v1beta1.Fee")
 }
 
-func init() { proto.RegisterFile("cosmos/tx/tx.proto", fileDescriptor_9b35c9d5d6b7bce8) }
+func init() { proto.RegisterFile("cosmos/tx/v1beta1/tx.proto", fileDescriptor_96d1575ffde80842) }
 
-var fileDescriptor_9b35c9d5d6b7bce8 = []byte{
-	// 795 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0x4f, 0x6f, 0xe3, 0x44,
-	0x14, 0x8f, 0xe3, 0x24, 0x8d, 0x5f, 0xff, 0xed, 0xce, 0x2e, 0x92, 0x9b, 0x0a, 0x37, 0x8a, 0x54,
-	0x14, 0x0e, 0xd8, 0xa5, 0x20, 0xf1, 0xe7, 0x82, 0x9a, 0xc2, 0xaa, 0x2b, 0x58, 0x40, 0x93, 0x8a,
-	0xc3, 0x5e, 0x2c, 0xdb, 0x99, 0x38, 0xa3, 0x8d, 0x67, 0x82, 0x67, 0xac, 0xda, 0x48, 0x7c, 0x07,
-	0x2e, 0x7c, 0x09, 0x0e, 0x7c, 0x03, 0xee, 0x7b, 0xdc, 0x23, 0x27, 0x40, 0xed, 0x07, 0x01, 0xcd,
-	0x78, 0x9c, 0x0d, 0xab, 0xee, 0xf6, 0xb2, 0xa7, 0xbc, 0xf9, 0xbd, 0xdf, 0x7b, 0xbf, 0x97, 0xf7,
-	0xc7, 0x80, 0x12, 0x2e, 0x32, 0x2e, 0x02, 0x59, 0x06, 0xb2, 0xf4, 0x57, 0x39, 0x97, 0x1c, 0x39,
-	0x35, 0xe6, 0xcb, 0x72, 0xf0, 0x30, 0xe5, 0x29, 0xd7, 0x68, 0xa0, 0xac, 0x9a, 0x30, 0x18, 0x98,
-	0xa0, 0x24, 0xaf, 0x56, 0x92, 0x9b, 0x1f, 0xe3, 0x7b, 0xd0, 0xf8, 0xea, 0x1c, 0x35, 0x78, 0xf4,
-	0x52, 0x45, 0xd0, 0x94, 0x51, 0x96, 0x36, 0xbf, 0x86, 0x70, 0x90, 0x72, 0x9e, 0x2e, 0x49, 0xa0,
-	0x5f, 0x71, 0x31, 0x0f, 0x22, 0x56, 0xd5, 0xae, 0xd1, 0xcf, 0xd0, 0xbe, 0x2c, 0xd1, 0x31, 0x74,
-	0x62, 0x3e, 0xab, 0x5c, 0x6b, 0x68, 0x8d, 0xb7, 0x4f, 0xef, 0xfb, 0xeb, 0x12, 0xfd, 0xcb, 0x72,
-	0xc2, 0x67, 0x15, 0xd6, 0x6e, 0x74, 0x02, 0x4e, 0x54, 0xc8, 0x45, 0x48, 0xd9, 0x9c, 0xbb, 0x6d,
-	0xcd, 0x7d, 0xb0, 0xc1, 0x3d, 0x2b, 0xe4, 0xe2, 0x31, 0x9b, 0x73, 0xdc, 0x8f, 0x8c, 0x85, 0x3c,
-	0x00, 0x55, 0x4a, 0x24, 0x8b, 0x9c, 0x08, 0xd7, 0x1e, 0xda, 0xe3, 0x1d, 0xbc, 0x81, 0x8c, 0x18,
-	0x74, 0x2f, 0x4b, 0x1c, 0x5d, 0xa1, 0x77, 0x01, 0x94, 0x44, 0x18, 0x57, 0x92, 0x08, 0x5d, 0xc7,
-	0x0e, 0x76, 0x14, 0x32, 0x51, 0x00, 0x7a, 0x0f, 0xf6, 0xd7, 0xca, 0x86, 0xd3, 0xd6, 0x9c, 0xdd,
-	0x46, 0xaa, 0xe6, 0xdd, 0xa5, 0xf7, 0x87, 0x05, 0x5b, 0x53, 0x9a, 0xb2, 0x2f, 0x79, 0xf2, 0xb6,
-	0x24, 0x0f, 0xa0, 0x9f, 0x2c, 0x22, 0xca, 0x42, 0x3a, 0x73, 0xed, 0xa1, 0x35, 0x76, 0xf0, 0x96,
-	0x7e, 0x3f, 0x9e, 0xa1, 0x63, 0xd8, 0x8b, 0x92, 0x84, 0x17, 0x4c, 0x86, 0xac, 0xc8, 0x62, 0x92,
-	0xbb, 0x9d, 0xa1, 0x35, 0xee, 0xe0, 0x5d, 0x83, 0x7e, 0xab, 0x41, 0xf4, 0x3e, 0xdc, 0x6b, 0x68,
-	0x82, 0xfc, 0x58, 0x10, 0x96, 0x10, 0xb7, 0xab, 0x89, 0xfb, 0x06, 0x9f, 0x1a, 0x78, 0xf4, 0x6b,
-	0x1b, 0x7a, 0xf5, 0x48, 0xd0, 0x09, 0xf4, 0x33, 0x22, 0x44, 0x94, 0xea, 0xe2, 0xed, 0xf1, 0xf6,
-	0xe9, 0x43, 0xbf, 0x9e, 0xb3, 0xdf, 0xcc, 0xd9, 0x3f, 0x63, 0x15, 0x5e, 0xb3, 0x10, 0x82, 0x4e,
-	0x46, 0xb2, 0x7a, 0x72, 0x0e, 0xd6, 0xb6, 0x2a, 0x51, 0xd2, 0x8c, 0xf0, 0x42, 0x86, 0x0b, 0x42,
-	0xd3, 0x85, 0xd4, 0xff, 0xa1, 0x83, 0x77, 0x0d, 0x7a, 0xa1, 0x41, 0x34, 0x81, 0xfb, 0xa4, 0x94,
-	0x84, 0x09, 0xca, 0x59, 0xc8, 0x57, 0x92, 0x72, 0x26, 0xdc, 0x7f, 0xb7, 0xde, 0x20, 0x7b, 0x6f,
-	0xcd, 0xff, 0xae, 0xa6, 0xa3, 0xa7, 0xe0, 0x31, 0xce, 0xc2, 0x24, 0xa7, 0x92, 0x26, 0xd1, 0x32,
-	0xbc, 0x25, 0xe1, 0xfe, 0x1b, 0x12, 0x1e, 0x32, 0xce, 0xce, 0x4d, 0xec, 0x57, 0xaf, 0xe4, 0x1e,
-	0xcd, 0xa1, 0xdf, 0x6c, 0x1f, 0xfa, 0x14, 0x76, 0xd4, 0xc4, 0x49, 0xae, 0x47, 0xd7, 0x34, 0xe7,
-	0x9d, 0x8d, 0x45, 0x9d, 0x6a, 0xb7, 0x5e, 0xd5, 0x6d, 0xb1, 0xb6, 0x05, 0x1a, 0x82, 0x3d, 0x27,
-	0xc4, 0x6c, 0xf6, 0xde, 0x46, 0xc0, 0x23, 0x42, 0xb0, 0x72, 0x8d, 0xae, 0x00, 0x5e, 0x06, 0xa3,
-	0x4f, 0x00, 0x56, 0x45, 0xbc, 0xa4, 0x49, 0xf8, 0x8c, 0x34, 0xc7, 0xe3, 0x36, 0x61, 0xe6, 0x6e,
-	0xbf, 0xd7, 0x84, 0xaf, 0x49, 0x85, 0x9d, 0x55, 0x63, 0xaa, 0x43, 0xca, 0xf8, 0x8c, 0xbc, 0xee,
-	0x90, 0x9e, 0xf0, 0x19, 0xa9, 0x0f, 0x29, 0x33, 0xd6, 0xe8, 0xf7, 0x36, 0xf4, 0x1b, 0x18, 0x7d,
-	0x0c, 0x3d, 0x41, 0x59, 0xba, 0x24, 0x46, 0x73, 0x70, 0x4b, 0xac, 0x3f, 0xd5, 0x8c, 0x8b, 0x16,
-	0x36, 0x5c, 0xf4, 0x21, 0x74, 0xb3, 0x62, 0x29, 0xa9, 0x11, 0x3c, 0xb8, 0x2d, 0xe8, 0x89, 0x22,
-	0x5c, 0xb4, 0x70, 0xcd, 0x1c, 0x7c, 0x06, 0xbd, 0x3a, 0x0d, 0x0a, 0xa0, 0xa3, 0x6a, 0xd1, 0x82,
-	0x7b, 0xa7, 0x87, 0x1b, 0xb1, 0xcd, 0xa7, 0x46, 0xf5, 0x45, 0xe5, 0xc1, 0x9a, 0x38, 0xb8, 0x82,
-	0xae, 0x4e, 0x86, 0x3e, 0x87, 0x7e, 0x4c, 0x65, 0x94, 0xe7, 0x51, 0xd3, 0x22, 0xef, 0x95, 0x16,
-	0x9d, 0xf3, 0x6c, 0x15, 0x25, 0x72, 0x42, 0xe5, 0x99, 0x62, 0xe1, 0x35, 0x1f, 0x9d, 0x02, 0xac,
-	0xfb, 0xa4, 0xce, 0xcf, 0x7e, 0x5d, 0xa3, 0x9c, 0xa6, 0x51, 0x62, 0xd2, 0x05, 0x5b, 0x14, 0xd9,
-	0xe8, 0x27, 0xb0, 0x1f, 0x11, 0x82, 0x7e, 0x80, 0x5e, 0x94, 0xa9, 0x13, 0x32, 0x6b, 0xb0, 0xd3,
-	0x44, 0x9f, 0x73, 0xca, 0x26, 0x27, 0xcf, 0xff, 0x3a, 0x6a, 0xfd, 0xf6, 0xf7, 0xd1, 0x38, 0xa5,
-	0x72, 0x51, 0xc4, 0x7e, 0xc2, 0xb3, 0xe0, 0x7f, 0x5f, 0xd8, 0x0f, 0xc4, 0xec, 0x59, 0x20, 0xab,
-	0x15, 0xa9, 0x03, 0x04, 0x36, 0xd9, 0xd0, 0x21, 0x38, 0x69, 0x24, 0xc2, 0x25, 0xcd, 0xa8, 0xd4,
-	0x0d, 0xed, 0xe0, 0x7e, 0x1a, 0x89, 0x6f, 0xd4, 0x7b, 0xf2, 0xc5, 0xf3, 0x6b, 0xcf, 0x7a, 0x71,
-	0xed, 0x59, 0xff, 0x5c, 0x7b, 0xd6, 0x2f, 0x37, 0x5e, 0xeb, 0xc5, 0x8d, 0xd7, 0xfa, 0xf3, 0xc6,
-	0x6b, 0x3d, 0x3d, 0xbe, 0x5b, 0x28, 0x90, 0x65, 0xdc, 0xd3, 0x9b, 0xff, 0xd1, 0x7f, 0x01, 0x00,
-	0x00, 0xff, 0xff, 0x8a, 0xb6, 0xa1, 0x83, 0x40, 0x06, 0x00, 0x00,
+var fileDescriptor_96d1575ffde80842 = []byte{
+	// 830 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0x4f, 0x6f, 0xdc, 0x44,
+	0x14, 0x5f, 0xef, 0xbf, 0xec, 0xbe, 0x24, 0x4d, 0x3b, 0xaa, 0xd0, 0x66, 0xa3, 0xba, 0xc1, 0x28,
+	0xb0, 0x08, 0xd5, 0x6e, 0xc3, 0x81, 0x3f, 0x42, 0x82, 0x6c, 0x4b, 0x49, 0x05, 0x05, 0x34, 0xc9,
+	0xa9, 0x17, 0x6b, 0xec, 0x9d, 0x78, 0x47, 0x5d, 0xcf, 0x2c, 0x9e, 0x71, 0xb1, 0x3f, 0x01, 0x97,
+	0x22, 0x71, 0xe1, 0x4b, 0xf0, 0x1d, 0xb8, 0xf7, 0xd8, 0x23, 0x07, 0x04, 0x28, 0xf9, 0x20, 0xa0,
+	0x19, 0x8f, 0xdd, 0x50, 0xa2, 0xdd, 0x0b, 0xa7, 0x7d, 0xf3, 0xe6, 0xf7, 0xfb, 0xbd, 0xdf, 0xbe,
+	0x37, 0xcf, 0x30, 0x8e, 0x85, 0x4c, 0x85, 0x0c, 0x54, 0x11, 0x3c, 0xbb, 0x17, 0x51, 0x45, 0xee,
+	0x05, 0xaa, 0xf0, 0x97, 0x99, 0x50, 0x02, 0xdd, 0xa8, 0xee, 0x7c, 0x55, 0xf8, 0xf6, 0x6e, 0x7c,
+	0x33, 0x11, 0x89, 0x30, 0xb7, 0x81, 0x8e, 0x2a, 0xe0, 0xf8, 0x1d, 0x2b, 0x12, 0x11, 0x49, 0x83,
+	0x38, 0x2b, 0x97, 0x4a, 0x34, 0x6a, 0xd5, 0xd1, 0x02, 0xdd, 0xcb, 0xc0, 0x06, 0x21, 0x18, 0x7f,
+	0x4d, 0x48, 0x15, 0x81, 0x64, 0x09, 0x67, 0x3c, 0x69, 0x50, 0xf6, 0x6c, 0x81, 0xbb, 0x89, 0x10,
+	0xc9, 0x82, 0x06, 0xe6, 0x14, 0xe5, 0x67, 0x01, 0xe1, 0x65, 0x75, 0xe5, 0xfd, 0xe8, 0x40, 0xfb,
+	0xb4, 0x40, 0x77, 0xa0, 0x1b, 0x89, 0x59, 0x39, 0x72, 0xf6, 0x9d, 0xc9, 0xe6, 0xe1, 0xae, 0xff,
+	0x9f, 0xff, 0xe2, 0x9f, 0x16, 0x53, 0x31, 0x2b, 0xb1, 0x81, 0xa1, 0x0f, 0x61, 0x48, 0x72, 0x35,
+	0x0f, 0x19, 0x3f, 0x13, 0xa3, 0xb6, 0xe1, 0xec, 0x5d, 0xc1, 0x39, 0xca, 0xd5, 0xfc, 0x11, 0x3f,
+	0x13, 0x78, 0x40, 0x6c, 0x84, 0x5c, 0x00, 0xed, 0x8d, 0xa8, 0x3c, 0xa3, 0x72, 0xd4, 0xd9, 0xef,
+	0x4c, 0xb6, 0xf0, 0xa5, 0x8c, 0xc7, 0xa1, 0x77, 0x5a, 0x60, 0xf2, 0x3d, 0xba, 0x05, 0xa0, 0x4b,
+	0x85, 0x51, 0xa9, 0xa8, 0x34, 0xbe, 0xb6, 0xf0, 0x50, 0x67, 0xa6, 0x3a, 0x81, 0xde, 0x86, 0x9d,
+	0xc6, 0x81, 0xc5, 0xb4, 0x0d, 0x66, 0xbb, 0x2e, 0x55, 0xe1, 0xd6, 0xd5, 0xfb, 0xd5, 0x81, 0x8d,
+	0x13, 0x96, 0xf0, 0x07, 0x22, 0xfe, 0xbf, 0x4a, 0xee, 0xc2, 0x20, 0x9e, 0x13, 0xc6, 0x43, 0x36,
+	0x1b, 0x75, 0xf6, 0x9d, 0xc9, 0x10, 0x6f, 0x98, 0xf3, 0xa3, 0x19, 0x3a, 0x80, 0x6b, 0x24, 0x8e,
+	0x45, 0xce, 0x55, 0xc8, 0xf3, 0x34, 0xa2, 0xd9, 0xa8, 0xbb, 0xef, 0x4c, 0xba, 0x78, 0xdb, 0x66,
+	0xbf, 0x36, 0x49, 0xf4, 0x2e, 0x5c, 0xaf, 0x61, 0x92, 0x7e, 0x97, 0x53, 0x1e, 0xd3, 0x51, 0xcf,
+	0x00, 0x77, 0x6c, 0xfe, 0xc4, 0xa6, 0xbd, 0x9f, 0xdb, 0xd0, 0xaf, 0x46, 0x83, 0xee, 0xc2, 0x20,
+	0xa5, 0x52, 0x92, 0xc4, 0x98, 0xef, 0x4c, 0x36, 0x0f, 0x6f, 0xfa, 0xd5, 0xe0, 0xfd, 0x7a, 0xf0,
+	0xfe, 0x11, 0x2f, 0x71, 0x83, 0x42, 0x08, 0xba, 0x29, 0x4d, 0xab, 0x09, 0x0e, 0xb1, 0x89, 0xb5,
+	0x45, 0xc5, 0x52, 0x2a, 0x72, 0x15, 0xce, 0x29, 0x4b, 0xe6, 0xca, 0xfc, 0x87, 0x2e, 0xde, 0xb6,
+	0xd9, 0x63, 0x93, 0x44, 0x53, 0xb8, 0x41, 0x0b, 0x45, 0xb9, 0x64, 0x82, 0x87, 0x62, 0xa9, 0x98,
+	0xe0, 0x72, 0xf4, 0xf7, 0xc6, 0x8a, 0xb2, 0xd7, 0x1b, 0xfc, 0x37, 0x15, 0x1c, 0x3d, 0x01, 0x97,
+	0x0b, 0x1e, 0xc6, 0x19, 0x53, 0x2c, 0x26, 0x8b, 0xf0, 0x0a, 0xc1, 0x9d, 0x15, 0x82, 0x7b, 0x5c,
+	0xf0, 0xfb, 0x96, 0xfb, 0xf9, 0x6b, 0xda, 0xde, 0x33, 0x18, 0xd4, 0xaf, 0x0f, 0x7d, 0x06, 0x5b,
+	0x7a, 0xe2, 0x34, 0x33, 0xa3, 0xab, 0x9b, 0x73, 0xeb, 0x8a, 0x07, 0x7b, 0x62, 0x60, 0xe6, 0xc9,
+	0x6e, 0xca, 0x26, 0x96, 0x68, 0x02, 0x9d, 0x33, 0x4a, 0xed, 0x4b, 0x7f, 0xe3, 0x0a, 0xe2, 0x43,
+	0x4a, 0xb1, 0x86, 0x78, 0xcf, 0x1d, 0x80, 0x57, 0x2a, 0xe8, 0x01, 0xc0, 0x32, 0x8f, 0x16, 0x2c,
+	0x0e, 0x9f, 0xd2, 0x7a, 0xbb, 0x0e, 0x6a, 0xbe, 0xde, 0x6b, 0xdf, 0x6e, 0x7c, 0x2d, 0xf4, 0xad,
+	0x41, 0x7f, 0x49, 0x4b, 0x3c, 0x5c, 0xd6, 0xa1, 0x5e, 0xb7, 0x54, 0xcc, 0xe8, 0xba, 0x75, 0x7b,
+	0x2c, 0x66, 0xb4, 0x5a, 0xb7, 0xd4, 0x46, 0xde, 0xef, 0x6d, 0x18, 0xd4, 0x69, 0xf4, 0x09, 0xf4,
+	0x25, 0xe3, 0xc9, 0x82, 0x5a, 0x23, 0xde, 0x0a, 0x0d, 0xff, 0xc4, 0x20, 0x8f, 0x5b, 0xd8, 0x72,
+	0xd0, 0x47, 0xd0, 0x4b, 0xf3, 0x85, 0x62, 0xd6, 0xc0, 0x9b, 0xab, 0xc8, 0x8f, 0x35, 0xf0, 0xb8,
+	0x85, 0x2b, 0xc6, 0xf8, 0x08, 0xfa, 0x95, 0x1c, 0xfa, 0x00, 0xba, 0xda, 0x9b, 0x31, 0x70, 0xed,
+	0xf0, 0xad, 0x4b, 0x1a, 0xf5, 0x17, 0xeb, 0xf2, 0x28, 0xb4, 0x1e, 0x36, 0x84, 0xf1, 0x73, 0x07,
+	0x7a, 0x46, 0x15, 0x7d, 0x01, 0x83, 0x88, 0x29, 0x92, 0x65, 0xa4, 0x6e, 0xe8, 0x7b, 0xab, 0x1a,
+	0x7a, 0x5f, 0xa4, 0x4b, 0x12, 0xab, 0x29, 0x53, 0x47, 0x9a, 0x82, 0x1b, 0x32, 0xfa, 0x18, 0xa0,
+	0xe9, 0xaa, 0x5e, 0xe5, 0xce, 0xba, 0xb6, 0x0e, 0xeb, 0xb6, 0xca, 0x69, 0x0f, 0x3a, 0x32, 0x4f,
+	0xbd, 0x1f, 0x1c, 0xe8, 0x3c, 0xa4, 0x14, 0xc5, 0xd0, 0x27, 0xa9, 0xde, 0x4b, 0xfb, 0xb6, 0x76,
+	0xff, 0xe5, 0xe8, 0x95, 0x15, 0xc6, 0xa7, 0x77, 0x5f, 0xfc, 0x71, 0xbb, 0xf5, 0xcb, 0x9f, 0xb7,
+	0x27, 0x09, 0x53, 0xf3, 0x3c, 0xf2, 0x63, 0x91, 0x06, 0xf6, 0x3b, 0x5e, 0xfd, 0xdc, 0x91, 0xb3,
+	0xa7, 0x81, 0x2a, 0x97, 0x54, 0x1a, 0x82, 0xc4, 0x56, 0x1a, 0xed, 0xc1, 0x30, 0x21, 0x32, 0x5c,
+	0xb0, 0x94, 0x29, 0x33, 0x84, 0x2e, 0x1e, 0x24, 0x44, 0x7e, 0xa5, 0xcf, 0xd3, 0x4f, 0x5f, 0x9c,
+	0xbb, 0xce, 0xcb, 0x73, 0xd7, 0xf9, 0xeb, 0xdc, 0x75, 0x7e, 0xba, 0x70, 0x5b, 0x2f, 0x2f, 0xdc,
+	0xd6, 0x6f, 0x17, 0x6e, 0xeb, 0xc9, 0xc1, 0xfa, 0x42, 0x81, 0x2a, 0xa2, 0xbe, 0xd9, 0xad, 0xf7,
+	0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x43, 0xc7, 0xe9, 0x47, 0xe3, 0x06, 0x00, 0x00,
 }
 
 func (m *Tx) Marshal() (dAtA []byte, err error) {