diff --git a/app/app.go b/app/app.go index d7b00cee..537e5723 100644 --- a/app/app.go +++ b/app/app.go @@ -164,10 +164,17 @@ import ( validatorvesting "github.com/0glabs/0g-chain/x/validator-vesting" validatorvestingrest "github.com/0glabs/0g-chain/x/validator-vesting/client/rest" validatorvestingtypes "github.com/0glabs/0g-chain/x/validator-vesting/types" + + council "github.com/0glabs/0g-chain/x/council/v1" + councilkeeper "github.com/0glabs/0g-chain/x/council/v1/keeper" + counciltypes "github.com/0glabs/0g-chain/x/council/v1/types" + das "github.com/0glabs/0g-chain/x/das/v1" + daskeeper "github.com/0glabs/0g-chain/x/das/v1/keeper" + dastypes "github.com/0glabs/0g-chain/x/das/v1/types" ) const ( - appName = "kava" + appName = "0gchain" ) var ( @@ -230,6 +237,8 @@ var ( community.AppModuleBasic{}, metrics.AppModuleBasic{}, consensus.AppModuleBasic{}, + council.AppModuleBasic{}, + das.AppModuleBasic{}, ) // module account permissions @@ -335,6 +344,8 @@ type App struct { mintKeeper mintkeeper.Keeper communityKeeper communitykeeper.Keeper consensusParamsKeeper consensusparamkeeper.Keeper + CouncilKeeper councilkeeper.Keeper + DasKeeper daskeeper.Keeper // make scoped keepers public for test purposes ScopedIBCKeeper capabilitykeeper.ScopedKeeper @@ -390,6 +401,7 @@ func NewApp( committeetypes.StoreKey, incentivetypes.StoreKey, evmutiltypes.StoreKey, savingstypes.StoreKey, earntypes.StoreKey, minttypes.StoreKey, consensusparamtypes.StoreKey, crisistypes.StoreKey, + counciltypes.StoreKey, dastypes.StoreKey, ) tkeys := sdk.NewTransientStoreKeys(paramstypes.TStoreKey, evmtypes.TransientKey, feemarkettypes.TransientKey) memKeys := sdk.NewMemoryStoreKeys(capabilitytypes.MemStoreKey) @@ -806,6 +818,11 @@ func NewApp( ) app.govKeeper.SetTallyHandler(tallyHandler) + app.CouncilKeeper = councilkeeper.NewKeeper( + keys[counciltypes.StoreKey], appCodec, app.stakingKeeper, + ) + app.DasKeeper = daskeeper.NewKeeper(keys[dastypes.StoreKey], appCodec, app.stakingKeeper) + // create the module manager (Note: Any module instantiated in the module manager that is later modified // must be passed by reference here.) app.mm = module.NewManager( @@ -849,6 +866,8 @@ func NewApp( mint.NewAppModule(appCodec, app.mintKeeper, app.accountKeeper, nil, mintSubspace), community.NewAppModule(app.communityKeeper, app.accountKeeper), metrics.NewAppModule(options.TelemetryOptions), + council.NewAppModule(app.CouncilKeeper, app.stakingKeeper), + das.NewAppModule(app.DasKeeper), ) // Warning: Some begin blockers must run before others. Ensure the dependencies are understood before modifying this list. @@ -904,6 +923,9 @@ func NewApp( routertypes.ModuleName, consensusparamtypes.ModuleName, packetforwardtypes.ModuleName, + + counciltypes.ModuleName, + dastypes.ModuleName, ) // Warning: Some end blockers must run before others. Ensure the dependencies are understood before modifying this list. @@ -949,6 +971,8 @@ func NewApp( metricstypes.ModuleName, consensusparamtypes.ModuleName, packetforwardtypes.ModuleName, + counciltypes.ModuleName, + dastypes.ModuleName, ) // Warning: Some init genesis methods must run before others. Ensure the dependencies are understood before modifying this list @@ -993,6 +1017,8 @@ func NewApp( consensusparamtypes.ModuleName, packetforwardtypes.ModuleName, crisistypes.ModuleName, // runs the invariants at genesis, should run after other modules + counciltypes.ModuleName, + dastypes.ModuleName, ) app.mm.RegisterInvariants(&app.crisisKeeper) diff --git a/cmd/0gchain/cmd/rocksdb/compact.go b/cmd/0gchain/cmd/rocksdb/compact.go index 035f675b..fcc1a9c5 100644 --- a/cmd/0gchain/cmd/rocksdb/compact.go +++ b/cmd/0gchain/cmd/rocksdb/compact.go @@ -14,7 +14,7 @@ import ( "syscall" "time" - "github.com/0glabs/0g-chain/cmd/kava/opendb" + "github.com/0glabs/0g-chain/cmd/0gchain/opendb" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/server" "github.com/linxGnu/grocksdb" diff --git a/crypto/vrf/algorithm.go b/crypto/vrf/algorithm.go new file mode 100644 index 00000000..bc344e44 --- /dev/null +++ b/crypto/vrf/algorithm.go @@ -0,0 +1,58 @@ +package vrf + +import ( + "github.com/cosmos/cosmos-sdk/crypto/hd" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" +) + +var ( + // SupportedAlgorithms defines the list of signing algorithms used on Evmos: + // - eth_secp256k1 (Ethereum) + // - secp256k1 (Tendermint) + SupportedAlgorithms = keyring.SigningAlgoList{VrfAlgo} + // SupportedAlgorithmsLedger defines the list of signing algorithms used on Evmos for the Ledger device: + // - eth_secp256k1 (Ethereum) + // - secp256k1 (Tendermint) + SupportedAlgorithmsLedger = keyring.SigningAlgoList{VrfAlgo} +) + +func VrfOption() keyring.Option { + return func(options *keyring.Options) { + options.SupportedAlgos = SupportedAlgorithms + options.SupportedAlgosLedger = SupportedAlgorithmsLedger + } +} + +const ( + VrfType = hd.PubKeyType(KeyType) +) + +var ( + _ keyring.SignatureAlgo = VrfAlgo + VrfAlgo = vrfAlgo{} +) + +type vrfAlgo struct{} + +func (s vrfAlgo) Name() hd.PubKeyType { + return VrfType +} + +func (s vrfAlgo) Derive() hd.DeriveFn { + return func(mnemonic, bip39Passphrase, path string) ([]byte, error) { + key, err := GenerateKey() + if err != nil { + return nil, err + } + + return key.Bytes(), nil + } +} + +func (s vrfAlgo) Generate() hd.GenerateFn { + return func(bz []byte) cryptotypes.PrivKey { + key, _ := GenerateKey() + return key + } +} diff --git a/crypto/vrf/keys.pb.go b/crypto/vrf/keys.pb.go new file mode 100644 index 00000000..e67dc52b --- /dev/null +++ b/crypto/vrf/keys.pb.go @@ -0,0 +1,496 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: crypto/vrf/keys.proto + +package vrf + +import ( + fmt "fmt" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/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 + +// PubKey defines a type alias for an vrf.PublicKey that implements +// Vrf's PubKey interface. It represents the 32-byte compressed public +// key format. +type PubKey struct { + // key is the public key in byte form + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *PubKey) Reset() { *m = PubKey{} } +func (*PubKey) ProtoMessage() {} +func (*PubKey) Descriptor() ([]byte, []int) { + return fileDescriptor_eae59d1af27f5957, []int{0} +} +func (m *PubKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PubKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PubKey.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 *PubKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_PubKey.Merge(m, src) +} +func (m *PubKey) XXX_Size() int { + return m.Size() +} +func (m *PubKey) XXX_DiscardUnknown() { + xxx_messageInfo_PubKey.DiscardUnknown(m) +} + +var xxx_messageInfo_PubKey proto.InternalMessageInfo + +func (m *PubKey) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +// PrivKey defines a type alias for an vrf.PrivateKey that implements +// Vrf's PrivateKey interface. +type PrivKey struct { + // key is the private key in byte form + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *PrivKey) Reset() { *m = PrivKey{} } +func (m *PrivKey) String() string { return proto.CompactTextString(m) } +func (*PrivKey) ProtoMessage() {} +func (*PrivKey) Descriptor() ([]byte, []int) { + return fileDescriptor_eae59d1af27f5957, []int{1} +} +func (m *PrivKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrivKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PrivKey.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 *PrivKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrivKey.Merge(m, src) +} +func (m *PrivKey) XXX_Size() int { + return m.Size() +} +func (m *PrivKey) XXX_DiscardUnknown() { + xxx_messageInfo_PrivKey.DiscardUnknown(m) +} + +var xxx_messageInfo_PrivKey proto.InternalMessageInfo + +func (m *PrivKey) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func init() { + proto.RegisterType((*PubKey)(nil), "crypto.vrf.PubKey") + proto.RegisterType((*PrivKey)(nil), "crypto.vrf.PrivKey") +} + +func init() { proto.RegisterFile("crypto/vrf/keys.proto", fileDescriptor_eae59d1af27f5957) } + +var fileDescriptor_eae59d1af27f5957 = []byte{ + // 174 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4d, 0x2e, 0xaa, 0x2c, + 0x28, 0xc9, 0xd7, 0x2f, 0x2b, 0x4a, 0xd3, 0xcf, 0x4e, 0xad, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, + 0xc9, 0x17, 0xe2, 0x82, 0x08, 0xeb, 0x95, 0x15, 0xa5, 0x49, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, + 0x85, 0xf5, 0x41, 0x2c, 0x88, 0x0a, 0x25, 0x05, 0x2e, 0xb6, 0x80, 0xd2, 0x24, 0xef, 0xd4, 0x4a, + 0x21, 0x01, 0x2e, 0xe6, 0xec, 0xd4, 0x4a, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x9e, 0x20, 0x10, 0xd3, + 0x8a, 0x65, 0xc6, 0x02, 0x79, 0x06, 0x25, 0x69, 0x2e, 0xf6, 0x80, 0xa2, 0xcc, 0x32, 0xac, 0x4a, + 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, 0xdf, 0x20, 0x3d, 0x27, 0x31, 0xa9, 0x58, 0xdf, + 0x20, 0x5d, 0x37, 0x39, 0x23, 0x31, 0x33, 0x4f, 0x1f, 0xe1, 0xd8, 0x24, 0x36, 0xb0, 0x33, 0x8c, + 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xdb, 0xb8, 0x32, 0x07, 0xc1, 0x00, 0x00, 0x00, +} + +func (m *PubKey) 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 *PubKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PubKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PrivKey) 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 *PrivKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PrivKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintKeys(dAtA []byte, offset int, v uint64) int { + offset -= sovKeys(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *PubKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *PrivKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func sovKeys(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozKeys(x uint64) (n int) { + return sovKeys(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *PubKey) 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 ErrIntOverflowKeys + } + 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: PubKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PubKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrivKey) 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 ErrIntOverflowKeys + } + 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: PrivKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrivKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipKeys(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, ErrIntOverflowKeys + } + 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, ErrIntOverflowKeys + } + 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, ErrIntOverflowKeys + } + 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, ErrInvalidLengthKeys + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupKeys + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthKeys + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthKeys = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowKeys = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupKeys = fmt.Errorf("proto: unexpected end of group") +) diff --git a/crypto/vrf/vrf.go b/crypto/vrf/vrf.go new file mode 100644 index 00000000..a3586cb2 --- /dev/null +++ b/crypto/vrf/vrf.go @@ -0,0 +1,194 @@ +package vrf + +import ( + "bytes" + "crypto/subtle" + "fmt" + + errorsmod "cosmossdk.io/errors" + tmcrypto "github.com/cometbft/cometbft/crypto" + vrfalgo "github.com/coniks-sys/coniks-go/crypto/vrf" + "github.com/cosmos/cosmos-sdk/codec" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/ethereum/go-ethereum/common" +) + +const ( + // PrivKeySize defines the size of the PrivKey bytes + PrivKeySize = 64 + // PubKeySize defines the size of the PubKey bytes + PubKeySize = 32 + // KeyType is the string constant for the vrf algorithm + KeyType = "vrf" +) + +// Amino encoding names +const ( + // PrivKeyName defines the amino encoding name for the vrf private key + PrivKeyName = "vrf/PrivKey" + // PubKeyName defines the amino encoding name for the vrf public key + PubKeyName = "vrf/PubKey" +) + +// ---------------------------------------------------------------------------- +// vrf Private Key + +var ( + _ cryptotypes.PrivKey = &PrivKey{} + _ codec.AminoMarshaler = &PrivKey{} +) + +// GenerateKey generates a new random private key. It returns an error upon +// failure. +func GenerateKey() (*PrivKey, error) { + priv, err := vrfalgo.GenerateKey(nil) + if err != nil { + return nil, err + } + + return &PrivKey{ + Key: priv, + }, nil +} + +func (privKey PrivKey) getVrfPrivateKey() vrfalgo.PrivateKey { + return vrfalgo.PrivateKey(privKey.Key) +} + +// Bytes returns the byte representation of the Private Key. +func (privKey PrivKey) Bytes() []byte { + bz := make([]byte, len(privKey.Key)) + copy(bz, privKey.Key) + + return bz +} + +// PubKey returns the private key's public key. If the privkey is not valid +// it returns a nil value. +func (privKey PrivKey) PubKey() cryptotypes.PubKey { + pk, _ := vrfalgo.PrivateKey(privKey.Key).Public() + + return &PubKey{ + Key: pk, + } +} + +// Equals returns true if two private keys are equal and false otherwise. +func (privKey PrivKey) Equals(other cryptotypes.LedgerPrivKey) bool { + return privKey.Type() == other.Type() && subtle.ConstantTimeCompare(privKey.Bytes(), other.Bytes()) == 1 +} + +// Type returns vrf +func (privKey PrivKey) Type() string { + return KeyType +} + +// Compute generates the vrf value for the byte slice m using the +// underlying private key sk. +func (privKey PrivKey) Sign(digestBz []byte) ([]byte, error) { + sk := privKey.getVrfPrivateKey() + + return sk.Compute(digestBz), nil +} + +// MarshalAmino overrides Amino binary marshaling. +func (privKey PrivKey) MarshalAmino() ([]byte, error) { + return privKey.Key, nil +} + +// UnmarshalAmino overrides Amino binary marshaling. +func (privKey *PrivKey) UnmarshalAmino(bz []byte) error { + if len(bz) != PrivKeySize { + return fmt.Errorf("invalid privkey size, expected %d got %d", PrivKeySize, len(bz)) + } + privKey.Key = bz + + return nil +} + +// MarshalAminoJSON overrides Amino JSON marshaling. +func (privKey PrivKey) MarshalAminoJSON() ([]byte, error) { + // When we marshal to Amino JSON, we don't marshal the "key" field itself, + // just its contents (i.e. the key bytes). + return privKey.MarshalAmino() +} + +// UnmarshalAminoJSON overrides Amino JSON marshaling. +func (privKey *PrivKey) UnmarshalAminoJSON(bz []byte) error { + return privKey.UnmarshalAmino(bz) +} + +// ---------------------------------------------------------------------------- +// vrf Public Key + +var ( + _ cryptotypes.PubKey = &PubKey{} + _ codec.AminoMarshaler = &PubKey{} +) + +// func (pubKey PubKey) getVrfPublicKey() vrfalgo.PublicKey { +// return vrfalgo.PublicKey(pubKey.Key) +// } + +// Address returns the address of the ECDSA public key. +// The function will return an empty address if the public key is invalid. +func (pubKey PubKey) Address() tmcrypto.Address { + return tmcrypto.Address(common.BytesToAddress(pubKey.Key).Bytes()) +} + +// Bytes returns the raw bytes of the ECDSA public key. +func (pubKey PubKey) Bytes() []byte { + bz := make([]byte, len(pubKey.Key)) + copy(bz, pubKey.Key) + + return bz +} + +// String implements the fmt.Stringer interface. +func (pubKey PubKey) String() string { + return fmt.Sprintf("vrf{%X}", pubKey.Key) +} + +// Type returns vrf +func (pubKey PubKey) Type() string { + return KeyType +} + +// Equals returns true if the pubkey type is the same and their bytes are deeply equal. +func (pubKey PubKey) Equals(other cryptotypes.PubKey) bool { + return pubKey.Type() == other.Type() && bytes.Equal(pubKey.Bytes(), other.Bytes()) +} + +// Verify returns true iff vrf=Compute(m) for the sk that +// corresponds to pk. +func (pubKey PubKey) VerifySignature(msg, sig []byte) bool { + panic("not implement") +} + +// MarshalAmino overrides Amino binary marshaling. +func (pubKey PubKey) MarshalAmino() ([]byte, error) { + return pubKey.Key, nil +} + +// UnmarshalAmino overrides Amino binary marshaling. +func (pubKey *PubKey) UnmarshalAmino(bz []byte) error { + if len(bz) != PubKeySize { + return errorsmod.Wrapf(errortypes.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz)) + } + pubKey.Key = bz + + return nil +} + +// MarshalAminoJSON overrides Amino JSON marshaling. +func (pubKey PubKey) MarshalAminoJSON() ([]byte, error) { + // When we marshal to Amino JSON, we don't marshal the "key" field itself, + // just its contents (i.e. the key bytes). + return pubKey.MarshalAmino() +} + +// UnmarshalAminoJSON overrides Amino JSON marshaling. +func (pubKey *PubKey) UnmarshalAminoJSON(bz []byte) error { + return pubKey.UnmarshalAmino(bz) +} diff --git a/crypto/vrf/vrf_test.go b/crypto/vrf/vrf_test.go new file mode 100644 index 00000000..f5696182 --- /dev/null +++ b/crypto/vrf/vrf_test.go @@ -0,0 +1,96 @@ +package vrf + +import ( + "testing" + + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" + + "encoding/base64" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/codec" +) + +func TestPrivKey(t *testing.T) { + // validate type and equality + privKey, err := GenerateKey() + require.NoError(t, err) + require.Implements(t, (*cryptotypes.PrivKey)(nil), privKey) + + // validate inequality + privKey2, err := GenerateKey() + require.NoError(t, err) + require.False(t, privKey.Equals(privKey2)) +} + +func TestPrivKey_PubKey(t *testing.T) { + privKey, err := GenerateKey() + require.NoError(t, err) + + // validate type and equality + pubKey := &PubKey{ + Key: privKey.PubKey().Bytes(), + } + require.Implements(t, (*cryptotypes.PubKey)(nil), pubKey) + + // validate inequality + privKey2, err := GenerateKey() + require.NoError(t, err) + require.False(t, pubKey.Equals(privKey2.PubKey())) +} + +func TestMarshalAmino(t *testing.T) { + aminoCdc := codec.NewLegacyAmino() + privKey, err := GenerateKey() + require.NoError(t, err) + + pubKey := privKey.PubKey().(*PubKey) + + testCases := []struct { + desc string + msg codec.AminoMarshaler + typ interface{} + expBinary []byte + expJSON string + }{ + { + "vrf private key", + privKey, + &PrivKey{}, + append([]byte{64}, privKey.Bytes()...), // Length-prefixed. + "\"" + base64.StdEncoding.EncodeToString(privKey.Bytes()) + "\"", + }, + { + "vrf public key", + pubKey, + &PubKey{}, + append([]byte{32}, pubKey.Bytes()...), // Length-prefixed. + "\"" + base64.StdEncoding.EncodeToString(pubKey.Bytes()) + "\"", + }, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + // Do a round trip of encoding/decoding binary. + bz, err := aminoCdc.Marshal(tc.msg) + require.NoError(t, err) + require.Equal(t, tc.expBinary, bz) + + err = aminoCdc.Unmarshal(bz, tc.typ) + require.NoError(t, err) + + require.Equal(t, tc.msg, tc.typ) + + // Do a round trip of encoding/decoding JSON. + bz, err = aminoCdc.MarshalJSON(tc.msg) + require.NoError(t, err) + require.Equal(t, tc.expJSON, string(bz)) + + err = aminoCdc.UnmarshalJSON(bz, tc.typ) + require.NoError(t, err) + + require.Equal(t, tc.msg, tc.typ) + }) + } +} diff --git a/go.mod b/go.mod index aa22ed76..82e03482 100644 --- a/go.mod +++ b/go.mod @@ -9,6 +9,7 @@ require ( github.com/cenkalti/backoff/v4 v4.1.3 github.com/cometbft/cometbft v0.37.4 github.com/cometbft/cometbft-db v0.9.1 + github.com/coniks-sys/coniks-go v0.0.0-20180722014011-11acf4819b71 github.com/cosmos/cosmos-proto v1.0.0-beta.4 github.com/cosmos/cosmos-sdk v0.47.10 github.com/cosmos/go-bip39 v1.0.0 diff --git a/go.sum b/go.sum index 33f558d2..05106bfb 100644 --- a/go.sum +++ b/go.sum @@ -396,6 +396,8 @@ github.com/coinbase/rosetta-sdk-go v0.7.9 h1:lqllBjMnazTjIqYrOGv8h8jxjg9+hJazIGZ github.com/coinbase/rosetta-sdk-go v0.7.9/go.mod h1:0/knutI7XGVqXmmH4OQD8OckFrbQ8yMsUZTG7FXCR2M= github.com/confio/ics23/go v0.9.0 h1:cWs+wdbS2KRPZezoaaj+qBleXgUk5WOQFMP3CQFGTr4= github.com/confio/ics23/go v0.9.0/go.mod h1:4LPZ2NYqnYIVRklaozjNR1FScgDJ2s5Xrp+e/mYVRak= +github.com/coniks-sys/coniks-go v0.0.0-20180722014011-11acf4819b71 h1:MFLTqgfJclmtaQ1SRUrWwmDX/1UBok3XWUethkJ2swQ= +github.com/coniks-sys/coniks-go v0.0.0-20180722014011-11acf4819b71/go.mod h1:TrHYHH4Wze7v7Hkwu1MH1W+mCPQKM+gs+PicdEV14o8= github.com/consensys/bavard v0.1.8-0.20210406032232-f3452dc9b572/go.mod h1:Bpd0/3mZuaj6Sj+PqrmIquiOKy397AKGThQPaGzNXAQ= github.com/consensys/bavard v0.1.8-0.20210915155054-088da2f7f54a/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= github.com/consensys/gnark-crypto v0.4.1-0.20210426202927-39ac3d4b3f1f/go.mod h1:815PAHg3wvysy0SyIqanF8gZ0Y1wjk/hrDHD/iT88+Q= diff --git a/helper/da/client/client.go b/helper/da/client/client.go new file mode 100644 index 00000000..533c9e9c --- /dev/null +++ b/helper/da/client/client.go @@ -0,0 +1,61 @@ +package client + +import ( + "context" + "time" + + "github.com/0glabs/0g-evmos/helper/da/light" + + "github.com/pkg/errors" +) + +type DaLightRpcClient interface { + Sample(ctx context.Context, streamId, headerHash []byte, blobIdx, times uint32) (bool, error) + Destroy() + GetInstanceCount() int +} + +type daLightClient struct { + maxInstance int + pool ConnectionPool +} + +func NewDaLightClient(address string, instanceLimit int) DaLightRpcClient { + return &daLightClient{ + maxInstance: instanceLimit, + pool: NewConnectionPool(address, instanceLimit, 10*time.Minute), + } +} + +func (c *daLightClient) Sample(ctx context.Context, streamId, headerHash []byte, blobIdx, times uint32) (bool, error) { + connection, err := c.pool.GetConnection() + if err != nil { + return false, errors.Wrap(err, "failed to connect to da light server") + } + defer c.pool.ReleaseConnection(connection) + + req := &light.SampleRequest{ + StreamId: streamId, + BatchHeaderHash: headerHash, + BlobIndex: blobIdx, + Times: times, + } + client := light.NewLightClient(connection) + reply, err := client.Sample(ctx, req) + if err != nil { + return false, errors.Wrap(err, "failed to sample from da light server") + } + + return reply.Success, nil +} + +func (c *daLightClient) Destroy() { + if c.pool != nil { + c.pool.Close() + c.pool = nil + } +} + +func (c *daLightClient) GetInstanceCount() int { + return c.maxInstance +} diff --git a/helper/da/client/pool.go b/helper/da/client/pool.go new file mode 100644 index 00000000..887704a0 --- /dev/null +++ b/helper/da/client/pool.go @@ -0,0 +1,101 @@ +package client + +import ( + "errors" + "sync" + "time" + + "google.golang.org/grpc" + "google.golang.org/grpc/backoff" + "google.golang.org/grpc/credentials/insecure" +) + +type ConnectionPool interface { + GetConnection() (*grpc.ClientConn, error) + ReleaseConnection(*grpc.ClientConn) + Close() +} + +type connectionPoolImpl struct { + address string + maxSize int + timeout time.Duration + param grpc.ConnectParams + + mu sync.Mutex + pool []*grpc.ClientConn +} + +func NewConnectionPool(address string, maxSize int, timeout time.Duration) ConnectionPool { + return &connectionPoolImpl{ + address: address, + maxSize: maxSize, + timeout: timeout, + param: grpc.ConnectParams{ + Backoff: backoff.Config{ + BaseDelay: 1.0 * time.Second, + Multiplier: 1.5, + Jitter: 0.2, + MaxDelay: 30 * time.Second, + }, + MinConnectTimeout: 30 * time.Second, + }, + pool: make([]*grpc.ClientConn, 0, maxSize), + } +} + +func (p *connectionPoolImpl) GetConnection() (*grpc.ClientConn, error) { + p.mu.Lock() + defer p.mu.Unlock() + + if p.pool == nil { + return nil, errors.New("connection pool is closed") + } + + // Check if there's any available connection in the pool + if len(p.pool) > 0 { + conn := p.pool[0] + p.pool = p.pool[1:] + return conn, nil + } + + // If the pool is empty, create a new connection + conn, err := grpc.Dial(p.address, grpc.WithBlock(), + grpc.WithConnectParams(p.param), + grpc.WithTransportCredentials(insecure.NewCredentials())) + if err != nil { + return nil, err + } + return conn, nil +} + +func (p *connectionPoolImpl) ReleaseConnection(conn *grpc.ClientConn) { + p.mu.Lock() + defer p.mu.Unlock() + + if p.pool != nil { + // If the pool is full, close the connection + if len(p.pool) >= p.maxSize { + conn.Close() + return + } + + // Add the connection back to the pool + p.pool = append(p.pool, conn) + } else { + conn.Close() + } +} + +func (p *connectionPoolImpl) Close() { + p.mu.Lock() + defer p.mu.Unlock() + + if p.pool != nil { + for _, conn := range p.pool { + conn.Close() + } + + p.pool = nil + } +} diff --git a/helper/da/go.mod b/helper/da/go.mod new file mode 100644 index 00000000..b0e11e7e --- /dev/null +++ b/helper/da/go.mod @@ -0,0 +1,26 @@ +module github.com/0glabs/0g-evmos/helper/da + +go 1.20 + +require ( + github.com/json-iterator/go v1.1.12 + github.com/lesismal/nbio v1.5.4 + github.com/pkg/errors v0.9.1 + github.com/rs/zerolog v1.32.0 + google.golang.org/grpc v1.63.2 + google.golang.org/protobuf v1.33.0 +) + +require ( + github.com/lesismal/llib v1.1.13 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.19 // indirect + github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/stretchr/testify v1.8.4 // indirect + golang.org/x/crypto v0.19.0 // indirect + golang.org/x/net v0.21.0 // indirect + golang.org/x/sys v0.17.0 // indirect + golang.org/x/text v0.14.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de // indirect +) diff --git a/helper/da/go.sum b/helper/da/go.sum new file mode 100644 index 00000000..cc3cf3ca --- /dev/null +++ b/helper/da/go.sum @@ -0,0 +1,60 @@ +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/lesismal/llib v1.1.13 h1:+w1+t0PykXpj2dXQck0+p6vdC9/mnbEXHgUy/HXDGfE= +github.com/lesismal/llib v1.1.13/go.mod h1:70tFXXe7P1FZ02AU9l8LgSOK7d7sRrpnkUr3rd3gKSg= +github.com/lesismal/nbio v1.5.4 h1:fZ6FOVZOBm7nFuudYsq+WyHJuM2UNuPdlvF/1LVa6lo= +github.com/lesismal/nbio v1.5.4/go.mod h1:mvfYBAA1jmrafXf2XvkM28jWkMTfA5jGks+HKDBMmOc= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0= +github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +golang.org/x/crypto v0.0.0-20210513122933-cd7d49e622d5/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= +golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210510120150-4163338589ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de h1:cZGRis4/ot9uVm639a+rHCUaG0JJHEsdyzSQTMX+suY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de/go.mod h1:H4O17MA/PE9BsGx3w+a+W2VOLLD1Qf7oJneAoU6WktY= +google.golang.org/grpc v1.63.2 h1:MUeiw1B2maTVZthpU5xvASfTh3LDbxHd6IJ6QQVU+xM= +google.golang.org/grpc v1.63.2/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDomNkRA= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/helper/da/light/light.pb.go b/helper/da/light/light.pb.go new file mode 100644 index 00000000..60c987f2 --- /dev/null +++ b/helper/da/light/light.pb.go @@ -0,0 +1,397 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v4.25.3 +// source: light/light.proto + +package light + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// SampleRequest contains the blob to sample (by batch and blob index) and required sample times +type SampleRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StreamId []byte `protobuf:"bytes,1,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"` + BatchHeaderHash []byte `protobuf:"bytes,2,opt,name=batch_header_hash,json=batchHeaderHash,proto3" json:"batch_header_hash,omitempty"` + BlobIndex uint32 `protobuf:"varint,3,opt,name=blob_index,json=blobIndex,proto3" json:"blob_index,omitempty"` + Times uint32 `protobuf:"varint,4,opt,name=times,proto3" json:"times,omitempty"` +} + +func (x *SampleRequest) Reset() { + *x = SampleRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_light_light_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SampleRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SampleRequest) ProtoMessage() {} + +func (x *SampleRequest) ProtoReflect() protoreflect.Message { + mi := &file_light_light_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SampleRequest.ProtoReflect.Descriptor instead. +func (*SampleRequest) Descriptor() ([]byte, []int) { + return file_light_light_proto_rawDescGZIP(), []int{0} +} + +func (x *SampleRequest) GetStreamId() []byte { + if x != nil { + return x.StreamId + } + return nil +} + +func (x *SampleRequest) GetBatchHeaderHash() []byte { + if x != nil { + return x.BatchHeaderHash + } + return nil +} + +func (x *SampleRequest) GetBlobIndex() uint32 { + if x != nil { + return x.BlobIndex + } + return 0 +} + +func (x *SampleRequest) GetTimes() uint32 { + if x != nil { + return x.Times + } + return 0 +} + +// SampleReply contains the sample result +type SampleReply struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` +} + +func (x *SampleReply) Reset() { + *x = SampleReply{} + if protoimpl.UnsafeEnabled { + mi := &file_light_light_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SampleReply) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SampleReply) ProtoMessage() {} + +func (x *SampleReply) ProtoReflect() protoreflect.Message { + mi := &file_light_light_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SampleReply.ProtoReflect.Descriptor instead. +func (*SampleReply) Descriptor() ([]byte, []int) { + return file_light_light_proto_rawDescGZIP(), []int{1} +} + +func (x *SampleReply) GetSuccess() bool { + if x != nil { + return x.Success + } + return false +} + +type RetrieveRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BatchHeaderHash []byte `protobuf:"bytes,1,opt,name=batch_header_hash,json=batchHeaderHash,proto3" json:"batch_header_hash,omitempty"` + BlobIndex uint32 `protobuf:"varint,2,opt,name=blob_index,json=blobIndex,proto3" json:"blob_index,omitempty"` +} + +func (x *RetrieveRequest) Reset() { + *x = RetrieveRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_light_light_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RetrieveRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RetrieveRequest) ProtoMessage() {} + +func (x *RetrieveRequest) ProtoReflect() protoreflect.Message { + mi := &file_light_light_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RetrieveRequest.ProtoReflect.Descriptor instead. +func (*RetrieveRequest) Descriptor() ([]byte, []int) { + return file_light_light_proto_rawDescGZIP(), []int{2} +} + +func (x *RetrieveRequest) GetBatchHeaderHash() []byte { + if x != nil { + return x.BatchHeaderHash + } + return nil +} + +func (x *RetrieveRequest) GetBlobIndex() uint32 { + if x != nil { + return x.BlobIndex + } + return 0 +} + +type RetrieveReply struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Status bool `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *RetrieveReply) Reset() { + *x = RetrieveReply{} + if protoimpl.UnsafeEnabled { + mi := &file_light_light_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RetrieveReply) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RetrieveReply) ProtoMessage() {} + +func (x *RetrieveReply) ProtoReflect() protoreflect.Message { + mi := &file_light_light_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RetrieveReply.ProtoReflect.Descriptor instead. +func (*RetrieveReply) Descriptor() ([]byte, []int) { + return file_light_light_proto_rawDescGZIP(), []int{3} +} + +func (x *RetrieveReply) GetStatus() bool { + if x != nil { + return x.Status + } + return false +} + +func (x *RetrieveReply) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +var File_light_light_proto protoreflect.FileDescriptor + +var file_light_light_proto_rawDesc = []byte{ + 0x0a, 0x11, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x22, 0x8d, 0x01, 0x0a, 0x0d, 0x53, + 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x08, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x2a, 0x0a, 0x11, 0x62, 0x61, 0x74, + 0x63, 0x68, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x48, 0x61, 0x73, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x62, 0x49, + 0x6e, 0x64, 0x65, 0x78, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x05, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x22, 0x27, 0x0a, 0x0b, 0x53, 0x61, + 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, + 0x63, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x22, 0x5c, 0x0a, 0x0f, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x0f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x48, 0x61, + 0x73, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x62, 0x49, 0x6e, 0x64, 0x65, + 0x78, 0x22, 0x3b, 0x0a, 0x0d, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, 0x70, + 0x6c, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x32, 0x79, + 0x0a, 0x05, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x12, 0x34, 0x0a, 0x06, 0x53, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x12, 0x14, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, + 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x12, 0x3a, 0x0a, + 0x08, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x12, 0x16, 0x2e, 0x6c, 0x69, 0x67, 0x68, + 0x74, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x14, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, + 0x76, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x42, 0x30, 0x5a, 0x2e, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x30, 0x67, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x30, + 0x67, 0x2d, 0x64, 0x61, 0x74, 0x61, 0x2d, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x2f, 0x72, 0x75, 0x6e, + 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_light_light_proto_rawDescOnce sync.Once + file_light_light_proto_rawDescData = file_light_light_proto_rawDesc +) + +func file_light_light_proto_rawDescGZIP() []byte { + file_light_light_proto_rawDescOnce.Do(func() { + file_light_light_proto_rawDescData = protoimpl.X.CompressGZIP(file_light_light_proto_rawDescData) + }) + return file_light_light_proto_rawDescData +} + +var file_light_light_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_light_light_proto_goTypes = []interface{}{ + (*SampleRequest)(nil), // 0: light.SampleRequest + (*SampleReply)(nil), // 1: light.SampleReply + (*RetrieveRequest)(nil), // 2: light.RetrieveRequest + (*RetrieveReply)(nil), // 3: light.RetrieveReply +} +var file_light_light_proto_depIdxs = []int32{ + 0, // 0: light.Light.Sample:input_type -> light.SampleRequest + 2, // 1: light.Light.Retrieve:input_type -> light.RetrieveRequest + 1, // 2: light.Light.Sample:output_type -> light.SampleReply + 3, // 3: light.Light.Retrieve:output_type -> light.RetrieveReply + 2, // [2:4] is the sub-list for method output_type + 0, // [0:2] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_light_light_proto_init() } +func file_light_light_proto_init() { + if File_light_light_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_light_light_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SampleRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_light_light_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SampleReply); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_light_light_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RetrieveRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_light_light_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RetrieveReply); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_light_light_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_light_light_proto_goTypes, + DependencyIndexes: file_light_light_proto_depIdxs, + MessageInfos: file_light_light_proto_msgTypes, + }.Build() + File_light_light_proto = out.File + file_light_light_proto_rawDesc = nil + file_light_light_proto_goTypes = nil + file_light_light_proto_depIdxs = nil +} diff --git a/helper/da/light/light_grpc.pb.go b/helper/da/light/light_grpc.pb.go new file mode 100644 index 00000000..0586c987 --- /dev/null +++ b/helper/da/light/light_grpc.pb.go @@ -0,0 +1,141 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.2.0 +// - protoc v4.25.3 +// source: light/light.proto + +package light + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +// LightClient is the client API for Light service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type LightClient interface { + Sample(ctx context.Context, in *SampleRequest, opts ...grpc.CallOption) (*SampleReply, error) + Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveReply, error) +} + +type lightClient struct { + cc grpc.ClientConnInterface +} + +func NewLightClient(cc grpc.ClientConnInterface) LightClient { + return &lightClient{cc} +} + +func (c *lightClient) Sample(ctx context.Context, in *SampleRequest, opts ...grpc.CallOption) (*SampleReply, error) { + out := new(SampleReply) + err := c.cc.Invoke(ctx, "/light.Light/Sample", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightClient) Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveReply, error) { + out := new(RetrieveReply) + err := c.cc.Invoke(ctx, "/light.Light/Retrieve", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// LightServer is the server API for Light service. +// All implementations must embed UnimplementedLightServer +// for forward compatibility +type LightServer interface { + Sample(context.Context, *SampleRequest) (*SampleReply, error) + Retrieve(context.Context, *RetrieveRequest) (*RetrieveReply, error) + mustEmbedUnimplementedLightServer() +} + +// UnimplementedLightServer must be embedded to have forward compatible implementations. +type UnimplementedLightServer struct { +} + +func (UnimplementedLightServer) Sample(context.Context, *SampleRequest) (*SampleReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method Sample not implemented") +} +func (UnimplementedLightServer) Retrieve(context.Context, *RetrieveRequest) (*RetrieveReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method Retrieve not implemented") +} +func (UnimplementedLightServer) mustEmbedUnimplementedLightServer() {} + +// UnsafeLightServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to LightServer will +// result in compilation errors. +type UnsafeLightServer interface { + mustEmbedUnimplementedLightServer() +} + +func RegisterLightServer(s grpc.ServiceRegistrar, srv LightServer) { + s.RegisterService(&Light_ServiceDesc, srv) +} + +func _Light_Sample_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SampleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightServer).Sample(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/light.Light/Sample", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightServer).Sample(ctx, req.(*SampleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Light_Retrieve_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RetrieveRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightServer).Retrieve(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/light.Light/Retrieve", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightServer).Retrieve(ctx, req.(*RetrieveRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Light_ServiceDesc is the grpc.ServiceDesc for Light service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Light_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "light.Light", + HandlerType: (*LightServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Sample", + Handler: _Light_Sample_Handler, + }, + { + MethodName: "Retrieve", + Handler: _Light_Retrieve_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "light/light.proto", +} diff --git a/helper/da/main.go b/helper/da/main.go new file mode 100644 index 00000000..001737a8 --- /dev/null +++ b/helper/da/main.go @@ -0,0 +1,89 @@ +package main + +import ( + "context" + "flag" + "fmt" + "io" + "log" + "net/url" + "os" + "os/signal" + "time" + + "github.com/0glabs/0g-evmos/helper/da/service" + "github.com/0glabs/0g-evmos/helper/da/types" + + "github.com/lesismal/nbio/nbhttp" + "github.com/lesismal/nbio/nbhttp/websocket" +) + +const ( + subscribeMsg = "{\"jsonrpc\":\"2.0\",\"method\":\"subscribe\",\"id\":1,\"params\":{\"query\":\"tm.event='Tx'\"}}" +) + +var ( + rpcAddress = flag.String("rpc-address", "34.214.2.28:32001", "address of da-light rpc server") + wsAddress = flag.String("ws-address", "127.0.0.1:26657", "address of emvos ws server") + relativePath = flag.String("relative-path", "", "relative path of evmosd") + account = flag.String("account", "", "account to run evmosd cli") + keyring = flag.String("keyring", "", "keyring to run evmosd cli") + homePath = flag.String("home", "", "home path of evmosd node") +) + +func newUpgrader() *websocket.Upgrader { + u := websocket.NewUpgrader() + u.OnMessage(func(c *websocket.Conn, messageType websocket.MessageType, data []byte) { + log.Println("onEcho:", string(data)) + ctx := context.WithValue(context.Background(), types.DA_RPC_ADDRESS, *rpcAddress) + ctx = context.WithValue(ctx, types.NODE_CLI_RELATIVE_PATH, *relativePath) + ctx = context.WithValue(ctx, types.NODE_CLI_EXEC_ACCOUNT, *account) + ctx = context.WithValue(ctx, types.NODE_CLI_EXEC_KEYRING, *keyring) + ctx = context.WithValue(ctx, types.NODE_HOME_PATH, *homePath) + go func() { service.OnMessage(ctx, c, messageType, data) }() + }) + + u.OnClose(func(c *websocket.Conn, err error) { + fmt.Println("OnClose:", c.RemoteAddr().String(), err) + service.OnClose() + }) + + return u +} + +func main() { + flag.Parse() + engine := nbhttp.NewEngine(nbhttp.Config{}) + err := engine.Start() + if err != nil { + fmt.Printf("nbio.Start failed: %v\n", err) + return + } + + go func() { + u := url.URL{Scheme: "ws", Host: *wsAddress, Path: "/websocket"} + dialer := &websocket.Dialer{ + Engine: engine, + Upgrader: newUpgrader(), + DialTimeout: time.Second * 3, + } + c, res, err := dialer.Dial(u.String(), nil) + if err != nil { + if res != nil && res.Body != nil { + bReason, _ := io.ReadAll(res.Body) + fmt.Printf("dial failed: %v, reason: %v\n", err, string(bReason)) + } else { + fmt.Printf("dial failed: %v\n", err) + } + return + } + c.WriteMessage(websocket.TextMessage, []byte(subscribeMsg)) + }() + + interrupt := make(chan os.Signal, 1) + signal.Notify(interrupt, os.Interrupt) + <-interrupt + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + engine.Shutdown(ctx) +} diff --git a/helper/da/proto/light.proto b/helper/da/proto/light.proto new file mode 100644 index 00000000..f816b54f --- /dev/null +++ b/helper/da/proto/light.proto @@ -0,0 +1,33 @@ +syntax = "proto3"; + +package light; + +option go_package = "proto/light"; + +service Light { + rpc Sample(SampleRequest) returns (SampleReply) {} + rpc Retrieve(RetrieveRequest) returns (RetrieveReply) {} +} + +// SampleRequest contains the blob to sample (by batch and blob index) and required sample times +message SampleRequest { + bytes stream_id = 1; + bytes batch_header_hash = 2; + uint32 blob_index = 3; + uint32 times = 4; +} + +// SampleReply contains the sample result +message SampleReply { + bool success = 1; +} + +message RetrieveRequest { + bytes batch_header_hash = 1; + uint32 blob_index = 2; +} + +message RetrieveReply { + bool status = 1; + bytes data = 2; +} \ No newline at end of file diff --git a/helper/da/service/handler.go b/helper/da/service/handler.go new file mode 100644 index 00000000..e7f5d19f --- /dev/null +++ b/helper/da/service/handler.go @@ -0,0 +1,186 @@ +package service + +import ( + "context" + "encoding/hex" + "os" + "os/exec" + "strconv" + "strings" + + "github.com/0glabs/0g-evmos/helper/da/client" + "github.com/0glabs/0g-evmos/helper/da/types" + "github.com/0glabs/0g-evmos/helper/da/utils/sizedw8grp" + + jsoniter "github.com/json-iterator/go" + "github.com/lesismal/nbio/nbhttp/websocket" + "github.com/pkg/errors" + "github.com/rs/zerolog/log" +) + +const ( + defaultClientInstance = 10 +) + +var rpcClient client.DaLightRpcClient + +func OnMessage(ctx context.Context, c *websocket.Conn, messageType websocket.MessageType, data []byte) { + if messageType == websocket.TextMessage { + rawMsg := unwrapJsonRpc(data) + if verifyQuery(rawMsg) { + eventStr := jsoniter.Get(rawMsg, "events").ToString() + events := map[string][]string{} + if err := jsoniter.UnmarshalFromString(eventStr, &events); err == nil { + dasRequestMap := make(map[string]string, 4) + for key, val := range events { + if strings.HasPrefix(key, "das_request.") { + dasRequestMap[strings.ReplaceAll(key, "das_request.", "")] = val[0] + } + } + if len(dasRequestMap) == 4 { + rid, _ := strconv.ParseUint(dasRequestMap["request_id"], 10, 64) + numBlobs, _ := strconv.ParseUint(dasRequestMap["num_blobs"], 10, 64) + req := types.DASRequest{ + RequestId: rid, + StreamId: dasRequestMap["stream_id"], + BatchHeaderHash: dasRequestMap["batch_header_hash"], + NumBlobs: numBlobs, + } + err := handleDasRequest(ctx, req) + + if err != nil { + log.Err(err).Msgf("failed to handle das request: %v, %v", req, err) + } else { + log.Info().Msgf("successfully handled das request: %v", req) + } + } + } + } + } else { + // TODO: handle other message + } +} + +func OnClose() { + if rpcClient != nil { + rpcClient.Destroy() + rpcClient = nil + } +} + +func unwrapJsonRpc(data []byte) []byte { + result := jsoniter.Get(data, "result") + if 0 < len(result.Keys()) { + return []byte(result.ToString()) + } + return []byte{} +} + +func verifyQuery(data []byte) bool { + if len(data) > 0 { + return jsoniter.Get(data, "query").ToString() == "tm.event='Tx'" + } + return false +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} + +func handleDasRequest(ctx context.Context, request types.DASRequest) error { + if rpcClient == nil { + addrVal := ctx.Value(types.DA_RPC_ADDRESS) + if addrVal == nil { + return errors.New("da light service address not found in context") + } + + limit := ctx.Value(types.INSTANCE_LIMIT) + if limit == nil { + limit = defaultClientInstance + } + + rpcClient = client.NewDaLightClient(addrVal.(string), limit.(int)) + } + + streamID, err := hex.DecodeString(request.StreamId) + if err != nil { + return err + } + + batchHeaderHash, err := hex.DecodeString(request.BatchHeaderHash) + if err != nil { + return err + } + + result := make(chan bool, request.NumBlobs) + taskCnt := min(rpcClient.GetInstanceCount(), int(request.NumBlobs)) + wg := sizedw8grp.New(taskCnt) + + for i := uint64(0); i < request.NumBlobs; i++ { + wg.Add() + go func(idx uint64) { + defer wg.Done() + ret, err := rpcClient.Sample(ctx, streamID, batchHeaderHash, uint32(idx), 1) + if err != nil { + log.Err(err).Msgf("failed to sample data availability with blob index %d", idx) + result <- false + } else { + log.Info().Msgf("sample result for blob index %d: %v", idx, ret) + result <- ret + } + }(i) + } + wg.Wait() + close(result) + + finalResult := true + for val := range result { + if !val { + finalResult = false + break + } + } + + return runEvmosdCliReportDasResult(ctx, request.RequestId, finalResult) +} + +func runEvmosdCliReportDasResult(ctx context.Context, requestId uint64, result bool) error { + relativePath := ctx.Value(types.NODE_CLI_RELATIVE_PATH) + if relativePath == nil { + return errors.New("relativePath not found in context") + } + + account := ctx.Value(types.NODE_CLI_EXEC_ACCOUNT) + if account == nil { + return errors.New("account not found in context") + } + + args := []string{ + "tx", + "das", + "report-das-result", + strconv.FormatUint(requestId, 10), + strconv.FormatBool(result), + "--from", account.(string), + "--gas-prices", "767812500aevmos", // TODO: use args to set gas prices + } + + homePath := ctx.Value(types.NODE_HOME_PATH) + if homePath != nil { + args = append(args, "--home", homePath.(string)) + } + + keyring := ctx.Value(types.NODE_CLI_EXEC_KEYRING) + if keyring != nil { + args = append(args, "--keyring-backend", keyring.(string)) + } + + cmdStr := relativePath.(string) + "evmosd" + cmd := exec.Command(cmdStr, append(args, "-y")...) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + return cmd.Run() +} diff --git a/helper/da/types/dasreq.go b/helper/da/types/dasreq.go new file mode 100644 index 00000000..1c3b92e3 --- /dev/null +++ b/helper/da/types/dasreq.go @@ -0,0 +1,8 @@ +package types + +type DASRequest struct { + RequestId uint64 `json:"request_id"` + StreamId string `json:"stream_id"` + BatchHeaderHash string `json:"batch_header_hash"` + NumBlobs uint64 `json:"num_blobs"` +} diff --git a/helper/da/types/keys.go b/helper/da/types/keys.go new file mode 100644 index 00000000..e824f793 --- /dev/null +++ b/helper/da/types/keys.go @@ -0,0 +1,10 @@ +package types + +const ( + DA_RPC_ADDRESS = "rpc_address" + INSTANCE_LIMIT = "instance_limit" + NODE_CLI_RELATIVE_PATH = "relative_path" + NODE_CLI_EXEC_ACCOUNT = "node_exec_account" + NODE_CLI_EXEC_KEYRING = "node_exec_keyring" + NODE_HOME_PATH = "home_path" +) diff --git a/helper/da/utils/sizedw8grp/sizedw8grp.go b/helper/da/utils/sizedw8grp/sizedw8grp.go new file mode 100644 index 00000000..ac7348e6 --- /dev/null +++ b/helper/da/utils/sizedw8grp/sizedw8grp.go @@ -0,0 +1,51 @@ +package sizedw8grp + +import ( + "context" + "math" + "sync" +) + +type SizedWaitGroup struct { + Size int + + current chan struct{} + wg sync.WaitGroup +} + +func New(limit int) SizedWaitGroup { + size := math.MaxInt32 + if limit > 0 { + size = limit + } + return SizedWaitGroup{ + Size: size, + + current: make(chan struct{}, size), + wg: sync.WaitGroup{}, + } +} + +func (s *SizedWaitGroup) Add() { + _ = s.AddWithContext(context.Background()) +} + +func (s *SizedWaitGroup) AddWithContext(ctx context.Context) error { + select { + case <-ctx.Done(): + return ctx.Err() + case s.current <- struct{}{}: + break + } + s.wg.Add(1) + return nil +} + +func (s *SizedWaitGroup) Done() { + <-s.current + s.wg.Done() +} + +func (s *SizedWaitGroup) Wait() { + s.wg.Wait() +} diff --git a/proto/crypto/vrf/keys.proto b/proto/crypto/vrf/keys.proto new file mode 100644 index 00000000..4526cdf4 --- /dev/null +++ b/proto/crypto/vrf/keys.proto @@ -0,0 +1,25 @@ +// Copyright Tharsis Labs Ltd.(Evmos) +// SPDX-License-Identifier:ENCL-1.0(https://github.com/evmos/evmos/blob/main/LICENSE) +syntax = "proto3"; +package crypto.vrf; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/0glabs/0g-chain/crypto/vrf"; + +// PubKey defines a type alias for an vrf.PublicKey that implements +// Vrf's PubKey interface. It represents the 32-byte compressed public +// key format. +message PubKey { + option (gogoproto.goproto_stringer) = false; + + // key is the public key in byte form + bytes key = 1; +} + +// PrivKey defines a type alias for an vrf.PrivateKey that implements +// Vrf's PrivateKey interface. +message PrivKey { + // key is the private key in byte form + bytes key = 1; +} diff --git a/proto/zgchain/council/v1/genesis.proto b/proto/zgchain/council/v1/genesis.proto new file mode 100644 index 00000000..0385548b --- /dev/null +++ b/proto/zgchain/council/v1/genesis.proto @@ -0,0 +1,52 @@ +syntax = "proto3"; +package zgchain.council.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/council/v1/types"; + +message Params { + uint64 council_size = 1; +} + +// GenesisState defines the council module's genesis state. +message GenesisState { + option (gogoproto.goproto_getters) = false; + + Params params = 1 [(gogoproto.nullable) = false]; + uint64 voting_start_height = 2; + uint64 voting_period = 3; + uint64 current_council_id = 4 [(gogoproto.customname) = "CurrentCouncilID"]; + repeated Council councils = 5 [(gogoproto.nullable) = false]; +} + +message Council { + uint64 id = 1 [(gogoproto.customname) = "ID"]; + uint64 voting_start_height = 2; + uint64 start_height = 3; + uint64 end_height = 4; + repeated Vote votes = 5 [(gogoproto.nullable) = false]; + repeated bytes members = 6 [ + (cosmos_proto.scalar) = "cosmos.AddressBytes", + (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress" + ]; +} + +message Vote { + option (gogoproto.goproto_getters) = false; + + uint64 council_id = 1 [(gogoproto.customname) = "CouncilID"]; + bytes voter = 2 [ + (cosmos_proto.scalar) = "cosmos.AddressBytes", + (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress" + ]; + repeated Ballot ballots = 3; +} + +message Ballot { + uint64 id = 1 [(gogoproto.customname) = "ID"]; + bytes content = 2; +} diff --git a/proto/zgchain/council/v1/query.proto b/proto/zgchain/council/v1/query.proto new file mode 100644 index 00000000..dce6f552 --- /dev/null +++ b/proto/zgchain/council/v1/query.proto @@ -0,0 +1,34 @@ +syntax = "proto3"; +package zgchain.council.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; +import "zgchain/council/v1/genesis.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/council/v1/types"; +option (gogoproto.goproto_getters_all) = false; + +// Query defines the gRPC querier service for committee module +service Query { + rpc CurrentCouncilID(QueryCurrentCouncilIDRequest) returns (QueryCurrentCouncilIDResponse) { + option (google.api.http).get = "/0gchain/council/v1/current-council-id"; + } + rpc RegisteredVoters(QueryRegisteredVotersRequest) returns (QueryRegisteredVotersResponse) { + option (google.api.http).get = "/0gchain/council/v1/registered-voters"; + } +} + +message QueryCurrentCouncilIDRequest {} + +message QueryCurrentCouncilIDResponse { + uint64 current_council_id = 1 [(gogoproto.customname) = "CurrentCouncilID"]; +} + +message QueryRegisteredVotersRequest {} + +message QueryRegisteredVotersResponse { + repeated string voters = 1; +} diff --git a/proto/zgchain/council/v1/tx.proto b/proto/zgchain/council/v1/tx.proto new file mode 100644 index 00000000..055344e4 --- /dev/null +++ b/proto/zgchain/council/v1/tx.proto @@ -0,0 +1,31 @@ +syntax = "proto3"; +package zgchain.council.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "zgchain/council/v1/genesis.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/council/v1/types"; +option (gogoproto.goproto_getters_all) = false; + +// Msg defines the committee Msg service +service Msg { + rpc Register(MsgRegister) returns (MsgRegisterResponse); + rpc Vote(MsgVote) returns (MsgVoteResponse); +} + +message MsgRegister { + string voter = 1; + bytes key = 2; +} + +message MsgRegisterResponse {} + +message MsgVote { + uint64 council_id = 1 [(gogoproto.customname) = "CouncilID"]; + string voter = 2; + repeated Ballot ballots = 3; +} + +message MsgVoteResponse {} diff --git a/proto/zgchain/das/v1/genesis.proto b/proto/zgchain/das/v1/genesis.proto new file mode 100644 index 00000000..a988d8fd --- /dev/null +++ b/proto/zgchain/das/v1/genesis.proto @@ -0,0 +1,37 @@ +syntax = "proto3"; +package zgchain.das.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/das/v1/types"; + +message Params {} + +// GenesisState defines the das module's genesis state. +message GenesisState { + option (gogoproto.goproto_getters) = false; + + Params params = 1 [(gogoproto.nullable) = false]; + uint64 next_request_id = 2 [(gogoproto.customname) = "NextRequestID"]; + repeated DASRequest requests = 3 [(gogoproto.nullable) = false]; + repeated DASResponse responses = 4 [(gogoproto.nullable) = false]; +} + +message DASRequest { + uint64 id = 1 [(gogoproto.customname) = "ID"]; + bytes stream_id = 2 [(gogoproto.customname) = "StreamID"]; + bytes batch_header_hash = 3; + uint32 num_blobs = 4; +} + +message DASResponse { + uint64 id = 1 [(gogoproto.customname) = "ID"]; + bytes sampler = 2 [ + (cosmos_proto.scalar) = "cosmos.AddressBytes", + (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress" + ]; + repeated bool results = 3; +} diff --git a/proto/zgchain/das/v1/query.proto b/proto/zgchain/das/v1/query.proto new file mode 100644 index 00000000..924ebf94 --- /dev/null +++ b/proto/zgchain/das/v1/query.proto @@ -0,0 +1,24 @@ +syntax = "proto3"; +package zgchain.das.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/das/v1/types"; +option (gogoproto.goproto_getters_all) = false; + +// Query defines the gRPC querier service for the das module +service Query { + rpc NextRequestID(QueryNextRequestIDRequest) returns (QueryNextRequestIDResponse) { + option (google.api.http).get = "/0gchain/das/v1/next-request-id"; + } +} + +message QueryNextRequestIDRequest {} + +message QueryNextRequestIDResponse { + uint64 next_request_id = 1 [(gogoproto.customname) = "NextRequestID"]; +} diff --git a/proto/zgchain/das/v1/tx.proto b/proto/zgchain/das/v1/tx.proto new file mode 100644 index 00000000..c8d388ca --- /dev/null +++ b/proto/zgchain/das/v1/tx.proto @@ -0,0 +1,35 @@ +syntax = "proto3"; +package zgchain.das.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "zgchain/das/v1/genesis.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/das/v1/types"; +option (gogoproto.goproto_getters_all) = false; + +// Msg defines the das Msg service +service Msg { + rpc RequestDAS(MsgRequestDAS) returns (MsgRequestDASResponse); + rpc ReportDASResult(MsgReportDASResult) returns (MsgReportDASResultResponse); +} + +message MsgRequestDAS { + string requester = 1 [(gogoproto.moretags) = "Requester"]; + string stream_id = 2 [(gogoproto.customname) = "StreamID"]; + string batch_header_hash = 3; + uint32 num_blobs = 4; +} + +message MsgRequestDASResponse { + uint64 request_id = 1 [(gogoproto.customname) = "RequestID"]; +} + +message MsgReportDASResult { + uint64 request_id = 1 [(gogoproto.customname) = "RequestID"]; + string sampler = 2; + repeated bool results = 3; +} + +message MsgReportDASResultResponse {} diff --git a/x/auction/types/auction.pb.go b/x/auction/types/auction.pb.go index 8e7191d1..70d13504 100644 --- a/x/auction/types/auction.pb.go +++ b/x/auction/types/auction.pb.go @@ -252,49 +252,49 @@ func init() { } var fileDescriptor_b9b5dac2c776ef9e = []byte{ - // 657 bytes of a gzipped FileDescriptorProto + // 662 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x54, 0xcd, 0x6e, 0xd3, 0x4a, - 0x14, 0xce, 0x24, 0xbd, 0x49, 0x3a, 0xae, 0xee, 0x55, 0xe6, 0x56, 0xc8, 0xad, 0x90, 0x1d, 0xba, - 0x80, 0x80, 0x14, 0x5b, 0x2d, 0x1b, 0xc4, 0x06, 0xd5, 0x2d, 0xd0, 0x6e, 0xba, 0x30, 0x48, 0x48, - 0x6c, 0xcc, 0xd8, 0x33, 0x75, 0x46, 0xb5, 0x3d, 0x91, 0x67, 0x52, 0xd2, 0xb7, 0xe8, 0xc3, 0x74, - 0xc5, 0x1e, 0xa9, 0xaa, 0x84, 0x54, 0xb1, 0x42, 0x2c, 0x02, 0xa4, 0x6f, 0xc1, 0x0a, 0x8d, 0x3d, - 0x6e, 0x1b, 0xd1, 0x45, 0x90, 0x60, 0xc1, 0x2a, 0x3e, 0xdf, 0x9c, 0xf3, 0x7d, 0xe7, 0x37, 0x70, - 0xed, 0x00, 0x1f, 0x62, 0x17, 0x8f, 0x22, 0xc9, 0x78, 0xe6, 0x1e, 0xae, 0x87, 0x54, 0xe2, 0xf5, - 0xca, 0x76, 0x86, 0x39, 0x97, 0x1c, 0x2d, 0x2b, 0x1f, 0xa7, 0xc2, 0xb4, 0xcf, 0xaa, 0x15, 0x71, - 0x91, 0x72, 0xe1, 0x86, 0x58, 0xd0, 0xcb, 0xc0, 0x88, 0x33, 0x1d, 0xb5, 0xba, 0x52, 0xbe, 0x07, - 0x85, 0xe5, 0x96, 0x86, 0x7e, 0x5a, 0x8e, 0x79, 0xcc, 0x4b, 0x5c, 0x7d, 0x69, 0xd4, 0x8e, 0x39, - 0x8f, 0x13, 0xea, 0x16, 0x56, 0x38, 0xda, 0x77, 0x25, 0x4b, 0xa9, 0x90, 0x38, 0x1d, 0x96, 0x0e, - 0x6b, 0x1f, 0x1a, 0xd0, 0xf0, 0xb0, 0xa0, 0x9b, 0x65, 0x26, 0xe8, 0x16, 0xac, 0x33, 0x62, 0x82, - 0x2e, 0xe8, 0x2d, 0x78, 0xcd, 0xe9, 0xc4, 0xae, 0xef, 0x6e, 0xfb, 0x75, 0x46, 0xd0, 0x6d, 0xb8, - 0xc8, 0x32, 0x26, 0x19, 0x96, 0x3c, 0x37, 0xeb, 0x5d, 0xd0, 0x5b, 0xf4, 0xaf, 0x00, 0xb4, 0x0e, - 0x1b, 0x09, 0x97, 0x66, 0xa3, 0x0b, 0x7a, 0xc6, 0xc6, 0x8a, 0xa3, 0x13, 0x53, 0x55, 0x54, 0xa5, - 0x39, 0x5b, 0x9c, 0x65, 0xde, 0xc2, 0xe9, 0xc4, 0xae, 0xf9, 0xca, 0x17, 0xbd, 0x81, 0xcd, 0x90, - 0x11, 0x42, 0x73, 0x73, 0xa1, 0x0b, 0x7a, 0x4b, 0xde, 0xce, 0xf7, 0x89, 0xdd, 0x8f, 0x99, 0x1c, - 0x8c, 0x42, 0x27, 0xe2, 0xa9, 0x2e, 0x4e, 0xff, 0xf4, 0x05, 0x39, 0x70, 0xe5, 0xd1, 0x90, 0x0a, - 0x67, 0x33, 0x8a, 0x36, 0x09, 0xc9, 0xa9, 0x10, 0x1f, 0x4f, 0xfa, 0xff, 0x6b, 0x25, 0x8d, 0x78, - 0x47, 0x92, 0x0a, 0x5f, 0xf3, 0xaa, 0xa4, 0x42, 0x46, 0xcc, 0x7f, 0xe6, 0x4c, 0x2a, 0x64, 0x04, - 0x3d, 0x80, 0x9d, 0x01, 0x16, 0x41, 0x4e, 0x23, 0xca, 0x0e, 0x29, 0x09, 0x42, 0x46, 0x84, 0xd9, - 0xec, 0x82, 0x5e, 0xdb, 0xff, 0x6f, 0x80, 0x85, 0xaf, 0x71, 0x8f, 0x11, 0x81, 0x9e, 0xc0, 0x36, - 0xcd, 0x48, 0xa0, 0x1a, 0x6a, 0xb6, 0x0a, 0x8d, 0x55, 0xa7, 0xec, 0xb6, 0x53, 0x75, 0xdb, 0x79, - 0x59, 0x75, 0xdb, 0x6b, 0x2b, 0x91, 0xe3, 0x2f, 0x36, 0xf0, 0x5b, 0x34, 0x23, 0x0a, 0x47, 0xcf, - 0xe0, 0x52, 0x8a, 0xc7, 0xc1, 0x25, 0x49, 0xfb, 0x17, 0x48, 0x60, 0x8a, 0xc7, 0x4f, 0x4b, 0x9e, - 0xc7, 0xc6, 0xd9, 0x49, 0xbf, 0xa5, 0xe7, 0xb7, 0x96, 0xc2, 0x7f, 0x5f, 0x8c, 0xf2, 0x61, 0x32, - 0x12, 0xd5, 0x44, 0xf7, 0xe0, 0x92, 0xaa, 0x39, 0xd0, 0xbb, 0x56, 0xcc, 0xd6, 0xd8, 0xb8, 0xe3, - 0xdc, 0xb4, 0x80, 0xce, 0xb5, 0x55, 0x28, 0xd5, 0xce, 0x27, 0x36, 0xf0, 0x8d, 0xf0, 0x0a, 0x9e, - 0x95, 0x7b, 0x07, 0xa0, 0xb1, 0x4d, 0x43, 0xf9, 0x87, 0xc4, 0xd0, 0x1e, 0x44, 0x11, 0xcf, 0x73, - 0x2a, 0x86, 0x3c, 0x23, 0x2c, 0x8b, 0x03, 0x42, 0x43, 0x59, 0xec, 0xdf, 0x1c, 0x23, 0xed, 0xcc, - 0x84, 0xaa, 0x34, 0x67, 0x93, 0x3f, 0xab, 0xc3, 0xce, 0x16, 0x4f, 0x12, 0x2c, 0x69, 0x8e, 0x93, - 0xbf, 0xa4, 0x04, 0xf4, 0x08, 0xb6, 0xd4, 0xda, 0xa8, 0xd5, 0x9e, 0xf3, 0xde, 0x9a, 0x29, 0x1e, - 0x7b, 0x8c, 0xa0, 0x3d, 0x68, 0x24, 0x5c, 0x06, 0x39, 0x95, 0xa3, 0x3c, 0x13, 0xc5, 0xdd, 0x19, - 0x1b, 0xf7, 0x6e, 0x2e, 0xec, 0x15, 0x65, 0xf1, 0x40, 0x52, 0xa2, 0x2f, 0x8b, 0x0a, 0xcd, 0x05, - 0x13, 0x2e, 0xfd, 0x92, 0x60, 0xb6, 0x99, 0xef, 0x01, 0xec, 0xfc, 0x14, 0x84, 0xf6, 0xe1, 0x22, - 0xae, 0x0c, 0x13, 0x74, 0x1b, 0xbf, 0xf5, 0xd0, 0xaf, 0xa8, 0xd1, 0x0e, 0x6c, 0xbd, 0x2d, 0xc4, - 0x85, 0x59, 0x2f, 0x54, 0x1c, 0x95, 0xed, 0xe7, 0x89, 0x7d, 0x77, 0x0e, 0xa5, 0xdd, 0x4c, 0xfa, - 0x55, 0xb8, 0xf7, 0xfc, 0xf4, 0x9b, 0x55, 0x3b, 0x9d, 0x5a, 0xe0, 0x7c, 0x6a, 0x81, 0xaf, 0x53, - 0x0b, 0x1c, 0x5f, 0x58, 0xb5, 0xf3, 0x0b, 0xab, 0xf6, 0xe9, 0xc2, 0xaa, 0xbd, 0xbe, 0x7f, 0x8d, - 0x4e, 0xf5, 0xad, 0x9f, 0xe0, 0x50, 0x14, 0x5f, 0xee, 0xf8, 0xf2, 0x1f, 0xbf, 0x60, 0x0d, 0x9b, - 0xc5, 0x01, 0x3f, 0xfc, 0x11, 0x00, 0x00, 0xff, 0xff, 0x87, 0x6d, 0x9c, 0x17, 0x0e, 0x06, 0x00, - 0x00, + 0x14, 0xce, 0x24, 0xbd, 0x49, 0x3a, 0xae, 0xee, 0x55, 0xe6, 0x56, 0x57, 0x6e, 0x75, 0x65, 0x87, + 0x2e, 0x20, 0xaa, 0x14, 0xbb, 0x2d, 0x1b, 0xc4, 0x06, 0xd5, 0x2d, 0xa8, 0xdd, 0x74, 0x61, 0x90, + 0x90, 0xd8, 0x98, 0xb1, 0x67, 0xea, 0x8c, 0x6a, 0x7b, 0x22, 0xcf, 0xa4, 0xa4, 0x6f, 0xd1, 0x87, + 0xe9, 0x8a, 0x3d, 0x52, 0x55, 0x09, 0xa9, 0x62, 0x85, 0x58, 0x04, 0x48, 0xdf, 0x82, 0x15, 0x1a, + 0x7b, 0xdc, 0x36, 0xa2, 0x8b, 0x20, 0xc1, 0x82, 0x55, 0x72, 0xbe, 0x39, 0xe7, 0xfb, 0xce, 0xaf, + 0xe1, 0xda, 0x11, 0x3e, 0xc6, 0x2e, 0x1e, 0x45, 0x92, 0xf1, 0xcc, 0x3d, 0xde, 0x0c, 0xa9, 0xc4, + 0x9b, 0x95, 0xed, 0x0c, 0x73, 0x2e, 0x39, 0x5a, 0x56, 0x3e, 0x4e, 0x85, 0x69, 0x9f, 0x55, 0x2b, + 0xe2, 0x22, 0xe5, 0xc2, 0x0d, 0xb1, 0xa0, 0xd7, 0x81, 0x11, 0x67, 0x3a, 0x6a, 0x75, 0xa5, 0x7c, + 0x0f, 0x0a, 0xcb, 0x2d, 0x0d, 0xfd, 0xb4, 0x1c, 0xf3, 0x98, 0x97, 0xb8, 0xfa, 0xa7, 0x51, 0x3b, + 0xe6, 0x3c, 0x4e, 0xa8, 0x5b, 0x58, 0xe1, 0xe8, 0xd0, 0x95, 0x2c, 0xa5, 0x42, 0xe2, 0x74, 0x58, + 0x3a, 0xac, 0xbd, 0x6f, 0x40, 0xc3, 0xc3, 0x82, 0x6e, 0x97, 0x99, 0xa0, 0xff, 0x60, 0x9d, 0x11, + 0x13, 0x74, 0x41, 0x6f, 0xc1, 0x6b, 0x4e, 0x27, 0x76, 0x7d, 0x7f, 0xd7, 0xaf, 0x33, 0x82, 0xfe, + 0x87, 0x8b, 0x2c, 0x63, 0x92, 0x61, 0xc9, 0x73, 0xb3, 0xde, 0x05, 0xbd, 0x45, 0xff, 0x06, 0x40, + 0x9b, 0xb0, 0x91, 0x70, 0x69, 0x36, 0xba, 0xa0, 0x67, 0x6c, 0xad, 0x38, 0x3a, 0x31, 0x55, 0x45, + 0x55, 0x9a, 0xb3, 0xc3, 0x59, 0xe6, 0x2d, 0x9c, 0x4f, 0xec, 0x9a, 0xaf, 0x7c, 0xd1, 0x6b, 0xd8, + 0x0c, 0x19, 0x21, 0x34, 0x37, 0x17, 0xba, 0xa0, 0xb7, 0xe4, 0xed, 0x7d, 0x9b, 0xd8, 0xfd, 0x98, + 0xc9, 0xc1, 0x28, 0x74, 0x22, 0x9e, 0xea, 0xe2, 0xf4, 0x4f, 0x5f, 0x90, 0x23, 0x57, 0x9e, 0x0c, + 0xa9, 0x70, 0xb6, 0xa3, 0x68, 0x9b, 0x90, 0x9c, 0x0a, 0xf1, 0xe1, 0xac, 0xff, 0xaf, 0x56, 0xd2, + 0x88, 0x77, 0x22, 0xa9, 0xf0, 0x35, 0xaf, 0x4a, 0x2a, 0x64, 0xc4, 0xfc, 0x6b, 0xce, 0xa4, 0x42, + 0x46, 0xd0, 0x3a, 0xec, 0x0c, 0xb0, 0x08, 0x72, 0x1a, 0x51, 0x76, 0x4c, 0x49, 0x10, 0x32, 0x22, + 0xcc, 0x66, 0x17, 0xf4, 0xda, 0xfe, 0x3f, 0x03, 0x2c, 0x7c, 0x8d, 0x7b, 0x8c, 0x08, 0xf4, 0x04, + 0xb6, 0x69, 0x46, 0x02, 0xd5, 0x50, 0xb3, 0x55, 0x68, 0xac, 0x3a, 0x65, 0xb7, 0x9d, 0xaa, 0xdb, + 0xce, 0x8b, 0xaa, 0xdb, 0x5e, 0x5b, 0x89, 0x9c, 0x7e, 0xb6, 0x81, 0xdf, 0xa2, 0x19, 0x51, 0x38, + 0x7a, 0x06, 0x97, 0x52, 0x3c, 0x0e, 0xae, 0x49, 0xda, 0x3f, 0x41, 0x02, 0x53, 0x3c, 0x7e, 0x5a, + 0xf2, 0x3c, 0x36, 0x2e, 0xce, 0xfa, 0x2d, 0x3d, 0xbf, 0xb5, 0x14, 0xfe, 0xfd, 0x7c, 0x94, 0x0f, + 0x93, 0x91, 0xa8, 0x26, 0x7a, 0x00, 0x97, 0x54, 0xcd, 0x81, 0xde, 0xb5, 0x62, 0xb6, 0xc6, 0xd6, + 0x3d, 0xe7, 0xae, 0x05, 0x74, 0x6e, 0xad, 0x42, 0xa9, 0x76, 0x39, 0xb1, 0x81, 0x6f, 0x84, 0x37, + 0xf0, 0xac, 0xdc, 0x5b, 0x00, 0x8d, 0x5d, 0x1a, 0xca, 0xdf, 0x24, 0x86, 0x0e, 0x20, 0x8a, 0x78, + 0x9e, 0x53, 0x31, 0xe4, 0x19, 0x61, 0x59, 0x1c, 0x10, 0x1a, 0xca, 0x62, 0xff, 0xe6, 0x18, 0x69, + 0x67, 0x26, 0x54, 0xa5, 0x39, 0x9b, 0xfc, 0x45, 0x1d, 0x76, 0x76, 0x78, 0x92, 0x60, 0x49, 0x73, + 0x9c, 0xfc, 0x21, 0x25, 0xa0, 0x47, 0xb0, 0xa5, 0xd6, 0x46, 0xad, 0xf6, 0x9c, 0xf7, 0xd6, 0x4c, + 0xf1, 0xd8, 0x63, 0x04, 0x1d, 0x40, 0x23, 0xe1, 0x32, 0xc8, 0xa9, 0x1c, 0xe5, 0x99, 0x28, 0xee, + 0xce, 0xd8, 0x7a, 0x70, 0x77, 0x61, 0x2f, 0x29, 0x8b, 0x07, 0x92, 0x12, 0x7d, 0x59, 0x54, 0x68, + 0x2e, 0x98, 0x70, 0xe9, 0x97, 0x04, 0xb3, 0xcd, 0x7c, 0x07, 0x60, 0xe7, 0x87, 0x20, 0x74, 0x08, + 0x17, 0x71, 0x65, 0x98, 0xa0, 0xdb, 0xf8, 0xa5, 0x87, 0x7e, 0x43, 0x8d, 0xf6, 0x60, 0xeb, 0x4d, + 0x21, 0x2e, 0xcc, 0x7a, 0xa1, 0xe2, 0xa8, 0x6c, 0x3f, 0x4d, 0xec, 0xfb, 0x73, 0x28, 0xed, 0x67, + 0xd2, 0xaf, 0xc2, 0xbd, 0xbd, 0xf3, 0xaf, 0x56, 0xed, 0x7c, 0x6a, 0x81, 0xcb, 0xa9, 0x05, 0xbe, + 0x4c, 0x2d, 0x70, 0x7a, 0x65, 0xd5, 0x2e, 0xaf, 0xac, 0xda, 0xc7, 0x2b, 0xab, 0xf6, 0x6a, 0xfd, + 0x16, 0xdd, 0x46, 0x9c, 0xe0, 0x50, 0xb8, 0x1b, 0x71, 0x3f, 0x1a, 0x60, 0x96, 0xb9, 0xe3, 0xeb, + 0x4f, 0x7e, 0x41, 0x1b, 0x36, 0x8b, 0x0b, 0x7e, 0xf8, 0x3d, 0x00, 0x00, 0xff, 0xff, 0x61, 0xc3, + 0xa5, 0x61, 0x0f, 0x06, 0x00, 0x00, } func (m *BaseAuction) Marshal() (dAtA []byte, err error) { diff --git a/x/auction/types/genesis.pb.go b/x/auction/types/genesis.pb.go index d47b786a..87627e3e 100644 --- a/x/auction/types/genesis.pb.go +++ b/x/auction/types/genesis.pb.go @@ -124,38 +124,39 @@ func init() { } var fileDescriptor_d0e5cb58293042f7 = []byte{ - // 496 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0xc1, 0x6e, 0xd3, 0x30, - 0x18, 0xc7, 0x93, 0x35, 0x94, 0xca, 0xed, 0xc6, 0x30, 0x39, 0xa4, 0x13, 0x4a, 0xab, 0x1e, 0xa6, - 0x72, 0xa8, 0xa3, 0x95, 0x1b, 0xb7, 0x85, 0x4a, 0x13, 0x9c, 0x50, 0xa6, 0x5d, 0xe0, 0x10, 0x39, - 0x89, 0x17, 0xa2, 0x25, 0x71, 0x65, 0x3b, 0xa5, 0x7d, 0x0b, 0x8e, 0x3c, 0x08, 0x87, 0x3d, 0x42, - 0xc5, 0x69, 0x47, 0xc4, 0x61, 0x40, 0xfb, 0x22, 0x28, 0x8e, 0x9b, 0x16, 0xd8, 0x65, 0x3b, 0xd5, - 0xfe, 0xbe, 0xff, 0xf7, 0xfb, 0xff, 0xed, 0x3a, 0x60, 0x70, 0x85, 0x67, 0xd8, 0xc1, 0x45, 0x28, - 0x12, 0x9a, 0x3b, 0xb3, 0x93, 0x80, 0x08, 0x7c, 0xe2, 0xc4, 0x24, 0x27, 0x3c, 0xe1, 0x68, 0xca, - 0xa8, 0xa0, 0xd0, 0x2c, 0x35, 0x48, 0x69, 0x90, 0xd2, 0x1c, 0x75, 0x43, 0xca, 0x33, 0xca, 0x7d, - 0xa9, 0x71, 0xaa, 0x4d, 0x35, 0x70, 0x64, 0xc6, 0x34, 0xa6, 0x55, 0xbd, 0x5c, 0xa9, 0x6a, 0x37, - 0xa6, 0x34, 0x4e, 0x89, 0x23, 0x77, 0x41, 0x71, 0xe9, 0xe0, 0x7c, 0xa1, 0x5a, 0xf6, 0xbf, 0xad, - 0xa8, 0x60, 0x58, 0xba, 0xc9, 0xca, 0xe0, 0x5a, 0x07, 0x9d, 0xb3, 0x2a, 0xd3, 0xb9, 0xc0, 0x82, - 0xc0, 0x63, 0xf0, 0x24, 0x27, 0x73, 0xe1, 0xab, 0x50, 0x7e, 0x12, 0x59, 0x7a, 0x5f, 0x1f, 0x1a, - 0xde, 0x7e, 0x59, 0x3e, 0xad, 0xaa, 0x6f, 0x22, 0xf8, 0x0a, 0x34, 0xa7, 0x98, 0xe1, 0x8c, 0x5b, - 0x7b, 0x7d, 0x7d, 0xd8, 0x1e, 0x3f, 0x47, 0x77, 0x9d, 0x05, 0xbd, 0x93, 0x1a, 0xd7, 0x58, 0xde, - 0xf6, 0x34, 0x4f, 0x4d, 0xc0, 0x09, 0x68, 0x29, 0x1d, 0xb7, 0x1a, 0xfd, 0xc6, 0xb0, 0x3d, 0x36, - 0x51, 0x95, 0x13, 0x6d, 0x72, 0xa2, 0xd3, 0x7c, 0xe1, 0xc2, 0x6f, 0x5f, 0x47, 0x07, 0x2a, 0x9d, - 0x72, 0xf6, 0xea, 0xc9, 0xc1, 0xb5, 0x01, 0x9a, 0x15, 0x1e, 0x5e, 0x00, 0x33, 0xc3, 0xf3, 0x3a, - 0xf3, 0xe6, 0x8c, 0x32, 0x79, 0x7b, 0xdc, 0xfd, 0x0f, 0x3e, 0x51, 0x02, 0xb7, 0x55, 0xe6, 0xfa, - 0xf2, 0xb3, 0xa7, 0x7b, 0x30, 0xc3, 0x73, 0xe5, 0xb1, 0xe9, 0x96, 0xd8, 0x4b, 0xca, 0x3e, 0x61, - 0x16, 0xf9, 0x41, 0x12, 0x6d, 0xb1, 0xcd, 0x7b, 0x60, 0x15, 0xc0, 0x4d, 0xa2, 0x5d, 0x2c, 0x23, - 0x33, 0xc2, 0x38, 0xf9, 0x1b, 0xfb, 0xf8, 0x1e, 0x58, 0x05, 0xd8, 0xc5, 0x7e, 0x00, 0x4f, 0x93, - 0x3c, 0x64, 0x24, 0x23, 0xb9, 0xf0, 0x79, 0xc1, 0xa6, 0x69, 0x51, 0x5e, 0xaf, 0x3e, 0xec, 0xb8, - 0xa8, 0x1c, 0xfc, 0x71, 0xdb, 0x3b, 0x8e, 0x13, 0xf1, 0xb1, 0x08, 0x50, 0x48, 0x33, 0xf5, 0xae, - 0xd4, 0xcf, 0x88, 0x47, 0x57, 0x8e, 0x58, 0x4c, 0x09, 0x47, 0x13, 0x12, 0x7a, 0x87, 0x35, 0xe8, - 0xbc, 0xe2, 0xc0, 0x0b, 0x70, 0xb0, 0x85, 0x47, 0x24, 0x10, 0x96, 0xf1, 0x20, 0xf2, 0x7e, 0x4d, - 0x99, 0x90, 0x40, 0x40, 0x0c, 0xcc, 0x2d, 0x36, 0xa4, 0x69, 0x8a, 0x05, 0x61, 0x38, 0xb5, 0x1e, - 0x3d, 0x08, 0xfe, 0xac, 0x66, 0xbd, 0xae, 0x51, 0x6f, 0x8d, 0xd6, 0xde, 0x61, 0xc3, 0xeb, 0xec, - 0xde, 0xb4, 0x7b, 0xb6, 0xfc, 0x6d, 0x6b, 0xcb, 0x95, 0xad, 0xdf, 0xac, 0x6c, 0xfd, 0xd7, 0xca, - 0xd6, 0x3f, 0xaf, 0x6d, 0xed, 0x66, 0x6d, 0x6b, 0xdf, 0xd7, 0xb6, 0xf6, 0xfe, 0xc5, 0x8e, 0x5d, - 0xf9, 0xa8, 0x47, 0x29, 0x0e, 0xb8, 0x5c, 0x39, 0xf3, 0xfa, 0x83, 0x96, 0xae, 0x41, 0x53, 0xfe, - 0x49, 0x2f, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x34, 0x3b, 0x9f, 0xed, 0x03, 0x00, 0x00, + // 501 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0xbd, 0x6e, 0xdb, 0x30, + 0x14, 0x85, 0xa5, 0x44, 0x75, 0x0d, 0xda, 0x49, 0x53, 0x56, 0x83, 0x1c, 0x14, 0xb2, 0xe1, 0x21, + 0x30, 0x0a, 0x98, 0x4c, 0xdc, 0xad, 0x5b, 0x54, 0x03, 0xfd, 0x99, 0x0a, 0x05, 0x59, 0xda, 0x41, + 0xa0, 0x24, 0x46, 0x11, 0x22, 0x89, 0x06, 0x49, 0xb9, 0xf6, 0x5b, 0x74, 0xec, 0x83, 0x74, 0xc8, + 0x23, 0x18, 0x9d, 0x32, 0x16, 0x1d, 0xd2, 0xd6, 0x7e, 0x91, 0x42, 0x12, 0x2d, 0xbb, 0x3f, 0x4b, + 0x32, 0x49, 0xbc, 0xf7, 0xdc, 0xef, 0x1c, 0x52, 0x22, 0xe8, 0x5f, 0x91, 0x29, 0xc1, 0x24, 0x0f, + 0x64, 0xcc, 0x32, 0x3c, 0x3d, 0xf1, 0xa9, 0x24, 0x27, 0x38, 0xa2, 0x19, 0x15, 0xb1, 0x40, 0x13, + 0xce, 0x24, 0x83, 0x66, 0xa1, 0x41, 0x4a, 0x83, 0x94, 0xe6, 0xb0, 0x13, 0x30, 0x91, 0x32, 0xe1, + 0x95, 0x1a, 0x5c, 0x2d, 0xaa, 0x81, 0x43, 0x33, 0x62, 0x11, 0xab, 0xea, 0xc5, 0x9b, 0xaa, 0x76, + 0x22, 0xc6, 0xa2, 0x84, 0xe2, 0x72, 0xe5, 0xe7, 0x17, 0x98, 0x64, 0x73, 0xd5, 0xb2, 0xff, 0x6e, + 0x85, 0x39, 0x27, 0xa5, 0x5b, 0x59, 0xe9, 0x5f, 0xeb, 0xa0, 0xfd, 0xaa, 0xca, 0x74, 0x26, 0x89, + 0xa4, 0xf0, 0x08, 0x3c, 0xca, 0xe8, 0x4c, 0x7a, 0x2a, 0x94, 0x17, 0x87, 0x96, 0xde, 0xd3, 0x07, + 0x86, 0xbb, 0x57, 0x94, 0x4f, 0xab, 0xea, 0x9b, 0x10, 0xbe, 0x00, 0x8d, 0x09, 0xe1, 0x24, 0x15, + 0xd6, 0x4e, 0x4f, 0x1f, 0xb4, 0x46, 0x4f, 0xd1, 0xff, 0xf6, 0x82, 0xde, 0x95, 0x1a, 0xc7, 0x58, + 0xdc, 0x76, 0x35, 0x57, 0x4d, 0xc0, 0x31, 0x68, 0x2a, 0x9d, 0xb0, 0x76, 0x7b, 0xbb, 0x83, 0xd6, + 0xc8, 0x44, 0x55, 0x4e, 0xb4, 0xce, 0x89, 0x4e, 0xb3, 0xb9, 0x03, 0xbf, 0x7e, 0x19, 0xee, 0xab, + 0x74, 0xca, 0xd9, 0xad, 0x27, 0xfb, 0xd7, 0x06, 0x68, 0x54, 0x78, 0x78, 0x0e, 0xcc, 0x94, 0xcc, + 0xea, 0xcc, 0xeb, 0x3d, 0x96, 0xc9, 0x5b, 0xa3, 0xce, 0x3f, 0xf0, 0xb1, 0x12, 0x38, 0xcd, 0x22, + 0xd7, 0xe7, 0x1f, 0x5d, 0xdd, 0x85, 0x29, 0x99, 0x29, 0x8f, 0x75, 0xb7, 0xc0, 0x5e, 0x30, 0xfe, + 0x91, 0xf0, 0xd0, 0xf3, 0xe3, 0x70, 0x83, 0x6d, 0xdc, 0x01, 0xab, 0x00, 0x4e, 0x1c, 0x6e, 0x63, + 0x39, 0x9d, 0x52, 0x2e, 0xe8, 0x9f, 0xd8, 0x87, 0x77, 0xc0, 0x2a, 0xc0, 0x36, 0xf6, 0x03, 0x78, + 0x1c, 0x67, 0x01, 0xa7, 0x29, 0xcd, 0xa4, 0x27, 0x72, 0x3e, 0x49, 0xf2, 0xe2, 0x78, 0xf5, 0x41, + 0xdb, 0x41, 0xc5, 0xe0, 0xf7, 0xdb, 0xee, 0x51, 0x14, 0xcb, 0xcb, 0xdc, 0x47, 0x01, 0x4b, 0xd5, + 0x7f, 0xa5, 0x1e, 0x43, 0x11, 0x5e, 0x61, 0x39, 0x9f, 0x50, 0x81, 0xc6, 0x34, 0x70, 0x0f, 0x6a, + 0xd0, 0x59, 0xc5, 0x81, 0xe7, 0x60, 0x7f, 0x03, 0x0f, 0xa9, 0x2f, 0x2d, 0xe3, 0x5e, 0xe4, 0xbd, + 0x9a, 0x32, 0xa6, 0xbe, 0x84, 0x04, 0x98, 0x1b, 0x6c, 0xc0, 0x92, 0x84, 0x48, 0xca, 0x49, 0x62, + 0x3d, 0xb8, 0x17, 0xfc, 0x49, 0xcd, 0x7a, 0x59, 0xa3, 0xde, 0x1a, 0xcd, 0x9d, 0x83, 0x5d, 0xb7, + 0xbd, 0x7d, 0xd2, 0xce, 0xeb, 0xc5, 0x2f, 0x5b, 0x5b, 0x2c, 0x6d, 0xfd, 0x66, 0x69, 0xeb, 0x3f, + 0x97, 0xb6, 0xfe, 0x69, 0x65, 0x6b, 0x37, 0x2b, 0x5b, 0xfb, 0xb6, 0xb2, 0xb5, 0xf7, 0xcf, 0xb6, + 0xec, 0x8e, 0xa3, 0x84, 0xf8, 0x02, 0x1f, 0x47, 0xc3, 0xe0, 0x92, 0xc4, 0x19, 0x9e, 0xd5, 0x37, + 0xba, 0xb4, 0xf5, 0x1b, 0xe5, 0x57, 0x7a, 0xfe, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x35, 0x98, + 0x5b, 0xee, 0x03, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/auction/types/query.pb.go b/x/auction/types/query.pb.go index 7a6f9014..870fc067 100644 --- a/x/auction/types/query.pb.go +++ b/x/auction/types/query.pb.go @@ -389,47 +389,47 @@ func init() { func init() { proto.RegisterFile("kava/auction/v1beta1/query.proto", fileDescriptor_0afd5f8bae92c6bb) } var fileDescriptor_0afd5f8bae92c6bb = []byte{ - // 630 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0x3f, 0x6f, 0xd3, 0x4e, - 0x18, 0xc7, 0xed, 0x34, 0x4d, 0xd3, 0xfb, 0xe9, 0xc7, 0x70, 0x18, 0x29, 0x35, 0xc1, 0x89, 0x2c, - 0xe8, 0x5f, 0x72, 0xee, 0x9f, 0xad, 0x03, 0x52, 0x0b, 0x2a, 0xea, 0x82, 0xa8, 0x47, 0x16, 0x74, - 0x4e, 0x0e, 0xd7, 0xa2, 0xf1, 0xb9, 0x39, 0xa7, 0x24, 0x42, 0x2c, 0xb0, 0x20, 0xb1, 0x20, 0x10, - 0x7b, 0x79, 0x23, 0xcc, 0x1d, 0x2b, 0x31, 0xc0, 0x84, 0x50, 0xc2, 0xc0, 0xcb, 0x40, 0xbe, 0x7b, - 0x9c, 0xc4, 0x60, 0x42, 0x36, 0xdf, 0x73, 0xdf, 0xe7, 0xb9, 0xcf, 0x3d, 0xcf, 0xf7, 0x8c, 0xea, - 0x4f, 0xe9, 0x19, 0x75, 0x68, 0xb7, 0x19, 0x07, 0x3c, 0x74, 0xce, 0xb6, 0x3c, 0x16, 0xd3, 0x2d, - 0xe7, 0xb4, 0xcb, 0x3a, 0x7d, 0x12, 0x75, 0x78, 0xcc, 0xb1, 0x91, 0x28, 0x08, 0x28, 0x08, 0x28, - 0xcc, 0xf5, 0x26, 0x17, 0x6d, 0x2e, 0x1c, 0x8f, 0x0a, 0xa6, 0xe4, 0xa3, 0xe4, 0x88, 0xfa, 0x41, - 0x48, 0xa5, 0x5a, 0x56, 0x30, 0x0d, 0x9f, 0xfb, 0x5c, 0x7e, 0x3a, 0xc9, 0x17, 0x44, 0xab, 0x3e, - 0xe7, 0xfe, 0x09, 0x73, 0x68, 0x14, 0x38, 0x34, 0x0c, 0x79, 0x2c, 0x53, 0x04, 0xec, 0x2e, 0xc1, - 0xae, 0x5c, 0x79, 0xdd, 0x27, 0x0e, 0x0d, 0x01, 0xc8, 0xb4, 0x73, 0x91, 0x7d, 0x16, 0x32, 0x11, - 0x40, 0xba, 0x6d, 0x20, 0x7c, 0x94, 0x40, 0x3d, 0xa4, 0x1d, 0xda, 0x16, 0x2e, 0x3b, 0xed, 0x32, - 0x11, 0xdb, 0x47, 0xe8, 0x6a, 0x26, 0x2a, 0x22, 0x1e, 0x0a, 0x86, 0x77, 0x51, 0x29, 0x92, 0x91, - 0x8a, 0x5e, 0xd7, 0x57, 0xff, 0xdb, 0xae, 0x92, 0xbc, 0x2b, 0x13, 0x95, 0xb5, 0x5f, 0xbc, 0xf8, - 0x56, 0xd3, 0x5c, 0xc8, 0xb0, 0xef, 0x40, 0xc9, 0x3d, 0x25, 0x86, 0x93, 0xf0, 0x0d, 0x84, 0x20, - 0xfd, 0x71, 0xd0, 0x92, 0x65, 0x8b, 0xee, 0x22, 0x44, 0x0e, 0x5b, 0xbb, 0xe5, 0xd7, 0xe7, 0x35, - 0xed, 0xe7, 0x79, 0x4d, 0xb3, 0x0f, 0x90, 0x91, 0xcd, 0x07, 0x26, 0x82, 0x16, 0x40, 0x0e, 0x50, - 0x06, 0x51, 0x1d, 0x21, 0x69, 0x47, 0xc8, 0x5e, 0xd8, 0x77, 0x53, 0x91, 0xfd, 0x49, 0xcf, 0x16, - 0x4a, 0xef, 0x8c, 0x31, 0x2a, 0xc6, 0xfd, 0x88, 0xc9, 0x2a, 0x8b, 0xae, 0xfc, 0xc6, 0x06, 0x9a, - 0xe7, 0xcf, 0x42, 0xd6, 0xa9, 0x14, 0x64, 0x50, 0x2d, 0x92, 0x68, 0x8b, 0x85, 0xbc, 0x5d, 0x99, - 0x53, 0x51, 0xb9, 0x48, 0xa2, 0xd1, 0x31, 0x15, 0xac, 0x52, 0x54, 0x51, 0xb9, 0xc0, 0x07, 0x08, - 0x8d, 0xc7, 0x5c, 0x99, 0x97, 0x84, 0xcb, 0x44, 0x79, 0x82, 0x24, 0x9e, 0x20, 0xca, 0x42, 0xe3, - 0xde, 0xf9, 0x0c, 0x88, 0xdc, 0x89, 0xcc, 0x89, 0x46, 0xbc, 0xd3, 0xd1, 0xb5, 0xdf, 0x2e, 0x00, - 0xad, 0xd8, 0x44, 0x65, 0xb8, 0x65, 0x32, 0xa0, 0xb9, 0xbf, 0xf6, 0x62, 0xa4, 0xc2, 0xf7, 0x33, - 0x74, 0x05, 0x49, 0xb7, 0xf2, 0x4f, 0x3a, 0x75, 0xdc, 0x24, 0x9e, 0x7d, 0x1d, 0x2d, 0x49, 0xa6, - 0x07, 0xac, 0x17, 0x03, 0xd7, 0xe1, 0xbd, 0xd4, 0x4d, 0xb7, 0x91, 0x99, 0xb7, 0x09, 0xd4, 0x57, - 0x50, 0x61, 0x34, 0xf9, 0x42, 0xd0, 0xda, 0xfe, 0x52, 0x44, 0xf3, 0x52, 0x8e, 0x5f, 0xe9, 0xa8, - 0xa4, 0xbc, 0x84, 0x57, 0xf3, 0x9d, 0xf6, 0xa7, 0x75, 0xcd, 0xb5, 0x19, 0x94, 0xea, 0x64, 0xfb, - 0xe6, 0xcb, 0xcf, 0x3f, 0xde, 0x17, 0x2c, 0x5c, 0x75, 0x72, 0x1f, 0x8a, 0x32, 0x2e, 0xfe, 0xa0, - 0xa3, 0x05, 0xa0, 0xc6, 0xd3, 0x8a, 0x67, 0x8d, 0x6d, 0xae, 0xcf, 0x22, 0x05, 0x90, 0x1d, 0x09, - 0xd2, 0xc0, 0x1b, 0xf9, 0x20, 0xe9, 0xb8, 0x9c, 0xe7, 0xe3, 0xa7, 0xf2, 0x02, 0xbf, 0xd1, 0x51, - 0x39, 0xb5, 0x00, 0x9e, 0xe1, 0xb4, 0x51, 0x87, 0x36, 0x66, 0xd2, 0x02, 0xda, 0xb2, 0x44, 0xab, - 0x63, 0x6b, 0x3a, 0x1a, 0xfe, 0xa8, 0xa3, 0xff, 0x33, 0xf3, 0xc5, 0xce, 0x94, 0x63, 0xf2, 0x6c, - 0x62, 0x6e, 0xce, 0x9e, 0x00, 0x70, 0x0d, 0x09, 0xb7, 0x82, 0x6f, 0xe5, 0xc3, 0x85, 0xac, 0x17, - 0x37, 0x20, 0xd8, 0x08, 0x5a, 0xfb, 0x77, 0x2f, 0x06, 0x96, 0x7e, 0x39, 0xb0, 0xf4, 0xef, 0x03, - 0x4b, 0x7f, 0x3b, 0xb4, 0xb4, 0xcb, 0xa1, 0xa5, 0x7d, 0x1d, 0x5a, 0xda, 0xa3, 0x35, 0x3f, 0x88, - 0x8f, 0xbb, 0x1e, 0x69, 0xf2, 0xb6, 0x2c, 0xd5, 0x38, 0xa1, 0x9e, 0x50, 0x45, 0x7b, 0xa3, 0xb2, - 0xc9, 0x1f, 0x41, 0x78, 0x25, 0xf9, 0x94, 0x76, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0x51, 0x53, - 0x3d, 0x4a, 0x10, 0x06, 0x00, 0x00, + // 634 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xcf, 0x4f, 0xd4, 0x40, + 0x14, 0xc7, 0xdb, 0x65, 0xf9, 0x35, 0x46, 0x0f, 0x63, 0x4d, 0x96, 0x8a, 0x85, 0x34, 0x0a, 0x08, + 0xee, 0xcc, 0x02, 0x37, 0x0e, 0x26, 0x10, 0x82, 0xe1, 0x62, 0xa4, 0x47, 0x2f, 0x66, 0xba, 0x3b, + 0x96, 0x46, 0x76, 0xa6, 0xec, 0x74, 0x11, 0x62, 0xbc, 0xe8, 0xc5, 0xc4, 0x8b, 0xd1, 0x78, 0xc7, + 0x7f, 0xc4, 0x33, 0x47, 0x12, 0x0f, 0x7a, 0x32, 0x06, 0x3c, 0xf8, 0x67, 0x98, 0xce, 0xbc, 0xee, + 0x6e, 0xb5, 0xae, 0x7b, 0xeb, 0xbc, 0xf9, 0xbe, 0x37, 0x9f, 0x79, 0xef, 0x3b, 0x45, 0xf3, 0xcf, + 0xd8, 0x11, 0xa3, 0xac, 0xdb, 0x4c, 0x63, 0x29, 0xe8, 0xd1, 0x6a, 0xc8, 0x53, 0xb6, 0x4a, 0x0f, + 0xbb, 0xbc, 0x73, 0x42, 0x92, 0x8e, 0x4c, 0x25, 0x76, 0x32, 0x05, 0x01, 0x05, 0x01, 0x85, 0xbb, + 0xdc, 0x94, 0xaa, 0x2d, 0x15, 0x0d, 0x99, 0xe2, 0x46, 0xde, 0x4b, 0x4e, 0x58, 0x14, 0x0b, 0xa6, + 0xd5, 0xba, 0x82, 0xeb, 0x44, 0x32, 0x92, 0xfa, 0x93, 0x66, 0x5f, 0x10, 0x9d, 0x8d, 0xa4, 0x8c, + 0x0e, 0x38, 0x65, 0x49, 0x4c, 0x99, 0x10, 0x32, 0xd5, 0x29, 0x0a, 0x76, 0x67, 0x60, 0x57, 0xaf, + 0xc2, 0xee, 0x53, 0xca, 0x04, 0x00, 0xb9, 0x7e, 0x29, 0x72, 0xc4, 0x05, 0x57, 0x31, 0xa4, 0xfb, + 0x0e, 0xc2, 0x7b, 0x19, 0xd4, 0x23, 0xd6, 0x61, 0x6d, 0x15, 0xf0, 0xc3, 0x2e, 0x57, 0xa9, 0xbf, + 0x87, 0xae, 0x17, 0xa2, 0x2a, 0x91, 0x42, 0x71, 0xbc, 0x81, 0x26, 0x12, 0x1d, 0xa9, 0xd9, 0xf3, + 0xf6, 0xd2, 0x95, 0xb5, 0x59, 0x52, 0x76, 0x65, 0x62, 0xb2, 0xb6, 0xaa, 0x67, 0xdf, 0xe7, 0xac, + 0x00, 0x32, 0xfc, 0xfb, 0x50, 0x72, 0xd3, 0x88, 0xe1, 0x24, 0x7c, 0x0b, 0x21, 0x48, 0x7f, 0x12, + 0xb7, 0x74, 0xd9, 0x6a, 0x30, 0x0d, 0x91, 0xdd, 0xd6, 0xc6, 0xd4, 0x9b, 0xd3, 0x39, 0xeb, 0xd7, + 0xe9, 0x9c, 0xe5, 0xef, 0x20, 0xa7, 0x98, 0x0f, 0x4c, 0x04, 0x4d, 0x82, 0x1c, 0xa0, 0x1c, 0x62, + 0x3a, 0x42, 0xf2, 0x8e, 0x90, 0x4d, 0x71, 0x12, 0xe4, 0x22, 0xff, 0xb3, 0x5d, 0x2c, 0x94, 0xdf, + 0x19, 0x63, 0x54, 0x4d, 0x4f, 0x12, 0xae, 0xab, 0x4c, 0x07, 0xfa, 0x1b, 0x3b, 0x68, 0x5c, 0x3e, + 0x17, 0xbc, 0x53, 0xab, 0xe8, 0xa0, 0x59, 0x64, 0xd1, 0x16, 0x17, 0xb2, 0x5d, 0x1b, 0x33, 0x51, + 0xbd, 0xc8, 0xa2, 0xc9, 0x3e, 0x53, 0xbc, 0x56, 0x35, 0x51, 0xbd, 0xc0, 0x3b, 0x08, 0xf5, 0xc7, + 0x5c, 0x1b, 0xd7, 0x84, 0x0b, 0xc4, 0x78, 0x82, 0x64, 0x9e, 0x20, 0xc6, 0x42, 0xfd, 0xde, 0x45, + 0x1c, 0x88, 0x82, 0x81, 0xcc, 0x81, 0x46, 0xbc, 0xb7, 0xd1, 0x8d, 0x3f, 0x2e, 0x00, 0xad, 0x68, + 0xa0, 0x29, 0xb8, 0x65, 0x36, 0xa0, 0xb1, 0x7f, 0xf6, 0xa2, 0xa7, 0xc2, 0x0f, 0x0a, 0x74, 0x15, + 0x4d, 0xb7, 0xf8, 0x5f, 0x3a, 0x73, 0xdc, 0x20, 0x9e, 0x7f, 0x13, 0xcd, 0x68, 0xa6, 0x87, 0xfc, + 0x38, 0x05, 0xae, 0xdd, 0xed, 0xdc, 0x4d, 0xf7, 0x90, 0x5b, 0xb6, 0x09, 0xd4, 0xd7, 0x50, 0xa5, + 0x37, 0xf9, 0x4a, 0xdc, 0x5a, 0xfb, 0x5a, 0x45, 0xe3, 0x5a, 0x8e, 0x5f, 0xdb, 0x68, 0xc2, 0x78, + 0x09, 0x2f, 0x95, 0x3b, 0xed, 0x6f, 0xeb, 0xba, 0x77, 0x47, 0x50, 0x9a, 0x93, 0xfd, 0xdb, 0xaf, + 0xbe, 0xfc, 0xfc, 0x50, 0xf1, 0xf0, 0x2c, 0x2d, 0x7d, 0x28, 0xc6, 0xb8, 0xf8, 0xa3, 0x8d, 0x26, + 0x81, 0x1a, 0x0f, 0x2b, 0x5e, 0x34, 0xb6, 0xbb, 0x3c, 0x8a, 0x14, 0x40, 0xd6, 0x35, 0x48, 0x1d, + 0xaf, 0x94, 0x83, 0xe4, 0xe3, 0xa2, 0x2f, 0xfa, 0x4f, 0xe5, 0x25, 0x7e, 0x6b, 0xa3, 0xa9, 0xdc, + 0x02, 0x78, 0x84, 0xd3, 0x7a, 0x1d, 0x5a, 0x19, 0x49, 0x0b, 0x68, 0x0b, 0x1a, 0x6d, 0x1e, 0x7b, + 0xc3, 0xd1, 0xf0, 0x27, 0x1b, 0x5d, 0x2d, 0xcc, 0x17, 0xd3, 0x21, 0xc7, 0x94, 0xd9, 0xc4, 0x6d, + 0x8c, 0x9e, 0x00, 0x70, 0x75, 0x0d, 0xb7, 0x88, 0xef, 0x94, 0xc3, 0x09, 0x7e, 0x9c, 0xd6, 0x21, + 0x58, 0x8f, 0x5b, 0x5b, 0xdb, 0x67, 0x17, 0x9e, 0x7d, 0x7e, 0xe1, 0xd9, 0x3f, 0x2e, 0x3c, 0xfb, + 0xdd, 0xa5, 0x67, 0x9d, 0x5f, 0x7a, 0xd6, 0xb7, 0x4b, 0xcf, 0x7a, 0xbc, 0x1c, 0xc5, 0xe9, 0x7e, + 0x37, 0x24, 0x4d, 0xd9, 0xa6, 0x8d, 0xe8, 0x80, 0x85, 0x8a, 0x36, 0xa2, 0x7a, 0x73, 0x9f, 0xc5, + 0x82, 0x1e, 0xf7, 0xea, 0x66, 0xbf, 0x04, 0x15, 0x4e, 0xe8, 0xb7, 0xb4, 0xfe, 0x3b, 0x00, 0x00, + 0xff, 0xff, 0x39, 0xdb, 0x8f, 0x24, 0x11, 0x06, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/auction/types/tx.pb.go b/x/auction/types/tx.pb.go index 2853a56f..51032510 100644 --- a/x/auction/types/tx.pb.go +++ b/x/auction/types/tx.pb.go @@ -114,27 +114,27 @@ func init() { func init() { proto.RegisterFile("kava/auction/v1beta1/tx.proto", fileDescriptor_226282be4da73be5) } var fileDescriptor_226282be4da73be5 = []byte{ - // 311 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcd, 0x4e, 0x2c, 0x4b, - 0xd4, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, - 0xd4, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x01, 0x49, 0xeb, 0x41, 0xa5, - 0xf5, 0xa0, 0xd2, 0x52, 0x72, 0xc9, 0xf9, 0xc5, 0xb9, 0xf9, 0xc5, 0xfa, 0x49, 0x89, 0xc5, 0xa9, - 0x70, 0x3d, 0xc9, 0xf9, 0x99, 0x79, 0x10, 0x5d, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0xa6, - 0x3e, 0x88, 0x05, 0x11, 0x55, 0x6a, 0x67, 0xe4, 0xe2, 0xf6, 0x2d, 0x4e, 0x0f, 0xc8, 0x49, 0x4c, - 0x4e, 0x75, 0xca, 0x4c, 0x11, 0x92, 0xe5, 0xe2, 0x82, 0x1a, 0x1c, 0x9f, 0x99, 0x22, 0xc1, 0xa8, - 0xc0, 0xa8, 0xc1, 0x12, 0xc4, 0x09, 0x15, 0xf1, 0x4c, 0x11, 0x12, 0xe3, 0x62, 0x4b, 0xca, 0x4c, - 0x49, 0x49, 0x2d, 0x92, 0x60, 0x52, 0x60, 0xd4, 0xe0, 0x0c, 0x82, 0xf2, 0x84, 0xcc, 0xb9, 0xd8, - 0x12, 0x73, 0xf3, 0x4b, 0xf3, 0x4a, 0x24, 0x98, 0x15, 0x18, 0x35, 0xb8, 0x8d, 0x24, 0xf5, 0x20, - 0xae, 0xd1, 0x03, 0xb9, 0x06, 0xe6, 0x44, 0x3d, 0xe7, 0xfc, 0xcc, 0x3c, 0x27, 0x96, 0x13, 0xf7, - 0xe4, 0x19, 0x82, 0xa0, 0xca, 0xad, 0x38, 0x3a, 0x16, 0xc8, 0x33, 0xbc, 0x58, 0x20, 0xcf, 0xa0, - 0x24, 0xca, 0x25, 0x8c, 0xe4, 0x90, 0xa0, 0xd4, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0xa3, 0x78, - 0x2e, 0x66, 0xdf, 0xe2, 0x74, 0xa1, 0x08, 0x2e, 0x0e, 0xb8, 0x1b, 0x15, 0xf5, 0xb0, 0x05, 0x80, - 0x1e, 0x92, 0x6e, 0x29, 0x4d, 0x82, 0x4a, 0x60, 0x16, 0x38, 0x39, 0x9f, 0x78, 0x24, 0xc7, 0x78, - 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, - 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x66, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, - 0xae, 0x3e, 0xc8, 0x38, 0xdd, 0x9c, 0xc4, 0xa4, 0x62, 0x30, 0x4b, 0xbf, 0x02, 0x1e, 0x3b, 0x25, - 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0xd0, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xbd, - 0x2b, 0xa7, 0xac, 0xba, 0x01, 0x00, 0x00, + // 316 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xb1, 0x4e, 0x42, 0x31, + 0x18, 0x85, 0x6f, 0x85, 0x10, 0x28, 0xdb, 0x15, 0x0d, 0x92, 0x50, 0x90, 0x09, 0x4d, 0x6c, 0x01, + 0x07, 0x13, 0x47, 0x74, 0x71, 0x20, 0x31, 0x77, 0x32, 0x2e, 0xa4, 0xb7, 0xb7, 0x29, 0x8d, 0xd0, + 0x9f, 0xd0, 0x42, 0xf0, 0x09, 0x74, 0xf4, 0x11, 0x78, 0x1c, 0x46, 0x46, 0x27, 0x63, 0x60, 0xf1, + 0x31, 0x0c, 0x50, 0x08, 0x83, 0x89, 0xdb, 0xdf, 0xff, 0x9c, 0xd3, 0x7e, 0x39, 0xc5, 0xe5, 0x17, + 0x3e, 0xe1, 0x8c, 0x8f, 0x85, 0xd3, 0x60, 0xd8, 0xa4, 0x19, 0x4b, 0xc7, 0x9b, 0xcc, 0x4d, 0xe9, + 0x70, 0x04, 0x0e, 0xc2, 0xc2, 0x5a, 0xa6, 0x5e, 0xa6, 0x5e, 0x2e, 0x11, 0x01, 0x76, 0x00, 0x96, + 0xc5, 0xdc, 0xca, 0x7d, 0x46, 0x80, 0x36, 0xdb, 0x54, 0xa9, 0xa0, 0x40, 0xc1, 0x66, 0x64, 0xeb, + 0x69, 0xbb, 0xad, 0xbd, 0x21, 0x9c, 0xef, 0x58, 0xf5, 0xd8, 0xe7, 0x42, 0xb6, 0x75, 0x12, 0x96, + 0x31, 0xf6, 0x17, 0x77, 0x75, 0x52, 0x44, 0x55, 0x54, 0x4f, 0x47, 0x39, 0xbf, 0x79, 0x48, 0xc2, + 0x53, 0x9c, 0x89, 0x75, 0x92, 0xc8, 0x51, 0xf1, 0xa8, 0x8a, 0xea, 0xb9, 0xc8, 0x9f, 0xc2, 0x1b, + 0x9c, 0xe1, 0x03, 0x18, 0x1b, 0x57, 0x4c, 0x55, 0x51, 0x3d, 0xdf, 0x3a, 0xa3, 0x5b, 0x1a, 0xba, + 0xa6, 0xd9, 0x21, 0xd2, 0x3b, 0xd0, 0xa6, 0x9d, 0x9e, 0x7f, 0x55, 0x82, 0xc8, 0xdb, 0x6f, 0xb3, + 0xef, 0xb3, 0x4a, 0xf0, 0x33, 0xab, 0x04, 0xb5, 0x13, 0x7c, 0x7c, 0x00, 0x12, 0x49, 0x3b, 0x04, + 0x63, 0x65, 0xab, 0x8b, 0x53, 0x1d, 0xab, 0xc2, 0x27, 0x9c, 0xdd, 0x33, 0x9e, 0xd3, 0xbf, 0x0a, + 0xa0, 0x07, 0xe9, 0xd2, 0xc5, 0xbf, 0x96, 0xdd, 0x03, 0xed, 0xfb, 0xf9, 0x92, 0xa0, 0xc5, 0x92, + 0xa0, 0xef, 0x25, 0x41, 0x1f, 0x2b, 0x12, 0x2c, 0x56, 0x24, 0xf8, 0x5c, 0x91, 0xe0, 0xf9, 0x52, + 0x69, 0xd7, 0x1b, 0xc7, 0x54, 0xc0, 0x80, 0x35, 0x54, 0x9f, 0xc7, 0x96, 0x35, 0xd4, 0x95, 0xe8, + 0x71, 0x6d, 0xd8, 0x74, 0xff, 0x3d, 0xee, 0x75, 0x28, 0x6d, 0x9c, 0xd9, 0xd4, 0x79, 0xfd, 0x1b, + 0x00, 0x00, 0xff, 0xff, 0x12, 0xef, 0xd5, 0x8d, 0xbb, 0x01, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/bep3/types/bep3.pb.go b/x/bep3/types/bep3.pb.go index 5a9c3ab5..8eb26b37 100644 --- a/x/bep3/types/bep3.pb.go +++ b/x/bep3/types/bep3.pb.go @@ -550,79 +550,79 @@ func init() { func init() { proto.RegisterFile("kava/bep3/v1beta1/bep3.proto", fileDescriptor_01a01937d931b013) } var fileDescriptor_01a01937d931b013 = []byte{ - // 1147 bytes of a gzipped FileDescriptorProto + // 1151 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4d, 0x6f, 0x1a, 0x57, 0x17, 0xf6, 0x18, 0x4c, 0xec, 0x03, 0x26, 0xbc, 0xd7, 0xc9, 0x1b, 0xec, 0xa4, 0x40, 0x9c, 0xaa, - 0x42, 0x51, 0x0d, 0xf9, 0x68, 0x77, 0x55, 0x55, 0x06, 0x70, 0x8c, 0xe4, 0x00, 0x1a, 0x6c, 0xf5, - 0x63, 0xd1, 0xe9, 0x9d, 0x99, 0x0b, 0x5c, 0x99, 0x99, 0x3b, 0x9a, 0x3b, 0x24, 0xf8, 0x1f, 0x74, - 0xd1, 0x45, 0xbb, 0xeb, 0xbe, 0xbb, 0x2e, 0xab, 0xfc, 0x88, 0x2c, 0xa3, 0xac, 0xaa, 0x2e, 0x9c, - 0xca, 0xf9, 0x17, 0xd9, 0xb4, 0xba, 0x1f, 0x06, 0x9c, 0xba, 0x15, 0x0b, 0x36, 0xf6, 0x9c, 0xaf, - 0xe7, 0x9c, 0xb9, 0x73, 0x9e, 0xe7, 0x02, 0x77, 0x4e, 0xf0, 0x33, 0x5c, 0x75, 0x48, 0xf8, 0xb8, - 0xfa, 0xec, 0xa1, 0x43, 0x62, 0xfc, 0x50, 0x1a, 0x95, 0x30, 0x62, 0x31, 0x43, 0xff, 0x13, 0xd1, - 0x8a, 0x74, 0xe8, 0xe8, 0x4e, 0xc1, 0x65, 0xdc, 0x67, 0xbc, 0xea, 0x60, 0x4e, 0xa6, 0x25, 0x2e, - 0xa3, 0x81, 0x2a, 0xd9, 0xd9, 0x56, 0x71, 0x5b, 0x5a, 0x55, 0x65, 0xe8, 0xd0, 0x8d, 0x01, 0x1b, - 0x30, 0xe5, 0x17, 0x4f, 0xda, 0x5b, 0x18, 0x30, 0x36, 0x18, 0x91, 0xaa, 0xb4, 0x9c, 0x71, 0xbf, - 0xea, 0x8d, 0x23, 0x1c, 0x53, 0xa6, 0x01, 0x77, 0x6d, 0x48, 0x75, 0x71, 0x84, 0x7d, 0x8e, 0x8e, - 0x21, 0x83, 0x39, 0x27, 0xb1, 0x1d, 0x4a, 0x3b, 0x6f, 0x94, 0x12, 0xe5, 0xf4, 0xa3, 0x0f, 0x2a, - 0xff, 0x18, 0xb2, 0x52, 0x13, 0x69, 0xb2, 0xca, 0xdc, 0x7a, 0x79, 0x56, 0x5c, 0xf9, 0xf5, 0x4d, - 0x31, 0x3d, 0xf3, 0x71, 0x2b, 0x8d, 0x67, 0xc6, 0xee, 0x0f, 0x6b, 0x00, 0xb3, 0x20, 0xba, 0x01, - 0x6b, 0x1e, 0x09, 0x98, 0x9f, 0x37, 0x4a, 0x46, 0x79, 0xc3, 0x52, 0x06, 0xba, 0x07, 0xd7, 0xc4, - 0x4b, 0xda, 0xd4, 0xcb, 0xaf, 0x96, 0x8c, 0x72, 0xc2, 0x84, 0xf3, 0xb3, 0x62, 0xaa, 0xce, 0x68, - 0xd0, 0x6a, 0x58, 0x29, 0x11, 0x6a, 0x79, 0xe8, 0x09, 0x64, 0xf8, 0x38, 0x0c, 0x47, 0xa7, 0xf6, - 0x88, 0xfa, 0x34, 0xce, 0x27, 0x4a, 0x46, 0x39, 0xfd, 0xa8, 0x70, 0xc5, 0x80, 0x3d, 0x99, 0x76, - 0x28, 0xb2, 0xcc, 0xa4, 0x98, 0xd0, 0x4a, 0xf3, 0x99, 0x0b, 0xfd, 0x1f, 0x52, 0xd8, 0x8d, 0xe9, - 0x33, 0x92, 0x4f, 0x96, 0x8c, 0xf2, 0xba, 0xa5, 0x2d, 0xc4, 0x20, 0xeb, 0x91, 0x70, 0x1c, 0x9f, - 0xda, 0xd8, 0xf3, 0x22, 0xc2, 0x79, 0x7e, 0xad, 0x64, 0x94, 0x33, 0xe6, 0xc1, 0xbb, 0xb3, 0xe2, - 0xde, 0x80, 0xc6, 0xc3, 0xb1, 0x53, 0x71, 0x99, 0xaf, 0x8f, 0x5d, 0xff, 0xdb, 0xe3, 0xde, 0x49, - 0x35, 0x3e, 0x0d, 0x09, 0xaf, 0xd4, 0x5c, 0xb7, 0xa6, 0x0a, 0x5f, 0xbf, 0xd8, 0xdb, 0xd2, 0x1f, - 0x47, 0x7b, 0xcc, 0xd3, 0x98, 0x70, 0x6b, 0x53, 0xe1, 0x6b, 0x1f, 0xfa, 0x1a, 0x36, 0xfa, 0x74, - 0x42, 0x3c, 0xbb, 0x4f, 0x48, 0x3e, 0x25, 0x0e, 0xc4, 0xfc, 0x4c, 0x8c, 0xfb, 0xc7, 0x59, 0xf1, - 0xa3, 0x05, 0xfa, 0xb5, 0x82, 0xf8, 0xf5, 0x8b, 0x3d, 0xd0, 0x8d, 0x5a, 0x41, 0x6c, 0xad, 0x4b, - 0xb8, 0x7d, 0x42, 0x90, 0x07, 0xd7, 0x7d, 0x1a, 0xd8, 0xfc, 0x39, 0x0e, 0x6d, 0xec, 0xb3, 0x71, - 0x10, 0xe7, 0xaf, 0x2d, 0xa1, 0xc1, 0xa6, 0x4f, 0x83, 0xde, 0x73, 0x1c, 0xd6, 0x24, 0xa4, 0xec, - 0x82, 0x27, 0x97, 0xba, 0xac, 0x2f, 0xa5, 0x0b, 0x9e, 0xcc, 0x75, 0xf9, 0x10, 0xb2, 0xe2, 0x5d, - 0x9c, 0x11, 0x73, 0x4f, 0x6c, 0xf1, 0x27, 0xbf, 0x51, 0x32, 0xca, 0x49, 0x2b, 0xe3, 0xd3, 0xc0, - 0x14, 0xf6, 0x21, 0x73, 0x4f, 0x64, 0x16, 0x9e, 0xcc, 0x67, 0x81, 0xce, 0xc2, 0x93, 0x69, 0xd6, - 0xee, 0x6f, 0xab, 0x90, 0x9e, 0x5b, 0x0f, 0x64, 0xc1, 0x9a, 0xda, 0x26, 0x63, 0x09, 0x73, 0x2b, - 0x28, 0x74, 0x17, 0x32, 0x31, 0xf5, 0x89, 0x5a, 0x53, 0xa2, 0x56, 0x7a, 0xdd, 0x4a, 0x0b, 0xdf, - 0xa1, 0x72, 0xa1, 0x06, 0x48, 0xd3, 0x0e, 0x49, 0x44, 0x99, 0xa7, 0x57, 0x79, 0xbb, 0xa2, 0xc8, - 0x5a, 0xb9, 0x20, 0x6b, 0xa5, 0xa1, 0xc9, 0x6a, 0xae, 0x8b, 0xb9, 0x7e, 0x7e, 0x53, 0x34, 0x2c, - 0x10, 0x75, 0x5d, 0x59, 0x86, 0xfa, 0x90, 0x93, 0x28, 0x42, 0x2d, 0x3c, 0xcd, 0x8a, 0xe4, 0x12, - 0xde, 0x23, 0x2b, 0x50, 0x4d, 0x01, 0x2a, 0xe7, 0xdd, 0xfd, 0x4b, 0x70, 0x38, 0x66, 0x3e, 0x75, - 0xc5, 0x57, 0x41, 0x2e, 0xa4, 0xf4, 0xc7, 0x56, 0x1a, 0xb1, 0x5d, 0xd1, 0xb5, 0x62, 0x8e, 0x29, - 0x09, 0x05, 0x7b, 0xcd, 0x07, 0x5a, 0x1f, 0xca, 0x0b, 0xcc, 0x21, 0x0a, 0xb8, 0xa5, 0xa1, 0x91, - 0x03, 0x28, 0xc2, 0x81, 0xc7, 0x7c, 0x3b, 0x18, 0xfb, 0x0e, 0x89, 0xec, 0x21, 0xe6, 0x43, 0x79, - 0x94, 0x19, 0xf3, 0x93, 0x77, 0x67, 0xc5, 0x07, 0x97, 0x10, 0x7d, 0x12, 0x3b, 0xfd, 0x78, 0xf6, - 0x30, 0xa2, 0x0e, 0xaf, 0x3a, 0x82, 0x73, 0x95, 0x03, 0x32, 0x51, 0xe4, 0xcb, 0x29, 0xbc, 0xb6, - 0x84, 0x3b, 0xc0, 0x7c, 0x88, 0xee, 0xc1, 0x26, 0x99, 0x84, 0x34, 0x22, 0xf6, 0x90, 0xd0, 0xc1, - 0x50, 0x49, 0x4a, 0xd2, 0xca, 0x28, 0xe7, 0x81, 0xf4, 0xa1, 0x3b, 0xb0, 0x21, 0x8e, 0x83, 0xc7, + 0x45, 0x51, 0x0d, 0x4e, 0xd2, 0xee, 0xaa, 0x4a, 0x0c, 0xe0, 0x18, 0xc9, 0x01, 0x34, 0xd8, 0xea, + 0xc7, 0xa2, 0xd3, 0x3b, 0x33, 0x17, 0xb8, 0x32, 0x33, 0x77, 0x34, 0x77, 0x48, 0xf0, 0x3f, 0xe8, + 0xa2, 0x8b, 0x76, 0xd7, 0x7d, 0x77, 0x5d, 0x56, 0xf9, 0x11, 0x59, 0x46, 0x59, 0x55, 0x5d, 0x38, + 0x95, 0xf3, 0x2f, 0xb2, 0x69, 0x75, 0x3f, 0x0c, 0x38, 0x4d, 0x2b, 0x16, 0x6c, 0xec, 0x39, 0x5f, + 0xcf, 0x39, 0x73, 0xe7, 0x3c, 0xcf, 0x05, 0xee, 0x9c, 0xe2, 0xa7, 0xb8, 0xea, 0x90, 0xf0, 0x51, + 0xf5, 0xe9, 0x03, 0x87, 0xc4, 0xf8, 0x81, 0x34, 0x2a, 0x61, 0xc4, 0x62, 0x86, 0xfe, 0x27, 0xa2, + 0x15, 0xe9, 0xd0, 0xd1, 0x9d, 0x82, 0xcb, 0xb8, 0xcf, 0x78, 0xd5, 0xc1, 0x9c, 0x4c, 0x4b, 0x5c, + 0x46, 0x03, 0x55, 0xb2, 0xb3, 0xad, 0xe2, 0xb6, 0xb4, 0xaa, 0xca, 0xd0, 0xa1, 0x1b, 0x03, 0x36, + 0x60, 0xca, 0x2f, 0x9e, 0xb4, 0xb7, 0x30, 0x60, 0x6c, 0x30, 0x22, 0x55, 0x69, 0x39, 0xe3, 0x7e, + 0xd5, 0x1b, 0x47, 0x38, 0xa6, 0x4c, 0x03, 0xee, 0xda, 0x90, 0xea, 0xe2, 0x08, 0xfb, 0x1c, 0x9d, + 0x40, 0x06, 0x73, 0x4e, 0x62, 0x3b, 0x94, 0x76, 0xde, 0x28, 0x25, 0xca, 0xe9, 0x87, 0x1f, 0x54, + 0xfe, 0x31, 0x64, 0xa5, 0x26, 0xd2, 0x64, 0x95, 0xb9, 0xf5, 0xe2, 0xbc, 0xb8, 0xf2, 0xeb, 0xeb, + 0x62, 0x7a, 0xe6, 0xe3, 0x56, 0x1a, 0xcf, 0x8c, 0xdd, 0x1f, 0xd6, 0x00, 0x66, 0x41, 0x74, 0x03, + 0xd6, 0x3c, 0x12, 0x30, 0x3f, 0x6f, 0x94, 0x8c, 0xf2, 0x86, 0xa5, 0x0c, 0x74, 0x0f, 0xae, 0x89, + 0x97, 0xb4, 0xa9, 0x97, 0x5f, 0x2d, 0x19, 0xe5, 0x84, 0x09, 0x17, 0xe7, 0xc5, 0x54, 0x9d, 0xd1, + 0xa0, 0xd5, 0xb0, 0x52, 0x22, 0xd4, 0xf2, 0xd0, 0x63, 0xc8, 0xf0, 0x71, 0x18, 0x8e, 0xce, 0xec, + 0x11, 0xf5, 0x69, 0x9c, 0x4f, 0x94, 0x8c, 0x72, 0xfa, 0x61, 0xe1, 0x3d, 0x03, 0xf6, 0x64, 0xda, + 0x91, 0xc8, 0x32, 0x93, 0x62, 0x42, 0x2b, 0xcd, 0x67, 0x2e, 0xf4, 0x7f, 0x48, 0x61, 0x37, 0xa6, + 0x4f, 0x49, 0x3e, 0x59, 0x32, 0xca, 0xeb, 0x96, 0xb6, 0x10, 0x83, 0xac, 0x47, 0xc2, 0x71, 0x7c, + 0x66, 0x63, 0xcf, 0x8b, 0x08, 0xe7, 0xf9, 0xb5, 0x92, 0x51, 0xce, 0x98, 0x87, 0x6f, 0xcf, 0x8b, + 0x7b, 0x03, 0x1a, 0x0f, 0xc7, 0x4e, 0xc5, 0x65, 0xbe, 0x3e, 0x76, 0xfd, 0x6f, 0x8f, 0x7b, 0xa7, + 0xd5, 0xf8, 0x2c, 0x24, 0xbc, 0x52, 0x73, 0xdd, 0x9a, 0x2a, 0x7c, 0xf5, 0x7c, 0x6f, 0x4b, 0x7f, + 0x1c, 0xed, 0x31, 0xcf, 0x62, 0xc2, 0xad, 0x4d, 0x85, 0xaf, 0x7d, 0xe8, 0x6b, 0xd8, 0xe8, 0xd3, + 0x09, 0xf1, 0xec, 0x3e, 0x21, 0xf9, 0x94, 0x38, 0x10, 0xf3, 0x73, 0x31, 0xee, 0x1f, 0xe7, 0xc5, + 0x8f, 0x16, 0xe8, 0xd7, 0x0a, 0xe2, 0x57, 0xcf, 0xf7, 0x40, 0x37, 0x6a, 0x05, 0xb1, 0xb5, 0x2e, + 0xe1, 0x0e, 0x08, 0x41, 0x1e, 0x5c, 0xf7, 0x69, 0x60, 0xf3, 0x67, 0x38, 0xb4, 0xb1, 0xcf, 0xc6, + 0x41, 0x9c, 0xbf, 0xb6, 0x84, 0x06, 0x9b, 0x3e, 0x0d, 0x7a, 0xcf, 0x70, 0x58, 0x93, 0x90, 0xb2, + 0x0b, 0x9e, 0x5c, 0xe9, 0xb2, 0xbe, 0x94, 0x2e, 0x78, 0x32, 0xd7, 0xe5, 0x43, 0xc8, 0x8a, 0x77, + 0x71, 0x46, 0xcc, 0x3d, 0xb5, 0xc5, 0x9f, 0xfc, 0x46, 0xc9, 0x28, 0x27, 0xad, 0x8c, 0x4f, 0x03, + 0x53, 0xd8, 0x47, 0xcc, 0x3d, 0x95, 0x59, 0x78, 0x32, 0x9f, 0x05, 0x3a, 0x0b, 0x4f, 0xa6, 0x59, + 0xbb, 0xbf, 0xad, 0x42, 0x7a, 0x6e, 0x3d, 0x90, 0x05, 0x6b, 0x6a, 0x9b, 0x8c, 0x25, 0xcc, 0xad, + 0xa0, 0xd0, 0x5d, 0xc8, 0xc4, 0xd4, 0x27, 0x6a, 0x4d, 0x89, 0x5a, 0xe9, 0x75, 0x2b, 0x2d, 0x7c, + 0x47, 0xca, 0x85, 0x1a, 0x20, 0x4d, 0x3b, 0x24, 0x11, 0x65, 0x9e, 0x5e, 0xe5, 0xed, 0x8a, 0x22, + 0x6b, 0xe5, 0x92, 0xac, 0x95, 0x86, 0x26, 0xab, 0xb9, 0x2e, 0xe6, 0xfa, 0xf9, 0x75, 0xd1, 0xb0, + 0x40, 0xd4, 0x75, 0x65, 0x19, 0xea, 0x43, 0x4e, 0xa2, 0x08, 0xb5, 0xf0, 0x34, 0x2b, 0x92, 0x4b, + 0x78, 0x8f, 0xac, 0x40, 0x35, 0x05, 0xa8, 0x9c, 0x77, 0xf7, 0x2f, 0xc1, 0xe1, 0x98, 0xf9, 0xd4, + 0x15, 0x5f, 0x05, 0xb9, 0x90, 0xd2, 0x1f, 0x5b, 0x69, 0xc4, 0x76, 0x45, 0xd7, 0x8a, 0x39, 0xa6, + 0x24, 0x14, 0xec, 0x35, 0xf7, 0xb5, 0x3e, 0x94, 0x17, 0x98, 0x43, 0x14, 0x70, 0x4b, 0x43, 0x23, + 0x07, 0x50, 0x84, 0x03, 0x8f, 0xf9, 0x76, 0x30, 0xf6, 0x1d, 0x12, 0xd9, 0x43, 0xcc, 0x87, 0xf2, + 0x28, 0x33, 0xe6, 0xa7, 0x6f, 0xcf, 0x8b, 0xfb, 0x57, 0x10, 0x7d, 0x12, 0x3b, 0xfd, 0x78, 0xf6, + 0x30, 0xa2, 0x0e, 0xaf, 0x3a, 0x82, 0x73, 0x95, 0x43, 0x32, 0x51, 0xe4, 0xcb, 0x29, 0xbc, 0xb6, + 0x84, 0x3b, 0xc4, 0x7c, 0x88, 0xee, 0xc1, 0x26, 0x99, 0x84, 0x34, 0x22, 0xf6, 0x90, 0xd0, 0xc1, + 0x50, 0x49, 0x4a, 0xd2, 0xca, 0x28, 0xe7, 0xa1, 0xf4, 0xa1, 0x3b, 0xb0, 0x21, 0x8e, 0x83, 0xc7, 0xd8, 0x0f, 0xe5, 0xe9, 0x26, 0xac, 0x99, 0x03, 0x7d, 0x07, 0x29, 0x4e, 0x02, 0x8f, 0x44, 0x4b, 0xd7, 0x0a, 0x8d, 0x8b, 0xfa, 0xb0, 0x11, 0x11, 0x97, 0x86, 0x94, 0x04, 0xb1, 0x14, 0x89, 0x65, - 0x36, 0x99, 0x41, 0xa3, 0x8f, 0x01, 0xa9, 0x8e, 0x36, 0x8b, 0x87, 0x24, 0xb2, 0xdd, 0x21, 0xa6, - 0x81, 0x12, 0x0d, 0x2b, 0xa7, 0x22, 0x1d, 0x11, 0xa8, 0x0b, 0x3f, 0x7a, 0x04, 0x37, 0xa7, 0xa5, - 0x97, 0x0a, 0x24, 0xff, 0xad, 0xad, 0x69, 0x70, 0xae, 0xe6, 0x2e, 0x64, 0xdc, 0x11, 0x13, 0xab, - 0xea, 0x4c, 0x59, 0x9c, 0xb0, 0xd2, 0xca, 0x27, 0x29, 0x8a, 0x3e, 0x85, 0x14, 0x8f, 0x71, 0x3c, - 0xe6, 0x92, 0xbc, 0xd9, 0x2b, 0xaf, 0x1f, 0xb1, 0x83, 0x3d, 0x99, 0x64, 0xe9, 0x64, 0x54, 0x84, - 0xb4, 0x1b, 0x31, 0xce, 0xf5, 0x0c, 0x69, 0x49, 0x38, 0x90, 0x2e, 0xd5, 0xfa, 0x73, 0xd8, 0xf0, - 0x68, 0x44, 0x5c, 0x41, 0xa6, 0x7c, 0x46, 0x42, 0x97, 0xfe, 0x05, 0xba, 0x71, 0x91, 0x67, 0xcd, - 0x4a, 0x76, 0x7f, 0x4a, 0x80, 0xba, 0xe2, 0x94, 0x76, 0xa0, 0x03, 0xb8, 0x4e, 0x03, 0x97, 0xf9, - 0x34, 0x18, 0xd8, 0xea, 0x6a, 0x91, 0x02, 0xf2, 0x9f, 0x5c, 0x50, 0x37, 0x51, 0xf6, 0xa2, 0x6e, - 0x86, 0xc4, 0xc6, 0xf1, 0x80, 0xcd, 0x21, 0xad, 0x2e, 0x88, 0x74, 0x51, 0xa7, 0x91, 0xf6, 0x21, - 0xeb, 0x8e, 0xa3, 0x48, 0x7c, 0x10, 0x0d, 0x94, 0x58, 0x0c, 0x68, 0x53, 0x97, 0x69, 0x9c, 0x6f, - 0xe1, 0xf6, 0xbc, 0x7c, 0xd9, 0xef, 0x81, 0x26, 0x17, 0x03, 0xcd, 0xcf, 0xc9, 0x5d, 0xfd, 0x12, - 0xfe, 0xbe, 0x96, 0x47, 0x32, 0xc2, 0x21, 0x27, 0x9e, 0x24, 0xce, 0x82, 0xe2, 0x27, 0x45, 0xb3, - 0xa9, 0xea, 0xee, 0x9f, 0x02, 0xcc, 0x56, 0x01, 0xdd, 0x86, 0x5b, 0xbd, 0x2f, 0x6b, 0x5d, 0xbb, - 0x77, 0x54, 0x3b, 0x3a, 0xee, 0xd9, 0xc7, 0xed, 0x5e, 0xb7, 0x59, 0x6f, 0xed, 0xb7, 0x9a, 0x8d, - 0xdc, 0x0a, 0xba, 0x01, 0xb9, 0xf9, 0x60, 0xa7, 0xdb, 0x6c, 0xe7, 0x0c, 0xb4, 0x0d, 0x37, 0xe7, - 0xbd, 0xf5, 0xce, 0xd3, 0xee, 0x61, 0xf3, 0xa8, 0xd9, 0xc8, 0xad, 0xa2, 0x5b, 0xb0, 0x35, 0x1f, - 0x6a, 0x7e, 0xd5, 0x6d, 0x59, 0xcd, 0x46, 0x2e, 0xb1, 0x93, 0xfc, 0xfe, 0x97, 0xc2, 0xca, 0x7d, - 0x06, 0x9b, 0x97, 0x56, 0x05, 0x15, 0x60, 0x47, 0xe6, 0x37, 0x5a, 0x56, 0xb3, 0x7e, 0xd4, 0xea, - 0xb4, 0xdf, 0x1b, 0xe0, 0x62, 0xba, 0x59, 0xbc, 0xd5, 0xae, 0x77, 0x9e, 0xb6, 0xda, 0x4f, 0x72, - 0xc6, 0x15, 0xc1, 0xce, 0xf1, 0xd1, 0x93, 0x8e, 0x08, 0xae, 0xaa, 0x86, 0xe6, 0x17, 0x2f, 0xcf, - 0x0b, 0xc6, 0xab, 0xf3, 0x82, 0xf1, 0xe7, 0x79, 0xc1, 0xf8, 0xf1, 0x6d, 0x61, 0xe5, 0xd5, 0xdb, - 0xc2, 0xca, 0xef, 0x6f, 0x0b, 0x2b, 0xdf, 0xcc, 0x2b, 0xbc, 0x58, 0xe8, 0xbd, 0x11, 0x76, 0xb8, - 0x7c, 0xaa, 0x4e, 0xd4, 0x2f, 0x4f, 0xa9, 0x05, 0x4e, 0x4a, 0x9e, 0xeb, 0xe3, 0xbf, 0x03, 0x00, - 0x00, 0xff, 0xff, 0x79, 0xfe, 0xe7, 0xb2, 0x93, 0x0a, 0x00, 0x00, + 0x36, 0x99, 0x41, 0xa3, 0x4f, 0x00, 0xa9, 0x8e, 0x36, 0x8b, 0x87, 0x24, 0xb2, 0xdd, 0x21, 0xa6, + 0x81, 0x12, 0x0d, 0x2b, 0xa7, 0x22, 0x1d, 0x11, 0xa8, 0x0b, 0x3f, 0x7a, 0x08, 0x37, 0xa7, 0xa5, + 0x57, 0x0a, 0x24, 0xff, 0xad, 0xad, 0x69, 0x70, 0xae, 0xe6, 0x2e, 0x64, 0xdc, 0x11, 0x13, 0xab, + 0xea, 0x4c, 0x59, 0x9c, 0xb0, 0xd2, 0xca, 0x27, 0x29, 0x8a, 0x3e, 0x83, 0x14, 0x8f, 0x71, 0x3c, + 0xe6, 0x92, 0xbc, 0xd9, 0xf7, 0x5e, 0x3f, 0x62, 0x07, 0x7b, 0x32, 0xc9, 0xd2, 0xc9, 0xa8, 0x08, + 0x69, 0x37, 0x62, 0x9c, 0xeb, 0x19, 0xd2, 0x92, 0x70, 0x20, 0x5d, 0xaa, 0xf5, 0x17, 0xb0, 0xe1, + 0xd1, 0x88, 0xb8, 0x82, 0x4c, 0xf9, 0x8c, 0x84, 0x2e, 0xfd, 0x0b, 0x74, 0xe3, 0x32, 0xcf, 0x9a, + 0x95, 0xec, 0xfe, 0x94, 0x00, 0x75, 0xc5, 0x29, 0xed, 0x40, 0x87, 0x70, 0x9d, 0x06, 0x2e, 0xf3, + 0x69, 0x30, 0xb0, 0xd5, 0xd5, 0x22, 0x05, 0xe4, 0x3f, 0xb9, 0xa0, 0x6e, 0xa2, 0xec, 0x65, 0xdd, + 0x0c, 0x89, 0x8d, 0xe3, 0x01, 0x9b, 0x43, 0x5a, 0x5d, 0x10, 0xe9, 0xb2, 0x4e, 0x23, 0x1d, 0x40, + 0xd6, 0x1d, 0x47, 0x91, 0xf8, 0x20, 0x1a, 0x28, 0xb1, 0x18, 0xd0, 0xa6, 0x2e, 0xd3, 0x38, 0xdf, + 0xc2, 0xed, 0x79, 0xf9, 0xb2, 0xdf, 0x01, 0x4d, 0x2e, 0x06, 0x9a, 0x9f, 0x93, 0xbb, 0xfa, 0x15, + 0xfc, 0x03, 0x2d, 0x8f, 0x64, 0x84, 0x43, 0x4e, 0x3c, 0x49, 0x9c, 0x05, 0xc5, 0x4f, 0x8a, 0x66, + 0x53, 0xd5, 0xdd, 0x3f, 0x03, 0x98, 0xad, 0x02, 0xba, 0x0d, 0xb7, 0x7a, 0x5f, 0xd6, 0xba, 0x76, + 0xef, 0xb8, 0x76, 0x7c, 0xd2, 0xb3, 0x4f, 0xda, 0xbd, 0x6e, 0xb3, 0xde, 0x3a, 0x68, 0x35, 0x1b, + 0xb9, 0x15, 0x74, 0x03, 0x72, 0xf3, 0xc1, 0x4e, 0xb7, 0xd9, 0xce, 0x19, 0x68, 0x1b, 0x6e, 0xce, + 0x7b, 0xeb, 0x9d, 0x27, 0xdd, 0xa3, 0xe6, 0x71, 0xb3, 0x91, 0x5b, 0x45, 0xb7, 0x60, 0x6b, 0x3e, + 0xd4, 0xfc, 0xaa, 0xdb, 0xb2, 0x9a, 0x8d, 0x5c, 0x62, 0x27, 0xf9, 0xfd, 0x2f, 0x85, 0x95, 0xfb, + 0x0c, 0x36, 0xaf, 0xac, 0x0a, 0x2a, 0xc0, 0x8e, 0xcc, 0x6f, 0xb4, 0xac, 0x66, 0xfd, 0xb8, 0xd5, + 0x69, 0xbf, 0x33, 0xc0, 0xe5, 0x74, 0xb3, 0x78, 0xab, 0x5d, 0xef, 0x3c, 0x69, 0xb5, 0x1f, 0xe7, + 0x8c, 0xf7, 0x04, 0x3b, 0x27, 0xc7, 0x8f, 0x3b, 0x22, 0xb8, 0xaa, 0x1a, 0x9a, 0xb5, 0x17, 0x17, + 0x05, 0xe3, 0xe5, 0x45, 0xc1, 0xf8, 0xf3, 0xa2, 0x60, 0xfc, 0xf8, 0xa6, 0xb0, 0xf2, 0xf2, 0x4d, + 0x61, 0xe5, 0xf7, 0x37, 0x85, 0x95, 0x6f, 0x3e, 0x9e, 0xd3, 0x81, 0xfd, 0xc1, 0x08, 0x3b, 0xbc, + 0xba, 0x3f, 0xd8, 0x93, 0x3c, 0xa8, 0x4e, 0xd4, 0x4f, 0x4f, 0x29, 0x06, 0x4e, 0x4a, 0x1e, 0xec, + 0xa3, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x59, 0x81, 0x30, 0x67, 0x94, 0x0a, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { diff --git a/x/bep3/types/genesis.pb.go b/x/bep3/types/genesis.pb.go index 83cc2815..f7f00ab9 100644 --- a/x/bep3/types/genesis.pb.go +++ b/x/bep3/types/genesis.pb.go @@ -107,30 +107,30 @@ func init() { func init() { proto.RegisterFile("kava/bep3/v1beta1/genesis.proto", fileDescriptor_ad8c98a16ce5aad0) } var fileDescriptor_ad8c98a16ce5aad0 = []byte{ - // 356 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xb1, 0x6e, 0xea, 0x30, - 0x14, 0x86, 0x13, 0x40, 0x08, 0x25, 0xdc, 0x81, 0x70, 0xaf, 0x94, 0x8b, 0xda, 0x04, 0x75, 0xa8, - 0x58, 0x6a, 0x0b, 0x18, 0xba, 0xb6, 0x59, 0xba, 0xb6, 0x81, 0x2e, 0x5d, 0x90, 0x83, 0xdc, 0xd4, - 0x22, 0xa9, 0x2d, 0x8e, 0x03, 0xe5, 0x2d, 0x78, 0x8e, 0xbe, 0x48, 0x19, 0x19, 0x3b, 0x95, 0x0a, - 0x5e, 0xa4, 0xb2, 0x13, 0xca, 0x00, 0x9b, 0xed, 0xf3, 0x9d, 0xef, 0x9c, 0xfc, 0xb1, 0xfc, 0x09, - 0x99, 0x11, 0x1c, 0x51, 0xd1, 0xc7, 0xb3, 0x6e, 0x44, 0x25, 0xe9, 0xe2, 0x98, 0xbe, 0x52, 0x60, - 0x80, 0xc4, 0x94, 0x4b, 0xee, 0x34, 0x14, 0x80, 0x14, 0x80, 0x0a, 0xa0, 0xf5, 0x37, 0xe6, 0x31, - 0xd7, 0x55, 0xac, 0x4e, 0x39, 0xd8, 0xf2, 0x63, 0xce, 0xe3, 0x84, 0x62, 0x7d, 0x8b, 0xb2, 0x67, - 0x2c, 0x59, 0x4a, 0x41, 0x92, 0x54, 0x14, 0xc0, 0xd9, 0xf1, 0x28, 0xad, 0xd5, 0xd5, 0x8b, 0x8f, - 0x92, 0x55, 0xbf, 0xcb, 0x27, 0x0f, 0x24, 0x91, 0xd4, 0xb9, 0xb6, 0xaa, 0x82, 0x4c, 0x49, 0x0a, - 0xae, 0xd9, 0x36, 0x3b, 0x76, 0xef, 0x3f, 0x3a, 0xda, 0x04, 0xdd, 0x6b, 0x20, 0xa8, 0xac, 0xbe, - 0x7c, 0x23, 0x2c, 0x70, 0xe7, 0xd1, 0xaa, 0x13, 0xc9, 0x53, 0x36, 0x1e, 0xc1, 0x9c, 0x08, 0x70, - 0x4b, 0xed, 0x72, 0xc7, 0xee, 0x9d, 0x9f, 0x68, 0xbf, 0xd5, 0xd8, 0x60, 0x4e, 0x44, 0xd0, 0x54, - 0x8a, 0xf7, 0x8d, 0x6f, 0x1f, 0xde, 0x20, 0xb4, 0xc9, 0xe1, 0xe2, 0x3c, 0x58, 0x35, 0xc8, 0x84, - 0x48, 0x18, 0x05, 0xb7, 0xac, 0x95, 0xde, 0x29, 0x25, 0x00, 0x95, 0x03, 0xc5, 0x2d, 0x82, 0x7f, - 0x85, 0xf3, 0xcf, 0xe1, 0x91, 0x51, 0x08, 0x7f, 0x35, 0xce, 0xd0, 0x6a, 0x8a, 0x29, 0x9d, 0x31, - 0x9e, 0xc1, 0x28, 0x4a, 0xf8, 0x78, 0x32, 0x52, 0x99, 0xb9, 0x15, 0xfd, 0xbd, 0x2d, 0x94, 0x07, - 0x8a, 0xf6, 0x81, 0xa2, 0xe1, 0x3e, 0xd0, 0xa0, 0xa6, 0xcc, 0xcb, 0x8d, 0x6f, 0x86, 0x8d, 0xbd, - 0x20, 0x50, 0xfd, 0x8a, 0x08, 0x6e, 0x56, 0x5b, 0xcf, 0x5c, 0x6f, 0x3d, 0xf3, 0x7b, 0xeb, 0x99, - 0xcb, 0x9d, 0x67, 0xac, 0x77, 0x9e, 0xf1, 0xb9, 0xf3, 0x8c, 0xa7, 0xcb, 0x98, 0xc9, 0x97, 0x2c, - 0x42, 0x63, 0x9e, 0x62, 0xb5, 0xfa, 0x55, 0x42, 0x22, 0xd0, 0x27, 0xfc, 0x96, 0xff, 0x18, 0xb9, - 0x10, 0x14, 0xa2, 0xaa, 0x1e, 0xd9, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x24, 0x63, 0x3b, 0x63, - 0x1d, 0x02, 0x00, 0x00, + // 361 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xbf, 0x6e, 0xe2, 0x40, + 0x10, 0x87, 0x6d, 0x40, 0x08, 0xd9, 0x5c, 0x81, 0xb9, 0x93, 0x7c, 0xe8, 0xce, 0x46, 0xd7, 0x1c, + 0x4d, 0x76, 0xf9, 0x53, 0xa4, 0xc6, 0x4d, 0xda, 0xc4, 0x90, 0x26, 0x0d, 0x5a, 0x5b, 0x9b, 0x65, + 0x85, 0xcd, 0xae, 0xd8, 0x35, 0x84, 0xb7, 0xe0, 0x39, 0xf2, 0x22, 0xa1, 0xa4, 0x4c, 0x15, 0x22, + 0x78, 0x91, 0x68, 0xd7, 0x26, 0x14, 0xd0, 0x79, 0x66, 0xbe, 0xf9, 0xc6, 0xfe, 0xd9, 0xf2, 0x67, + 0x68, 0x89, 0x60, 0x84, 0xf9, 0x00, 0x2e, 0x7b, 0x11, 0x96, 0xa8, 0x07, 0x09, 0x9e, 0x63, 0x41, + 0x05, 0xe0, 0x0b, 0x26, 0x99, 0xd3, 0x50, 0x00, 0x50, 0x00, 0x28, 0x80, 0xd6, 0x4f, 0xc2, 0x08, + 0xd3, 0x53, 0xa8, 0x9e, 0x72, 0xb0, 0xe5, 0x13, 0xc6, 0x48, 0x82, 0xa1, 0xae, 0xa2, 0xec, 0x19, + 0x4a, 0x9a, 0x62, 0x21, 0x51, 0xca, 0x0b, 0xe0, 0xcf, 0xe5, 0x29, 0xad, 0xd5, 0xd3, 0x7f, 0x6f, + 0x25, 0xab, 0x7e, 0x97, 0x5f, 0x1e, 0x49, 0x24, 0xb1, 0x73, 0x6b, 0x55, 0x39, 0x5a, 0xa0, 0x54, + 0xb8, 0x66, 0xdb, 0xec, 0xd8, 0xfd, 0xdf, 0xe0, 0xe2, 0x4d, 0xc0, 0xbd, 0x06, 0x82, 0xca, 0xf6, + 0xc3, 0x37, 0xc2, 0x02, 0x77, 0x1e, 0xad, 0x3a, 0x92, 0x2c, 0xa5, 0xf1, 0x44, 0xac, 0x10, 0x17, + 0x6e, 0xa9, 0x5d, 0xee, 0xd8, 0xfd, 0xbf, 0x57, 0xd6, 0x87, 0x1a, 0x1b, 0xad, 0x10, 0x0f, 0x9a, + 0x4a, 0xf1, 0xba, 0xf7, 0xed, 0x73, 0x4f, 0x84, 0x36, 0x3a, 0x17, 0xce, 0x83, 0x55, 0x13, 0x19, + 0xe7, 0x09, 0xc5, 0xc2, 0x2d, 0x6b, 0xa5, 0x77, 0x4d, 0x29, 0x04, 0x96, 0x23, 0xc5, 0xad, 0x83, + 0x5f, 0x85, 0xf3, 0xc7, 0xb9, 0x49, 0xb1, 0x08, 0xbf, 0x35, 0xce, 0xd8, 0x6a, 0xf2, 0x05, 0x5e, + 0x52, 0x96, 0x89, 0x49, 0x94, 0xb0, 0x78, 0x36, 0x51, 0x99, 0xb9, 0x15, 0xfd, 0xbd, 0x2d, 0x90, + 0x07, 0x0a, 0x4e, 0x81, 0x82, 0xf1, 0x29, 0xd0, 0xa0, 0xa6, 0xcc, 0x9b, 0xbd, 0x6f, 0x86, 0x8d, + 0x93, 0x20, 0x50, 0xfb, 0x8a, 0x08, 0x86, 0xdb, 0x83, 0x67, 0xee, 0x0e, 0x9e, 0xf9, 0x79, 0xf0, + 0xcc, 0xcd, 0xd1, 0x33, 0x76, 0x47, 0xcf, 0x78, 0x3f, 0x7a, 0xc6, 0xd3, 0x7f, 0x42, 0xe5, 0x34, + 0x8b, 0x40, 0xcc, 0x52, 0xd8, 0x25, 0x09, 0x8a, 0x04, 0xec, 0x92, 0x9b, 0x78, 0x8a, 0xe8, 0x1c, + 0xbe, 0xe4, 0x7f, 0x46, 0xae, 0x39, 0x16, 0x51, 0x55, 0xdf, 0x1c, 0x7c, 0x05, 0x00, 0x00, 0xff, + 0xff, 0x8d, 0x70, 0x3b, 0x72, 0x1e, 0x02, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/bep3/types/query.pb.go b/x/bep3/types/query.pb.go index 55eaa124..7ed87d66 100644 --- a/x/bep3/types/query.pb.go +++ b/x/bep3/types/query.pb.go @@ -726,81 +726,81 @@ func init() { func init() { proto.RegisterFile("kava/bep3/v1beta1/query.proto", fileDescriptor_a5e4082d53c18bf6) } var fileDescriptor_a5e4082d53c18bf6 = []byte{ - // 1176 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4f, 0x6f, 0x1b, 0xc5, - 0x1b, 0xb6, 0x9d, 0xc4, 0x8d, 0x5f, 0x3b, 0xf9, 0xfd, 0x98, 0x06, 0xba, 0x71, 0x5b, 0xdb, 0x5d, - 0x54, 0xd7, 0x2d, 0x8d, 0xb7, 0x4d, 0x05, 0x08, 0x90, 0x10, 0x4d, 0x4a, 0x08, 0x52, 0x95, 0xc2, - 0xe6, 0xc6, 0x81, 0xd5, 0x78, 0x77, 0x58, 0x8f, 0xe2, 0xdd, 0xd9, 0xec, 0xac, 0xd3, 0x86, 0xaa, - 0x07, 0x38, 0x71, 0x42, 0x48, 0x20, 0x04, 0xb7, 0x9e, 0xb9, 0x82, 0xf8, 0x0c, 0x3d, 0x56, 0x70, - 0xe1, 0x02, 0x45, 0x09, 0x07, 0x3e, 0x06, 0x9a, 0x3f, 0x6b, 0xaf, 0x63, 0x27, 0x71, 0x4e, 0xf6, - 0xbe, 0xef, 0xfb, 0x3c, 0xef, 0x33, 0x33, 0xcf, 0xfc, 0x81, 0xcb, 0x3b, 0x78, 0x0f, 0x5b, 0x1d, - 0x12, 0xdd, 0xb1, 0xf6, 0x6e, 0x77, 0x48, 0x82, 0x6f, 0x5b, 0xbb, 0x7d, 0x12, 0xef, 0xb7, 0xa3, - 0x98, 0x25, 0x0c, 0xbd, 0x24, 0xd2, 0x6d, 0x91, 0x6e, 0xeb, 0x74, 0xf5, 0x86, 0xcb, 0x78, 0xc0, - 0xb8, 0xd5, 0xc1, 0x9c, 0xa8, 0xda, 0x01, 0x32, 0xc2, 0x3e, 0x0d, 0x71, 0x42, 0x59, 0xa8, 0xe0, - 0xd5, 0x5a, 0xb6, 0x36, 0xad, 0x72, 0x19, 0x4d, 0xf3, 0xcb, 0x2a, 0xef, 0xc8, 0x2f, 0x4b, 0x7d, - 0xe8, 0xd4, 0x92, 0xcf, 0x7c, 0xa6, 0xe2, 0xe2, 0x9f, 0x8e, 0x5e, 0xf2, 0x19, 0xf3, 0x7b, 0xc4, - 0xc2, 0x11, 0xb5, 0x70, 0x18, 0xb2, 0x44, 0x76, 0x4b, 0x31, 0x35, 0x9d, 0x95, 0x5f, 0x9d, 0xfe, - 0x67, 0x96, 0xd7, 0x8f, 0xb3, 0x72, 0x2e, 0x8d, 0x0f, 0x56, 0x0e, 0x4d, 0x66, 0xcd, 0x25, 0x40, - 0x1f, 0x8b, 0xe1, 0x7c, 0x84, 0x63, 0x1c, 0x70, 0x9b, 0xec, 0xf6, 0x09, 0x4f, 0xcc, 0x2d, 0x38, - 0x3f, 0x12, 0xe5, 0x11, 0x0b, 0x39, 0x41, 0x6f, 0x42, 0x31, 0x92, 0x11, 0x23, 0xdf, 0xc8, 0xb7, - 0xca, 0xab, 0xcb, 0xed, 0xb1, 0x99, 0x6a, 0x2b, 0xc8, 0xda, 0xec, 0xb3, 0xbf, 0xea, 0x39, 0x5b, - 0x97, 0x9b, 0x6f, 0xc1, 0x05, 0xc9, 0x77, 0x97, 0x73, 0x92, 0x6c, 0xf7, 0xa3, 0xa8, 0xb7, 0xaf, - 0x5b, 0xa1, 0x25, 0x98, 0xf3, 0x48, 0xc8, 0x02, 0x49, 0x59, 0xb2, 0xd5, 0xc7, 0xdb, 0xf3, 0x5f, - 0x3d, 0xad, 0xe7, 0xfe, 0x7d, 0x5a, 0xcf, 0x99, 0x3f, 0xce, 0xc0, 0xf9, 0x11, 0x98, 0xd6, 0xb2, - 0x09, 0xff, 0xa3, 0xa1, 0xcb, 0x02, 0x1a, 0xfa, 0x0e, 0x97, 0xa9, 0x81, 0x28, 0x3d, 0xa5, 0x62, - 0xfe, 0x07, 0xb2, 0xd6, 0x19, 0x0d, 0xb5, 0xa8, 0xc5, 0x14, 0xa7, 0x18, 0x05, 0x13, 0xeb, 0x27, - 0x3e, 0xcb, 0x30, 0x15, 0xa6, 0x64, 0x4a, 0x71, 0x9a, 0x69, 0x03, 0x16, 0xdd, 0x7e, 0x1c, 0x93, - 0x30, 0x49, 0x89, 0x66, 0xa6, 0x23, 0x5a, 0xd0, 0x30, 0xcd, 0xf3, 0x29, 0x5c, 0x4c, 0x68, 0x40, - 0x9c, 0x1e, 0x0d, 0x68, 0x42, 0x3c, 0xe7, 0x08, 0xe9, 0xec, 0x74, 0xa4, 0x86, 0xe0, 0xb8, 0xaf, - 0x28, 0xd6, 0x47, 0xf8, 0x37, 0xa0, 0x22, 0xf9, 0x49, 0x0f, 0x47, 0x9c, 0x78, 0xc6, 0x9c, 0x26, - 0x54, 0x4e, 0x6a, 0xa7, 0x4e, 0x6a, 0xdf, 0xd3, 0x4e, 0x5a, 0x9b, 0x17, 0x84, 0x3f, 0xbc, 0xa8, - 0xe7, 0xed, 0xb2, 0x00, 0xbe, 0xaf, 0x70, 0xe6, 0x0e, 0x18, 0xe3, 0xcb, 0xaa, 0xd7, 0xe7, 0x01, - 0x54, 0xb0, 0x08, 0x8f, 0x2e, 0x4e, 0x73, 0x82, 0x63, 0x26, 0xa0, 0xf5, 0x08, 0xca, 0x78, 0x98, - 0x32, 0xaf, 0xc2, 0xf2, 0x91, 0x66, 0x94, 0xa4, 0x86, 0xcd, 0xf8, 0x65, 0x17, 0xaa, 0x93, 0xca, - 0xb4, 0xaa, 0x6d, 0x58, 0xcc, 0xa8, 0xa2, 0x44, 0x38, 0x79, 0xe6, 0xcc, 0xba, 0x16, 0x70, 0x96, - 0xdc, 0x7c, 0x07, 0x5e, 0x51, 0x2d, 0x13, 0x16, 0x50, 0x77, 0xfb, 0x21, 0x8e, 0x52, 0x73, 0x5f, - 0x80, 0x73, 0xfc, 0x21, 0x8e, 0x1c, 0xea, 0x69, 0x7b, 0x17, 0xc5, 0xe7, 0x87, 0x5e, 0x46, 0xaf, - 0x9f, 0x6e, 0x8d, 0x0c, 0x58, 0x8b, 0xbd, 0x0f, 0x65, 0x2c, 0xa3, 0x8e, 0x40, 0x69, 0x53, 0x5e, - 0x9d, 0xa4, 0x74, 0x0c, 0xab, 0x85, 0x02, 0x1e, 0x64, 0xcc, 0x2f, 0xe6, 0x00, 0x4d, 0x68, 0xb2, - 0x08, 0x85, 0x81, 0xba, 0x02, 0xf5, 0x90, 0x0b, 0x45, 0x1c, 0xb0, 0x7e, 0x98, 0x18, 0x05, 0x39, - 0x33, 0x27, 0xd8, 0xec, 0x96, 0xe8, 0xf1, 0xd3, 0x8b, 0x7a, 0xcb, 0xa7, 0x49, 0xb7, 0xdf, 0x69, - 0xbb, 0x2c, 0xd0, 0xc7, 0x99, 0xfe, 0x59, 0xe1, 0xde, 0x8e, 0x95, 0xec, 0x47, 0x84, 0x4b, 0x00, - 0xb7, 0x35, 0x35, 0xba, 0x09, 0x28, 0xc6, 0xa1, 0xc7, 0x02, 0x27, 0xec, 0x07, 0x1d, 0x12, 0x3b, - 0x5d, 0xcc, 0xbb, 0x72, 0xb3, 0x94, 0xec, 0xff, 0xab, 0xcc, 0x96, 0x4c, 0x6c, 0x62, 0xde, 0x45, - 0xaf, 0xc2, 0x02, 0x79, 0x14, 0xd1, 0x98, 0x38, 0x5d, 0x42, 0xfd, 0x6e, 0x22, 0x37, 0xc0, 0xac, - 0x5d, 0x51, 0xc1, 0x4d, 0x19, 0x43, 0x97, 0xa0, 0x24, 0xac, 0xc9, 0x13, 0x1c, 0x44, 0xd2, 0xd0, - 0x33, 0xf6, 0x30, 0x80, 0x6e, 0x41, 0x91, 0x93, 0xd0, 0x23, 0xb1, 0x51, 0x14, 0x4d, 0xd6, 0x8c, - 0xdf, 0x7e, 0x59, 0x59, 0xd2, 0x03, 0xbb, 0xeb, 0x79, 0x31, 0xe1, 0x7c, 0x3b, 0x89, 0x69, 0xe8, - 0xdb, 0xba, 0x0e, 0xbd, 0x01, 0xa5, 0x98, 0xb8, 0x34, 0xa2, 0x24, 0x4c, 0x8c, 0x73, 0xa7, 0x80, - 0x86, 0xa5, 0x62, 0x68, 0x8a, 0xc1, 0x61, 0x49, 0x97, 0xc4, 0x8e, 0xdb, 0xc5, 0x34, 0x34, 0xe6, - 0xd5, 0xd0, 0x54, 0xe6, 0x81, 0x48, 0xac, 0x8b, 0x38, 0x5a, 0x85, 0x97, 0x07, 0xd0, 0x11, 0x40, - 0x49, 0x02, 0xce, 0x0f, 0x92, 0x19, 0xcc, 0x15, 0xa8, 0xb8, 0x3d, 0xc6, 0x89, 0xe7, 0x74, 0x7a, - 0xcc, 0xdd, 0x31, 0x40, 0x0e, 0xb6, 0xac, 0x62, 0x6b, 0x22, 0x84, 0x5e, 0x87, 0x22, 0x4f, 0x70, - 0xd2, 0xe7, 0x46, 0xb9, 0x91, 0x6f, 0x2d, 0xae, 0x5e, 0x9e, 0x60, 0x1a, 0xe1, 0x82, 0x6d, 0x59, - 0x64, 0xeb, 0x62, 0x54, 0x87, 0xb2, 0x1b, 0x33, 0xce, 0xb5, 0x86, 0x4a, 0x23, 0xdf, 0x9a, 0xb7, - 0x41, 0x86, 0x54, 0xeb, 0x77, 0xa1, 0xe4, 0xd1, 0x98, 0xb8, 0xe2, 0x50, 0x30, 0x16, 0x24, 0x75, - 0xe3, 0x18, 0xea, 0x7b, 0x69, 0x9d, 0x3d, 0x84, 0x98, 0xbf, 0x16, 0xc6, 0xdc, 0x9e, 0x6e, 0x61, - 0xb4, 0x0a, 0xe7, 0x68, 0xb8, 0xc7, 0x7a, 0x7b, 0x44, 0xb9, 0xf1, 0x84, 0xe9, 0x4e, 0x0b, 0x51, - 0x0d, 0x40, 0x9a, 0x40, 0x9e, 0x52, 0x72, 0x83, 0xcc, 0xda, 0x99, 0x48, 0x66, 0x1e, 0x66, 0xce, - 0x32, 0x0f, 0x23, 0xc3, 0x9c, 0x3d, 0xf3, 0x30, 0xd1, 0x06, 0xc0, 0xf0, 0x55, 0xa0, 0x4f, 0xd7, - 0xe6, 0xc8, 0x3e, 0x52, 0xcf, 0x8d, 0xe1, 0x9d, 0xe9, 0x13, 0x3d, 0x0d, 0x76, 0x06, 0x99, 0x39, - 0x25, 0x7e, 0xce, 0xa7, 0x47, 0x6d, 0x76, 0xe2, 0xf4, 0x16, 0xde, 0x82, 0x4a, 0xe6, 0x9c, 0x48, - 0x8f, 0xb4, 0x33, 0x1d, 0x14, 0xe5, 0xe1, 0x41, 0xc1, 0xd1, 0x07, 0x23, 0xf2, 0xd5, 0x15, 0x76, - 0xed, 0x54, 0xf9, 0x8a, 0x2f, 0xab, 0x7f, 0xf5, 0xcf, 0x39, 0x98, 0x93, 0xaa, 0xd1, 0xe7, 0x50, - 0x54, 0x0f, 0x03, 0x34, 0x49, 0xd6, 0xf8, 0x0b, 0xa4, 0xda, 0x3c, 0xad, 0x4c, 0xb5, 0x33, 0xaf, - 0x7c, 0xf9, 0xfb, 0x3f, 0xdf, 0x16, 0x2e, 0xa2, 0x65, 0x6b, 0xfc, 0x99, 0xa3, 0x1e, 0x1f, 0xe8, - 0xfb, 0x3c, 0x94, 0x33, 0x67, 0x39, 0xba, 0x71, 0x1c, 0xf5, 0xf8, 0xeb, 0xa4, 0xfa, 0xda, 0x54, - 0xb5, 0x5a, 0x4b, 0x5b, 0x6a, 0x69, 0xa1, 0xe6, 0x04, 0x2d, 0xf2, 0xc6, 0x50, 0x57, 0xa1, 0xf5, - 0x58, 0xbe, 0x71, 0x9e, 0x08, 0x61, 0x0b, 0x23, 0xd7, 0x14, 0xba, 0x79, 0x7a, 0xbb, 0xe1, 0xa5, - 0x57, 0x5d, 0x99, 0xb2, 0x5a, 0xcb, 0x6b, 0x49, 0x79, 0x26, 0x6a, 0x9c, 0x28, 0x4f, 0xc8, 0xf8, - 0x2e, 0x0f, 0x30, 0xb4, 0x0a, 0xba, 0x7e, 0x6c, 0x9f, 0xa3, 0x17, 0x5e, 0xf5, 0xc6, 0x34, 0xa5, - 0x5a, 0x8f, 0x25, 0xf5, 0x5c, 0x47, 0xd7, 0x26, 0xe9, 0x91, 0xe5, 0xc2, 0xce, 0xd6, 0x63, 0x7d, - 0x83, 0x3e, 0x41, 0x5f, 0x8b, 0x85, 0xcc, 0xf8, 0x74, 0x8a, 0x66, 0xfc, 0xf4, 0x85, 0x1c, 0xdf, - 0x50, 0x66, 0x53, 0x2a, 0x6b, 0xa0, 0xda, 0x89, 0xca, 0xf8, 0xda, 0x7b, 0xcf, 0x0e, 0x6a, 0xf9, - 0xe7, 0x07, 0xb5, 0xfc, 0xdf, 0x07, 0xb5, 0xfc, 0x37, 0x87, 0xb5, 0xdc, 0xf3, 0xc3, 0x5a, 0xee, - 0x8f, 0xc3, 0x5a, 0xee, 0x93, 0x66, 0xe6, 0x4a, 0x14, 0x1c, 0x2b, 0x3d, 0xdc, 0xe1, 0x8a, 0xed, - 0x91, 0xe2, 0x93, 0xd7, 0x62, 0xa7, 0x28, 0xdf, 0x5a, 0x77, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, - 0xd4, 0xac, 0x57, 0x4a, 0x92, 0x0c, 0x00, 0x00, + // 1179 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xcf, 0x6f, 0x1b, 0x45, + 0x14, 0xb6, 0x9d, 0xc4, 0x8d, 0x9f, 0x9d, 0x00, 0xd3, 0x40, 0x37, 0x6e, 0x6b, 0xbb, 0x8b, 0x9a, + 0xba, 0xa5, 0xf1, 0xa6, 0xa9, 0x00, 0x01, 0x12, 0x52, 0x92, 0x12, 0x82, 0x54, 0xa5, 0xb0, 0xb9, + 0x71, 0x60, 0x35, 0xde, 0x1d, 0xd6, 0xa3, 0x78, 0x77, 0x36, 0x3b, 0xeb, 0xb4, 0xa1, 0xea, 0x01, + 0x4e, 0x9c, 0x10, 0x12, 0x08, 0xc1, 0xad, 0x67, 0xae, 0x20, 0xfe, 0x86, 0x1e, 0x2b, 0xb8, 0x70, + 0x81, 0xa2, 0x84, 0x03, 0x7f, 0x06, 0x9a, 0x1f, 0x6b, 0xaf, 0x63, 0x27, 0x71, 0x4e, 0xf6, 0xbe, + 0xf7, 0xbe, 0xef, 0x7d, 0x33, 0xf3, 0xe6, 0xbd, 0x81, 0xab, 0xbb, 0x78, 0x1f, 0x5b, 0x6d, 0x12, + 0xdd, 0xb5, 0xf6, 0xef, 0xb4, 0x49, 0x82, 0xef, 0x58, 0x7b, 0x3d, 0x12, 0x1f, 0xb4, 0xa2, 0x98, + 0x25, 0x0c, 0xbd, 0x22, 0xdc, 0x2d, 0xe1, 0x6e, 0x69, 0x77, 0xf5, 0x96, 0xcb, 0x78, 0xc0, 0xb8, + 0xd5, 0xc6, 0x9c, 0xa8, 0xd8, 0x3e, 0x32, 0xc2, 0x3e, 0x0d, 0x71, 0x42, 0x59, 0xa8, 0xe0, 0xd5, + 0x5a, 0x36, 0x36, 0x8d, 0x72, 0x19, 0x4d, 0xfd, 0x8b, 0xca, 0xef, 0xc8, 0x2f, 0x4b, 0x7d, 0x68, + 0xd7, 0x82, 0xcf, 0x7c, 0xa6, 0xec, 0xe2, 0x9f, 0xb6, 0x5e, 0xf1, 0x19, 0xf3, 0xbb, 0xc4, 0xc2, + 0x11, 0xb5, 0x70, 0x18, 0xb2, 0x44, 0x66, 0x4b, 0x31, 0x35, 0xed, 0x95, 0x5f, 0xed, 0xde, 0xe7, + 0x96, 0xd7, 0x8b, 0xb3, 0x72, 0xae, 0x8c, 0x2e, 0x56, 0x2e, 0x4d, 0x7a, 0xcd, 0x05, 0x40, 0x9f, + 0x88, 0xe5, 0x7c, 0x8c, 0x63, 0x1c, 0x70, 0x9b, 0xec, 0xf5, 0x08, 0x4f, 0xcc, 0x6d, 0xb8, 0x38, + 0x64, 0xe5, 0x11, 0x0b, 0x39, 0x41, 0x6f, 0x43, 0x31, 0x92, 0x16, 0x23, 0xdf, 0xc8, 0x37, 0xcb, + 0xab, 0x8b, 0xad, 0x91, 0x9d, 0x6a, 0x29, 0xc8, 0xfa, 0xf4, 0xb3, 0xbf, 0xeb, 0x39, 0x5b, 0x87, + 0x9b, 0xef, 0xc0, 0x25, 0xc9, 0xb7, 0xc6, 0x39, 0x49, 0x76, 0x7a, 0x51, 0xd4, 0x3d, 0xd0, 0xa9, + 0xd0, 0x02, 0xcc, 0x78, 0x24, 0x64, 0x81, 0xa4, 0x2c, 0xd9, 0xea, 0xe3, 0xdd, 0xd9, 0xaf, 0x9f, + 0xd6, 0x73, 0xff, 0x3d, 0xad, 0xe7, 0xcc, 0x9f, 0xa6, 0xe0, 0xe2, 0x10, 0x4c, 0x6b, 0xd9, 0x82, + 0x97, 0x68, 0xe8, 0xb2, 0x80, 0x86, 0xbe, 0xc3, 0xa5, 0xab, 0x2f, 0x4a, 0x6f, 0xa9, 0xd8, 0xff, + 0xbe, 0xac, 0x0d, 0x46, 0x43, 0x2d, 0x6a, 0x3e, 0xc5, 0x29, 0x46, 0xc1, 0xc4, 0x7a, 0x89, 0xcf, + 0x32, 0x4c, 0x85, 0x09, 0x99, 0x52, 0x9c, 0x66, 0xda, 0x84, 0x79, 0xb7, 0x17, 0xc7, 0x24, 0x4c, + 0x52, 0xa2, 0xa9, 0xc9, 0x88, 0xe6, 0x34, 0x4c, 0xf3, 0x7c, 0x06, 0x97, 0x13, 0x1a, 0x10, 0xa7, + 0x4b, 0x03, 0x9a, 0x10, 0xcf, 0x39, 0x46, 0x3a, 0x3d, 0x19, 0xa9, 0x21, 0x38, 0xee, 0x2b, 0x8a, + 0x8d, 0x21, 0xfe, 0x4d, 0xa8, 0x48, 0x7e, 0xd2, 0xc5, 0x11, 0x27, 0x9e, 0x31, 0xa3, 0x09, 0x55, + 0x25, 0xb5, 0xd2, 0x4a, 0x6a, 0xdd, 0xd3, 0x95, 0xb4, 0x3e, 0x2b, 0x08, 0x7f, 0x7c, 0x51, 0xcf, + 0xdb, 0x65, 0x01, 0xfc, 0x40, 0xe1, 0xcc, 0x5d, 0x30, 0x46, 0x8f, 0x55, 0x9f, 0xcf, 0x03, 0xa8, + 0x60, 0x61, 0x1e, 0x3e, 0x9c, 0xa5, 0x31, 0x15, 0x33, 0x06, 0xad, 0x57, 0x50, 0xc6, 0x03, 0x97, + 0x79, 0x1d, 0x16, 0x8f, 0x25, 0xa3, 0x24, 0x2d, 0xd8, 0x4c, 0xbd, 0xec, 0x41, 0x75, 0x5c, 0x98, + 0x56, 0xb5, 0x03, 0xf3, 0x19, 0x55, 0x94, 0x88, 0x4a, 0x9e, 0x3a, 0xb7, 0xae, 0x39, 0x9c, 0x25, + 0x37, 0xdf, 0x83, 0xd7, 0x54, 0xca, 0x84, 0x05, 0xd4, 0xdd, 0x79, 0x88, 0xa3, 0xb4, 0xb8, 0x2f, + 0xc1, 0x05, 0xfe, 0x10, 0x47, 0x0e, 0xf5, 0x74, 0x79, 0x17, 0xc5, 0xe7, 0x47, 0x5e, 0x46, 0xaf, + 0x9f, 0x5e, 0x8d, 0x0c, 0x58, 0x8b, 0xbd, 0x0f, 0x65, 0x2c, 0xad, 0x8e, 0x40, 0xe9, 0xa2, 0xbc, + 0x3e, 0x4e, 0xe9, 0x08, 0x56, 0x0b, 0x05, 0xdc, 0xf7, 0x98, 0x5f, 0xce, 0x00, 0x1a, 0x93, 0x64, + 0x1e, 0x0a, 0x7d, 0x75, 0x05, 0xea, 0x21, 0x17, 0x8a, 0x38, 0x60, 0xbd, 0x30, 0x31, 0x0a, 0x72, + 0x67, 0x4e, 0x29, 0xb3, 0x15, 0x91, 0xe3, 0xe7, 0x17, 0xf5, 0xa6, 0x4f, 0x93, 0x4e, 0xaf, 0xdd, + 0x72, 0x59, 0xa0, 0xdb, 0x99, 0xfe, 0x59, 0xe6, 0xde, 0xae, 0x95, 0x1c, 0x44, 0x84, 0x4b, 0x00, + 0xb7, 0x35, 0x35, 0xba, 0x0d, 0x28, 0xc6, 0xa1, 0xc7, 0x02, 0x27, 0xec, 0x05, 0x6d, 0x12, 0x3b, + 0x1d, 0xcc, 0x3b, 0xf2, 0xb2, 0x94, 0xec, 0x97, 0x95, 0x67, 0x5b, 0x3a, 0xb6, 0x30, 0xef, 0xa0, + 0xd7, 0x61, 0x8e, 0x3c, 0x8a, 0x68, 0x4c, 0x9c, 0x0e, 0xa1, 0x7e, 0x27, 0x91, 0x17, 0x60, 0xda, + 0xae, 0x28, 0xe3, 0x96, 0xb4, 0xa1, 0x2b, 0x50, 0x12, 0xa5, 0xc9, 0x13, 0x1c, 0x44, 0xb2, 0xa0, + 0xa7, 0xec, 0x81, 0x01, 0xad, 0x40, 0x91, 0x93, 0xd0, 0x23, 0xb1, 0x51, 0x14, 0x49, 0xd6, 0x8d, + 0xdf, 0x7f, 0x5d, 0x5e, 0xd0, 0x0b, 0x5b, 0xf3, 0xbc, 0x98, 0x70, 0xbe, 0x93, 0xc4, 0x34, 0xf4, + 0x6d, 0x1d, 0x87, 0xde, 0x82, 0x52, 0x4c, 0x5c, 0x1a, 0x51, 0x12, 0x26, 0xc6, 0x85, 0x33, 0x40, + 0x83, 0x50, 0xb1, 0x34, 0xc5, 0xe0, 0xb0, 0xa4, 0x43, 0x62, 0xc7, 0xed, 0x60, 0x1a, 0x1a, 0xb3, + 0x6a, 0x69, 0xca, 0xf3, 0x40, 0x38, 0x36, 0x84, 0x1d, 0xad, 0xc2, 0xab, 0x7d, 0xe8, 0x10, 0xa0, + 0x24, 0x01, 0x17, 0xfb, 0xce, 0x0c, 0xe6, 0x1a, 0x54, 0xdc, 0x2e, 0xe3, 0xc4, 0x73, 0xda, 0x5d, + 0xe6, 0xee, 0x1a, 0x20, 0x17, 0x5b, 0x56, 0xb6, 0x75, 0x61, 0x42, 0x6f, 0x42, 0x91, 0x27, 0x38, + 0xe9, 0x71, 0xa3, 0xdc, 0xc8, 0x37, 0xe7, 0x57, 0xaf, 0x8e, 0x29, 0x1a, 0x51, 0x05, 0x3b, 0x32, + 0xc8, 0xd6, 0xc1, 0xa8, 0x0e, 0x65, 0x37, 0x66, 0x9c, 0x6b, 0x0d, 0x95, 0x46, 0xbe, 0x39, 0x6b, + 0x83, 0x34, 0xa9, 0xd4, 0xef, 0x43, 0xc9, 0xa3, 0x31, 0x71, 0x45, 0x53, 0x30, 0xe6, 0x24, 0x75, + 0xe3, 0x04, 0xea, 0x7b, 0x69, 0x9c, 0x3d, 0x80, 0x98, 0xbf, 0x15, 0x46, 0xaa, 0x3d, 0xbd, 0xc2, + 0x68, 0x15, 0x2e, 0xd0, 0x70, 0x9f, 0x75, 0xf7, 0x89, 0xaa, 0xc6, 0x53, 0xb6, 0x3b, 0x0d, 0x44, + 0x35, 0x00, 0x59, 0x04, 0xb2, 0x4b, 0xc9, 0x0b, 0x32, 0x6d, 0x67, 0x2c, 0x99, 0x7d, 0x98, 0x3a, + 0xcf, 0x3e, 0x0c, 0x2d, 0x73, 0xfa, 0xdc, 0xcb, 0x44, 0x9b, 0x00, 0x83, 0x57, 0x81, 0xee, 0xae, + 0x4b, 0x43, 0xf7, 0x48, 0x3d, 0x37, 0x06, 0x33, 0xd3, 0x27, 0x7a, 0x1b, 0xec, 0x0c, 0x32, 0xd3, + 0x25, 0x7e, 0xc9, 0xa7, 0xad, 0x36, 0xbb, 0x71, 0xfa, 0x0a, 0x6f, 0x43, 0x25, 0xd3, 0x27, 0xd2, + 0x96, 0x76, 0xae, 0x46, 0x51, 0x1e, 0x34, 0x0a, 0x8e, 0x3e, 0x1c, 0x92, 0xaf, 0x46, 0xd8, 0x8d, + 0x33, 0xe5, 0x2b, 0xbe, 0xac, 0xfe, 0xd5, 0xbf, 0x66, 0x60, 0x46, 0xaa, 0x46, 0x5f, 0x40, 0x51, + 0x3d, 0x0c, 0xd0, 0x38, 0x59, 0xa3, 0x2f, 0x90, 0xea, 0xd2, 0x59, 0x61, 0x2a, 0x9d, 0x79, 0xed, + 0xab, 0x3f, 0xfe, 0xfd, 0xae, 0x70, 0x19, 0x2d, 0x5a, 0xa3, 0xcf, 0x1c, 0xf5, 0xf8, 0x40, 0x3f, + 0xe4, 0xa1, 0x9c, 0xe9, 0xe5, 0xe8, 0xd6, 0x49, 0xd4, 0xa3, 0xaf, 0x93, 0xea, 0x1b, 0x13, 0xc5, + 0x6a, 0x2d, 0x2d, 0xa9, 0xa5, 0x89, 0x96, 0xc6, 0x68, 0x91, 0x13, 0x43, 0x8d, 0x42, 0xeb, 0xb1, + 0x7c, 0xe3, 0x3c, 0x11, 0xc2, 0xe6, 0x86, 0xc6, 0x14, 0xba, 0x7d, 0x76, 0xba, 0xc1, 0xd0, 0xab, + 0x2e, 0x4f, 0x18, 0xad, 0xe5, 0x35, 0xa5, 0x3c, 0x13, 0x35, 0x4e, 0x95, 0x27, 0x64, 0x7c, 0x9f, + 0x07, 0x18, 0x94, 0x0a, 0xba, 0x79, 0x62, 0x9e, 0xe3, 0x03, 0xaf, 0x7a, 0x6b, 0x92, 0x50, 0xad, + 0xc7, 0x92, 0x7a, 0x6e, 0xa2, 0x1b, 0xe3, 0xf4, 0xc8, 0x70, 0x51, 0xce, 0xd6, 0x63, 0x3d, 0x41, + 0x9f, 0xa0, 0x6f, 0xc4, 0x41, 0x66, 0xea, 0x74, 0x82, 0x64, 0xfc, 0xec, 0x83, 0x1c, 0xbd, 0x50, + 0xe6, 0x92, 0x54, 0xd6, 0x40, 0xb5, 0x53, 0x95, 0xf1, 0xf5, 0xb5, 0x67, 0x87, 0xb5, 0xfc, 0xf3, + 0xc3, 0x5a, 0xfe, 0x9f, 0xc3, 0x5a, 0xfe, 0xdb, 0xa3, 0x5a, 0xee, 0xf9, 0x51, 0x2d, 0xf7, 0xe7, + 0x51, 0x2d, 0xf7, 0xe9, 0x8d, 0xcc, 0x48, 0x5c, 0xf1, 0xbb, 0xb8, 0xcd, 0xad, 0x15, 0x7f, 0x59, + 0xb6, 0x55, 0xeb, 0x91, 0x22, 0x94, 0x73, 0xb1, 0x5d, 0x94, 0x8f, 0xad, 0xbb, 0xff, 0x07, 0x00, + 0x00, 0xff, 0xff, 0x5e, 0xee, 0xaf, 0xcf, 0x93, 0x0c, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/bep3/types/tx.pb.go b/x/bep3/types/tx.pb.go index 8929798a..8b8e4791 100644 --- a/x/bep3/types/tx.pb.go +++ b/x/bep3/types/tx.pb.go @@ -275,44 +275,45 @@ func init() { func init() { proto.RegisterFile("kava/bep3/v1beta1/tx.proto", fileDescriptor_019a1c7100544f13) } var fileDescriptor_019a1c7100544f13 = []byte{ - // 592 bytes of a gzipped FileDescriptorProto + // 594 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xbf, 0x6f, 0xd3, 0x40, - 0x14, 0xb6, 0x93, 0x92, 0xd2, 0x6b, 0x11, 0xe1, 0x5a, 0x24, 0xd7, 0x14, 0x3b, 0x4a, 0x45, 0xe5, - 0xa1, 0xb1, 0x69, 0xba, 0x31, 0xd1, 0x84, 0x81, 0x0e, 0x05, 0xc9, 0xd9, 0x58, 0xac, 0xb3, 0x7d, - 0xb5, 0xaf, 0xad, 0xef, 0x2c, 0xdf, 0x25, 0x2d, 0xff, 0x01, 0x23, 0x23, 0x62, 0xca, 0xcc, 0xc2, - 0xc2, 0xdf, 0x80, 0x3a, 0x56, 0x4c, 0x4c, 0x05, 0x25, 0x0b, 0x7f, 0x06, 0xf2, 0x8f, 0x84, 0xe6, - 0x97, 0xa8, 0x90, 0x98, 0x7c, 0xf7, 0xbe, 0xef, 0xbd, 0x7b, 0xf7, 0x7d, 0x7e, 0x07, 0xd4, 0x53, - 0xd4, 0x43, 0x96, 0x8b, 0xe3, 0x7d, 0xab, 0xb7, 0xe7, 0x62, 0x81, 0xf6, 0x2c, 0x71, 0x61, 0xc6, - 0x09, 0x13, 0x0c, 0x3e, 0x48, 0x31, 0x33, 0xc5, 0xcc, 0x02, 0x53, 0x35, 0x8f, 0xf1, 0x88, 0x71, - 0xcb, 0x45, 0x1c, 0x8f, 0x13, 0x3c, 0x46, 0x68, 0x9e, 0xa2, 0x6e, 0xe6, 0xb8, 0x93, 0xed, 0xac, - 0x7c, 0x53, 0x40, 0x1b, 0x01, 0x0b, 0x58, 0x1e, 0x4f, 0x57, 0x79, 0xb4, 0xfe, 0xb9, 0x0c, 0xd6, - 0x8f, 0x78, 0xd0, 0x4e, 0x30, 0x12, 0xf8, 0x40, 0xb0, 0x88, 0x78, 0x9d, 0x73, 0x14, 0xc3, 0x5d, - 0xb0, 0x74, 0x9c, 0xb0, 0x48, 0x91, 0x6b, 0xb2, 0xb1, 0xd2, 0x52, 0xbe, 0x7d, 0x69, 0x6c, 0x14, - 0xd5, 0x0e, 0x7c, 0x3f, 0xc1, 0x9c, 0x77, 0x44, 0x42, 0x68, 0x60, 0x67, 0x2c, 0x68, 0x80, 0x92, - 0x60, 0x4a, 0xe9, 0x2f, 0xdc, 0x92, 0x60, 0xb0, 0x09, 0x1e, 0x26, 0xd8, 0x23, 0x31, 0xc1, 0x54, - 0x38, 0x4c, 0x84, 0x38, 0x71, 0xbc, 0x10, 0x11, 0xaa, 0x94, 0xd3, 0x64, 0x7b, 0x7d, 0x0c, 0xbe, - 0x4e, 0xb1, 0x76, 0x0a, 0xc1, 0x5d, 0x00, 0x39, 0xa6, 0x3e, 0x4e, 0x26, 0x12, 0x96, 0xb2, 0x84, - 0x6a, 0x8e, 0x4c, 0xb2, 0x13, 0x44, 0x7d, 0x16, 0x39, 0xb4, 0x1b, 0xb9, 0x38, 0x71, 0x42, 0xc4, - 0x43, 0xe5, 0x4e, 0xce, 0xce, 0x91, 0x57, 0x19, 0xf0, 0x12, 0xf1, 0x10, 0x6e, 0x81, 0x15, 0x41, - 0x22, 0xcc, 0x05, 0x8a, 0x62, 0xa5, 0x52, 0x93, 0x8d, 0xb2, 0xfd, 0x27, 0x00, 0x3d, 0x50, 0x41, - 0x11, 0xeb, 0x52, 0xa1, 0x2c, 0xd7, 0xca, 0xc6, 0x6a, 0x73, 0xd3, 0x2c, 0x2e, 0x96, 0xea, 0x3f, - 0x32, 0xc5, 0x6c, 0x33, 0x42, 0x5b, 0x4f, 0x2f, 0xaf, 0x75, 0xe9, 0xd3, 0x0f, 0xdd, 0x08, 0x88, - 0x08, 0xbb, 0xae, 0xe9, 0xb1, 0xa8, 0xd0, 0xbf, 0xf8, 0x34, 0xb8, 0x7f, 0x6a, 0x89, 0xb7, 0x31, - 0xe6, 0x59, 0x02, 0xb7, 0x8b, 0xd2, 0x50, 0x07, 0xab, 0x21, 0x26, 0x41, 0x28, 0x1c, 0x1e, 0x23, - 0xaa, 0xdc, 0xad, 0xc9, 0xc6, 0x92, 0x0d, 0xf2, 0x50, 0x27, 0x46, 0xf4, 0xd9, 0xda, 0xbb, 0xbe, - 0x2e, 0x7d, 0xe8, 0xeb, 0xd2, 0xaf, 0xbe, 0x2e, 0xd5, 0x1f, 0x83, 0x47, 0x73, 0x0c, 0xb3, 0x31, - 0x8f, 0x19, 0xe5, 0xb8, 0xfe, 0x51, 0x06, 0x30, 0xc5, 0xcf, 0x10, 0x89, 0xfe, 0xd9, 0xcf, 0x6d, - 0xb0, 0xcc, 0xcf, 0x51, 0xec, 0x10, 0xbf, 0x30, 0x15, 0x0c, 0xae, 0xf5, 0x4a, 0x5a, 0xe8, 0xf0, - 0x85, 0x5d, 0x49, 0xa1, 0x43, 0x1f, 0x6e, 0x83, 0x7b, 0x13, 0x42, 0x17, 0x16, 0xae, 0xdd, 0xd4, - 0x78, 0xaa, 0xf7, 0x2d, 0xa0, 0xce, 0xf6, 0x36, 0x6e, 0xbd, 0x97, 0xfd, 0x8a, 0x36, 0x3e, 0xee, - 0x52, 0xff, 0xbf, 0xb6, 0x3e, 0x57, 0xd1, 0xe9, 0x73, 0x47, 0x6d, 0x35, 0xbf, 0x96, 0x40, 0xf9, - 0x88, 0x07, 0xf0, 0x04, 0x54, 0x67, 0xc6, 0x64, 0xc7, 0x9c, 0x99, 0x51, 0x73, 0x8e, 0x3b, 0xaa, - 0x79, 0x3b, 0xde, 0xe8, 0x4c, 0x18, 0x80, 0xfb, 0xd3, 0x0e, 0x3e, 0x59, 0x50, 0x62, 0x92, 0xa6, - 0x36, 0x6e, 0x45, 0x1b, 0x1f, 0x74, 0x02, 0xaa, 0x33, 0x82, 0x2f, 0xb8, 0xd4, 0x34, 0x6f, 0xd1, - 0xa5, 0x16, 0x09, 0xd9, 0x7a, 0x7e, 0x39, 0xd0, 0xe4, 0xab, 0x81, 0x26, 0xff, 0x1c, 0x68, 0xf2, - 0xfb, 0xa1, 0x26, 0x5d, 0x0d, 0x35, 0xe9, 0xfb, 0x50, 0x93, 0xde, 0xec, 0xdc, 0x18, 0x9a, 0xb4, - 0x66, 0xe3, 0x0c, 0xb9, 0x3c, 0x5b, 0x59, 0x17, 0xf9, 0xe3, 0x98, 0x0d, 0x8e, 0x5b, 0xc9, 0x1e, - 0xad, 0xfd, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x94, 0xca, 0xe1, 0xe1, 0x36, 0x05, 0x00, 0x00, + 0x14, 0xb6, 0x93, 0x92, 0xd2, 0x6b, 0x11, 0xe5, 0x5a, 0x24, 0xd7, 0x14, 0x3b, 0x6a, 0x05, 0x78, + 0x68, 0xec, 0x34, 0xdd, 0xd8, 0x92, 0x30, 0xd0, 0xa1, 0x20, 0x39, 0x1b, 0x8b, 0x75, 0xb6, 0xaf, + 0xf6, 0xb5, 0xf5, 0x9d, 0xe5, 0xbb, 0xa4, 0xe5, 0x3f, 0x60, 0x64, 0x44, 0x4c, 0x99, 0x59, 0x58, + 0xf8, 0x1b, 0x50, 0xc7, 0x8a, 0x89, 0xa9, 0xa0, 0x64, 0xe1, 0xcf, 0x40, 0xfe, 0x91, 0xd0, 0xfc, + 0x12, 0x15, 0x12, 0x53, 0x72, 0xef, 0xfb, 0xde, 0xbb, 0xf7, 0xbe, 0xcf, 0xef, 0x80, 0x7a, 0x8a, + 0x7a, 0xc8, 0x72, 0x71, 0x7c, 0x60, 0xf5, 0xf6, 0x5d, 0x2c, 0xd0, 0xbe, 0x25, 0x2e, 0xcc, 0x38, + 0x61, 0x82, 0xc1, 0x07, 0x29, 0x66, 0xa6, 0x98, 0x59, 0x60, 0xaa, 0xe6, 0x31, 0x1e, 0x31, 0x6e, + 0xb9, 0x88, 0xe3, 0x71, 0x82, 0xc7, 0x08, 0xcd, 0x53, 0xd4, 0xad, 0x1c, 0x77, 0xb2, 0x93, 0x95, + 0x1f, 0x0a, 0x68, 0x33, 0x60, 0x01, 0xcb, 0xe3, 0xe9, 0xbf, 0x3c, 0xba, 0xf3, 0xb9, 0x0c, 0x36, + 0x8e, 0x78, 0xd0, 0x4e, 0x30, 0x12, 0xb8, 0x29, 0x58, 0x44, 0xbc, 0xce, 0x39, 0x8a, 0xe1, 0x1e, + 0x58, 0x3a, 0x4e, 0x58, 0xa4, 0xc8, 0x55, 0xd9, 0x58, 0x69, 0x29, 0xdf, 0xbe, 0xd4, 0x36, 0x8b, + 0x6a, 0x4d, 0xdf, 0x4f, 0x30, 0xe7, 0x1d, 0x91, 0x10, 0x1a, 0xd8, 0x19, 0x0b, 0x1a, 0xa0, 0x24, + 0x98, 0x52, 0xfa, 0x0b, 0xb7, 0x24, 0x18, 0x6c, 0x80, 0x87, 0x09, 0xf6, 0x48, 0x4c, 0x30, 0x15, + 0x0e, 0x13, 0x21, 0x4e, 0x1c, 0x2f, 0x44, 0x84, 0x2a, 0xe5, 0x34, 0xd9, 0xde, 0x18, 0x83, 0xaf, + 0x53, 0xac, 0x9d, 0x42, 0x70, 0x0f, 0x40, 0x8e, 0xa9, 0x8f, 0x93, 0x89, 0x84, 0xa5, 0x2c, 0x61, + 0x3d, 0x47, 0x26, 0xd9, 0x09, 0xa2, 0x3e, 0x8b, 0x1c, 0xda, 0x8d, 0x5c, 0x9c, 0x38, 0x21, 0xe2, + 0xa1, 0x72, 0x27, 0x67, 0xe7, 0xc8, 0xab, 0x0c, 0x78, 0x89, 0x78, 0x08, 0xb7, 0xc1, 0x8a, 0x20, + 0x11, 0xe6, 0x02, 0x45, 0xb1, 0x52, 0xa9, 0xca, 0x46, 0xd9, 0xfe, 0x13, 0x80, 0x1e, 0xa8, 0xa0, + 0x88, 0x75, 0xa9, 0x50, 0x96, 0xab, 0x65, 0x63, 0xb5, 0xb1, 0x65, 0x16, 0x83, 0xa5, 0xfa, 0x8f, + 0x4c, 0x31, 0xdb, 0x8c, 0xd0, 0x56, 0xfd, 0xf2, 0x5a, 0x97, 0x3e, 0xfd, 0xd0, 0x8d, 0x80, 0x88, + 0xb0, 0xeb, 0x9a, 0x1e, 0x8b, 0x0a, 0xfd, 0x8b, 0x9f, 0x1a, 0xf7, 0x4f, 0x2d, 0xf1, 0x36, 0xc6, + 0x3c, 0x4b, 0xe0, 0x76, 0x51, 0x1a, 0xea, 0x60, 0x35, 0xc4, 0x24, 0x08, 0x85, 0xc3, 0x63, 0x44, + 0x95, 0xbb, 0x55, 0xd9, 0x58, 0xb2, 0x41, 0x1e, 0xea, 0xc4, 0x88, 0x3e, 0x5f, 0x7b, 0xd7, 0xd7, + 0xa5, 0x0f, 0x7d, 0x5d, 0xfa, 0xd5, 0xd7, 0xa5, 0x9d, 0xc7, 0xe0, 0xd1, 0x1c, 0xc3, 0x6c, 0xcc, + 0x63, 0x46, 0x39, 0xde, 0xf9, 0x28, 0x03, 0x98, 0xe2, 0x67, 0x88, 0x44, 0xff, 0xec, 0xe7, 0x2e, + 0x58, 0xe6, 0xe7, 0x28, 0x76, 0x88, 0x5f, 0x98, 0x0a, 0x06, 0xd7, 0x7a, 0x25, 0x2d, 0x74, 0xf8, + 0xc2, 0xae, 0xa4, 0xd0, 0xa1, 0x0f, 0x77, 0xc1, 0xbd, 0x09, 0xa1, 0x0b, 0x0b, 0xd7, 0x6e, 0x6a, + 0x3c, 0xd5, 0xfb, 0x36, 0x50, 0x67, 0x7b, 0x1b, 0xb7, 0xde, 0xcb, 0x3e, 0x45, 0x1b, 0x1f, 0x77, + 0xa9, 0xff, 0x5f, 0x5b, 0x9f, 0xab, 0xe8, 0xf4, 0xbd, 0xa3, 0xb6, 0x1a, 0x5f, 0x4b, 0xa0, 0x7c, + 0xc4, 0x03, 0x78, 0x02, 0xd6, 0x67, 0xd6, 0xe4, 0xa9, 0x39, 0xb3, 0xa3, 0xe6, 0x1c, 0x77, 0x54, + 0xf3, 0x76, 0xbc, 0xd1, 0x9d, 0x30, 0x00, 0xf7, 0xa7, 0x1d, 0x7c, 0xb2, 0xa0, 0xc4, 0x24, 0x4d, + 0xad, 0xdd, 0x8a, 0x36, 0xbe, 0xe8, 0x04, 0xac, 0xcf, 0x08, 0xbe, 0x60, 0xa8, 0x69, 0xde, 0xa2, + 0xa1, 0x16, 0x09, 0xd9, 0x6a, 0x5e, 0x0e, 0x34, 0xf9, 0x6a, 0xa0, 0xc9, 0x3f, 0x07, 0x9a, 0xfc, + 0x7e, 0xa8, 0x49, 0x57, 0x43, 0x4d, 0xfa, 0x3e, 0xd4, 0xa4, 0x37, 0xcf, 0x6e, 0x2c, 0x4d, 0x3d, + 0x38, 0x43, 0x2e, 0xb7, 0xea, 0x41, 0x2d, 0xdb, 0x73, 0xeb, 0x22, 0x7f, 0x1d, 0xb3, 0xcd, 0x71, + 0x2b, 0xd9, 0xab, 0x75, 0xf0, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xa8, 0x19, 0xd8, 0xb9, 0x37, 0x05, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/cdp/types/cdp.pb.go b/x/cdp/types/cdp.pb.go index a59e9caf..87f0190d 100644 --- a/x/cdp/types/cdp.pb.go +++ b/x/cdp/types/cdp.pb.go @@ -242,46 +242,46 @@ func init() { func init() { proto.RegisterFile("kava/cdp/v1beta1/cdp.proto", fileDescriptor_68a9ab097fb7be40) } var fileDescriptor_68a9ab097fb7be40 = []byte{ - // 613 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xcf, 0x6e, 0xd3, 0x30, - 0x1c, 0xae, 0xbb, 0x36, 0x5b, 0xbd, 0xb1, 0x4e, 0x06, 0xa1, 0xac, 0x87, 0xa4, 0x1a, 0x02, 0x7a, - 0x69, 0xa2, 0x01, 0x12, 0x17, 0x10, 0x5a, 0x1a, 0x0d, 0xca, 0x85, 0x29, 0x1a, 0x17, 0x0e, 0x54, - 0xae, 0xed, 0x96, 0x68, 0x69, 0x1c, 0xc5, 0xee, 0xd8, 0x1e, 0x02, 0x69, 0x0f, 0xb3, 0x87, 0xd8, - 0x81, 0xc3, 0xb4, 0x13, 0xe2, 0x10, 0x20, 0x7b, 0x0b, 0x4e, 0xc8, 0x4e, 0xba, 0xec, 0x58, 0x24, - 0x38, 0xf5, 0xf7, 0xc7, 0xdf, 0xf7, 0x73, 0x7f, 0xdf, 0x17, 0xc3, 0xce, 0x11, 0x3e, 0xc6, 0x2e, - 0xa1, 0x89, 0x7b, 0xbc, 0x3b, 0x66, 0x12, 0xef, 0xaa, 0xd8, 0x49, 0x52, 0x2e, 0x39, 0xda, 0x52, - 0x3d, 0x47, 0xe5, 0x65, 0xaf, 0x63, 0x11, 0x2e, 0x66, 0x5c, 0xb8, 0x63, 0x2c, 0x58, 0x05, 0xe0, - 0x61, 0x5c, 0x20, 0x3a, 0xdb, 0x45, 0x7f, 0xa4, 0x33, 0xb7, 0x48, 0xca, 0xd6, 0xbd, 0x29, 0x9f, - 0xf2, 0xa2, 0xae, 0xa2, 0xb2, 0x6a, 0x4f, 0x39, 0x9f, 0x46, 0xcc, 0xd5, 0xd9, 0x78, 0x3e, 0x71, - 0x65, 0x38, 0x63, 0x42, 0xe2, 0x59, 0x79, 0x87, 0x9d, 0x2f, 0x0d, 0xb8, 0x32, 0xf0, 0x0f, 0xd0, - 0x7d, 0x58, 0x0f, 0xa9, 0x09, 0xba, 0xa0, 0xd7, 0xf0, 0x8c, 0x3c, 0xb3, 0xeb, 0x43, 0x3f, 0xa8, - 0x87, 0x14, 0x7d, 0x84, 0x4d, 0xfe, 0x39, 0x66, 0xa9, 0x59, 0xef, 0x82, 0xde, 0x86, 0xf7, 0xe6, - 0x77, 0x66, 0xf7, 0xa7, 0xa1, 0xfc, 0x34, 0x1f, 0x3b, 0x84, 0xcf, 0xca, 0x2b, 0x94, 0x3f, 0x7d, - 0x41, 0x8f, 0x5c, 0x79, 0x9a, 0x30, 0xe1, 0xec, 0x11, 0xb2, 0x47, 0x69, 0xca, 0x84, 0xb8, 0x3a, - 0xef, 0xdf, 0x2d, 0x2f, 0x5a, 0x56, 0xbc, 0x53, 0xc9, 0x44, 0x50, 0xd0, 0x22, 0x04, 0x1b, 0x0a, - 0x61, 0xae, 0x74, 0x41, 0xaf, 0x15, 0xe8, 0x18, 0xbd, 0x82, 0x90, 0xf0, 0x28, 0xc2, 0x92, 0xa5, - 0x38, 0x32, 0x1b, 0x5d, 0xd0, 0x5b, 0x7f, 0xb2, 0xed, 0x94, 0x24, 0x6a, 0x35, 0x8b, 0x7d, 0x39, - 0x03, 0x1e, 0xc6, 0x5e, 0xe3, 0x22, 0xb3, 0x6b, 0xc1, 0x2d, 0x08, 0x7a, 0x09, 0x5b, 0x49, 0x1a, - 0xc6, 0x24, 0x4c, 0x70, 0x64, 0x36, 0x97, 0xc3, 0x57, 0x08, 0xf4, 0x16, 0x6e, 0x61, 0x42, 0xe6, - 0xb3, 0xb9, 0xe2, 0xa3, 0xa3, 0x09, 0x63, 0xc2, 0x34, 0x96, 0x63, 0x69, 0xdf, 0x02, 0xee, 0x33, - 0x26, 0xd0, 0x6b, 0xb8, 0xa1, 0xf0, 0xa3, 0x79, 0x42, 0x55, 0xcd, 0x5c, 0xd5, 0x3c, 0x1d, 0xa7, - 0xd0, 0xc5, 0x59, 0xe8, 0xe2, 0x1c, 0x2e, 0x74, 0xf1, 0xd6, 0x14, 0xd1, 0xd9, 0x0f, 0x1b, 0x04, - 0xeb, 0x0a, 0xf9, 0xbe, 0x00, 0x22, 0x06, 0xdb, 0x61, 0x2c, 0x59, 0xca, 0x84, 0x1c, 0x4d, 0x30, - 0x91, 0x3c, 0x35, 0xd7, 0xd4, 0xce, 0xbc, 0x17, 0xea, 0xfc, 0xf7, 0xcc, 0x7e, 0xb4, 0x84, 0x2c, - 0x3e, 0x23, 0x57, 0xe7, 0x7d, 0x58, 0xfe, 0x09, 0x9f, 0x91, 0x60, 0x73, 0x41, 0xba, 0xaf, 0x39, - 0x77, 0xbe, 0x02, 0xb8, 0xea, 0xb3, 0x84, 0x8b, 0x50, 0xa2, 0x2e, 0x34, 0x08, 0x4d, 0x46, 0x37, - 0xbe, 0x68, 0xe5, 0x99, 0xdd, 0x1c, 0xd0, 0x64, 0xe8, 0x07, 0x4d, 0x42, 0x93, 0x21, 0x45, 0x13, - 0xd8, 0xa2, 0xc5, 0x61, 0x5e, 0x38, 0xa4, 0xf5, 0x0f, 0x1d, 0x52, 0x51, 0xa3, 0xe7, 0xd0, 0xc0, - 0x33, 0x3e, 0x8f, 0xa5, 0xf6, 0xc9, 0x12, 0x3a, 0x94, 0xc7, 0x77, 0x52, 0xb8, 0x79, 0xc8, 0x25, - 0x8e, 0x0e, 0x6e, 0xc4, 0x7d, 0x0c, 0xdb, 0x95, 0x53, 0x46, 0xda, 0x7b, 0x40, 0x7b, 0x6f, 0xb3, - 0x2a, 0x1f, 0x2a, 0x17, 0x56, 0x33, 0xeb, 0x7f, 0x37, 0x53, 0xc0, 0xb6, 0x9e, 0x39, 0xa8, 0x0c, - 0xf9, 0xff, 0x87, 0x3e, 0x83, 0x77, 0xde, 0xa9, 0x0f, 0x6a, 0xe0, 0x1f, 0x0c, 0x63, 0xca, 0x4e, - 0xd0, 0x03, 0xb8, 0x5a, 0x88, 0x27, 0x4c, 0xd0, 0x5d, 0xe9, 0x35, 0x3c, 0x98, 0x67, 0xb6, 0xa1, - 0xd5, 0x13, 0x81, 0xa1, 0xe5, 0x13, 0xde, 0xe0, 0xe2, 0x97, 0x55, 0xbb, 0xc8, 0x2d, 0x70, 0x99, - 0x5b, 0xe0, 0x67, 0x6e, 0x81, 0xb3, 0x6b, 0xab, 0x76, 0x79, 0x6d, 0xd5, 0xbe, 0x5d, 0x5b, 0xb5, - 0x0f, 0x0f, 0x6f, 0xc9, 0xa8, 0x9e, 0xaa, 0x7e, 0x84, 0xc7, 0x42, 0x47, 0xee, 0x89, 0x7e, 0xd2, - 0xb4, 0x92, 0x63, 0x43, 0x9b, 0xf8, 0xe9, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x95, 0xe3, 0x65, - 0xc4, 0xeb, 0x04, 0x00, 0x00, + // 617 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0x41, 0x6f, 0xd3, 0x30, + 0x14, 0xae, 0xbb, 0x36, 0x5b, 0xbd, 0xb1, 0x4e, 0x06, 0xa1, 0xac, 0x87, 0xa4, 0x1a, 0x12, 0xf4, + 0xd2, 0x64, 0x03, 0x24, 0x2e, 0x20, 0xb4, 0x34, 0x1a, 0x94, 0x0b, 0x53, 0x34, 0x2e, 0x1c, 0xa8, + 0x5c, 0xdb, 0xcd, 0xa2, 0xa5, 0x71, 0x14, 0xbb, 0x63, 0xfb, 0x11, 0x48, 0xfb, 0x31, 0xfb, 0x11, + 0x3b, 0x70, 0x98, 0x76, 0x42, 0x1c, 0x0a, 0x74, 0xff, 0x82, 0x13, 0xb2, 0x93, 0x2e, 0x3d, 0x16, + 0x09, 0x4e, 0xf1, 0x7b, 0xcf, 0xdf, 0xf7, 0x5e, 0xde, 0xf7, 0x25, 0xb0, 0x75, 0x82, 0x4f, 0xb1, + 0x4b, 0x68, 0xea, 0x9e, 0xee, 0x0d, 0x99, 0xc4, 0x7b, 0xea, 0xec, 0xa4, 0x19, 0x97, 0x1c, 0x6d, + 0xa9, 0x9a, 0xa3, 0xe2, 0xa2, 0xd6, 0xb2, 0x08, 0x17, 0x63, 0x2e, 0xdc, 0x21, 0x16, 0xac, 0x04, + 0xf0, 0x28, 0xc9, 0x11, 0xad, 0xed, 0xbc, 0x3e, 0xd0, 0x91, 0x9b, 0x07, 0x45, 0xe9, 0x41, 0xc8, + 0x43, 0x9e, 0xe7, 0xd5, 0xa9, 0xc8, 0xda, 0x21, 0xe7, 0x61, 0xcc, 0x5c, 0x1d, 0x0d, 0x27, 0x23, + 0x57, 0x46, 0x63, 0x26, 0x24, 0x1e, 0x17, 0x33, 0xec, 0x7c, 0xa9, 0xc1, 0x95, 0x9e, 0x7f, 0x88, + 0x1e, 0xc2, 0x6a, 0x44, 0x4d, 0xd0, 0x06, 0x9d, 0x9a, 0x67, 0xcc, 0xa6, 0x76, 0xb5, 0xef, 0x07, + 0xd5, 0x88, 0xa2, 0x4f, 0xb0, 0xce, 0x3f, 0x27, 0x2c, 0x33, 0xab, 0x6d, 0xd0, 0xd9, 0xf0, 0xde, + 0xfe, 0x9e, 0xda, 0xdd, 0x30, 0x92, 0xc7, 0x93, 0xa1, 0x43, 0xf8, 0xb8, 0x18, 0xa1, 0x78, 0x74, + 0x05, 0x3d, 0x71, 0xe5, 0x79, 0xca, 0x84, 0xb3, 0x4f, 0xc8, 0x3e, 0xa5, 0x19, 0x13, 0xe2, 0xe6, + 0xb2, 0x7b, 0xbf, 0x18, 0xb4, 0xc8, 0x78, 0xe7, 0x92, 0x89, 0x20, 0xa7, 0x45, 0x08, 0xd6, 0x14, + 0xc2, 0x5c, 0x69, 0x83, 0x4e, 0x23, 0xd0, 0x67, 0xf4, 0x1a, 0x42, 0xc2, 0xe3, 0x18, 0x4b, 0x96, + 0xe1, 0xd8, 0xac, 0xb5, 0x41, 0x67, 0xfd, 0xe9, 0xb6, 0x53, 0x90, 0xa8, 0xd5, 0xcc, 0xf7, 0xe5, + 0xf4, 0x78, 0x94, 0x78, 0xb5, 0xab, 0xa9, 0x5d, 0x09, 0x16, 0x20, 0xe8, 0x15, 0x6c, 0xa4, 0x59, + 0x94, 0x90, 0x28, 0xc5, 0xb1, 0x59, 0x5f, 0x0e, 0x5f, 0x22, 0xd0, 0x3b, 0xb8, 0x85, 0x09, 0x99, + 0x8c, 0x27, 0x8a, 0x8f, 0x0e, 0x46, 0x8c, 0x09, 0xd3, 0x58, 0x8e, 0xa5, 0xb9, 0x00, 0x3c, 0x60, + 0x4c, 0xa0, 0x37, 0x70, 0x43, 0xe1, 0x07, 0x93, 0x94, 0xaa, 0x9c, 0xb9, 0xaa, 0x79, 0x5a, 0x4e, + 0xae, 0x8b, 0x33, 0xd7, 0xc5, 0x39, 0x9a, 0xeb, 0xe2, 0xad, 0x29, 0xa2, 0x8b, 0x1f, 0x36, 0x08, + 0xd6, 0x15, 0xf2, 0x43, 0x0e, 0x44, 0x0c, 0x36, 0xa3, 0x44, 0xb2, 0x8c, 0x09, 0x39, 0x18, 0x61, + 0x22, 0x79, 0x66, 0xae, 0xa9, 0x9d, 0x79, 0x2f, 0xd5, 0xfd, 0xef, 0x53, 0xfb, 0xf1, 0x12, 0xb2, + 0xf8, 0x8c, 0xdc, 0x5c, 0x76, 0x61, 0xf1, 0x12, 0x3e, 0x23, 0xc1, 0xe6, 0x9c, 0xf4, 0x40, 0x73, + 0xee, 0x7c, 0x05, 0x70, 0xd5, 0x67, 0x29, 0x17, 0x91, 0x44, 0x6d, 0x68, 0x10, 0x9a, 0x0e, 0xee, + 0x7c, 0xd1, 0x98, 0x4d, 0xed, 0x7a, 0x8f, 0xa6, 0x7d, 0x3f, 0xa8, 0x13, 0x9a, 0xf6, 0x29, 0x1a, + 0xc1, 0x06, 0xcd, 0x2f, 0xf3, 0xdc, 0x21, 0x8d, 0x7f, 0xe8, 0x90, 0x92, 0x1a, 0xbd, 0x80, 0x06, + 0x1e, 0xf3, 0x49, 0x22, 0xb5, 0x4f, 0x96, 0xd0, 0xa1, 0xb8, 0xbe, 0x93, 0xc1, 0xcd, 0x23, 0x2e, + 0x71, 0x7c, 0x78, 0x27, 0xee, 0x13, 0xd8, 0x2c, 0x9d, 0x32, 0xd0, 0xde, 0x03, 0xda, 0x7b, 0x9b, + 0x65, 0xfa, 0x48, 0xb9, 0xb0, 0xec, 0x59, 0xfd, 0xbb, 0x9e, 0x02, 0x36, 0x75, 0xcf, 0x5e, 0x69, + 0xc8, 0xff, 0xdf, 0xf4, 0x39, 0xbc, 0xf7, 0x5e, 0x7d, 0x50, 0x3d, 0xff, 0xb0, 0x9f, 0x50, 0x76, + 0x86, 0x1e, 0xc1, 0xd5, 0x5c, 0x3c, 0x61, 0x82, 0xf6, 0x4a, 0xa7, 0xe6, 0xc1, 0xd9, 0xd4, 0x36, + 0xb4, 0x7a, 0x22, 0x30, 0xb4, 0x7c, 0xc2, 0xf3, 0xaf, 0x7e, 0x59, 0x95, 0xab, 0x99, 0x05, 0xae, + 0x67, 0x16, 0xf8, 0x39, 0xb3, 0xc0, 0xc5, 0xad, 0x55, 0xb9, 0xbe, 0xb5, 0x2a, 0xdf, 0x6e, 0xad, + 0xca, 0xc7, 0x45, 0x47, 0xed, 0x86, 0x31, 0x1e, 0x0a, 0x77, 0x37, 0xec, 0x92, 0x63, 0x1c, 0x25, + 0xee, 0x99, 0xfe, 0xa7, 0x69, 0x29, 0x87, 0x86, 0x76, 0xf1, 0xb3, 0x3f, 0x01, 0x00, 0x00, 0xff, + 0xff, 0xac, 0x93, 0x62, 0xcb, 0xec, 0x04, 0x00, 0x00, } func (m *CDP) Marshal() (dAtA []byte, err error) { diff --git a/x/cdp/types/genesis.pb.go b/x/cdp/types/genesis.pb.go index 49ba9a75..b9a5d937 100644 --- a/x/cdp/types/genesis.pb.go +++ b/x/cdp/types/genesis.pb.go @@ -464,83 +464,83 @@ func init() { func init() { proto.RegisterFile("kava/cdp/v1beta1/genesis.proto", fileDescriptor_e4494a90aaab0034) } var fileDescriptor_e4494a90aaab0034 = []byte{ - // 1208 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xdd, 0x6e, 0x1a, 0xc7, - 0x17, 0xf7, 0xda, 0xc4, 0x81, 0xb1, 0x63, 0xf0, 0xc4, 0x49, 0xd6, 0x8e, 0xfe, 0xc0, 0xdf, 0x55, - 0x1b, 0x7a, 0x11, 0x50, 0x52, 0x29, 0x52, 0xa5, 0xa8, 0x69, 0xd6, 0x28, 0x11, 0x4a, 0x2a, 0xa1, - 0xb5, 0xaf, 0xda, 0x8b, 0xd5, 0xec, 0xec, 0x80, 0x47, 0x2c, 0x3b, 0xdb, 0x99, 0x81, 0x26, 0x79, - 0x85, 0xaa, 0x6a, 0xd4, 0x97, 0xa8, 0x14, 0xf5, 0xb2, 0x0f, 0x91, 0xde, 0x45, 0xbd, 0xaa, 0x7a, - 0x41, 0x2a, 0xf2, 0x22, 0xd5, 0x7c, 0x00, 0x6b, 0x30, 0x52, 0x64, 0xd3, 0x1b, 0x76, 0xe7, 0x7c, - 0xfc, 0xce, 0xc7, 0x9c, 0x73, 0xf6, 0x00, 0xca, 0x3d, 0x34, 0x44, 0x0d, 0x1c, 0xa5, 0x8d, 0xe1, - 0xbd, 0x90, 0x48, 0x74, 0xaf, 0xd1, 0x25, 0x09, 0x11, 0x54, 0xd4, 0x53, 0xce, 0x24, 0x83, 0x25, - 0xc5, 0xaf, 0xe3, 0x28, 0xad, 0x5b, 0xfe, 0x41, 0x19, 0x33, 0xd1, 0x67, 0xa2, 0x11, 0x22, 0x41, - 0xa6, 0x4a, 0x98, 0xd1, 0xc4, 0x68, 0x1c, 0xec, 0x1b, 0x7e, 0xa0, 0x4f, 0x0d, 0x73, 0xb0, 0xac, - 0xbd, 0x2e, 0xeb, 0x32, 0x43, 0x57, 0x6f, 0x96, 0x5a, 0xe9, 0x32, 0xd6, 0x8d, 0x49, 0x43, 0x9f, - 0xc2, 0x41, 0xa7, 0x21, 0x69, 0x9f, 0x08, 0x89, 0xfa, 0xa9, 0x15, 0x38, 0x58, 0xf0, 0x51, 0xf9, - 0xa3, 0x79, 0x87, 0x7f, 0xe4, 0xc0, 0xf6, 0x53, 0xe3, 0xf1, 0xb1, 0x44, 0x92, 0xc0, 0x07, 0x60, - 0x33, 0x45, 0x1c, 0xf5, 0x85, 0xeb, 0x54, 0x9d, 0xda, 0xd6, 0x7d, 0xb7, 0x3e, 0x1f, 0x41, 0xbd, - 0xad, 0xf9, 0x5e, 0xee, 0xed, 0xa8, 0xb2, 0xe6, 0x5b, 0x69, 0xf8, 0x08, 0xe4, 0x70, 0x94, 0x0a, - 0x77, 0xbd, 0xba, 0x51, 0xdb, 0xba, 0x7f, 0x63, 0x51, 0xeb, 0xa8, 0xd9, 0xf6, 0xf6, 0x94, 0xca, - 0x78, 0x54, 0xc9, 0x1d, 0x35, 0xdb, 0xe2, 0xcd, 0x7b, 0xf3, 0xf4, 0xb5, 0x22, 0x7c, 0x0a, 0xf2, - 0x11, 0x49, 0x99, 0xa0, 0x52, 0xb8, 0x1b, 0x1a, 0x64, 0x7f, 0x11, 0xa4, 0x69, 0x24, 0xbc, 0x92, - 0x02, 0x7a, 0xf3, 0xbe, 0x92, 0xb7, 0x04, 0xe1, 0x4f, 0x95, 0xe1, 0x97, 0xa0, 0x28, 0x24, 0xe2, - 0x92, 0x26, 0xdd, 0x00, 0x47, 0x69, 0x40, 0x23, 0x37, 0x57, 0x75, 0x6a, 0x39, 0x6f, 0x77, 0x3c, - 0xaa, 0x5c, 0x3b, 0xb6, 0xac, 0xa3, 0x28, 0x6d, 0x35, 0xfd, 0x6b, 0x22, 0x73, 0x8c, 0xe0, 0xff, - 0x00, 0x88, 0x48, 0x28, 0x83, 0x88, 0x24, 0xac, 0xef, 0x5e, 0xa9, 0x3a, 0xb5, 0x82, 0x5f, 0x50, - 0x94, 0xa6, 0x22, 0xc0, 0xdb, 0xa0, 0xd0, 0x65, 0x43, 0xcb, 0xdd, 0xd4, 0xdc, 0x7c, 0x97, 0x0d, - 0x0d, 0xf3, 0x47, 0x07, 0xdc, 0x4e, 0x39, 0x19, 0x52, 0x36, 0x10, 0x01, 0xc2, 0x78, 0xd0, 0x1f, - 0xc4, 0x48, 0x52, 0x96, 0x04, 0xfa, 0x3e, 0xdc, 0xab, 0x3a, 0xa6, 0xcf, 0x17, 0x63, 0xb2, 0xe9, - 0x7f, 0x9c, 0x51, 0x39, 0xa1, 0x7d, 0xe2, 0x55, 0x6d, 0x8c, 0xee, 0x12, 0x01, 0xe1, 0xef, 0x4f, - 0xec, 0x2d, 0xb0, 0x20, 0x07, 0x25, 0xc9, 0x24, 0x8a, 0x83, 0x94, 0xd3, 0x04, 0xd3, 0x14, 0xc5, - 0xc2, 0xcd, 0x6b, 0x0f, 0xee, 0x2c, 0xf5, 0xe0, 0x44, 0x29, 0xb4, 0x27, 0xf2, 0x5e, 0xd9, 0xda, - 0xbf, 0x79, 0x2e, 0x5b, 0xf8, 0x45, 0x79, 0x96, 0x70, 0xf8, 0xdb, 0x26, 0xd8, 0x34, 0xb5, 0x01, - 0x4f, 0xc1, 0x2e, 0x66, 0x71, 0x8c, 0x24, 0xe1, 0xca, 0x87, 0x49, 0x41, 0x29, 0xfb, 0xff, 0x3f, - 0xa7, 0x34, 0xa6, 0xa2, 0x5a, 0xdd, 0x73, 0xad, 0xe5, 0xd2, 0x1c, 0x43, 0xf8, 0x25, 0x3c, 0x47, - 0x81, 0x5f, 0xdb, 0x2b, 0xd3, 0x36, 0xdc, 0x75, 0x5d, 0xb3, 0xb7, 0xcf, 0x2b, 0x9c, 0x50, 0x1a, - 0x70, 0x53, 0xb6, 0xfa, 0x56, 0x35, 0x01, 0x3e, 0x03, 0xbb, 0xdd, 0x98, 0x85, 0x28, 0x0e, 0x34, - 0x50, 0x4c, 0xfb, 0x54, 0xba, 0x1b, 0x1a, 0x68, 0xbf, 0x6e, 0xfb, 0x4f, 0x35, 0x6b, 0xc6, 0x5d, - 0x9a, 0x58, 0x98, 0xa2, 0xd1, 0x54, 0xe8, 0xcf, 0x95, 0x1e, 0x7c, 0x01, 0xf6, 0xc5, 0x80, 0xa7, - 0xb1, 0xaa, 0x81, 0x01, 0x36, 0xd7, 0x7f, 0xca, 0x89, 0x38, 0x65, 0xb1, 0x29, 0xc3, 0x82, 0xf7, - 0x50, 0x69, 0xfe, 0x3d, 0xaa, 0x7c, 0xd6, 0xa5, 0xf2, 0x74, 0x10, 0xd6, 0x31, 0xeb, 0xdb, 0x36, - 0xb7, 0x8f, 0xbb, 0x22, 0xea, 0x35, 0xe4, 0xcb, 0x94, 0x88, 0x7a, 0x2b, 0x91, 0x7f, 0xfe, 0x7e, - 0x17, 0x58, 0x2f, 0x5a, 0x89, 0xf4, 0x6f, 0x59, 0xf8, 0xc7, 0x06, 0xfd, 0x64, 0x02, 0x0e, 0x63, - 0x70, 0x7d, 0xde, 0x72, 0xcc, 0xa4, 0x29, 0xe2, 0x4b, 0xda, 0xdc, 0x3d, 0x6b, 0xf3, 0x39, 0x93, - 0x90, 0x83, 0x9b, 0x3a, 0x5b, 0x8b, 0x41, 0x6e, 0xae, 0xc0, 0xe0, 0x9e, 0xc2, 0x5e, 0x88, 0xb0, - 0x03, 0x4a, 0x67, 0x6c, 0xaa, 0xf0, 0xae, 0xae, 0xc0, 0xda, 0x4e, 0xc6, 0x9a, 0x8a, 0xed, 0x0e, - 0x28, 0x62, 0xca, 0xf1, 0x80, 0xca, 0x20, 0xe4, 0x04, 0xf5, 0x08, 0x77, 0xf3, 0x55, 0xa7, 0x96, - 0xf7, 0x77, 0x2c, 0xd9, 0x33, 0x54, 0xf8, 0x10, 0x1c, 0xc4, 0xf4, 0xfb, 0x01, 0x8d, 0x4c, 0x9f, - 0x87, 0x31, 0xc3, 0xbd, 0x80, 0x26, 0x92, 0xf0, 0x21, 0x8a, 0xdd, 0x42, 0xd5, 0xa9, 0x6d, 0xf8, - 0x6e, 0x46, 0xc2, 0x53, 0x02, 0x2d, 0xcb, 0x3f, 0xfc, 0x65, 0x1d, 0x14, 0xa6, 0x65, 0x09, 0xf7, - 0xc0, 0x15, 0x33, 0x57, 0x1c, 0x3d, 0x57, 0xcc, 0x41, 0xb9, 0xc2, 0x49, 0x87, 0x70, 0x92, 0x60, - 0x12, 0x20, 0x21, 0x88, 0xd4, 0x25, 0x5e, 0xf0, 0x77, 0xa6, 0xe4, 0xc7, 0x8a, 0x0a, 0xa9, 0x6a, - 0xb8, 0x64, 0x48, 0xb8, 0x50, 0x9e, 0x74, 0x10, 0x96, 0x8c, 0xeb, 0x22, 0xbe, 0x6c, 0x72, 0x4a, - 0x33, 0xd8, 0x27, 0x1a, 0x15, 0x7e, 0x67, 0x3b, 0xae, 0x13, 0x33, 0xc6, 0x57, 0x52, 0xd3, 0xba, - 0x19, 0x9f, 0x28, 0xb8, 0xc3, 0x9f, 0xf3, 0xa0, 0x38, 0xd7, 0xf5, 0x4b, 0x52, 0x03, 0x41, 0x4e, - 0xe1, 0xd9, 0x7c, 0xe8, 0x77, 0x95, 0x85, 0xec, 0x85, 0x70, 0xf5, 0xb8, 0x40, 0x16, 0x9a, 0x04, - 0x67, 0x3c, 0x6c, 0x12, 0xec, 0x97, 0x32, 0xb0, 0xbe, 0xfa, 0x85, 0x5f, 0xd9, 0x2c, 0x98, 0x71, - 0x91, 0xfb, 0xb8, 0x71, 0xa1, 0x03, 0x35, 0x83, 0x02, 0x01, 0xf5, 0xed, 0x09, 0x69, 0x4c, 0xe5, - 0xcb, 0xa0, 0x43, 0xc8, 0x05, 0x1a, 0x75, 0xd1, 0xcd, 0xed, 0x29, 0xe4, 0x13, 0x42, 0x60, 0x00, - 0xb6, 0x27, 0xad, 0x22, 0xe8, 0x2b, 0xb2, 0x92, 0xce, 0xdc, 0xb2, 0x88, 0xc7, 0xf4, 0x15, 0x81, - 0x7d, 0x70, 0x3d, 0x9b, 0xee, 0x94, 0x24, 0x28, 0x96, 0x2f, 0x2f, 0xd0, 0x93, 0x8b, 0x91, 0xc0, - 0x0c, 0x70, 0xdb, 0xe0, 0xc2, 0x07, 0x60, 0x47, 0xa4, 0x4c, 0x06, 0x7d, 0xc4, 0x7b, 0x44, 0xaa, - 0xef, 0x7a, 0x5e, 0x5b, 0x2a, 0x8d, 0x47, 0x95, 0xed, 0xe3, 0x94, 0xc9, 0x6f, 0x34, 0xa3, 0xd5, - 0xf4, 0xb7, 0xc5, 0xec, 0x14, 0xc1, 0x67, 0xe0, 0x46, 0xd6, 0xcd, 0x99, 0x7a, 0x41, 0xab, 0xdf, - 0x1a, 0x8f, 0x2a, 0xd7, 0x9f, 0xcf, 0x04, 0xa6, 0x28, 0xd9, 0xe0, 0xa6, 0x60, 0x43, 0xe0, 0xf6, - 0x08, 0x49, 0x09, 0x0f, 0x38, 0xf9, 0x01, 0xf1, 0x28, 0x48, 0x09, 0xc7, 0x24, 0x91, 0xa8, 0x4b, - 0x5c, 0xb0, 0x82, 0xc0, 0x6f, 0x1a, 0x74, 0x5f, 0x83, 0xb7, 0xa7, 0xd8, 0x6a, 0xbd, 0xf8, 0x04, - 0x9f, 0x12, 0xdc, 0x0b, 0x66, 0x9f, 0x40, 0xfa, 0xca, 0x44, 0x44, 0x93, 0x88, 0xbc, 0x08, 0x30, - 0x1b, 0x24, 0xd2, 0xdd, 0x5a, 0xc1, 0x25, 0x57, 0xb5, 0xa1, 0xa3, 0x79, 0x3b, 0x2d, 0x65, 0xe6, - 0x48, 0x59, 0x39, 0x7f, 0xdc, 0x6c, 0xff, 0x17, 0xe3, 0xe6, 0xf0, 0xa7, 0x75, 0x70, 0x6b, 0xc9, - 0x06, 0xa4, 0x27, 0xf5, 0x6c, 0xcd, 0xd0, 0xe3, 0xc0, 0xcc, 0x88, 0x9d, 0x19, 0xf9, 0x44, 0x0d, - 0x86, 0x10, 0x1c, 0x2c, 0xdf, 0xcd, 0xec, 0xd6, 0x70, 0x50, 0x37, 0x8b, 0x74, 0x7d, 0xb2, 0x48, - 0xd7, 0x4f, 0x26, 0x8b, 0xb4, 0x97, 0x57, 0x41, 0xbd, 0x7e, 0x5f, 0x71, 0x7c, 0x77, 0xd9, 0xce, - 0x05, 0x09, 0x28, 0xea, 0xd9, 0x4f, 0x84, 0xbc, 0xf8, 0x00, 0x5e, 0x2c, 0x88, 0x9d, 0x09, 0xa8, - 0xcd, 0xc7, 0xaf, 0x0e, 0xb8, 0x71, 0xee, 0x46, 0xf6, 0xf1, 0xd9, 0x20, 0xa0, 0x38, 0xb7, 0x1c, - 0x9a, 0x29, 0x7a, 0xd9, 0xef, 0xe8, 0xd9, 0x85, 0xd0, 0x7b, 0xf4, 0x76, 0x5c, 0x76, 0xde, 0x8d, - 0xcb, 0xce, 0x3f, 0xe3, 0xb2, 0xf3, 0xfa, 0x43, 0x79, 0xed, 0xdd, 0x87, 0xf2, 0xda, 0x5f, 0x1f, - 0xca, 0x6b, 0xdf, 0x7e, 0x9a, 0xc1, 0x57, 0xab, 0xda, 0xdd, 0x18, 0x85, 0x42, 0xbf, 0x35, 0x5e, - 0xe8, 0x3f, 0x2a, 0xda, 0x44, 0xb8, 0xa9, 0x6f, 0xe2, 0x8b, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, - 0x5c, 0xdf, 0x27, 0x18, 0x65, 0x0d, 0x00, 0x00, + // 1210 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4f, 0x6f, 0x13, 0x47, + 0x14, 0xcf, 0x26, 0x26, 0xd8, 0x93, 0x10, 0x3b, 0x43, 0x80, 0x4d, 0x50, 0x6d, 0x37, 0x95, 0x4a, + 0x7a, 0xc0, 0x06, 0x2a, 0x21, 0x55, 0x42, 0x2d, 0x6c, 0x2c, 0x50, 0x04, 0x95, 0xa2, 0x4d, 0x4e, + 0xed, 0x61, 0x35, 0x3b, 0x3b, 0x5e, 0x8f, 0xbc, 0xde, 0xd9, 0xce, 0x8c, 0x5d, 0xe0, 0x2b, 0x54, + 0x55, 0x51, 0xbf, 0x44, 0x25, 0xd4, 0x63, 0x3f, 0x04, 0xbd, 0xa1, 0x9e, 0xaa, 0x1e, 0x4c, 0x65, + 0xbe, 0x48, 0x35, 0x7f, 0x6c, 0x6f, 0xec, 0x58, 0x42, 0xc1, 0xbd, 0x64, 0x3d, 0xef, 0xcf, 0xef, + 0xfd, 0x99, 0xf7, 0xde, 0xbc, 0x80, 0x6a, 0x17, 0x0d, 0x50, 0x13, 0x47, 0x59, 0x73, 0x70, 0x37, + 0x24, 0x12, 0xdd, 0x6d, 0xc6, 0x24, 0x25, 0x82, 0x8a, 0x46, 0xc6, 0x99, 0x64, 0xb0, 0xa2, 0xf8, + 0x0d, 0x1c, 0x65, 0x0d, 0xcb, 0xdf, 0xab, 0x62, 0x26, 0x7a, 0x4c, 0x34, 0x43, 0x24, 0xc8, 0x44, + 0x09, 0x33, 0x9a, 0x1a, 0x8d, 0xbd, 0x5d, 0xc3, 0x0f, 0xf4, 0xa9, 0x69, 0x0e, 0x96, 0xb5, 0x13, + 0xb3, 0x98, 0x19, 0xba, 0xfa, 0x65, 0xa9, 0xb5, 0x98, 0xb1, 0x38, 0x21, 0x4d, 0x7d, 0x0a, 0xfb, + 0xed, 0xa6, 0xa4, 0x3d, 0x22, 0x24, 0xea, 0x65, 0x56, 0x60, 0x6f, 0xce, 0x47, 0xe5, 0x8f, 0xe6, + 0xed, 0xff, 0x59, 0x00, 0x9b, 0x4f, 0x8c, 0xc7, 0x27, 0x12, 0x49, 0x02, 0xef, 0x83, 0xf5, 0x0c, + 0x71, 0xd4, 0x13, 0xae, 0x53, 0x77, 0x0e, 0x36, 0xee, 0xb9, 0x8d, 0xd9, 0x08, 0x1a, 0xc7, 0x9a, + 0xef, 0x15, 0xde, 0x0c, 0x6b, 0x2b, 0xbe, 0x95, 0x86, 0xdf, 0x80, 0x02, 0x8e, 0x32, 0xe1, 0xae, + 0xd6, 0xd7, 0x0e, 0x36, 0xee, 0x5d, 0x9b, 0xd7, 0x3a, 0x6c, 0x1d, 0x7b, 0x3b, 0x4a, 0x65, 0x34, + 0xac, 0x15, 0x0e, 0x5b, 0xc7, 0xe2, 0xf5, 0x3b, 0xf3, 0xf5, 0xb5, 0x22, 0x7c, 0x02, 0x8a, 0x11, + 0xc9, 0x98, 0xa0, 0x52, 0xb8, 0x6b, 0x1a, 0x64, 0x77, 0x1e, 0xa4, 0x65, 0x24, 0xbc, 0x8a, 0x02, + 0x7a, 0xfd, 0xae, 0x56, 0xb4, 0x04, 0xe1, 0x4f, 0x94, 0xe1, 0x57, 0xa0, 0x2c, 0x24, 0xe2, 0x92, + 0xa6, 0x71, 0x80, 0xa3, 0x2c, 0xa0, 0x91, 0x5b, 0xa8, 0x3b, 0x07, 0x05, 0x6f, 0x7b, 0x34, 0xac, + 0x5d, 0x39, 0xb1, 0xac, 0xc3, 0x28, 0x3b, 0x6a, 0xf9, 0x57, 0x44, 0xee, 0x18, 0xc1, 0x4f, 0x00, + 0x88, 0x48, 0x28, 0x83, 0x88, 0xa4, 0xac, 0xe7, 0x5e, 0xaa, 0x3b, 0x07, 0x25, 0xbf, 0xa4, 0x28, + 0x2d, 0x45, 0x80, 0x37, 0x41, 0x29, 0x66, 0x03, 0xcb, 0x5d, 0xd7, 0xdc, 0x62, 0xcc, 0x06, 0x86, + 0xf9, 0x93, 0x03, 0x6e, 0x66, 0x9c, 0x0c, 0x28, 0xeb, 0x8b, 0x00, 0x61, 0xdc, 0xef, 0xf5, 0x13, + 0x24, 0x29, 0x4b, 0x03, 0x7d, 0x1f, 0xee, 0x65, 0x1d, 0xd3, 0x17, 0xf3, 0x31, 0xd9, 0xf4, 0x3f, + 0xca, 0xa9, 0x9c, 0xd2, 0x1e, 0xf1, 0xea, 0x36, 0x46, 0x77, 0x81, 0x80, 0xf0, 0x77, 0xc7, 0xf6, + 0xe6, 0x58, 0x90, 0x83, 0x8a, 0x64, 0x12, 0x25, 0x41, 0xc6, 0x69, 0x8a, 0x69, 0x86, 0x12, 0xe1, + 0x16, 0xb5, 0x07, 0xb7, 0x16, 0x7a, 0x70, 0xaa, 0x14, 0x8e, 0xc7, 0xf2, 0x5e, 0xd5, 0xda, 0xbf, + 0x7e, 0x2e, 0x5b, 0xf8, 0x65, 0x79, 0x96, 0xb0, 0xff, 0xfb, 0x3a, 0x58, 0x37, 0xb5, 0x01, 0x3b, + 0x60, 0x1b, 0xb3, 0x24, 0x41, 0x92, 0x70, 0xe5, 0xc3, 0xb8, 0xa0, 0x94, 0xfd, 0x4f, 0xcf, 0x29, + 0x8d, 0x89, 0xa8, 0x56, 0xf7, 0x5c, 0x6b, 0xb9, 0x32, 0xc3, 0x10, 0x7e, 0x05, 0xcf, 0x50, 0xe0, + 0x43, 0x7b, 0x65, 0xda, 0x86, 0xbb, 0xaa, 0x6b, 0xf6, 0xe6, 0x79, 0x85, 0x13, 0x4a, 0x03, 0x6e, + 0xca, 0x56, 0xdf, 0xaa, 0x26, 0xc0, 0xa7, 0x60, 0x3b, 0x4e, 0x58, 0x88, 0x92, 0x40, 0x03, 0x25, + 0xb4, 0x47, 0xa5, 0xbb, 0xa6, 0x81, 0x76, 0x1b, 0xb6, 0xff, 0x54, 0xb3, 0xe6, 0xdc, 0xa5, 0xa9, + 0x85, 0x29, 0x1b, 0x4d, 0x85, 0xfe, 0x4c, 0xe9, 0xc1, 0xe7, 0x60, 0x57, 0xf4, 0x79, 0x96, 0xa8, + 0x1a, 0xe8, 0x63, 0x73, 0xfd, 0x1d, 0x4e, 0x44, 0x87, 0x25, 0xa6, 0x0c, 0x4b, 0xde, 0x03, 0xa5, + 0xf9, 0xcf, 0xb0, 0xf6, 0x79, 0x4c, 0x65, 0xa7, 0x1f, 0x36, 0x30, 0xeb, 0xd9, 0x36, 0xb7, 0x9f, + 0xdb, 0x22, 0xea, 0x36, 0xe5, 0x8b, 0x8c, 0x88, 0xc6, 0x51, 0x2a, 0xff, 0xfa, 0xe3, 0x36, 0xb0, + 0x5e, 0x1c, 0xa5, 0xd2, 0xbf, 0x61, 0xe1, 0x1f, 0x19, 0xf4, 0xd3, 0x31, 0x38, 0x4c, 0xc0, 0xd5, + 0x59, 0xcb, 0x09, 0x93, 0xa6, 0x88, 0x3f, 0xd2, 0xe6, 0xf6, 0x59, 0x9b, 0xcf, 0x98, 0x84, 0x1c, + 0x5c, 0xd7, 0xd9, 0x9a, 0x0f, 0x72, 0x7d, 0x09, 0x06, 0x77, 0x14, 0xf6, 0x5c, 0x84, 0x6d, 0x50, + 0x39, 0x63, 0x53, 0x85, 0x77, 0x79, 0x09, 0xd6, 0xb6, 0x72, 0xd6, 0x54, 0x6c, 0xb7, 0x40, 0x19, + 0x53, 0x8e, 0xfb, 0x54, 0x06, 0x21, 0x27, 0xa8, 0x4b, 0xb8, 0x5b, 0xac, 0x3b, 0x07, 0x45, 0x7f, + 0xcb, 0x92, 0x3d, 0x43, 0x85, 0x0f, 0xc0, 0x5e, 0x42, 0x7f, 0xe8, 0xd3, 0xc8, 0xf4, 0x79, 0x98, + 0x30, 0xdc, 0x0d, 0x68, 0x2a, 0x09, 0x1f, 0xa0, 0xc4, 0x2d, 0xd5, 0x9d, 0x83, 0x35, 0xdf, 0xcd, + 0x49, 0x78, 0x4a, 0xe0, 0xc8, 0xf2, 0xf7, 0x7f, 0x5d, 0x05, 0xa5, 0x49, 0x59, 0xc2, 0x1d, 0x70, + 0xc9, 0xcc, 0x15, 0x47, 0xcf, 0x15, 0x73, 0x50, 0xae, 0x70, 0xd2, 0x26, 0x9c, 0xa4, 0x98, 0x04, + 0x48, 0x08, 0x22, 0x75, 0x89, 0x97, 0xfc, 0xad, 0x09, 0xf9, 0x91, 0xa2, 0x42, 0xaa, 0x1a, 0x2e, + 0x1d, 0x10, 0x2e, 0x94, 0x27, 0x6d, 0x84, 0x25, 0xe3, 0xba, 0x88, 0x3f, 0x36, 0x39, 0x95, 0x29, + 0xec, 0x63, 0x8d, 0x0a, 0xbf, 0xb7, 0x1d, 0xd7, 0x4e, 0x18, 0xe3, 0x4b, 0xa9, 0x69, 0xdd, 0x8c, + 0x8f, 0x15, 0xdc, 0xfe, 0x2f, 0x45, 0x50, 0x9e, 0xe9, 0xfa, 0x05, 0xa9, 0x81, 0xa0, 0xa0, 0xf0, + 0x6c, 0x3e, 0xf4, 0x6f, 0x95, 0x85, 0xfc, 0x85, 0x70, 0xf5, 0xb9, 0x40, 0x16, 0x5a, 0x04, 0xe7, + 0x3c, 0x6c, 0x11, 0xec, 0x57, 0x72, 0xb0, 0xbe, 0xfa, 0x0b, 0xbf, 0xb6, 0x59, 0x30, 0xe3, 0xa2, + 0xf0, 0x61, 0xe3, 0x42, 0x07, 0x6a, 0x06, 0x05, 0x02, 0xea, 0xed, 0x09, 0x69, 0x42, 0xe5, 0x8b, + 0xa0, 0x4d, 0xc8, 0x05, 0x1a, 0x75, 0xde, 0xcd, 0xcd, 0x09, 0xe4, 0x63, 0x42, 0x60, 0x00, 0x36, + 0xc7, 0xad, 0x22, 0xe8, 0x4b, 0xb2, 0x94, 0xce, 0xdc, 0xb0, 0x88, 0x27, 0xf4, 0x25, 0x81, 0x3d, + 0x70, 0x35, 0x9f, 0xee, 0x8c, 0xa4, 0x28, 0x91, 0x2f, 0x2e, 0xd0, 0x93, 0xf3, 0x91, 0xc0, 0x1c, + 0xf0, 0xb1, 0xc1, 0x85, 0xf7, 0xc1, 0x96, 0xc8, 0x98, 0x0c, 0x7a, 0x88, 0x77, 0x89, 0x54, 0xef, + 0x7a, 0x51, 0x5b, 0xaa, 0x8c, 0x86, 0xb5, 0xcd, 0x93, 0x8c, 0xc9, 0x6f, 0x35, 0xe3, 0xa8, 0xe5, + 0x6f, 0x8a, 0xe9, 0x29, 0x82, 0x4f, 0xc1, 0xb5, 0xbc, 0x9b, 0x53, 0xf5, 0x92, 0x56, 0xbf, 0x31, + 0x1a, 0xd6, 0xae, 0x3e, 0x9b, 0x0a, 0x4c, 0x50, 0xf2, 0xc1, 0x4d, 0xc0, 0x06, 0xc0, 0xed, 0x12, + 0x92, 0x11, 0x1e, 0x70, 0xf2, 0x23, 0xe2, 0x51, 0x90, 0x11, 0x8e, 0x49, 0x2a, 0x51, 0x4c, 0x5c, + 0xb0, 0x84, 0xc0, 0xaf, 0x1b, 0x74, 0x5f, 0x83, 0x1f, 0x4f, 0xb0, 0xd5, 0x7a, 0xf1, 0x19, 0xee, + 0x10, 0xdc, 0x0d, 0xa6, 0x4f, 0x20, 0x7d, 0x69, 0x22, 0xa2, 0x69, 0x44, 0x9e, 0x07, 0x98, 0xf5, + 0x53, 0xe9, 0x6e, 0x2c, 0xe1, 0x92, 0xeb, 0xda, 0xd0, 0xe1, 0xac, 0x9d, 0x23, 0x65, 0xe6, 0x50, + 0x59, 0x39, 0x7f, 0xdc, 0x6c, 0xfe, 0x1f, 0xe3, 0x66, 0xff, 0xe7, 0x55, 0x70, 0x63, 0xc1, 0x06, + 0xa4, 0x27, 0xf5, 0x74, 0xcd, 0xd0, 0xe3, 0xc0, 0xcc, 0x88, 0xad, 0x29, 0xf9, 0x54, 0x0d, 0x86, + 0x10, 0xec, 0x2d, 0xde, 0xcd, 0xec, 0xd6, 0xb0, 0xd7, 0x30, 0x8b, 0x74, 0x63, 0xbc, 0x48, 0x37, + 0x4e, 0xc7, 0x8b, 0xb4, 0x57, 0x54, 0x41, 0xbd, 0x7a, 0x57, 0x73, 0x7c, 0x77, 0xd1, 0xce, 0x05, + 0x09, 0x28, 0xeb, 0xd9, 0x4f, 0x84, 0xbc, 0xf8, 0x00, 0x9e, 0x2f, 0x88, 0xad, 0x31, 0xa8, 0xcd, + 0xc7, 0x6f, 0x0e, 0xb8, 0x76, 0xee, 0x46, 0xf6, 0xe1, 0xd9, 0x20, 0xa0, 0x3c, 0xb3, 0x1c, 0x9a, + 0x29, 0xfa, 0xb1, 0xef, 0xe8, 0xd9, 0x85, 0xd0, 0x7b, 0xf8, 0x66, 0x54, 0x75, 0xde, 0x8e, 0xaa, + 0xce, 0xbf, 0xa3, 0xaa, 0xf3, 0xea, 0x7d, 0x75, 0xe5, 0xed, 0xfb, 0xea, 0xca, 0xdf, 0xef, 0xab, + 0x2b, 0xdf, 0xe5, 0xf1, 0xef, 0xc4, 0x09, 0x0a, 0x45, 0xf3, 0x4e, 0x7c, 0x1b, 0x77, 0x10, 0x4d, + 0x9b, 0xcf, 0xf5, 0x7f, 0x2a, 0xda, 0x46, 0xb8, 0xae, 0xaf, 0xe2, 0xcb, 0xff, 0x02, 0x00, 0x00, + 0xff, 0xff, 0x82, 0x92, 0x8e, 0xd7, 0x66, 0x0d, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/cdp/types/query.pb.go b/x/cdp/types/query.pb.go index ca16689f..13f3928e 100644 --- a/x/cdp/types/query.pb.go +++ b/x/cdp/types/query.pb.go @@ -839,79 +839,79 @@ func init() { func init() { proto.RegisterFile("kava/cdp/v1beta1/query.proto", fileDescriptor_fd68799328aaf74a) } var fileDescriptor_fd68799328aaf74a = []byte{ - // 1142 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcf, 0x6f, 0xdb, 0x54, - 0x1c, 0x8f, 0xd3, 0xb4, 0x4b, 0x5f, 0xa7, 0x26, 0x3c, 0x42, 0xe7, 0x9a, 0x92, 0xa4, 0x1e, 0x5b, - 0x0b, 0xa2, 0x36, 0x2b, 0xe2, 0xb7, 0xd0, 0xd4, 0xb4, 0x74, 0x1a, 0x12, 0x52, 0x31, 0x05, 0x24, - 0x24, 0x14, 0x5e, 0xec, 0xd7, 0xcc, 0x90, 0xf8, 0x79, 0x7e, 0x76, 0x47, 0x99, 0x26, 0x04, 0x87, - 0x89, 0xe3, 0x04, 0x07, 0x0e, 0x48, 0x68, 0x17, 0x2e, 0x9c, 0xf9, 0x23, 0x76, 0x9c, 0x80, 0x03, - 0xa7, 0x0d, 0x5a, 0x0e, 0xfc, 0x19, 0xd3, 0x7b, 0xfe, 0x3a, 0x76, 0xe2, 0xa4, 0xed, 0x0e, 0xbb, - 0x44, 0xf1, 0xf7, 0xd7, 0xe7, 0xf3, 0xfd, 0xfa, 0xfb, 0xc3, 0x68, 0xe9, 0x4b, 0xb2, 0x4f, 0x4c, - 0xdb, 0xf1, 0xcd, 0xfd, 0x4b, 0x1d, 0x1a, 0x92, 0x4b, 0xe6, 0xf5, 0x88, 0x06, 0x07, 0x86, 0x1f, - 0xb0, 0x90, 0xe1, 0xaa, 0xd0, 0x1a, 0xb6, 0xe3, 0x1b, 0xa0, 0xd5, 0xea, 0x36, 0xe3, 0x7d, 0xc6, - 0x4d, 0x12, 0x85, 0xd7, 0x06, 0x2e, 0xe2, 0x21, 0xf6, 0xd0, 0x5e, 0x04, 0x7d, 0x87, 0x70, 0x1a, - 0x87, 0x1a, 0x58, 0xf9, 0xa4, 0xeb, 0x7a, 0x24, 0x74, 0x99, 0x07, 0xb6, 0xf5, 0xac, 0x6d, 0x62, - 0x65, 0x33, 0x37, 0xd1, 0x2f, 0xc6, 0xfa, 0xb6, 0x7c, 0x32, 0xe3, 0x07, 0x50, 0xd5, 0xba, 0xac, - 0xcb, 0x62, 0xb9, 0xf8, 0x07, 0xd2, 0xa5, 0x2e, 0x63, 0xdd, 0x1e, 0x35, 0x89, 0xef, 0x9a, 0xc4, - 0xf3, 0x58, 0x28, 0xd1, 0x12, 0x9f, 0x06, 0x68, 0xe5, 0x53, 0x27, 0xda, 0x33, 0x43, 0xb7, 0x4f, - 0x79, 0x48, 0xfa, 0x3e, 0x18, 0x68, 0xb9, 0x5a, 0x88, 0xcc, 0x81, 0x6b, 0x4e, 0xd7, 0xa5, 0x1e, - 0xe5, 0x2e, 0x04, 0xd7, 0x6b, 0x08, 0x7f, 0x20, 0xb2, 0xdd, 0x21, 0x01, 0xe9, 0x73, 0x8b, 0x5e, - 0x8f, 0x28, 0x0f, 0xf5, 0x4f, 0xd0, 0xd3, 0x43, 0x52, 0xee, 0x33, 0x8f, 0x53, 0xfc, 0x1a, 0x9a, - 0xf1, 0xa5, 0x44, 0x55, 0x9a, 0xca, 0xea, 0xdc, 0xba, 0x6a, 0x8c, 0xd6, 0xd9, 0x88, 0x3d, 0x5a, - 0xa5, 0x7b, 0x0f, 0x1a, 0x05, 0x0b, 0xac, 0xdf, 0x2a, 0x7f, 0x7f, 0xb7, 0x51, 0xf8, 0xff, 0x6e, - 0xa3, 0xa0, 0x2f, 0xa0, 0x9a, 0x0c, 0xbc, 0x61, 0xdb, 0x2c, 0xf2, 0xc2, 0x01, 0xe0, 0x67, 0xe8, - 0x99, 0x11, 0x39, 0x40, 0x6e, 0xa1, 0x32, 0x01, 0x99, 0xaa, 0x34, 0xa7, 0x56, 0xe7, 0xd6, 0x75, - 0x03, 0x2a, 0x2a, 0xdf, 0x5e, 0x82, 0xfb, 0x3e, 0x73, 0xa2, 0x1e, 0x05, 0x77, 0x80, 0x1f, 0x78, - 0xea, 0x5f, 0xa0, 0x8a, 0x0c, 0xbf, 0xe9, 0xf8, 0x80, 0x88, 0x57, 0x50, 0xc5, 0x66, 0xbd, 0x1e, - 0x09, 0x69, 0x40, 0x7a, 0xed, 0xf0, 0xc0, 0xa7, 0x32, 0xa9, 0x59, 0x6b, 0x3e, 0x15, 0xef, 0x1e, - 0xf8, 0x14, 0x1b, 0x68, 0x9a, 0xdd, 0xf0, 0x68, 0xa0, 0x16, 0x85, 0xba, 0xa5, 0xfe, 0xf1, 0xfb, - 0x5a, 0x0d, 0x18, 0x6c, 0x38, 0x4e, 0x40, 0x39, 0xff, 0x30, 0x0c, 0x5c, 0xaf, 0x6b, 0xc5, 0x66, - 0xfa, 0x55, 0x54, 0x4d, 0xb1, 0x20, 0x8b, 0x57, 0xd1, 0x94, 0xed, 0xf8, 0x50, 0xb5, 0xe7, 0xf2, - 0x55, 0xdb, 0xdc, 0xda, 0x49, 0x6c, 0x81, 0xbb, 0xb0, 0xd7, 0xff, 0x55, 0xd2, 0x58, 0xfc, 0x49, - 0x13, 0xc7, 0x0b, 0xa8, 0xe8, 0x3a, 0xea, 0x54, 0x53, 0x59, 0x2d, 0xb5, 0x66, 0x0e, 0x1f, 0x34, - 0x8a, 0x57, 0xb7, 0xac, 0xa2, 0xeb, 0xe0, 0x1a, 0x9a, 0x0e, 0x44, 0x43, 0xaa, 0x25, 0x09, 0x13, - 0x3f, 0xe0, 0x6d, 0x84, 0xd2, 0xc1, 0x50, 0xa7, 0x65, 0x66, 0x17, 0x93, 0x57, 0x23, 0x26, 0xc3, - 0x88, 0x07, 0x32, 0x6d, 0x8c, 0x2e, 0x85, 0x14, 0xac, 0x8c, 0xa7, 0xfe, 0xab, 0x82, 0x9e, 0xca, - 0xe4, 0x08, 0x05, 0xbb, 0x82, 0x4a, 0xb6, 0xe3, 0x27, 0xaf, 0xfc, 0x84, 0x8a, 0xd5, 0x44, 0xc5, - 0x7e, 0x7b, 0xd8, 0x38, 0x9b, 0x11, 0x72, 0x4b, 0x06, 0xc0, 0x57, 0x86, 0x68, 0x16, 0x25, 0xcd, - 0x95, 0x13, 0x69, 0xc6, 0x31, 0x86, 0x78, 0x32, 0xe8, 0xdc, 0x2d, 0xea, 0x33, 0xee, 0x86, 0x4f, - 0xfc, 0x75, 0xe8, 0x9f, 0xc3, 0x48, 0xa4, 0x80, 0x83, 0xda, 0x94, 0x1d, 0x90, 0x41, 0x7d, 0x16, - 0xf3, 0xf5, 0x01, 0xaf, 0x56, 0x15, 0x6a, 0x53, 0x1e, 0x84, 0x19, 0x38, 0xeb, 0xef, 0x22, 0x4d, - 0x22, 0xec, 0xb2, 0x90, 0xf4, 0x76, 0x02, 0xd7, 0xb3, 0x5d, 0x9f, 0xf4, 0x1e, 0x37, 0x31, 0xfd, - 0x5b, 0x05, 0x3d, 0x3b, 0x36, 0x0e, 0xf0, 0xed, 0xa0, 0x4a, 0x28, 0x34, 0x6d, 0x3f, 0x51, 0x01, - 0xed, 0x66, 0x9e, 0xf6, 0x70, 0x88, 0xd6, 0x39, 0x60, 0x5f, 0x19, 0x96, 0x73, 0x6b, 0x3e, 0x1c, - 0x12, 0xe8, 0xdb, 0x59, 0x0a, 0x9b, 0x03, 0x7e, 0x8f, 0x9d, 0xcb, 0x6d, 0x05, 0x2d, 0x8d, 0x0f, - 0x04, 0xc9, 0xec, 0xa1, 0x6a, 0x9c, 0x4c, 0xea, 0x08, 0xd9, 0x2c, 0x4f, 0xc8, 0x26, 0x0d, 0xd2, - 0x52, 0x21, 0x9d, 0xea, 0x88, 0x82, 0x5b, 0x71, 0x85, 0x52, 0x89, 0xfe, 0x43, 0x09, 0xcd, 0x65, - 0xda, 0x19, 0x86, 0x53, 0x19, 0x37, 0x9c, 0x99, 0xae, 0x4a, 0x46, 0x19, 0xa3, 0x92, 0x4c, 0x72, - 0x4a, 0x0a, 0xe5, 0x7f, 0x7c, 0x19, 0xa1, 0x0c, 0xe7, 0x92, 0x9c, 0x84, 0xc5, 0xa1, 0x49, 0x18, - 0xcc, 0x16, 0x73, 0x3d, 0x58, 0x43, 0x19, 0x17, 0xfc, 0x0e, 0x9a, 0x4d, 0xdf, 0xe0, 0xf4, 0xe9, - 0xfc, 0x53, 0x0f, 0xfc, 0x1e, 0xaa, 0x12, 0xdb, 0x8e, 0xfa, 0x91, 0x88, 0xe7, 0xb4, 0xf7, 0x28, - 0xe5, 0xea, 0xcc, 0xe9, 0xa2, 0x54, 0x32, 0x8e, 0xdb, 0x94, 0x8a, 0xa9, 0x3e, 0x2b, 0xfc, 0xdb, - 0x91, 0xef, 0x08, 0x99, 0x7a, 0x46, 0xc6, 0xd1, 0x8c, 0xf8, 0x52, 0x1a, 0xc9, 0xa5, 0x34, 0x76, - 0x93, 0x4b, 0xd9, 0x2a, 0x8b, 0x40, 0x77, 0x1e, 0x36, 0x14, 0x6b, 0x4e, 0x78, 0x7e, 0x14, 0x3b, - 0x8a, 0xc6, 0x70, 0xbd, 0x90, 0x06, 0x94, 0x87, 0xed, 0x3d, 0x62, 0x87, 0x2c, 0x50, 0xcb, 0x71, - 0x63, 0x24, 0xe2, 0x6d, 0x29, 0x15, 0xec, 0x33, 0x1d, 0xb4, 0x4f, 0x7a, 0x11, 0x55, 0x67, 0x4f, - 0xc9, 0x3e, 0x75, 0xfc, 0x58, 0xf8, 0xe1, 0xd7, 0xd1, 0xb9, 0x54, 0xe4, 0x7e, 0x2d, 0xf7, 0x4b, - 0x3b, 0x5e, 0xb1, 0x48, 0x82, 0x2f, 0xe4, 0xd4, 0x96, 0xf8, 0x5d, 0xff, 0xeb, 0x0c, 0x9a, 0x96, - 0xdd, 0x89, 0x6f, 0xa0, 0x99, 0xf8, 0xd2, 0xe2, 0xe7, 0xf3, 0x6d, 0x97, 0x3f, 0xe8, 0xda, 0x85, - 0x13, 0xac, 0xe2, 0x2e, 0xd3, 0x9b, 0xdf, 0xfd, 0xf9, 0xdf, 0x8f, 0x45, 0x0d, 0xab, 0x66, 0xee, - 0xb3, 0x21, 0x3e, 0xe5, 0xf8, 0x1b, 0x54, 0x4e, 0x6e, 0x34, 0xbe, 0x38, 0x21, 0xe8, 0xc8, 0x71, - 0xd7, 0x56, 0x4e, 0xb4, 0x03, 0x78, 0x5d, 0xc2, 0x2f, 0x61, 0x2d, 0x0f, 0x9f, 0x9c, 0x72, 0xfc, - 0x93, 0x82, 0xe6, 0x87, 0xb7, 0x01, 0x7e, 0x69, 0x42, 0xfc, 0xb1, 0x7b, 0x4d, 0x5b, 0x3b, 0xa5, - 0x35, 0x70, 0x5a, 0x95, 0x9c, 0x74, 0xdc, 0xcc, 0x73, 0x1a, 0xde, 0x41, 0xf8, 0x67, 0x05, 0x55, - 0x46, 0x06, 0x1b, 0x1f, 0x0b, 0x96, 0xdb, 0x53, 0x9a, 0x71, 0x5a, 0x73, 0x20, 0xf7, 0x82, 0x24, - 0x77, 0x1e, 0x2f, 0x4f, 0x20, 0x97, 0x61, 0xc2, 0x50, 0x49, 0x5c, 0x58, 0xac, 0x4f, 0x80, 0xc8, - 0x7c, 0x62, 0x68, 0xe7, 0x8f, 0xb5, 0x01, 0xec, 0xba, 0xc4, 0x56, 0xf1, 0x82, 0x39, 0xee, 0xf3, - 0x93, 0xe3, 0xdb, 0x0a, 0x9a, 0xda, 0x74, 0x7c, 0xbc, 0x3c, 0x39, 0x58, 0x82, 0xa7, 0x1f, 0x67, - 0x02, 0x70, 0x6f, 0x48, 0xb8, 0x75, 0xfc, 0xf2, 0x78, 0x38, 0xf3, 0xa6, 0xdc, 0x7c, 0xb7, 0xcc, - 0x9b, 0x23, 0x8b, 0xfe, 0x16, 0xfe, 0x45, 0x41, 0x83, 0xeb, 0x37, 0xb1, 0x67, 0x47, 0xce, 0xfa, - 0xc4, 0x9e, 0x1d, 0xbd, 0xc6, 0xfa, 0x86, 0xe4, 0xf5, 0x36, 0x7e, 0x73, 0x02, 0xaf, 0xe4, 0xda, - 0x4e, 0x26, 0xd8, 0xba, 0x7c, 0xef, 0xb0, 0xae, 0xdc, 0x3f, 0xac, 0x2b, 0xff, 0x1c, 0xd6, 0x95, - 0x3b, 0x47, 0xf5, 0xc2, 0xfd, 0xa3, 0x7a, 0xe1, 0xef, 0xa3, 0x7a, 0xe1, 0xd3, 0x0b, 0x5d, 0x37, - 0xbc, 0x16, 0x75, 0x0c, 0x9b, 0xf5, 0x65, 0xf8, 0xb5, 0x1e, 0xe9, 0xf0, 0x18, 0xe8, 0x2b, 0x09, - 0x25, 0x02, 0xf0, 0xce, 0x8c, 0x5c, 0x78, 0xaf, 0x3c, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x2f, 0x73, - 0xf8, 0x07, 0x15, 0x0d, 0x00, 0x00, + // 1150 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4b, 0x6f, 0xe3, 0xd4, + 0x17, 0x8f, 0xd3, 0xb4, 0x93, 0xde, 0x8e, 0x9a, 0xfc, 0xef, 0x3f, 0x74, 0x5c, 0x53, 0x92, 0xd4, + 0x03, 0x6d, 0x41, 0xd4, 0xee, 0x14, 0xf1, 0x16, 0x82, 0xa6, 0xa5, 0xa3, 0x41, 0x42, 0x2a, 0xa6, + 0x80, 0x84, 0x84, 0xc2, 0x8d, 0x7d, 0xeb, 0x1a, 0x12, 0x5f, 0x8f, 0x1f, 0x1d, 0xca, 0x68, 0x84, + 0x60, 0x31, 0x62, 0x39, 0x82, 0x05, 0x0b, 0x24, 0x34, 0x1b, 0x36, 0xac, 0xf9, 0x10, 0xb3, 0x1c, + 0x01, 0x0b, 0x56, 0x33, 0xd0, 0xb2, 0xe0, 0x63, 0xa0, 0x7b, 0x7d, 0x1c, 0x3b, 0x71, 0xd2, 0x66, + 0x16, 0xb3, 0x89, 0xe2, 0xf3, 0xfa, 0xfd, 0xce, 0xf1, 0x79, 0x18, 0x2d, 0x7d, 0x4e, 0x8e, 0x88, + 0x6e, 0x5a, 0x9e, 0x7e, 0x74, 0xa5, 0x43, 0x43, 0x72, 0x45, 0xbf, 0x1e, 0x51, 0xff, 0x58, 0xf3, + 0x7c, 0x16, 0x32, 0x5c, 0xe5, 0x5a, 0xcd, 0xb4, 0x3c, 0x0d, 0xb4, 0x4a, 0xdd, 0x64, 0x41, 0x8f, + 0x05, 0x3a, 0x89, 0xc2, 0xc3, 0xbe, 0x0b, 0x7f, 0x88, 0x3d, 0x94, 0xe7, 0x40, 0xdf, 0x21, 0x01, + 0x8d, 0x43, 0xf5, 0xad, 0x3c, 0x62, 0x3b, 0x2e, 0x09, 0x1d, 0xe6, 0x82, 0x6d, 0x3d, 0x6b, 0x9b, + 0x58, 0x99, 0xcc, 0x49, 0xf4, 0x8b, 0xb1, 0xbe, 0x2d, 0x9e, 0xf4, 0xf8, 0x01, 0x54, 0x35, 0x9b, + 0xd9, 0x2c, 0x96, 0xf3, 0x7f, 0x20, 0x5d, 0xb2, 0x19, 0xb3, 0xbb, 0x54, 0x27, 0x9e, 0xa3, 0x13, + 0xd7, 0x65, 0xa1, 0x40, 0x4b, 0x7c, 0x1a, 0xa0, 0x15, 0x4f, 0x9d, 0xe8, 0x40, 0x0f, 0x9d, 0x1e, + 0x0d, 0x42, 0xd2, 0xf3, 0xc0, 0x40, 0xc9, 0xd5, 0x82, 0x67, 0x0e, 0x5c, 0x73, 0x3a, 0x9b, 0xba, + 0x34, 0x70, 0x20, 0xb8, 0x5a, 0x43, 0xf8, 0x3d, 0x9e, 0xed, 0x1e, 0xf1, 0x49, 0x2f, 0x30, 0xe8, + 0xf5, 0x88, 0x06, 0xa1, 0xfa, 0x11, 0xfa, 0xff, 0x80, 0x34, 0xf0, 0x98, 0x1b, 0x50, 0xfc, 0x12, + 0x9a, 0xf1, 0x84, 0x44, 0x96, 0x9a, 0xd2, 0xda, 0xdc, 0xa6, 0xac, 0x0d, 0xd7, 0x59, 0x8b, 0x3d, + 0x5a, 0xa5, 0x7b, 0x0f, 0x1a, 0x05, 0x03, 0xac, 0x5f, 0x2b, 0x7f, 0x7b, 0xb7, 0x51, 0xf8, 0xf7, + 0x6e, 0xa3, 0xa0, 0x2e, 0xa0, 0x9a, 0x08, 0xbc, 0x65, 0x9a, 0x2c, 0x72, 0xc3, 0x3e, 0xe0, 0x27, + 0xe8, 0x89, 0x21, 0x39, 0x40, 0xee, 0xa0, 0x32, 0x01, 0x99, 0x2c, 0x35, 0xa7, 0xd6, 0xe6, 0x36, + 0x55, 0x0d, 0x2a, 0x2a, 0xde, 0x5e, 0x82, 0xfb, 0x2e, 0xb3, 0xa2, 0x2e, 0x05, 0x77, 0x80, 0xef, + 0x7b, 0xaa, 0x9f, 0xa1, 0x8a, 0x08, 0xbf, 0x6d, 0x79, 0x80, 0x88, 0x57, 0x51, 0xc5, 0x64, 0xdd, + 0x2e, 0x09, 0xa9, 0x4f, 0xba, 0xed, 0xf0, 0xd8, 0xa3, 0x22, 0xa9, 0x59, 0x63, 0x3e, 0x15, 0xef, + 0x1f, 0x7b, 0x14, 0x6b, 0x68, 0x9a, 0xdd, 0x70, 0xa9, 0x2f, 0x17, 0xb9, 0xba, 0x25, 0xff, 0xf6, + 0xeb, 0x7a, 0x0d, 0x18, 0x6c, 0x59, 0x96, 0x4f, 0x83, 0xe0, 0xfd, 0xd0, 0x77, 0x5c, 0xdb, 0x88, + 0xcd, 0xd4, 0x6b, 0xa8, 0x9a, 0x62, 0x41, 0x16, 0x2f, 0xa2, 0x29, 0xd3, 0xf2, 0xa0, 0x6a, 0x4f, + 0xe5, 0xab, 0xb6, 0xbd, 0xb3, 0x97, 0xd8, 0x02, 0x77, 0x6e, 0xaf, 0xfe, 0x2d, 0xa5, 0xb1, 0x82, + 0xc7, 0x4d, 0x1c, 0x2f, 0xa0, 0xa2, 0x63, 0xc9, 0x53, 0x4d, 0x69, 0xad, 0xd4, 0x9a, 0x39, 0x79, + 0xd0, 0x28, 0x5e, 0xdb, 0x31, 0x8a, 0x8e, 0x85, 0x6b, 0x68, 0xda, 0xe7, 0x0d, 0x29, 0x97, 0x04, + 0x4c, 0xfc, 0x80, 0x77, 0x11, 0x4a, 0x07, 0x43, 0x9e, 0x16, 0x99, 0xad, 0x24, 0xaf, 0x86, 0x4f, + 0x86, 0x16, 0x0f, 0x64, 0xda, 0x18, 0x36, 0x85, 0x14, 0x8c, 0x8c, 0xa7, 0xfa, 0xb3, 0x84, 0xfe, + 0x97, 0xc9, 0x11, 0x0a, 0x76, 0x15, 0x95, 0x4c, 0xcb, 0x4b, 0x5e, 0xf9, 0x39, 0x15, 0xab, 0xf1, + 0x8a, 0xfd, 0xf2, 0xb0, 0x71, 0x31, 0x23, 0x0c, 0x0c, 0x11, 0x00, 0x5f, 0x1d, 0xa0, 0x59, 0x14, + 0x34, 0x57, 0xcf, 0xa5, 0x19, 0xc7, 0x18, 0xe0, 0xc9, 0xa0, 0x73, 0x77, 0xa8, 0xc7, 0x02, 0x27, + 0x7c, 0xec, 0xaf, 0x43, 0xfd, 0x14, 0x46, 0x22, 0x05, 0xec, 0xd7, 0xa6, 0x6c, 0x81, 0x0c, 0xea, + 0xb3, 0x98, 0xaf, 0x0f, 0x78, 0xb5, 0xaa, 0x50, 0x9b, 0x72, 0x3f, 0x4c, 0xdf, 0x59, 0x7d, 0x1b, + 0x29, 0x02, 0x61, 0x9f, 0x85, 0xa4, 0xbb, 0xe7, 0x3b, 0xae, 0xe9, 0x78, 0xa4, 0xfb, 0xa8, 0x89, + 0xa9, 0x5f, 0x4b, 0xe8, 0xc9, 0x91, 0x71, 0x80, 0x6f, 0x07, 0x55, 0x42, 0xae, 0x69, 0x7b, 0x89, + 0x0a, 0x68, 0x37, 0xf3, 0xb4, 0x07, 0x43, 0xb4, 0x2e, 0x01, 0xfb, 0xca, 0xa0, 0x3c, 0x30, 0xe6, + 0xc3, 0x01, 0x81, 0xba, 0x9b, 0xa5, 0xb0, 0xdd, 0xe7, 0xf7, 0xc8, 0xb9, 0xdc, 0x96, 0xd0, 0xd2, + 0xe8, 0x40, 0x90, 0xcc, 0x01, 0xaa, 0xc6, 0xc9, 0xa4, 0x8e, 0x90, 0xcd, 0xf2, 0x98, 0x6c, 0xd2, + 0x20, 0x2d, 0x19, 0xd2, 0xa9, 0x0e, 0x29, 0x02, 0x23, 0xae, 0x50, 0x2a, 0x51, 0xbf, 0x2b, 0xa1, + 0xb9, 0x4c, 0x3b, 0xc3, 0x70, 0x4a, 0xa3, 0x86, 0x33, 0xd3, 0x55, 0xc9, 0x28, 0x63, 0x54, 0x12, + 0x49, 0x4e, 0x09, 0xa1, 0xf8, 0x8f, 0xdf, 0x44, 0x28, 0xc3, 0xb9, 0x24, 0x26, 0x61, 0x71, 0x60, + 0x12, 0xfa, 0xb3, 0xc5, 0x1c, 0x17, 0xd6, 0x50, 0xc6, 0x05, 0xbf, 0x81, 0x66, 0xd3, 0x37, 0x38, + 0x3d, 0x99, 0x7f, 0xea, 0x81, 0xdf, 0x41, 0x55, 0x62, 0x9a, 0x51, 0x2f, 0xe2, 0xf1, 0xac, 0xf6, + 0x01, 0xa5, 0x81, 0x3c, 0x33, 0x59, 0x94, 0x4a, 0xc6, 0x71, 0x97, 0x52, 0x3e, 0xd5, 0x17, 0xb9, + 0x7f, 0x3b, 0xf2, 0x2c, 0x2e, 0x93, 0x2f, 0x88, 0x38, 0x8a, 0x16, 0x5f, 0x4a, 0x2d, 0xb9, 0x94, + 0xda, 0x7e, 0x72, 0x29, 0x5b, 0x65, 0x1e, 0xe8, 0xce, 0xc3, 0x86, 0x64, 0xcc, 0x71, 0xcf, 0x0f, + 0x62, 0x47, 0xde, 0x18, 0x8e, 0x1b, 0x52, 0x9f, 0x06, 0x61, 0xfb, 0x80, 0x98, 0x21, 0xf3, 0xe5, + 0x72, 0xdc, 0x18, 0x89, 0x78, 0x57, 0x48, 0x39, 0xfb, 0x4c, 0x07, 0x1d, 0x91, 0x6e, 0x44, 0xe5, + 0xd9, 0x09, 0xd9, 0xa7, 0x8e, 0x1f, 0x72, 0x3f, 0xfc, 0x32, 0xba, 0x94, 0x8a, 0x9c, 0x2f, 0xc5, + 0x7e, 0x69, 0xc7, 0x2b, 0x16, 0x09, 0xf0, 0x85, 0x9c, 0xda, 0xe0, 0xbf, 0x9b, 0x7f, 0x5c, 0x40, + 0xd3, 0xa2, 0x3b, 0xf1, 0x0d, 0x34, 0x13, 0x5f, 0x5a, 0xfc, 0x74, 0xbe, 0xed, 0xf2, 0x07, 0x5d, + 0x79, 0xe6, 0x1c, 0xab, 0xb8, 0xcb, 0xd4, 0xe6, 0x37, 0xbf, 0xff, 0xf3, 0x7d, 0x51, 0xc1, 0xb2, + 0x9e, 0xfb, 0x6c, 0x88, 0x4f, 0x39, 0xfe, 0x0a, 0x95, 0x93, 0x1b, 0x8d, 0x57, 0xc6, 0x04, 0x1d, + 0x3a, 0xee, 0xca, 0xea, 0xb9, 0x76, 0x00, 0xaf, 0x0a, 0xf8, 0x25, 0xac, 0xe4, 0xe1, 0x93, 0x53, + 0x8e, 0x7f, 0x90, 0xd0, 0xfc, 0xe0, 0x36, 0xc0, 0xcf, 0x8f, 0x89, 0x3f, 0x72, 0xaf, 0x29, 0xeb, + 0x13, 0x5a, 0x03, 0xa7, 0x35, 0xc1, 0x49, 0xc5, 0xcd, 0x3c, 0xa7, 0xc1, 0x1d, 0x84, 0x7f, 0x94, + 0x50, 0x65, 0x68, 0xb0, 0xf1, 0x99, 0x60, 0xb9, 0x3d, 0xa5, 0x68, 0x93, 0x9a, 0x03, 0xb9, 0x67, + 0x05, 0xb9, 0xcb, 0x78, 0x79, 0x0c, 0xb9, 0x0c, 0x13, 0x86, 0x4a, 0xfc, 0xc2, 0x62, 0x75, 0x0c, + 0x44, 0xe6, 0x13, 0x43, 0xb9, 0x7c, 0xa6, 0x0d, 0x60, 0xd7, 0x05, 0xb6, 0x8c, 0x17, 0xf4, 0x51, + 0x9f, 0x9f, 0x01, 0xbe, 0x2d, 0xa1, 0xa9, 0x6d, 0xcb, 0xc3, 0xcb, 0xe3, 0x83, 0x25, 0x78, 0xea, + 0x59, 0x26, 0x00, 0xf7, 0x8a, 0x80, 0xdb, 0xc4, 0x1b, 0xa3, 0xe1, 0xf4, 0x9b, 0x62, 0xf3, 0xdd, + 0xd2, 0x6f, 0x0e, 0x2d, 0xfa, 0x5b, 0xf8, 0x27, 0x09, 0xf5, 0xaf, 0xdf, 0xd8, 0x9e, 0x1d, 0x3a, + 0xeb, 0x63, 0x7b, 0x76, 0xf8, 0x1a, 0xab, 0x5b, 0x82, 0xd7, 0xeb, 0xf8, 0xd5, 0x31, 0xbc, 0x92, + 0x6b, 0x3b, 0x9e, 0x60, 0xeb, 0xad, 0x7b, 0x27, 0x75, 0xe9, 0xfe, 0x49, 0x5d, 0xfa, 0xeb, 0xa4, + 0x2e, 0xdd, 0x39, 0xad, 0x17, 0xee, 0x9f, 0xd6, 0x0b, 0x7f, 0x9e, 0xd6, 0x0b, 0x1f, 0xaf, 0xd8, + 0x4e, 0x78, 0x18, 0x75, 0x34, 0x93, 0xf5, 0xf4, 0x0d, 0xbb, 0x4b, 0x3a, 0x81, 0xbe, 0x61, 0xaf, + 0x9b, 0x87, 0xc4, 0x71, 0xf5, 0x2f, 0x04, 0x16, 0x8f, 0x10, 0x74, 0x66, 0xc4, 0xc6, 0x7b, 0xe1, + 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa8, 0x6d, 0x9d, 0x1e, 0x16, 0x0d, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/cdp/types/tx.pb.go b/x/cdp/types/tx.pb.go index f21bd475..ac7c1464 100644 --- a/x/cdp/types/tx.pb.go +++ b/x/cdp/types/tx.pb.go @@ -669,47 +669,48 @@ func init() { func init() { proto.RegisterFile("kava/cdp/v1beta1/tx.proto", fileDescriptor_3b8c9334ad8ab0d3) } var fileDescriptor_3b8c9334ad8ab0d3 = []byte{ - // 639 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x55, 0xc1, 0x6e, 0xd3, 0x4c, - 0x10, 0x8e, 0x9b, 0x26, 0x6d, 0xb6, 0xbf, 0x7e, 0x90, 0x09, 0x28, 0x89, 0xc0, 0x8d, 0x22, 0x0a, - 0xbd, 0xd4, 0xa6, 0x05, 0x21, 0x38, 0xa0, 0x8a, 0x24, 0x97, 0x4a, 0x44, 0xaa, 0x5c, 0x24, 0x24, - 0x2e, 0xd1, 0xda, 0xbb, 0x72, 0xad, 0x26, 0xde, 0x65, 0x77, 0xdb, 0x34, 0x6f, 0xc1, 0x1b, 0x70, - 0x41, 0xe2, 0x05, 0x78, 0x88, 0x1e, 0x2b, 0x4e, 0x9c, 0x02, 0x4a, 0x4e, 0x3c, 0x01, 0x57, 0x64, - 0xaf, 0xbd, 0x8e, 0x52, 0x27, 0x04, 0x10, 0x17, 0x6e, 0xeb, 0xfd, 0x66, 0x3e, 0x7d, 0xdf, 0x78, - 0x66, 0x16, 0x54, 0x4f, 0xe0, 0x19, 0xb4, 0x5c, 0x44, 0xad, 0xb3, 0x5d, 0x07, 0x0b, 0xb8, 0x6b, - 0x89, 0x73, 0x93, 0x32, 0x22, 0x88, 0x7e, 0x3d, 0x84, 0x4c, 0x17, 0x51, 0x33, 0x86, 0x6a, 0x86, - 0x4b, 0x78, 0x9f, 0x70, 0xcb, 0x81, 0x1c, 0xab, 0x78, 0x97, 0xf8, 0x81, 0xcc, 0xa8, 0x55, 0x25, - 0xde, 0x8d, 0xbe, 0x2c, 0xf9, 0x11, 0x43, 0x65, 0x8f, 0x78, 0x44, 0xde, 0x87, 0x27, 0x79, 0xdb, - 0xf8, 0xa6, 0x81, 0xff, 0x3a, 0xdc, 0x6b, 0x31, 0x0c, 0x05, 0x6e, 0xb5, 0x0f, 0xf5, 0x07, 0xa0, - 0xc8, 0x71, 0x80, 0x30, 0xab, 0x68, 0x75, 0x6d, 0xbb, 0xd4, 0xac, 0x7c, 0xfa, 0xb8, 0x53, 0x8e, - 0x89, 0x9e, 0x23, 0xc4, 0x30, 0xe7, 0x47, 0x82, 0xf9, 0x81, 0x67, 0xc7, 0x71, 0xfa, 0x3e, 0x00, - 0x2e, 0xe9, 0xf5, 0xa0, 0xc0, 0x0c, 0xf6, 0x2a, 0x2b, 0x75, 0x6d, 0x7b, 0x63, 0xaf, 0x6a, 0xc6, - 0x29, 0xa1, 0xd0, 0x44, 0xbd, 0xd9, 0x22, 0x7e, 0xd0, 0x5c, 0xbd, 0x18, 0x6d, 0xe6, 0xec, 0xa9, - 0x14, 0xfd, 0x19, 0x28, 0x51, 0xe6, 0x07, 0xae, 0x4f, 0x61, 0xaf, 0x92, 0x5f, 0x2e, 0x3f, 0xcd, - 0xd0, 0xef, 0x83, 0x6b, 0x29, 0x59, 0x57, 0x0c, 0x29, 0xae, 0xac, 0x86, 0xd2, 0xed, 0xff, 0xd3, - 0xeb, 0x97, 0x43, 0x8a, 0x1b, 0x4f, 0x40, 0x79, 0xda, 0xaa, 0x8d, 0x39, 0x25, 0x01, 0xc7, 0x7a, - 0x1d, 0x14, 0x5d, 0x44, 0xbb, 0x3e, 0x8a, 0x2c, 0xaf, 0x36, 0x4b, 0xe3, 0xd1, 0x66, 0xa1, 0x85, - 0xe8, 0x41, 0xdb, 0x2e, 0xb8, 0x88, 0x1e, 0xa0, 0xc6, 0x48, 0x03, 0xa0, 0xc3, 0xbd, 0x36, 0xa6, - 0x84, 0xfb, 0x42, 0x7f, 0x0c, 0x4a, 0x48, 0x1e, 0xc9, 0xcf, 0xcb, 0x94, 0x86, 0xea, 0x26, 0x28, - 0x90, 0x41, 0x80, 0x59, 0x54, 0xa4, 0x45, 0x39, 0x32, 0x6c, 0xa6, 0xb2, 0xf9, 0x5f, 0xaf, 0xec, - 0xd2, 0xa5, 0x29, 0x03, 0x3d, 0xf5, 0x97, 0x14, 0xa6, 0xf1, 0x45, 0x03, 0x1b, 0x1d, 0xee, 0xbd, - 0xf2, 0xc5, 0x31, 0x62, 0x70, 0xf0, 0x0f, 0xfa, 0xbe, 0x09, 0x6e, 0x4c, 0x19, 0x54, 0xc6, 0x3f, - 0x48, 0xe3, 0x6d, 0x06, 0x07, 0x6d, 0xec, 0x88, 0xdf, 0x18, 0x8a, 0x0c, 0x05, 0x2b, 0x59, 0x0a, - 0xfe, 0xb0, 0xf9, 0x63, 0x03, 0x89, 0x50, 0x65, 0xe0, 0xbd, 0x1c, 0x6b, 0x1b, 0x53, 0x38, 0xfc, - 0xdb, 0x0e, 0x9e, 0x82, 0x35, 0x0a, 0x87, 0x7d, 0x1c, 0x88, 0x65, 0xf5, 0x27, 0xf1, 0x8d, 0x5b, - 0xd1, 0x44, 0x2a, 0x95, 0x4a, 0xfe, 0x3b, 0x29, 0xff, 0x85, 0xff, 0xe6, 0xd4, 0x47, 0x50, 0xe0, - 0x50, 0xfe, 0x09, 0xc6, 0x74, 0x19, 0xf9, 0x32, 0x4e, 0x7f, 0x04, 0xd6, 0x1d, 0xc2, 0x18, 0x19, - 0x2c, 0xd1, 0x76, 0x2a, 0x32, 0xcb, 0x74, 0x3e, 0xb3, 0x71, 0xa4, 0x72, 0x25, 0x30, 0x51, 0xbe, - 0xf7, 0x3d, 0x0f, 0xf2, 0x1d, 0xee, 0xe9, 0x47, 0xa0, 0x94, 0xee, 0x54, 0xc3, 0x9c, 0x5d, 0xe4, - 0xe6, 0xf4, 0x22, 0xaa, 0xdd, 0x5b, 0x8c, 0xab, 0x45, 0xd5, 0x01, 0x6b, 0xc9, 0x0a, 0xba, 0x9d, - 0x99, 0x12, 0xa3, 0xb5, 0xbb, 0x8b, 0x50, 0x45, 0x77, 0x08, 0xd6, 0xd5, 0x68, 0xdf, 0xc9, 0xcc, - 0x48, 0xe0, 0xda, 0xd6, 0x42, 0x78, 0x9a, 0x51, 0xcd, 0x4c, 0x36, 0x63, 0x02, 0xcf, 0x61, 0x9c, - 0x6d, 0xe4, 0xb0, 0x8e, 0x69, 0x13, 0x67, 0xd7, 0x51, 0xe1, 0x73, 0xea, 0x78, 0xa5, 0xbd, 0x42, - 0xd2, 0xb4, 0xb5, 0xb2, 0x49, 0x15, 0x3e, 0x87, 0xf4, 0xca, 0x9f, 0x6f, 0xee, 0x5f, 0x8c, 0x0d, - 0xed, 0x72, 0x6c, 0x68, 0x5f, 0xc7, 0x86, 0xf6, 0x76, 0x62, 0xe4, 0x2e, 0x27, 0x46, 0xee, 0xf3, - 0xc4, 0xc8, 0xbd, 0xde, 0xf2, 0x7c, 0x71, 0x7c, 0xea, 0x98, 0x2e, 0xe9, 0x5b, 0x21, 0xd7, 0x4e, - 0x0f, 0x3a, 0x3c, 0x3a, 0x59, 0xe7, 0xd1, 0xc3, 0x1f, 0xf6, 0x19, 0x77, 0x8a, 0xd1, 0x8b, 0xfc, - 0xf0, 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2f, 0x75, 0x8a, 0x38, 0x11, 0x08, 0x00, 0x00, + // 642 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x55, 0x4d, 0x6e, 0xd3, 0x40, + 0x18, 0x8d, 0x9b, 0xfe, 0x65, 0x8a, 0x00, 0x99, 0x80, 0xd2, 0x08, 0xdc, 0x2a, 0x82, 0xd2, 0x4d, + 0xed, 0xb6, 0x20, 0x04, 0x0b, 0x04, 0x24, 0xd9, 0x54, 0x22, 0x52, 0xe5, 0x22, 0x21, 0xb1, 0xa9, + 0xc6, 0x9e, 0x91, 0x3b, 0x6a, 0xe2, 0x19, 0x66, 0xa6, 0x4d, 0x73, 0x0b, 0x6e, 0xc0, 0x06, 0x89, + 0x0b, 0x70, 0x88, 0x2e, 0x2b, 0x56, 0xac, 0x02, 0x4a, 0x56, 0x9c, 0x80, 0x2d, 0xb2, 0xc7, 0x1e, + 0x47, 0xa9, 0x13, 0x02, 0x88, 0x0d, 0x3b, 0x7b, 0xde, 0xf7, 0x3d, 0xbd, 0xf7, 0xfc, 0xcd, 0x67, + 0xb0, 0x7a, 0x0c, 0x4f, 0xa1, 0xe3, 0x23, 0xe6, 0x9c, 0xee, 0x78, 0x58, 0xc2, 0x1d, 0x47, 0x9e, + 0xd9, 0x8c, 0x53, 0x49, 0xcd, 0xeb, 0x11, 0x64, 0xfb, 0x88, 0xd9, 0x09, 0x54, 0xb5, 0x7c, 0x2a, + 0x3a, 0x54, 0x38, 0x1e, 0x14, 0x58, 0xd7, 0xfb, 0x94, 0x84, 0xaa, 0xa3, 0xba, 0xaa, 0xf0, 0xc3, + 0xf8, 0xcd, 0x51, 0x2f, 0x09, 0x54, 0x0e, 0x68, 0x40, 0xd5, 0x79, 0xf4, 0xa4, 0x4e, 0x6b, 0xdf, + 0x0d, 0x70, 0xa5, 0x25, 0x82, 0x06, 0xc7, 0x50, 0xe2, 0x46, 0x73, 0xdf, 0xdc, 0x06, 0x8b, 0x02, + 0x87, 0x08, 0xf3, 0x8a, 0xb1, 0x6e, 0x6c, 0x96, 0xea, 0x95, 0xcf, 0x9f, 0xb6, 0xca, 0x09, 0xd1, + 0x0b, 0x84, 0x38, 0x16, 0xe2, 0x40, 0x72, 0x12, 0x06, 0x6e, 0x52, 0x67, 0x3e, 0x03, 0xc0, 0xa7, + 0xed, 0x36, 0x94, 0x98, 0xc3, 0x76, 0x65, 0x6e, 0xdd, 0xd8, 0x5c, 0xd9, 0x5d, 0xb5, 0x93, 0x96, + 0x48, 0x68, 0xaa, 0xde, 0x6e, 0x50, 0x12, 0xd6, 0xe7, 0xcf, 0xfb, 0x6b, 0x05, 0x77, 0xa4, 0xc5, + 0x7c, 0x0a, 0x4a, 0x8c, 0x93, 0xd0, 0x27, 0x0c, 0xb6, 0x2b, 0xc5, 0xd9, 0xfa, 0xb3, 0x0e, 0xf3, + 0x3e, 0xb8, 0x96, 0x91, 0x1d, 0xca, 0x1e, 0xc3, 0x95, 0xf9, 0x48, 0xba, 0x7b, 0x35, 0x3b, 0x7e, + 0xd5, 0x63, 0xb8, 0xf6, 0x18, 0x94, 0x47, 0xad, 0xba, 0x58, 0x30, 0x1a, 0x0a, 0x6c, 0xae, 0x83, + 0x45, 0x1f, 0xb1, 0x43, 0x82, 0x62, 0xcb, 0xf3, 0xf5, 0xd2, 0xa0, 0xbf, 0xb6, 0xd0, 0x40, 0x6c, + 0xaf, 0xe9, 0x2e, 0xf8, 0x88, 0xed, 0xa1, 0x5a, 0xdf, 0x00, 0xa0, 0x25, 0x82, 0x26, 0x66, 0x54, + 0x10, 0x69, 0x3e, 0x02, 0x25, 0xa4, 0x1e, 0xe9, 0xaf, 0x63, 0xca, 0x4a, 0x4d, 0x1b, 0x2c, 0xd0, + 0x6e, 0x88, 0x79, 0x1c, 0xd2, 0xb4, 0x1e, 0x55, 0x36, 0x96, 0x6c, 0xf1, 0xf7, 0x93, 0x9d, 0x39, + 0x9a, 0x32, 0x30, 0x33, 0x7f, 0x69, 0x30, 0xb5, 0xaf, 0x06, 0x58, 0x69, 0x89, 0xe0, 0x35, 0x91, + 0x47, 0x88, 0xc3, 0xee, 0x7f, 0xe8, 0xfb, 0x26, 0xb8, 0x31, 0x62, 0x50, 0x1b, 0xff, 0xa8, 0x8c, + 0x37, 0x39, 0xec, 0x36, 0xb1, 0x27, 0xff, 0xe0, 0x52, 0xe4, 0x28, 0x98, 0xcb, 0x53, 0xf0, 0x97, + 0xc3, 0x9f, 0x18, 0x48, 0x85, 0x6a, 0x03, 0x1f, 0xd4, 0xb5, 0x76, 0x31, 0x83, 0xbd, 0x7f, 0xed, + 0xe0, 0x09, 0x58, 0x62, 0xb0, 0xd7, 0xc1, 0xa1, 0x9c, 0x55, 0x7f, 0x5a, 0x5f, 0xbb, 0x15, 0xdf, + 0x48, 0xad, 0x52, 0xcb, 0x7f, 0xaf, 0xe4, 0xbf, 0x24, 0x6f, 0x4f, 0x08, 0x82, 0x12, 0x47, 0xf2, + 0x8f, 0x31, 0x66, 0xb3, 0xc8, 0x57, 0x75, 0xe6, 0x43, 0xb0, 0xec, 0x51, 0xce, 0x69, 0x77, 0x86, + 0xb1, 0xd3, 0x95, 0x79, 0xa6, 0x8b, 0xb9, 0x83, 0xa3, 0x94, 0x6b, 0x81, 0xa9, 0xf2, 0xdd, 0x1f, + 0x45, 0x50, 0x6c, 0x89, 0xc0, 0x3c, 0x00, 0xa5, 0x6c, 0xa7, 0x5a, 0xf6, 0xf8, 0x22, 0xb7, 0x47, + 0x17, 0x51, 0x75, 0x63, 0x3a, 0xae, 0x17, 0x55, 0x0b, 0x2c, 0xa5, 0x2b, 0xe8, 0x76, 0x6e, 0x4b, + 0x82, 0x56, 0xef, 0x4e, 0x43, 0x35, 0xdd, 0x3e, 0x58, 0xd6, 0x57, 0xfb, 0x4e, 0x6e, 0x47, 0x0a, + 0x57, 0xef, 0x4d, 0x85, 0x47, 0x19, 0xf5, 0x9d, 0xc9, 0x67, 0x4c, 0xe1, 0x09, 0x8c, 0xe3, 0x83, + 0x1c, 0xe5, 0x98, 0x0d, 0x71, 0x7e, 0x8e, 0x1a, 0x9f, 0x90, 0xe3, 0xa5, 0xf1, 0x8a, 0x48, 0xb3, + 0xd1, 0xca, 0x27, 0xd5, 0xf8, 0x04, 0xd2, 0x4b, 0x5f, 0xbe, 0xfe, 0xfc, 0x7c, 0x60, 0x19, 0x17, + 0x03, 0xcb, 0xf8, 0x36, 0xb0, 0x8c, 0x77, 0x43, 0xab, 0x70, 0x31, 0xb4, 0x0a, 0x5f, 0x86, 0x56, + 0xe1, 0xcd, 0x46, 0x40, 0xe4, 0xd1, 0x89, 0x67, 0xfb, 0xb4, 0xe3, 0x6c, 0x07, 0x6d, 0xe8, 0x09, + 0x67, 0x3b, 0xd8, 0xf2, 0x8f, 0x20, 0x09, 0x9d, 0xb3, 0xf8, 0xcf, 0x1f, 0x0d, 0x9a, 0xf0, 0x16, + 0xe3, 0x5f, 0xf2, 0x83, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xae, 0x1f, 0xa2, 0x1e, 0x12, 0x08, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/committee/types/committee.pb.go b/x/committee/types/committee.pb.go index 12e02536..6c51e5bb 100644 --- a/x/committee/types/committee.pb.go +++ b/x/committee/types/committee.pb.go @@ -195,48 +195,48 @@ func init() { } var fileDescriptor_a2549fd9d70ca349 = []byte{ - // 649 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xcd, 0x6e, 0xd3, 0x40, - 0x10, 0xb6, 0x93, 0x90, 0xd2, 0x75, 0x1b, 0xd2, 0xa5, 0x54, 0x4e, 0x85, 0x6c, 0xab, 0x40, 0x15, - 0x81, 0x62, 0xab, 0xe1, 0xc6, 0x2d, 0xae, 0x13, 0xd5, 0x52, 0x69, 0x22, 0xc7, 0x3d, 0xc0, 0xc5, - 0xb2, 0xe3, 0x25, 0xb5, 0x1a, 0x67, 0x83, 0x77, 0x53, 0x35, 0x6f, 0xc0, 0x91, 0x63, 0x8f, 0x48, - 0xbc, 0x42, 0x1f, 0xa2, 0xea, 0xa9, 0xe2, 0x84, 0x38, 0x84, 0x92, 0x3e, 0x05, 0x9c, 0x90, 0xff, - 0x1a, 0x17, 0x8a, 0x04, 0x07, 0x4e, 0xde, 0xfd, 0xe6, 0x9b, 0x99, 0xfd, 0x66, 0x3e, 0x19, 0x6c, - 0x1e, 0xda, 0x47, 0xb6, 0xd2, 0xc3, 0xbe, 0xef, 0x51, 0x8a, 0x90, 0x72, 0xb4, 0xe5, 0x20, 0x6a, - 0x6f, 0xcd, 0x11, 0x79, 0x14, 0x60, 0x8a, 0xe1, 0x5a, 0xc8, 0x93, 0xe7, 0x68, 0xc2, 0x5b, 0xaf, - 0xf4, 0x30, 0xf1, 0x31, 0xb1, 0x22, 0x96, 0x12, 0x5f, 0xe2, 0x94, 0xf5, 0xd5, 0x3e, 0xee, 0xe3, - 0x18, 0x0f, 0x4f, 0x09, 0x5a, 0xe9, 0x63, 0xdc, 0x1f, 0x20, 0x25, 0xba, 0x39, 0xe3, 0x37, 0x8a, - 0x3d, 0x9c, 0x24, 0x21, 0xe1, 0xd7, 0x90, 0x3b, 0x0e, 0x6c, 0xea, 0xe1, 0x61, 0x1c, 0xdf, 0xf8, - 0x9e, 0x07, 0xcb, 0xaa, 0x4d, 0xd0, 0x76, 0xfa, 0x0a, 0xb8, 0x06, 0x72, 0x9e, 0xcb, 0xb3, 0x12, - 0x5b, 0x2d, 0xa8, 0xc5, 0xd9, 0x54, 0xcc, 0xe9, 0x9a, 0x91, 0xf3, 0x5c, 0x28, 0x01, 0xce, 0x45, - 0xa4, 0x17, 0x78, 0xa3, 0x30, 0x9d, 0xcf, 0x49, 0x6c, 0x75, 0xd1, 0xc8, 0x42, 0xd0, 0x01, 0x0b, - 0x3e, 0xf2, 0x1d, 0x14, 0x10, 0x3e, 0x2f, 0xe5, 0xab, 0x4b, 0xea, 0xce, 0x8f, 0xa9, 0x58, 0xeb, - 0x7b, 0xf4, 0x60, 0xec, 0x84, 0x32, 0x13, 0x29, 0xc9, 0xa7, 0x46, 0xdc, 0x43, 0x85, 0x4e, 0x46, - 0x88, 0xc8, 0x8d, 0x5e, 0xaf, 0xe1, 0xba, 0x01, 0x22, 0xe4, 0xd3, 0x69, 0xed, 0x7e, 0x22, 0x38, - 0x41, 0xd4, 0x09, 0x45, 0xc4, 0x48, 0x0b, 0xc3, 0x16, 0xe0, 0x46, 0x28, 0xf0, 0x3d, 0x42, 0x3c, - 0x3c, 0x24, 0x7c, 0x41, 0xca, 0x57, 0xb9, 0xfa, 0xaa, 0x1c, 0xab, 0x94, 0x53, 0x95, 0x72, 0x63, - 0x38, 0x51, 0x4b, 0xe7, 0xa7, 0x35, 0xd0, 0xb9, 0x26, 0x1b, 0xd9, 0x44, 0xb8, 0x0f, 0x4a, 0x47, - 0x98, 0x22, 0x8b, 0x1e, 0x04, 0x88, 0x1c, 0xe0, 0x81, 0xcb, 0xdf, 0x09, 0x05, 0xa9, 0xf2, 0xd9, - 0x54, 0x64, 0xbe, 0x4c, 0xc5, 0xcd, 0xbf, 0x78, 0xb6, 0x86, 0x7a, 0xc6, 0x72, 0x58, 0xc5, 0x4c, - 0x8b, 0xc0, 0x0e, 0x58, 0x19, 0x05, 0x78, 0x84, 0x89, 0x3d, 0xb0, 0xd2, 0x49, 0xf3, 0x45, 0x89, - 0xad, 0x72, 0xf5, 0xca, 0x6f, 0x8f, 0xd4, 0x12, 0x82, 0x7a, 0x37, 0x6c, 0x7a, 0xf2, 0x55, 0x64, - 0x8d, 0x72, 0x9a, 0x9d, 0xc6, 0x60, 0x0b, 0x2c, 0x51, 0x7b, 0x30, 0x98, 0x58, 0x38, 0x9e, 0xfb, - 0x82, 0xc4, 0x56, 0x4b, 0xf5, 0x47, 0xf2, 0xed, 0xde, 0x91, 0xcd, 0x90, 0xdb, 0x8e, 0xa8, 0x06, - 0x47, 0xe7, 0x97, 0x17, 0x2b, 0x27, 0x1f, 0x44, 0xe6, 0xfc, 0xb4, 0xb6, 0x78, 0xbd, 0xe9, 0x8d, - 0x63, 0x70, 0xef, 0x65, 0x34, 0xd6, 0xf9, 0xf2, 0x0d, 0x50, 0x72, 0x6c, 0x82, 0xac, 0xeb, 0xc2, - 0x91, 0x11, 0xb8, 0xfa, 0x93, 0x3f, 0xf5, 0xbb, 0xe1, 0x1d, 0xb5, 0x70, 0x31, 0x15, 0x59, 0x63, - 0xd9, 0xc9, 0x82, 0xb7, 0x75, 0xbe, 0x64, 0x41, 0xc9, 0xc4, 0x87, 0x68, 0xf8, 0x5f, 0x3b, 0xc3, - 0x16, 0x28, 0xbe, 0x1d, 0xe3, 0x60, 0xec, 0xc7, 0x6e, 0xfd, 0xe7, 0xe5, 0x26, 0xd9, 0x50, 0x04, - 0xf1, 0x28, 0x2d, 0x17, 0x0d, 0xb1, 0xcf, 0xe7, 0x23, 0xeb, 0x83, 0x08, 0xd2, 0x42, 0xe4, 0x16, - 0x89, 0x4f, 0x03, 0xc0, 0x65, 0x76, 0x01, 0x1f, 0x02, 0xde, 0x6c, 0xec, 0xee, 0xbe, 0xb2, 0xda, - 0x1d, 0x53, 0x6f, 0xef, 0x59, 0xfb, 0x7b, 0xdd, 0x4e, 0x73, 0x5b, 0x6f, 0xe9, 0x4d, 0xad, 0xcc, - 0xc0, 0xc7, 0x40, 0xba, 0x11, 0x6d, 0xe9, 0x46, 0xd7, 0xb4, 0x3a, 0x8d, 0xae, 0x69, 0x99, 0x3b, - 0x4d, 0xab, 0xd3, 0xee, 0x9a, 0x65, 0x16, 0x56, 0xc0, 0x83, 0x1b, 0x2c, 0xad, 0xd9, 0xd0, 0x76, - 0xf5, 0xbd, 0x66, 0x39, 0xb7, 0x5e, 0x78, 0xf7, 0x51, 0x60, 0x54, 0xfd, 0xec, 0x9b, 0xc0, 0x9c, - 0xcd, 0x04, 0xf6, 0x62, 0x26, 0xb0, 0x97, 0x33, 0x81, 0x7d, 0x7f, 0x25, 0x30, 0x17, 0x57, 0x02, - 0xf3, 0xf9, 0x4a, 0x60, 0x5e, 0x3f, 0xcb, 0xa8, 0x0e, 0x67, 0x5a, 0x1b, 0xd8, 0x0e, 0x89, 0x4e, - 0xca, 0x71, 0xe6, 0x6f, 0x15, 0xc9, 0x77, 0x8a, 0x91, 0x4b, 0x9f, 0xff, 0x0c, 0x00, 0x00, 0xff, - 0xff, 0x0d, 0x0b, 0x28, 0x7d, 0xcc, 0x04, 0x00, 0x00, + // 655 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xcd, 0x6e, 0xd3, 0x4c, + 0x14, 0xb5, 0x93, 0x7c, 0xe9, 0xd7, 0x71, 0x1b, 0xd2, 0xa1, 0x54, 0x4e, 0x85, 0x6c, 0xab, 0x40, + 0x15, 0x21, 0x62, 0xb7, 0x61, 0xc7, 0x2e, 0xae, 0x13, 0x35, 0xa8, 0x34, 0x91, 0xe3, 0x2e, 0x60, + 0x63, 0xf9, 0x67, 0x70, 0xac, 0xc6, 0x9e, 0xe0, 0x71, 0xaa, 0xe6, 0x0d, 0x58, 0xb2, 0xec, 0x12, + 0x89, 0x57, 0xe8, 0x43, 0x54, 0x5d, 0x55, 0xac, 0x10, 0x8b, 0x50, 0xd2, 0xa7, 0x80, 0x15, 0xf2, + 0x5f, 0x93, 0x42, 0x91, 0x60, 0xc1, 0x2a, 0x99, 0x73, 0xcf, 0xfd, 0x39, 0xf7, 0x1e, 0x19, 0x6c, + 0x1e, 0x1a, 0x47, 0x86, 0x64, 0x61, 0xcf, 0x73, 0xc3, 0x10, 0x21, 0xe9, 0x68, 0xdb, 0x44, 0xa1, + 0xb1, 0x3d, 0x43, 0xc4, 0x61, 0x80, 0x43, 0x0c, 0xd7, 0x22, 0x9e, 0x38, 0x43, 0x53, 0xde, 0x7a, + 0xc5, 0xc2, 0xc4, 0xc3, 0x44, 0x8f, 0x59, 0x52, 0xf2, 0x48, 0x52, 0xd6, 0x57, 0x1d, 0xec, 0xe0, + 0x04, 0x8f, 0xfe, 0xa5, 0x68, 0xc5, 0xc1, 0xd8, 0x19, 0x20, 0x29, 0x7e, 0x99, 0xa3, 0xd7, 0x92, + 0xe1, 0x8f, 0xd3, 0x10, 0xf7, 0x73, 0xc8, 0x1e, 0x05, 0x46, 0xe8, 0x62, 0x3f, 0x89, 0x6f, 0x7c, + 0xcb, 0x83, 0x65, 0xd9, 0x20, 0x68, 0x27, 0x9b, 0x02, 0xae, 0x81, 0x9c, 0x6b, 0xb3, 0xb4, 0x40, + 0x57, 0x0b, 0x72, 0x71, 0x3a, 0xe1, 0x73, 0x6d, 0x45, 0xcd, 0xb9, 0x36, 0x14, 0x00, 0x63, 0x23, + 0x62, 0x05, 0xee, 0x30, 0x4a, 0x67, 0x73, 0x02, 0x5d, 0x5d, 0x54, 0xe7, 0x21, 0x68, 0x82, 0x05, + 0x0f, 0x79, 0x26, 0x0a, 0x08, 0x9b, 0x17, 0xf2, 0xd5, 0x25, 0x79, 0xf7, 0xfb, 0x84, 0xaf, 0x39, + 0x6e, 0xd8, 0x1f, 0x99, 0x91, 0xcc, 0x54, 0x4a, 0xfa, 0x53, 0x23, 0xf6, 0xa1, 0x14, 0x8e, 0x87, + 0x88, 0x88, 0x0d, 0xcb, 0x6a, 0xd8, 0x76, 0x80, 0x08, 0xf9, 0x78, 0x5a, 0xbb, 0x9b, 0x0a, 0x4e, + 0x11, 0x79, 0x1c, 0x22, 0xa2, 0x66, 0x85, 0x61, 0x0b, 0x30, 0x43, 0x14, 0x78, 0x2e, 0x21, 0x2e, + 0xf6, 0x09, 0x5b, 0x10, 0xf2, 0x55, 0xa6, 0xbe, 0x2a, 0x26, 0x2a, 0xc5, 0x4c, 0xa5, 0xd8, 0xf0, + 0xc7, 0x72, 0xe9, 0xfc, 0xb4, 0x06, 0xba, 0xd7, 0x64, 0x75, 0x3e, 0x11, 0x1e, 0x80, 0xd2, 0x11, + 0x0e, 0x91, 0x1e, 0xf6, 0x03, 0x44, 0xfa, 0x78, 0x60, 0xb3, 0xff, 0x45, 0x82, 0x64, 0xf1, 0x6c, + 0xc2, 0x53, 0x9f, 0x27, 0xfc, 0xe6, 0x1f, 0x8c, 0xad, 0x20, 0x4b, 0x5d, 0x8e, 0xaa, 0x68, 0x59, + 0x11, 0xd8, 0x05, 0x2b, 0xc3, 0x00, 0x0f, 0x31, 0x31, 0x06, 0x7a, 0xb6, 0x69, 0xb6, 0x28, 0xd0, + 0x55, 0xa6, 0x5e, 0xf9, 0x65, 0x48, 0x25, 0x25, 0xc8, 0xff, 0x47, 0x4d, 0x4f, 0xbe, 0xf0, 0xb4, + 0x5a, 0xce, 0xb2, 0xb3, 0x18, 0x6c, 0x81, 0xa5, 0xd0, 0x18, 0x0c, 0xc6, 0x3a, 0x4e, 0xf6, 0xbe, + 0x20, 0xd0, 0xd5, 0x52, 0xfd, 0x81, 0x78, 0xbb, 0x77, 0x44, 0x2d, 0xe2, 0x76, 0x62, 0xaa, 0xca, + 0x84, 0xb3, 0xc7, 0xb3, 0x95, 0x93, 0xf7, 0x3c, 0x75, 0x7e, 0x5a, 0x5b, 0xbc, 0xbe, 0xf4, 0xc6, + 0x31, 0xb8, 0xf3, 0x22, 0x5e, 0xeb, 0xec, 0xf8, 0x2a, 0x28, 0x99, 0x06, 0x41, 0xfa, 0x75, 0xe1, + 0xd8, 0x08, 0x4c, 0xfd, 0xd1, 0xef, 0xfa, 0xdd, 0xf0, 0x8e, 0x5c, 0xb8, 0x98, 0xf0, 0xb4, 0xba, + 0x6c, 0xce, 0x83, 0xb7, 0x75, 0xbe, 0xa4, 0x41, 0x49, 0xc3, 0x87, 0xc8, 0xff, 0xa7, 0x9d, 0x61, + 0x0b, 0x14, 0xdf, 0x8c, 0x70, 0x30, 0xf2, 0x12, 0xb7, 0xfe, 0xf5, 0x71, 0xd3, 0x6c, 0xc8, 0x83, + 0x64, 0x95, 0xba, 0x8d, 0x7c, 0xec, 0xb1, 0xf9, 0xd8, 0xfa, 0x20, 0x86, 0x94, 0x08, 0xb9, 0x45, + 0xe2, 0xe3, 0x00, 0x30, 0x73, 0xb7, 0x80, 0xf7, 0x01, 0xab, 0x35, 0xf6, 0xf6, 0x5e, 0xea, 0x9d, + 0xae, 0xd6, 0xee, 0xec, 0xeb, 0x07, 0xfb, 0xbd, 0x6e, 0x73, 0xa7, 0xdd, 0x6a, 0x37, 0x95, 0x32, + 0x05, 0x1f, 0x02, 0xe1, 0x46, 0xb4, 0xd5, 0x56, 0x7b, 0x9a, 0xde, 0x6d, 0xf4, 0x34, 0x5d, 0xdb, + 0x6d, 0xea, 0xdd, 0x4e, 0x4f, 0x2b, 0xd3, 0xb0, 0x02, 0xee, 0xdd, 0x60, 0x29, 0xcd, 0x86, 0xb2, + 0xd7, 0xde, 0x6f, 0x96, 0x73, 0xeb, 0x85, 0xb7, 0x1f, 0x38, 0x4a, 0x7e, 0x7e, 0xf6, 0x95, 0xa3, + 0xce, 0xa6, 0x1c, 0x7d, 0x31, 0xe5, 0xe8, 0xcb, 0x29, 0x47, 0xbf, 0xbb, 0xe2, 0xa8, 0x8b, 0x2b, + 0x8e, 0xfa, 0x74, 0xc5, 0x51, 0xaf, 0x9e, 0xcc, 0xa9, 0xde, 0x72, 0x06, 0x86, 0x49, 0xa4, 0x2d, + 0xa7, 0x66, 0xf5, 0x0d, 0xd7, 0x97, 0x8e, 0xe7, 0x3e, 0x57, 0xb1, 0x7e, 0xb3, 0x18, 0xdb, 0xf4, + 0xe9, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x82, 0x6d, 0xe2, 0xcd, 0x04, 0x00, 0x00, } func (m *BaseCommittee) Marshal() (dAtA []byte, err error) { diff --git a/x/committee/types/genesis.pb.go b/x/committee/types/genesis.pb.go index 056c0700..d426758a 100644 --- a/x/committee/types/genesis.pb.go +++ b/x/committee/types/genesis.pb.go @@ -199,48 +199,48 @@ func init() { } var fileDescriptor_919b27ac60d8c5fd = []byte{ - // 647 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x54, 0x3f, 0x6f, 0xd3, 0x40, - 0x14, 0xb7, 0x1d, 0x53, 0x92, 0x4b, 0x1a, 0xd2, 0xa3, 0xad, 0xd2, 0x08, 0xd9, 0x55, 0xc5, 0x50, - 0x81, 0x62, 0xab, 0x65, 0x41, 0x15, 0x48, 0xc4, 0x49, 0x00, 0x2f, 0x69, 0x71, 0x42, 0xa5, 0x32, - 0x10, 0x39, 0xf1, 0x61, 0xac, 0x26, 0xbe, 0x28, 0x77, 0x8d, 0x9a, 0x6f, 0xd0, 0xb1, 0x23, 0x23, - 0x12, 0x4c, 0xcc, 0xfd, 0x10, 0x55, 0xa7, 0x8a, 0x89, 0x01, 0xb9, 0xc8, 0xfd, 0x06, 0x8c, 0x4c, - 0xe8, 0xce, 0x7f, 0x12, 0x51, 0x3a, 0xf9, 0xdd, 0x7b, 0xbf, 0xf7, 0xe7, 0xf7, 0x7b, 0x4f, 0x06, - 0x0f, 0x0f, 0xed, 0x89, 0xad, 0xf7, 0xf1, 0x70, 0xe8, 0x51, 0x8a, 0x90, 0x3e, 0xd9, 0xea, 0x21, - 0x6a, 0x6f, 0xe9, 0x2e, 0xf2, 0x11, 0xf1, 0x88, 0x36, 0x1a, 0x63, 0x8a, 0xe1, 0x2a, 0x43, 0x69, - 0x29, 0x4a, 0x8b, 0x51, 0x95, 0xb5, 0x3e, 0x26, 0x43, 0x4c, 0xba, 0x1c, 0xa5, 0x47, 0x8f, 0x28, - 0xa5, 0xb2, 0xec, 0x62, 0x17, 0x47, 0x7e, 0x66, 0xc5, 0xde, 0x35, 0x17, 0x63, 0x77, 0x80, 0x74, - 0xfe, 0xea, 0x1d, 0x7d, 0xd0, 0x6d, 0x7f, 0x1a, 0x87, 0xd4, 0x7f, 0x43, 0xd4, 0x1b, 0x22, 0x42, - 0xed, 0xe1, 0x28, 0x02, 0x6c, 0x7c, 0x95, 0x40, 0xe1, 0x55, 0x34, 0x56, 0x9b, 0xda, 0x14, 0xc1, - 0x67, 0xa0, 0xe4, 0xa3, 0x63, 0xca, 0xba, 0x8f, 0x30, 0xb1, 0x07, 0x5d, 0xcf, 0x29, 0x8b, 0xeb, - 0xe2, 0xa6, 0x6c, 0xc0, 0x30, 0x50, 0x8b, 0x2d, 0x74, 0x4c, 0xf7, 0xe2, 0x90, 0xd9, 0xb0, 0x8a, - 0xfe, 0xfc, 0xdb, 0x81, 0x75, 0x00, 0x52, 0x42, 0xa4, 0x2c, 0xad, 0x67, 0x36, 0xf3, 0xdb, 0xcb, - 0x5a, 0x34, 0x84, 0x96, 0x0c, 0xa1, 0xd5, 0xfc, 0xa9, 0xb1, 0x78, 0x71, 0x56, 0xcd, 0xd5, 0x13, - 0xac, 0x35, 0x97, 0x06, 0xdf, 0x80, 0x5c, 0xd2, 0x9d, 0x94, 0x33, 0xbc, 0xc6, 0xba, 0xf6, 0x7f, - 0xb1, 0xb4, 0xa4, 0xb7, 0xb1, 0x74, 0x1e, 0xa8, 0xc2, 0xb7, 0x2b, 0x35, 0x97, 0x78, 0x88, 0x35, - 0xab, 0x02, 0x9f, 0x82, 0x3b, 0x13, 0x4c, 0x11, 0x29, 0xcb, 0xbc, 0xdc, 0x83, 0xdb, 0xca, 0xed, - 0x63, 0x8a, 0x0c, 0x99, 0x95, 0xb2, 0xa2, 0x84, 0x1d, 0xf9, 0xe4, 0xb3, 0x2a, 0x6c, 0xfc, 0x16, - 0x41, 0x36, 0x29, 0x0c, 0x5b, 0xe0, 0x6e, 0x1f, 0xfb, 0x14, 0xf9, 0x94, 0x2b, 0x73, 0x1b, 0x43, - 0xe5, 0xe2, 0xac, 0x5a, 0x89, 0xd7, 0xe7, 0xe2, 0x49, 0xda, 0xa3, 0x1e, 0xe5, 0x5a, 0x49, 0x11, - 0xb8, 0x0a, 0x24, 0xcf, 0x29, 0x4b, 0x5c, 0xe4, 0x85, 0x30, 0x50, 0x25, 0xb3, 0x61, 0x49, 0x9e, - 0x03, 0xb7, 0x41, 0x21, 0x9d, 0x90, 0xad, 0x21, 0xc3, 0x11, 0xf7, 0xc2, 0x40, 0xcd, 0xa7, 0xc2, - 0x99, 0x0d, 0x2b, 0x9f, 0x82, 0x4c, 0x07, 0xbe, 0x00, 0x59, 0x07, 0xd9, 0xce, 0xc0, 0xf3, 0x51, - 0x59, 0xe6, 0xc3, 0x55, 0x6e, 0x0c, 0xd7, 0x49, 0x6e, 0xc0, 0xc8, 0x32, 0xa6, 0xa7, 0x57, 0xaa, - 0x68, 0xa5, 0x59, 0x3b, 0x59, 0x46, 0xf8, 0x13, 0x23, 0xfd, 0x53, 0x04, 0x32, 0x13, 0x04, 0xea, - 0x20, 0x7f, 0xf3, 0x1c, 0x8a, 0x61, 0xa0, 0x82, 0xb9, 0x53, 0x00, 0xa3, 0xd9, 0x19, 0xbc, 0x8f, - 0xe4, 0x1e, 0x73, 0x52, 0x05, 0xe3, 0xf5, 0x9f, 0x40, 0xad, 0xba, 0x1e, 0xfd, 0x78, 0xd4, 0x63, - 0x9a, 0xc7, 0x37, 0x1d, 0x7f, 0xaa, 0xc4, 0x39, 0xd4, 0xe9, 0x74, 0x84, 0x88, 0x56, 0xeb, 0xf7, - 0x6b, 0x8e, 0x33, 0x46, 0x84, 0x7c, 0x3f, 0xab, 0xde, 0x8f, 0xa5, 0x8b, 0x3d, 0xc6, 0x94, 0x22, - 0x12, 0x2d, 0x65, 0x0c, 0x9f, 0x83, 0x1c, 0x33, 0xba, 0x2c, 0x8d, 0xcb, 0x52, 0xbc, 0xfd, 0x42, - 0x18, 0x83, 0xce, 0x74, 0x84, 0xac, 0xec, 0x24, 0xb6, 0xa2, 0x9d, 0x3e, 0x72, 0x41, 0x36, 0x89, - 0xc1, 0x35, 0xb0, 0xb2, 0xbf, 0xdb, 0x69, 0x76, 0x3b, 0x07, 0x7b, 0xcd, 0xee, 0xdb, 0x56, 0x7b, - 0xaf, 0x59, 0x37, 0x5f, 0x9a, 0xcd, 0x46, 0x49, 0x80, 0x4b, 0x60, 0x71, 0x16, 0x3a, 0x68, 0xb6, - 0x4b, 0x22, 0x2c, 0x81, 0xc2, 0xcc, 0xd5, 0xda, 0x2d, 0x49, 0x70, 0x05, 0x2c, 0xcd, 0x3c, 0x35, - 0xa3, 0xdd, 0xa9, 0x99, 0xad, 0x52, 0xa6, 0x22, 0x9f, 0x7c, 0x51, 0x04, 0xa3, 0x79, 0x1e, 0x2a, - 0xe2, 0x65, 0xa8, 0x88, 0xbf, 0x42, 0x45, 0x3c, 0xbd, 0x56, 0x84, 0xcb, 0x6b, 0x45, 0xf8, 0x71, - 0xad, 0x08, 0xef, 0x1e, 0xcf, 0x89, 0xc2, 0xc6, 0xaf, 0x0e, 0xec, 0x1e, 0xe1, 0x96, 0x7e, 0x3c, - 0xf7, 0xff, 0xe0, 0xea, 0xf4, 0x16, 0xf8, 0x02, 0x9f, 0xfc, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x6a, - 0x30, 0x5b, 0x09, 0x5e, 0x04, 0x00, 0x00, + // 654 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x54, 0xbf, 0x6f, 0xd3, 0x40, + 0x14, 0xb6, 0x1d, 0x53, 0x92, 0x4b, 0x1a, 0xd2, 0xa3, 0xad, 0xd2, 0x08, 0xd9, 0x55, 0xc5, 0x50, + 0x21, 0x62, 0xb7, 0x65, 0x41, 0x15, 0x48, 0xc4, 0x49, 0x0a, 0x5e, 0xd2, 0xe2, 0x84, 0x4a, 0x65, + 0x20, 0x72, 0xe2, 0xc3, 0xb5, 0x9a, 0xf8, 0xa2, 0xdc, 0x35, 0x6a, 0xfe, 0x83, 0x8e, 0x1d, 0x19, + 0x91, 0x60, 0x62, 0xee, 0x1f, 0x51, 0x75, 0xaa, 0x98, 0x18, 0x50, 0x8a, 0xdc, 0xff, 0x80, 0x91, + 0x09, 0xdd, 0xf9, 0x47, 0x22, 0x4a, 0x27, 0xdf, 0xbd, 0xf7, 0xbd, 0xef, 0xde, 0xf7, 0xbd, 0x27, + 0x83, 0xc7, 0x47, 0xf6, 0xc8, 0xd6, 0xbb, 0xb8, 0xdf, 0xf7, 0x28, 0x45, 0x48, 0x1f, 0x6d, 0x76, + 0x10, 0xb5, 0x37, 0x75, 0x17, 0xf9, 0x88, 0x78, 0x44, 0x1b, 0x0c, 0x31, 0xc5, 0x70, 0x99, 0xa1, + 0xb4, 0x04, 0xa5, 0x45, 0xa8, 0xd2, 0x4a, 0x17, 0x93, 0x3e, 0x26, 0x6d, 0x8e, 0xd2, 0xc3, 0x4b, + 0x58, 0x52, 0x5a, 0x74, 0xb1, 0x8b, 0xc3, 0x38, 0x3b, 0x45, 0xd1, 0x15, 0x17, 0x63, 0xb7, 0x87, + 0x74, 0x7e, 0xeb, 0x1c, 0x7f, 0xd4, 0x6d, 0x7f, 0x1c, 0xa5, 0xd4, 0x7f, 0x53, 0xd4, 0xeb, 0x23, + 0x42, 0xed, 0xfe, 0x20, 0x04, 0xac, 0x7d, 0x95, 0x40, 0xee, 0x75, 0xd8, 0x56, 0x93, 0xda, 0x14, + 0xc1, 0x17, 0xa0, 0xe0, 0xa3, 0x13, 0xca, 0x5e, 0x1f, 0x60, 0x62, 0xf7, 0xda, 0x9e, 0x53, 0x14, + 0x57, 0xc5, 0x75, 0xd9, 0x80, 0xc1, 0x44, 0xcd, 0x37, 0xd0, 0x09, 0xdd, 0x8b, 0x52, 0x66, 0xcd, + 0xca, 0xfb, 0xb3, 0x77, 0x07, 0x56, 0x01, 0x48, 0x04, 0x91, 0xa2, 0xb4, 0x9a, 0x5a, 0xcf, 0x6e, + 0x2d, 0x6a, 0x61, 0x13, 0x5a, 0xdc, 0x84, 0x56, 0xf1, 0xc7, 0xc6, 0xfc, 0xe5, 0x79, 0x39, 0x53, + 0x8d, 0xb1, 0xd6, 0x4c, 0x19, 0x7c, 0x0b, 0x32, 0xf1, 0xeb, 0xa4, 0x98, 0xe2, 0x1c, 0xab, 0xda, + 0xff, 0xcd, 0xd2, 0xe2, 0xb7, 0x8d, 0x85, 0x8b, 0x89, 0x2a, 0x7c, 0xbb, 0x56, 0x33, 0x71, 0x84, + 0x58, 0x53, 0x16, 0xf8, 0x1c, 0xdc, 0x1b, 0x61, 0x8a, 0x48, 0x51, 0xe6, 0x74, 0x8f, 0xee, 0xa2, + 0xdb, 0xc7, 0x14, 0x19, 0x32, 0xa3, 0xb2, 0xc2, 0x82, 0x6d, 0xf9, 0xf4, 0xb3, 0x2a, 0xac, 0xfd, + 0x16, 0x41, 0x3a, 0x26, 0x86, 0x0d, 0x70, 0xbf, 0x8b, 0x7d, 0x8a, 0x7c, 0xca, 0x9d, 0xb9, 0x4b, + 0xa1, 0x72, 0x79, 0x5e, 0x2e, 0x45, 0xe3, 0x73, 0xf1, 0x28, 0x79, 0xa3, 0x1a, 0xd6, 0x5a, 0x31, + 0x09, 0x5c, 0x06, 0x92, 0xe7, 0x14, 0x25, 0x6e, 0xf2, 0x5c, 0x30, 0x51, 0x25, 0xb3, 0x66, 0x49, + 0x9e, 0x03, 0xb7, 0x40, 0x2e, 0xe9, 0x90, 0x8d, 0x21, 0xc5, 0x11, 0x0f, 0x82, 0x89, 0x9a, 0x4d, + 0x8c, 0x33, 0x6b, 0x56, 0x36, 0x01, 0x99, 0x0e, 0x7c, 0x05, 0xd2, 0x0e, 0xb2, 0x9d, 0x9e, 0xe7, + 0xa3, 0xa2, 0xcc, 0x9b, 0x2b, 0xdd, 0x6a, 0xae, 0x15, 0xef, 0x80, 0x91, 0x66, 0x4a, 0xcf, 0xae, + 0x55, 0xd1, 0x4a, 0xaa, 0xb6, 0xd3, 0x4c, 0xf0, 0x27, 0x26, 0xfa, 0xa7, 0x08, 0x64, 0x66, 0x08, + 0xd4, 0x41, 0xf6, 0xf6, 0x3a, 0xe4, 0x83, 0x89, 0x0a, 0x66, 0x56, 0x01, 0x0c, 0xa6, 0x6b, 0xf0, + 0x21, 0xb4, 0x7b, 0xc8, 0x45, 0xe5, 0x8c, 0x37, 0x7f, 0x26, 0x6a, 0xd9, 0xf5, 0xe8, 0xe1, 0x71, + 0x87, 0x79, 0x1e, 0xed, 0x74, 0xf4, 0x29, 0x13, 0xe7, 0x48, 0xa7, 0xe3, 0x01, 0x22, 0x5a, 0xa5, + 0xdb, 0xad, 0x38, 0xce, 0x10, 0x11, 0xf2, 0xfd, 0xbc, 0xfc, 0x30, 0xb2, 0x2e, 0x8a, 0x18, 0x63, + 0x8a, 0x48, 0x38, 0x94, 0x21, 0x7c, 0x09, 0x32, 0xec, 0xd0, 0x66, 0x65, 0xdc, 0x96, 0xfc, 0xdd, + 0x1b, 0xc2, 0x14, 0xb4, 0xc6, 0x03, 0x64, 0xa5, 0x47, 0xd1, 0x29, 0x9c, 0xe9, 0x13, 0x17, 0xa4, + 0xe3, 0x1c, 0x5c, 0x01, 0x4b, 0xfb, 0xbb, 0xad, 0x7a, 0xbb, 0x75, 0xb0, 0x57, 0x6f, 0xbf, 0x6b, + 0x34, 0xf7, 0xea, 0x55, 0x73, 0xc7, 0xac, 0xd7, 0x0a, 0x02, 0x5c, 0x00, 0xf3, 0xd3, 0xd4, 0x41, + 0xbd, 0x59, 0x10, 0x61, 0x01, 0xe4, 0xa6, 0xa1, 0xc6, 0x6e, 0x41, 0x82, 0x4b, 0x60, 0x61, 0x1a, + 0xa9, 0x18, 0xcd, 0x56, 0xc5, 0x6c, 0x14, 0x52, 0x25, 0xf9, 0xf4, 0x8b, 0x22, 0x18, 0x3b, 0x17, + 0x81, 0x22, 0x5e, 0x05, 0x8a, 0xf8, 0x2b, 0x50, 0xc4, 0xb3, 0x1b, 0x45, 0xb8, 0xba, 0x51, 0x84, + 0x1f, 0x37, 0x8a, 0xf0, 0xfe, 0xe9, 0x8c, 0x29, 0x1b, 0x6e, 0xcf, 0xee, 0x10, 0x7d, 0xc3, 0x2d, + 0x77, 0x0f, 0x6d, 0xcf, 0xd7, 0x4f, 0x66, 0x7e, 0x20, 0xdc, 0x9e, 0xce, 0x1c, 0x9f, 0xe0, 0xb3, + 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc7, 0xe1, 0x44, 0xe7, 0x5f, 0x04, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/committee/types/permissions.pb.go b/x/committee/types/permissions.pb.go index 6b570947..bb9816e8 100644 --- a/x/committee/types/permissions.pb.go +++ b/x/committee/types/permissions.pb.go @@ -447,39 +447,40 @@ func init() { } var fileDescriptor_bdfaf7be16465ae4 = []byte{ - // 507 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x4f, 0x8b, 0xd3, 0x40, - 0x18, 0x87, 0x1b, 0xb3, 0x88, 0x3b, 0xe2, 0xb2, 0x64, 0x4b, 0xc9, 0x86, 0x35, 0x2d, 0xf5, 0x12, - 0x28, 0x9b, 0x50, 0xc5, 0xcb, 0xde, 0xda, 0xae, 0x78, 0xf1, 0x50, 0xb2, 0x8a, 0xe0, 0x25, 0x4c, - 0x9a, 0x31, 0x0d, 0x3b, 0xc9, 0xc4, 0x79, 0x27, 0xed, 0x16, 0x04, 0xbf, 0x82, 0x5f, 0x43, 0xcf, - 0x7e, 0x88, 0xc5, 0xd3, 0x1e, 0x3d, 0xa9, 0xb4, 0x1f, 0xc3, 0x8b, 0xe4, 0x6f, 0x03, 0x1b, 0x72, - 0x9b, 0x79, 0xf3, 0xfc, 0xde, 0xc9, 0x33, 0x2f, 0x83, 0x8c, 0x6b, 0xbc, 0xc2, 0xd6, 0x82, 0x85, - 0x61, 0x20, 0x04, 0x21, 0xd6, 0x6a, 0xec, 0x12, 0x81, 0xc7, 0x56, 0x4c, 0x78, 0x18, 0x00, 0x04, - 0x2c, 0x02, 0x33, 0xe6, 0x4c, 0x30, 0xa5, 0x97, 0x92, 0x66, 0x45, 0x9a, 0x05, 0xa9, 0x9d, 0x2e, - 0x18, 0x84, 0x0c, 0x9c, 0x8c, 0xb2, 0xf2, 0x4d, 0x1e, 0xd1, 0xba, 0x3e, 0xf3, 0x59, 0x5e, 0x4f, - 0x57, 0x79, 0x75, 0xd8, 0x47, 0x4f, 0x5e, 0x33, 0x6f, 0x5e, 0x1d, 0x70, 0x71, 0xf4, 0xf3, 0xc7, - 0x39, 0xda, 0xef, 0x87, 0x23, 0x74, 0x7a, 0xc5, 0x3e, 0x8a, 0x35, 0xe6, 0xe4, 0x5d, 0xec, 0x73, - 0xec, 0x91, 0x16, 0x78, 0x80, 0x8e, 0xde, 0x92, 0x1b, 0xd1, 0x42, 0x8c, 0x51, 0x7f, 0xc6, 0xc2, - 0x30, 0x89, 0x02, 0xb1, 0x99, 0x5d, 0xce, 0x6d, 0x12, 0xe3, 0xcd, 0x25, 0x71, 0xdb, 0x22, 0x17, - 0xc8, 0xa8, 0x47, 0xde, 0x07, 0x62, 0xe9, 0x71, 0xbc, 0x9e, 0x31, 0x4a, 0xb1, 0x20, 0x1c, 0xd3, - 0x96, 0xec, 0x4b, 0xf4, 0xac, 0xca, 0xce, 0x19, 0xa3, 0x6f, 0x48, 0xe4, 0x95, 0x0d, 0x5a, 0x62, - 0xdf, 0x24, 0xd4, 0x9b, 0x63, 0x8e, 0x43, 0x98, 0x2d, 0x71, 0xe4, 0xd7, 0x94, 0x95, 0x2f, 0xa8, - 0x87, 0x29, 0x65, 0x6b, 0xe2, 0x39, 0x71, 0x46, 0x38, 0x8b, 0x0c, 0x01, 0x55, 0x1a, 0xc8, 0xc6, - 0xe3, 0xe7, 0x23, 0xb3, 0x79, 0x34, 0xe6, 0x24, 0x4f, 0xd5, 0xdb, 0x4e, 0xcf, 0x6e, 0x7f, 0xf7, - 0x3b, 0xdf, 0xff, 0xf4, 0xbb, 0x0d, 0x1f, 0xc1, 0xee, 0xe2, 0x86, 0xea, 0xbd, 0x7f, 0xfd, 0x27, - 0xa1, 0x93, 0x86, 0xb8, 0xa2, 0xa1, 0x47, 0x90, 0xb8, 0x10, 0xe3, 0x05, 0x51, 0xa5, 0x81, 0x64, - 0x1c, 0xda, 0xd5, 0x5e, 0x39, 0x46, 0xf2, 0x35, 0xd9, 0xa8, 0x0f, 0xb2, 0x72, 0xba, 0x54, 0x26, - 0xe8, 0x29, 0x04, 0x91, 0x4f, 0x89, 0x03, 0x89, 0x9b, 0x89, 0x39, 0xa5, 0x26, 0x16, 0x82, 0x83, - 0x2a, 0x0f, 0x64, 0xe3, 0xd0, 0xd6, 0x72, 0xe8, 0xaa, 0x60, 0x8a, 0x73, 0x27, 0x29, 0xa1, 0x00, - 0x3a, 0x0b, 0x13, 0x2a, 0x82, 0xaa, 0x03, 0x38, 0x9c, 0x7c, 0x4a, 0x02, 0x4e, 0x42, 0x12, 0x09, - 0x50, 0x0f, 0xda, 0xef, 0xa7, 0xec, 0x69, 0xef, 0x33, 0xd3, 0x83, 0xf4, 0x7e, 0x6c, 0x2d, 0x6b, - 0x5b, 0x7e, 0x87, 0x1a, 0x00, 0xc3, 0xcf, 0xe8, 0xa4, 0x21, 0x58, 0x0a, 0x4a, 0x7b, 0xc1, 0x63, - 0x24, 0xaf, 0x30, 0x2d, 0x95, 0x57, 0x98, 0xa6, 0xca, 0xa5, 0xe2, 0xde, 0x59, 0x08, 0x5e, 0x0d, - 0xb4, 0x50, 0x2e, 0xa0, 0xca, 0x59, 0x08, 0x5e, 0xcc, 0x62, 0xfa, 0xea, 0x76, 0xab, 0x4b, 0x77, - 0x5b, 0x5d, 0xfa, 0xbb, 0xd5, 0xa5, 0xaf, 0x3b, 0xbd, 0x73, 0xb7, 0xd3, 0x3b, 0xbf, 0x76, 0x7a, - 0xe7, 0xc3, 0xc8, 0x0f, 0xc4, 0x32, 0x71, 0x53, 0x4f, 0x2b, 0x15, 0x3e, 0xa7, 0xd8, 0x85, 0x6c, - 0x65, 0xdd, 0xd4, 0x5e, 0xb8, 0xd8, 0xc4, 0x04, 0xdc, 0x87, 0xd9, 0x5b, 0x7c, 0xf1, 0x3f, 0x00, - 0x00, 0xff, 0xff, 0x64, 0xe8, 0xa8, 0x0a, 0x00, 0x04, 0x00, 0x00, + // 513 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xcf, 0x6e, 0xd3, 0x40, + 0x10, 0x87, 0x63, 0x52, 0x21, 0xba, 0x88, 0xaa, 0x72, 0xa3, 0x28, 0x8d, 0x8a, 0x13, 0x85, 0x4b, + 0xa4, 0xd2, 0xb8, 0x01, 0x71, 0xe9, 0x2d, 0x49, 0x05, 0x17, 0x0e, 0x91, 0x0b, 0x42, 0xe2, 0x62, + 0x8d, 0x93, 0xc5, 0x59, 0x75, 0xed, 0x35, 0x3b, 0xeb, 0xa4, 0x91, 0x90, 0x78, 0x05, 0x5e, 0x03, + 0xce, 0x3c, 0x44, 0xc5, 0xa9, 0x47, 0x4e, 0x80, 0x92, 0xc7, 0xe0, 0x82, 0xfc, 0x37, 0x96, 0xb0, + 0x7c, 0xf3, 0xce, 0x7e, 0xbf, 0x59, 0x7f, 0x3b, 0x5a, 0xd2, 0xbf, 0x86, 0x25, 0x98, 0x33, 0xe1, + 0x79, 0x4c, 0x29, 0x4a, 0xcd, 0xe5, 0xd0, 0xa1, 0x0a, 0x86, 0x66, 0x40, 0xa5, 0xc7, 0x10, 0x99, + 0xf0, 0x71, 0x10, 0x48, 0xa1, 0x84, 0xde, 0x8c, 0xc8, 0x41, 0x4e, 0x0e, 0x52, 0xb2, 0x7d, 0x3c, + 0x13, 0xe8, 0x09, 0xb4, 0x63, 0xca, 0x4c, 0x16, 0x49, 0xa4, 0xdd, 0x70, 0x85, 0x2b, 0x92, 0x7a, + 0xf4, 0x95, 0x54, 0x7b, 0x1d, 0xf2, 0xe8, 0x95, 0x98, 0x4f, 0xf3, 0x03, 0x2e, 0x0e, 0x7e, 0x7c, + 0x3f, 0x23, 0xbb, 0x75, 0xef, 0x94, 0x1c, 0x5f, 0x89, 0x0f, 0x6a, 0x05, 0x92, 0xbe, 0x0d, 0x5c, + 0x09, 0x73, 0x5a, 0x01, 0x77, 0xc9, 0xc1, 0x1b, 0x7a, 0xa3, 0x2a, 0x88, 0x21, 0xe9, 0x4c, 0x84, + 0xe7, 0x85, 0x3e, 0x53, 0xeb, 0xc9, 0xe5, 0xd4, 0xa2, 0x01, 0xac, 0x2f, 0xa9, 0x53, 0x15, 0xb9, + 0x20, 0xfd, 0x62, 0xe4, 0x1d, 0x53, 0x8b, 0xb9, 0x84, 0xd5, 0x44, 0x70, 0x0e, 0x8a, 0x4a, 0xe0, + 0x15, 0xd9, 0x17, 0xe4, 0x49, 0x9e, 0x9d, 0x0a, 0xc1, 0x5f, 0x53, 0x7f, 0x9e, 0x35, 0xa8, 0x88, + 0x7d, 0xd5, 0x48, 0x73, 0x0a, 0x12, 0x3c, 0x9c, 0x2c, 0xc0, 0x77, 0x0b, 0xca, 0xfa, 0x67, 0xd2, + 0x04, 0xce, 0xc5, 0x8a, 0xce, 0xed, 0x20, 0x26, 0xec, 0x59, 0x8c, 0x60, 0x4b, 0xeb, 0xd6, 0xfb, + 0x0f, 0x9f, 0x9d, 0x0e, 0xca, 0x47, 0x33, 0x18, 0x25, 0xa9, 0x62, 0xdb, 0xf1, 0xc9, 0xed, 0xaf, + 0x4e, 0xed, 0xdb, 0xef, 0x4e, 0xa3, 0x64, 0x13, 0xad, 0x06, 0x94, 0x54, 0xff, 0xfb, 0xd7, 0xbf, + 0x1a, 0x39, 0x2a, 0x89, 0xeb, 0x6d, 0xf2, 0x00, 0x43, 0x07, 0x03, 0x98, 0xd1, 0x96, 0xd6, 0xd5, + 0xfa, 0xfb, 0x56, 0xbe, 0xd6, 0x0f, 0x49, 0xfd, 0x9a, 0xae, 0x5b, 0xf7, 0xe2, 0x72, 0xf4, 0xa9, + 0x8f, 0xc8, 0x63, 0x64, 0xbe, 0xcb, 0xa9, 0x8d, 0xa1, 0x13, 0x8b, 0xd9, 0x99, 0x26, 0x28, 0x25, + 0xb1, 0x55, 0xef, 0xd6, 0xfb, 0xfb, 0x56, 0x3b, 0x81, 0xae, 0x52, 0x26, 0x3d, 0x77, 0x14, 0x11, + 0x3a, 0x92, 0x13, 0x2f, 0xe4, 0x8a, 0xe5, 0x1d, 0xd0, 0x96, 0xf4, 0x63, 0xc8, 0x24, 0xf5, 0xa8, + 0xaf, 0xb0, 0xb5, 0x57, 0x7d, 0x3f, 0x59, 0x4f, 0x6b, 0x97, 0x19, 0xef, 0x45, 0xf7, 0x63, 0xb5, + 0xe3, 0xb6, 0xd9, 0x3e, 0x16, 0x00, 0xec, 0x7d, 0x22, 0x47, 0x25, 0xc1, 0x4c, 0x50, 0xdb, 0x09, + 0x1e, 0x92, 0xfa, 0x12, 0x78, 0xa6, 0xbc, 0x04, 0x1e, 0x29, 0x67, 0x8a, 0x3b, 0x67, 0xa5, 0x64, + 0x3e, 0xd0, 0x54, 0x39, 0x85, 0x72, 0x67, 0xa5, 0x64, 0x3a, 0x8b, 0xf1, 0xcb, 0xdb, 0x8d, 0xa1, + 0xdd, 0x6d, 0x0c, 0xed, 0xcf, 0xc6, 0xd0, 0xbe, 0x6c, 0x8d, 0xda, 0xdd, 0xd6, 0xa8, 0xfd, 0xdc, + 0x1a, 0xb5, 0xf7, 0x4f, 0x5d, 0xa6, 0x16, 0xa1, 0x13, 0x79, 0x9a, 0xe7, 0x2e, 0x07, 0x07, 0xcd, + 0x73, 0xf7, 0x6c, 0xb6, 0x00, 0xe6, 0x9b, 0x37, 0x85, 0x27, 0xae, 0xd6, 0x01, 0x45, 0xe7, 0x7e, + 0xfc, 0x18, 0x9f, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x18, 0x3f, 0xff, 0x00, 0x01, 0x04, 0x00, + 0x00, } func (m *GodPermission) Marshal() (dAtA []byte, err error) { diff --git a/x/committee/types/proposal.pb.go b/x/committee/types/proposal.pb.go index a329a925..c01eb1b5 100644 --- a/x/committee/types/proposal.pb.go +++ b/x/committee/types/proposal.pb.go @@ -115,29 +115,30 @@ func init() { } var fileDescriptor_4886de4a6c720e57 = []byte{ - // 348 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xbf, 0x4e, 0x02, 0x41, - 0x10, 0xc6, 0xef, 0xfc, 0x97, 0x70, 0x07, 0x31, 0xb9, 0x10, 0x05, 0x8a, 0x95, 0x90, 0x98, 0x90, - 0x18, 0x76, 0x03, 0x76, 0x76, 0x02, 0x85, 0x74, 0x86, 0xd2, 0x86, 0xec, 0xc1, 0xb8, 0x5c, 0x3c, - 0x76, 0x2e, 0xdc, 0x02, 0xf2, 0x16, 0xbe, 0x84, 0x6f, 0x40, 0xe7, 0x0b, 0x10, 0x2a, 0x4a, 0x2b, - 0xa3, 0xc7, 0x8b, 0x98, 0xfb, 0xc3, 0x86, 0xce, 0xc2, 0x6e, 0xbe, 0x6f, 0xbe, 0xcb, 0xfc, 0x6e, - 0x66, 0xad, 0xeb, 0x17, 0x3e, 0xe7, 0x6c, 0x88, 0x93, 0x89, 0xa7, 0x14, 0x00, 0x9b, 0x37, 0x5d, - 0x50, 0xbc, 0xc9, 0x82, 0x29, 0x06, 0x18, 0x72, 0x9f, 0x06, 0x53, 0x54, 0xe8, 0x5c, 0xc4, 0x31, - 0xaa, 0x63, 0x34, 0x8b, 0x55, 0xca, 0x43, 0x0c, 0x27, 0x18, 0x0e, 0x92, 0x14, 0x4b, 0x45, 0xfa, - 0x49, 0xa5, 0x28, 0x50, 0x60, 0xea, 0xc7, 0x55, 0xe6, 0x96, 0x05, 0xa2, 0xf0, 0x81, 0x25, 0xca, - 0x9d, 0x3d, 0x33, 0x2e, 0x97, 0x69, 0xab, 0xf6, 0x61, 0x5a, 0x97, 0x9d, 0xfd, 0x84, 0xce, 0x98, - 0x4b, 0x01, 0x8f, 0x19, 0x85, 0x53, 0xb4, 0x4e, 0x95, 0xa7, 0x7c, 0x28, 0x99, 0x55, 0xb3, 0x9e, - 0xeb, 0xa7, 0xc2, 0xa9, 0x5a, 0xf6, 0x08, 0xc2, 0xe1, 0xd4, 0x0b, 0x94, 0x87, 0xb2, 0x74, 0x94, - 0xf4, 0x0e, 0x2d, 0xe7, 0xc1, 0x2a, 0x48, 0x58, 0x0c, 0x34, 0x78, 0xe9, 0xb8, 0x6a, 0xd6, 0xed, - 0x56, 0x91, 0xa6, 0x18, 0x74, 0x8f, 0x41, 0xef, 0xe5, 0xb2, 0x5d, 0xd8, 0xac, 0x1a, 0x39, 0x4d, - 0xd0, 0xcf, 0x4b, 0x58, 0x68, 0x75, 0x47, 0x36, 0xab, 0x46, 0x25, 0xfb, 0x41, 0x81, 0xf3, 0xfd, - 0x06, 0x68, 0x07, 0xa5, 0x02, 0xa9, 0x6a, 0xef, 0x87, 0xf4, 0x5d, 0xf0, 0x41, 0xfd, 0x9f, 0xbe, - 0x65, 0xe5, 0x35, 0xf9, 0xc0, 0x1b, 0x25, 0xf0, 0x27, 0xed, 0xf3, 0xe8, 0xeb, 0xca, 0xd6, 0xa3, - 0x7a, 0xdd, 0xbe, 0xad, 0x43, 0xbd, 0xd1, 0x5f, 0x9c, 0xed, 0xde, 0xfa, 0x87, 0x18, 0xeb, 0x88, - 0x98, 0xdb, 0x88, 0x98, 0xdf, 0x11, 0x31, 0xdf, 0x76, 0xc4, 0xd8, 0xee, 0x88, 0xf1, 0xb9, 0x23, - 0xc6, 0xd3, 0x8d, 0xf0, 0xd4, 0x78, 0xe6, 0xc6, 0x97, 0x66, 0xf1, 0xc9, 0x1b, 0x3e, 0x77, 0xc3, - 0xa4, 0x62, 0xaf, 0x07, 0xaf, 0x44, 0x2d, 0x03, 0x08, 0xdd, 0xb3, 0x64, 0x7b, 0xb7, 0xbf, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x58, 0x7f, 0x45, 0x9a, 0x44, 0x02, 0x00, 0x00, + // 353 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xbf, 0x6e, 0xf2, 0x30, + 0x14, 0xc5, 0xe3, 0xef, 0x9f, 0x44, 0x02, 0xfa, 0xa4, 0x08, 0xb5, 0xc0, 0xe0, 0x22, 0xa4, 0x4a, + 0x0c, 0xc5, 0x06, 0xba, 0x75, 0x2b, 0x30, 0x94, 0x4e, 0x15, 0x63, 0x17, 0xe4, 0x04, 0xd7, 0x58, + 0x0d, 0xbe, 0x11, 0x31, 0x50, 0xde, 0xa2, 0x2f, 0xd1, 0x37, 0x60, 0xeb, 0x0b, 0x20, 0x26, 0xc6, + 0x4e, 0x55, 0x1b, 0x5e, 0xa4, 0x22, 0x09, 0x16, 0x5b, 0x87, 0x6e, 0x3e, 0xe7, 0x1e, 0xeb, 0xfe, + 0x7c, 0x7d, 0xed, 0xf3, 0x47, 0x36, 0x67, 0xd4, 0x87, 0xc9, 0x44, 0x6a, 0xcd, 0x39, 0x9d, 0xb7, + 0x3c, 0xae, 0x59, 0x8b, 0x86, 0x53, 0x08, 0x21, 0x62, 0x01, 0x09, 0xa7, 0xa0, 0xc1, 0x3d, 0xd9, + 0xc7, 0x88, 0x89, 0x91, 0x2c, 0x56, 0x29, 0xfb, 0x10, 0x4d, 0x20, 0x1a, 0x26, 0x29, 0x9a, 0x8a, + 0xf4, 0x4a, 0xa5, 0x28, 0x40, 0x40, 0xea, 0xef, 0x4f, 0x99, 0x5b, 0x16, 0x00, 0x22, 0xe0, 0x34, + 0x51, 0xde, 0xec, 0x81, 0x32, 0xb5, 0x4c, 0x4b, 0xb5, 0x57, 0x64, 0x9f, 0x76, 0x0f, 0x1d, 0xba, + 0x63, 0xa6, 0x04, 0xbf, 0xcb, 0x28, 0xdc, 0xa2, 0xfd, 0x57, 0x4b, 0x1d, 0xf0, 0x12, 0xaa, 0xa2, + 0x7a, 0x6e, 0x90, 0x0a, 0xb7, 0x6a, 0x3b, 0x23, 0x1e, 0xf9, 0x53, 0x19, 0x6a, 0x09, 0xaa, 0xf4, + 0x2b, 0xa9, 0x1d, 0x5b, 0xee, 0x8d, 0x5d, 0x50, 0x7c, 0x31, 0x34, 0xe0, 0xa5, 0xdf, 0x55, 0x54, + 0x77, 0xda, 0x45, 0x92, 0x62, 0x90, 0x03, 0x06, 0xb9, 0x56, 0xcb, 0x4e, 0x61, 0xb3, 0x6a, 0xe4, + 0x0c, 0xc1, 0x20, 0xaf, 0xf8, 0xc2, 0xa8, 0x2b, 0xbc, 0x59, 0x35, 0x2a, 0xd9, 0x03, 0x05, 0xcc, + 0x0f, 0x13, 0x20, 0x5d, 0x50, 0x9a, 0x2b, 0x5d, 0x7b, 0x39, 0xa6, 0xef, 0xf1, 0x80, 0xeb, 0x9f, + 0xd3, 0xb7, 0xed, 0xbc, 0x21, 0x1f, 0xca, 0x51, 0x02, 0xff, 0xa7, 0xf3, 0x3f, 0x7e, 0x3f, 0x73, + 0x4c, 0xab, 0x7e, 0x6f, 0xe0, 0x98, 0x50, 0x7f, 0xf4, 0x1d, 0x67, 0xe7, 0x76, 0xfd, 0x89, 0xad, + 0x75, 0x8c, 0xd1, 0x36, 0xc6, 0xe8, 0x23, 0xc6, 0xe8, 0x79, 0x87, 0xad, 0xed, 0x0e, 0x5b, 0x6f, + 0x3b, 0x6c, 0xdd, 0x5f, 0x08, 0xa9, 0xc7, 0x33, 0x6f, 0xff, 0xd3, 0xb4, 0x29, 0x02, 0xe6, 0x45, + 0xb4, 0x29, 0x1a, 0xfe, 0x98, 0x49, 0x45, 0x9f, 0x8e, 0xd6, 0x44, 0x2f, 0x43, 0x1e, 0x79, 0xff, + 0x92, 0xf1, 0x5d, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0xf9, 0x4a, 0x8b, 0xf9, 0x45, 0x02, 0x00, + 0x00, } func (m *CommitteeChangeProposal) Marshal() (dAtA []byte, err error) { diff --git a/x/committee/types/query.pb.go b/x/committee/types/query.pb.go index 335f8d8f..303c6604 100644 --- a/x/committee/types/query.pb.go +++ b/x/committee/types/query.pb.go @@ -762,83 +762,84 @@ func init() { } var fileDescriptor_b81d271efeb6eee5 = []byte{ - // 1211 bytes of a gzipped FileDescriptorProto + // 1217 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x96, 0xc1, 0x6f, 0xe3, 0xc4, 0x17, 0xc7, 0xeb, 0x34, 0xed, 0x26, 0x2f, 0xdb, 0xfe, 0xfa, 0x1b, 0x95, 0x92, 0x86, 0x55, 0xd2, - 0x35, 0xab, 0xa5, 0x5b, 0x88, 0x4d, 0x53, 0x50, 0x05, 0xa2, 0x82, 0x4d, 0xdb, 0x45, 0x11, 0x12, - 0xea, 0x9a, 0xc2, 0x81, 0x95, 0x88, 0x26, 0xf5, 0x6c, 0x6a, 0x35, 0xb1, 0x5d, 0x8f, 0xd3, 0x36, - 0x2a, 0xbd, 0x70, 0x47, 0x5a, 0x09, 0x81, 0xb4, 0x07, 0x24, 0x84, 0x40, 0x42, 0xe2, 0x86, 0xf6, - 0x8f, 0xa8, 0xf6, 0xb4, 0x12, 0x17, 0xc4, 0x21, 0x40, 0xca, 0x1f, 0x82, 0x3c, 0x33, 0x9e, 0xb8, - 0x49, 0xdb, 0xb8, 0x39, 0x25, 0xb6, 0xdf, 0xfb, 0xce, 0x67, 0xde, 0xbc, 0x79, 0xef, 0x81, 0xba, - 0x87, 0x0f, 0xb0, 0xbe, 0xe3, 0x34, 0x9b, 0x96, 0xef, 0x13, 0xa2, 0x1f, 0x2c, 0xd7, 0x88, 0x8f, - 0x97, 0xf5, 0xfd, 0x16, 0xf1, 0xda, 0x9a, 0xeb, 0x39, 0xbe, 0x83, 0xe6, 0x02, 0x1b, 0x4d, 0xda, - 0x68, 0xc2, 0x26, 0xb7, 0xb4, 0xe3, 0xd0, 0xa6, 0x43, 0xf5, 0x1a, 0xa6, 0x84, 0x3b, 0x48, 0x77, - 0x17, 0xd7, 0x2d, 0x1b, 0xfb, 0x96, 0x63, 0x73, 0x8d, 0xdc, 0x3c, 0xb7, 0xad, 0xb2, 0x27, 0x9d, - 0x3f, 0x88, 0x4f, 0xb3, 0x75, 0xa7, 0xee, 0xf0, 0xf7, 0xc1, 0x3f, 0xf1, 0xf6, 0x56, 0xdd, 0x71, - 0xea, 0x0d, 0xa2, 0x63, 0xd7, 0xd2, 0xb1, 0x6d, 0x3b, 0x3e, 0x53, 0x0b, 0x7d, 0xe6, 0xc5, 0x57, - 0xf6, 0x54, 0x6b, 0x3d, 0xd6, 0xb1, 0x2d, 0x68, 0x73, 0x85, 0xfe, 0x4f, 0xbe, 0xd5, 0x24, 0xd4, - 0xc7, 0x4d, 0x57, 0x18, 0xdc, 0xb9, 0x64, 0xcb, 0x75, 0x62, 0x13, 0x6a, 0x89, 0x15, 0xd4, 0x2c, - 0xcc, 0x3d, 0x0c, 0xb6, 0xb4, 0x1e, 0xda, 0x51, 0x83, 0xec, 0xb7, 0x08, 0xf5, 0xd5, 0x2f, 0xe0, - 0xe5, 0x81, 0x2f, 0xd4, 0x75, 0x6c, 0x4a, 0xd0, 0x3a, 0x80, 0xd4, 0xa5, 0x59, 0x65, 0x61, 0x7c, - 0x31, 0x53, 0x9a, 0xd5, 0x38, 0x90, 0x16, 0x02, 0x69, 0xf7, 0xed, 0x76, 0x79, 0xea, 0xf9, 0xb3, - 0x62, 0x5a, 0x2a, 0x18, 0x11, 0x37, 0xf5, 0x5d, 0x78, 0xe9, 0xbc, 0xbe, 0x58, 0x18, 0xdd, 0x86, - 0x9b, 0xd2, 0xac, 0x6a, 0x99, 0x59, 0x65, 0x41, 0x59, 0x4c, 0x1a, 0x19, 0xf9, 0xae, 0x62, 0xaa, - 0x8f, 0xfa, 0xa9, 0x25, 0xda, 0x7d, 0x48, 0x4b, 0x43, 0xe6, 0x19, 0x93, 0xac, 0xe7, 0x25, 0xc1, - 0xb6, 0x3c, 0xc7, 0x75, 0x28, 0x6e, 0xd0, 0x6b, 0x80, 0xed, 0x09, 0xb0, 0x88, 0xaf, 0x00, 0x7b, - 0x08, 0x69, 0x37, 0x7c, 0x29, 0x42, 0x56, 0xd4, 0x2e, 0xce, 0x38, 0xed, 0x9c, 0x44, 0xa8, 0x50, - 0x4e, 0x9e, 0x76, 0x0a, 0x63, 0x46, 0x4f, 0x45, 0x5d, 0x85, 0xd9, 0x3e, 0x4b, 0xce, 0x59, 0x80, - 0x4c, 0x68, 0xd4, 0xc3, 0x84, 0xf0, 0x55, 0xc5, 0x54, 0xbf, 0x4e, 0xf4, 0x6d, 0x51, 0x52, 0x3e, - 0x86, 0x9b, 0x6e, 0xab, 0x56, 0x0d, 0x6d, 0xaf, 0x8c, 0x60, 0xb1, 0xdb, 0x29, 0x64, 0xb6, 0x5a, - 0xb5, 0x50, 0xe4, 0xf9, 0xb3, 0x62, 0x4e, 0x64, 0x7c, 0xdd, 0x39, 0x90, 0x9b, 0x59, 0x77, 0x6c, - 0x9f, 0xd8, 0xbe, 0x91, 0x71, 0x7b, 0xa6, 0x68, 0x0e, 0x12, 0x96, 0x99, 0x4d, 0x04, 0x64, 0xe5, - 0xc9, 0x6e, 0xa7, 0x90, 0xa8, 0x6c, 0x18, 0x09, 0xcb, 0x44, 0xa5, 0xbe, 0x10, 0x8f, 0x33, 0x8b, - 0xff, 0x05, 0x2b, 0xc9, 0xb3, 0xaa, 0x6c, 0x9c, 0x8b, 0x39, 0xfa, 0x00, 0x52, 0x26, 0xc1, 0x66, - 0xc3, 0xb2, 0x49, 0x36, 0xc9, 0x78, 0x73, 0x03, 0xbc, 0xdb, 0xe1, 0xe5, 0x28, 0xa7, 0x82, 0x28, - 0x3e, 0xf9, 0xab, 0xa0, 0x18, 0xd2, 0x4b, 0xbd, 0x05, 0x39, 0x16, 0x8e, 0x8f, 0xc9, 0x91, 0x1f, - 0x22, 0x56, 0x36, 0xc2, 0x8b, 0xf0, 0x08, 0x5e, 0xb9, 0xf0, 0xab, 0x08, 0xd9, 0x7b, 0x30, 0x63, - 0x93, 0x23, 0xbf, 0x3a, 0x10, 0xf2, 0x32, 0xea, 0x76, 0x0a, 0xd3, 0x7d, 0x5e, 0xd3, 0x76, 0xf4, - 0xd9, 0x54, 0xbf, 0x84, 0xff, 0x33, 0xf1, 0xcf, 0x1c, 0x5f, 0x5e, 0xbd, 0xa1, 0x07, 0x88, 0x1e, - 0x00, 0xf4, 0x4a, 0x0f, 0x0b, 0x63, 0xa6, 0x74, 0x57, 0x13, 0xc1, 0x0f, 0xea, 0x94, 0xc6, 0x0b, - 0x5b, 0x78, 0x06, 0x5b, 0xb8, 0x1e, 0x5e, 0x2f, 0x23, 0xe2, 0xa9, 0xfe, 0xa4, 0x00, 0x8a, 0x2e, - 0x2f, 0xb6, 0xb4, 0x09, 0x13, 0x07, 0xc1, 0x0b, 0x91, 0xa7, 0xf7, 0xae, 0xcc, 0xd3, 0xc0, 0xb5, - 0x2f, 0x47, 0xb9, 0x37, 0xfa, 0xf0, 0x02, 0xca, 0xd7, 0x86, 0x52, 0x72, 0xa5, 0x73, 0x98, 0x15, - 0x98, 0x89, 0x2c, 0x15, 0x33, 0x46, 0xb3, 0x7c, 0x13, 0x1e, 0x5b, 0x38, 0xcd, 0x99, 0x3c, 0xf5, - 0xa9, 0x12, 0x09, 0xb8, 0xdc, 0xb0, 0x7e, 0x81, 0x58, 0x79, 0xba, 0xdb, 0x29, 0x40, 0xe4, 0xe8, - 0x86, 0x8a, 0xa3, 0x35, 0x48, 0x07, 0x7f, 0xaa, 0x7e, 0xdb, 0x25, 0x2c, 0x75, 0xa7, 0x4b, 0x0b, - 0x97, 0xc5, 0x2e, 0x58, 0x7f, 0xbb, 0xed, 0x12, 0x23, 0x75, 0x20, 0xfe, 0xa9, 0x6f, 0x09, 0xb4, - 0x6d, 0xdc, 0x68, 0xb4, 0x63, 0x5f, 0xe6, 0x5f, 0x92, 0xe2, 0x0c, 0x85, 0xdb, 0xa8, 0x5b, 0xfa, - 0x08, 0xd2, 0x6d, 0x42, 0xab, 0xfc, 0xe0, 0xd9, 0xb6, 0xca, 0x5a, 0x70, 0x9a, 0x7f, 0x76, 0x0a, - 0x77, 0xeb, 0x96, 0xbf, 0xdb, 0xaa, 0x05, 0xbb, 0x10, 0x3d, 0x4d, 0xfc, 0x14, 0xa9, 0xb9, 0xa7, - 0x07, 0xbb, 0xa5, 0xda, 0x06, 0xd9, 0x31, 0x52, 0x6d, 0x42, 0x59, 0x26, 0xa1, 0x0a, 0xa4, 0x6c, - 0x47, 0x68, 0x8d, 0x8f, 0xa4, 0x75, 0xc3, 0x76, 0xb8, 0xd4, 0x27, 0x30, 0xb5, 0xd3, 0xf2, 0x3c, - 0x62, 0xfb, 0x42, 0x2f, 0x39, 0x92, 0xde, 0x4d, 0x21, 0xc2, 0x45, 0x3f, 0x85, 0x69, 0xd7, 0xa1, - 0xd4, 0xaa, 0x35, 0x88, 0x50, 0x9d, 0x18, 0x49, 0x75, 0x2a, 0x54, 0x91, 0xb2, 0x3c, 0x01, 0x76, - 0x3d, 0x42, 0x77, 0x9d, 0x86, 0x99, 0x9d, 0x1c, 0x4d, 0x96, 0xe5, 0x44, 0x28, 0x82, 0x1e, 0xc0, - 0xe4, 0x7e, 0xcb, 0xf1, 0x5a, 0xcd, 0xec, 0x8d, 0x91, 0xe4, 0x84, 0xb7, 0xba, 0x29, 0xca, 0xbe, - 0x81, 0x0f, 0xb7, 0xb0, 0x87, 0x9b, 0xb2, 0xe0, 0xe4, 0x20, 0x45, 0x5b, 0x35, 0xea, 0xe2, 0x1d, - 0xde, 0x34, 0xd3, 0x86, 0x7c, 0x46, 0x33, 0x30, 0xbe, 0x47, 0xda, 0x22, 0xd1, 0x83, 0xbf, 0xea, - 0x8a, 0x68, 0x72, 0x11, 0x19, 0x91, 0x74, 0xf3, 0x90, 0xf2, 0xf0, 0x61, 0xd5, 0xc4, 0x3e, 0x16, - 0x3a, 0x37, 0x3c, 0x7c, 0xb8, 0x81, 0x7d, 0x5c, 0xfa, 0x2d, 0x03, 0x13, 0xcc, 0x0b, 0x3d, 0x55, - 0x00, 0x7a, 0x43, 0x05, 0xd2, 0xae, 0xac, 0x2e, 0x03, 0x73, 0x49, 0x4e, 0x8f, 0x6d, 0xcf, 0xa1, - 0xd4, 0xa5, 0xaf, 0x7e, 0xff, 0xf7, 0x9b, 0xc4, 0x1d, 0xa4, 0xea, 0x97, 0x4c, 0x44, 0xbd, 0xa1, - 0x04, 0xfd, 0xac, 0x40, 0x6f, 0x28, 0x40, 0xc5, 0x78, 0x4b, 0x85, 0x64, 0x5a, 0x5c, 0x73, 0x01, - 0xf6, 0x0e, 0x03, 0x5b, 0x41, 0xcb, 0xc3, 0xc1, 0xf4, 0xe3, 0x68, 0x5b, 0x3c, 0x41, 0xdf, 0x2a, - 0x90, 0x96, 0x33, 0x06, 0x8a, 0x37, 0x48, 0xd0, 0x78, 0x9c, 0x03, 0xa3, 0x8b, 0x7a, 0x8f, 0x71, - 0xbe, 0x8a, 0x6e, 0x5f, 0xc6, 0x29, 0x47, 0x12, 0xf4, 0x83, 0x02, 0x29, 0xd9, 0xe4, 0xdf, 0x88, - 0x39, 0xdf, 0x70, 0xaa, 0xeb, 0x4d, 0x43, 0xea, 0x2a, 0x83, 0x5a, 0x46, 0xfa, 0x50, 0x28, 0xfd, - 0x38, 0x52, 0x08, 0x4f, 0xd0, 0xaf, 0x0a, 0xf4, 0x35, 0x65, 0x54, 0xba, 0x72, 0xe9, 0x0b, 0xa7, - 0x82, 0xdc, 0xca, 0xb5, 0x7c, 0x04, 0xf4, 0x9b, 0x0c, 0x7a, 0x09, 0x2d, 0x5e, 0x06, 0x1d, 0x4c, - 0x07, 0xc5, 0x10, 0xb7, 0x68, 0x99, 0xe8, 0x7b, 0x05, 0x26, 0x78, 0x6d, 0x19, 0xde, 0x85, 0xe5, - 0x01, 0x2f, 0xc5, 0x31, 0x15, 0x48, 0x6b, 0x0c, 0x69, 0x15, 0xbd, 0x7d, 0xcd, 0x38, 0xea, 0xbc, - 0xc7, 0xff, 0xa8, 0x40, 0x32, 0x10, 0x44, 0x8b, 0x31, 0x86, 0x04, 0x4e, 0x17, 0x7f, 0x9c, 0x50, - 0x37, 0x19, 0xdc, 0xfb, 0x68, 0x6d, 0x24, 0x38, 0xfd, 0x98, 0xb5, 0xe5, 0x13, 0x16, 0x44, 0xd6, - 0x1d, 0x87, 0x04, 0x31, 0xda, 0x78, 0x87, 0x04, 0xf1, 0x5c, 0xb3, 0x1d, 0x3d, 0x88, 0x3e, 0xa3, - 0xfa, 0x4e, 0x81, 0xb4, 0x2c, 0xa6, 0x43, 0x6e, 0x73, 0x7f, 0xed, 0x1e, 0x72, 0x9b, 0x07, 0x6a, - 0xf4, 0xf0, 0x72, 0xe8, 0xe1, 0xc3, 0xa2, 0xcb, 0x7c, 0xca, 0x95, 0xd3, 0x7f, 0xf2, 0x63, 0xa7, - 0xdd, 0xbc, 0xf2, 0xa2, 0x9b, 0x57, 0xfe, 0xee, 0xe6, 0x95, 0x27, 0x67, 0xf9, 0xb1, 0x17, 0x67, - 0xf9, 0xb1, 0x3f, 0xce, 0xf2, 0x63, 0x9f, 0xbf, 0x1e, 0x69, 0x3f, 0x81, 0x56, 0xb1, 0x81, 0x6b, - 0x94, 0xab, 0x1e, 0x45, 0x74, 0x59, 0x1f, 0xaa, 0x4d, 0xb2, 0x59, 0x7c, 0xe5, 0xbf, 0x00, 0x00, - 0x00, 0xff, 0xff, 0xb4, 0xd1, 0x58, 0x0c, 0x8a, 0x0f, 0x00, 0x00, + 0x35, 0xab, 0xa5, 0x5b, 0x6d, 0xec, 0x36, 0x05, 0x55, 0x20, 0x2a, 0xd8, 0xb4, 0x5d, 0x14, 0x90, + 0x50, 0xd7, 0x14, 0x0e, 0xac, 0x44, 0x34, 0x89, 0x67, 0x53, 0xab, 0x89, 0xed, 0x7a, 0x9c, 0xb6, + 0x51, 0xe9, 0x85, 0x3b, 0xd2, 0x4a, 0x08, 0xa4, 0x3d, 0x20, 0x21, 0x04, 0x12, 0x12, 0x37, 0xb4, + 0x7f, 0x44, 0xb5, 0xa7, 0x95, 0xb8, 0x20, 0x0e, 0x01, 0x52, 0xfe, 0x10, 0xe4, 0xf1, 0x78, 0xe2, + 0x26, 0x6d, 0xed, 0xe6, 0x94, 0xd8, 0x7e, 0xef, 0x3b, 0x9f, 0x79, 0xf3, 0xe6, 0xbd, 0x07, 0xf2, + 0x1e, 0x3e, 0xc0, 0x6a, 0xdd, 0x6a, 0xb5, 0x0c, 0xd7, 0x25, 0x44, 0x3d, 0x58, 0xa9, 0x11, 0x17, + 0xaf, 0xa8, 0xfb, 0x6d, 0xe2, 0x74, 0x14, 0xdb, 0xb1, 0x5c, 0x0b, 0xcd, 0x79, 0x36, 0x8a, 0xb0, + 0x51, 0xb8, 0x4d, 0x6e, 0xa9, 0x6e, 0xd1, 0x96, 0x45, 0xd5, 0x1a, 0xa6, 0xc4, 0x77, 0x10, 0xee, + 0x36, 0x6e, 0x18, 0x26, 0x76, 0x0d, 0xcb, 0xf4, 0x35, 0x72, 0xf3, 0xbe, 0x6d, 0x95, 0x3d, 0xa9, + 0xfe, 0x03, 0xff, 0x34, 0xdb, 0xb0, 0x1a, 0x96, 0xff, 0xde, 0xfb, 0xc7, 0xdf, 0xde, 0x6a, 0x58, + 0x56, 0xa3, 0x49, 0x54, 0x6c, 0x1b, 0x2a, 0x36, 0x4d, 0xcb, 0x65, 0x6a, 0x81, 0xcf, 0x3c, 0xff, + 0xca, 0x9e, 0x6a, 0xed, 0x27, 0x2a, 0x36, 0x39, 0x6d, 0xae, 0x30, 0xf8, 0xc9, 0x35, 0x5a, 0x84, + 0xba, 0xb8, 0x65, 0x73, 0x83, 0x3b, 0x97, 0x6c, 0xb9, 0x41, 0x4c, 0x42, 0x0d, 0xbe, 0x82, 0x9c, + 0x85, 0xb9, 0x47, 0xde, 0x96, 0x36, 0x02, 0x3b, 0xaa, 0x91, 0xfd, 0x36, 0xa1, 0xae, 0xfc, 0x05, + 0xbc, 0x3a, 0xf4, 0x85, 0xda, 0x96, 0x49, 0x09, 0xda, 0x00, 0x10, 0xba, 0x34, 0x2b, 0x2d, 0x8c, + 0x2f, 0x66, 0x4a, 0xb3, 0x8a, 0x0f, 0xa4, 0x04, 0x40, 0xca, 0x03, 0xb3, 0x53, 0x9e, 0x7a, 0xf1, + 0xbc, 0x98, 0x16, 0x0a, 0x5a, 0xc8, 0x4d, 0x7e, 0x07, 0x5e, 0x39, 0xaf, 0xcf, 0x17, 0x46, 0xb7, + 0xe1, 0xa6, 0x30, 0xab, 0x1a, 0x7a, 0x56, 0x5a, 0x90, 0x16, 0x93, 0x5a, 0x46, 0xbc, 0xab, 0xe8, + 0xf2, 0xe3, 0x41, 0x6a, 0x81, 0xf6, 0x00, 0xd2, 0xc2, 0x90, 0x79, 0xc6, 0x24, 0xeb, 0x7b, 0x09, + 0xb0, 0x6d, 0xc7, 0xb2, 0x2d, 0x8a, 0x9b, 0xf4, 0x1a, 0x60, 0x7b, 0x1c, 0x2c, 0xe4, 0xcb, 0xc1, + 0x1e, 0x41, 0xda, 0x0e, 0x5e, 0xf2, 0x90, 0x15, 0x95, 0x8b, 0x33, 0x4e, 0x39, 0x27, 0x11, 0x28, + 0x94, 0x93, 0xa7, 0xdd, 0xc2, 0x98, 0xd6, 0x57, 0x91, 0xd7, 0x60, 0x76, 0xc0, 0xd2, 0xe7, 0x2c, + 0x40, 0x26, 0x30, 0xea, 0x63, 0x42, 0xf0, 0xaa, 0xa2, 0xcb, 0x5f, 0x27, 0x06, 0xb6, 0x28, 0x28, + 0x9f, 0xc0, 0x4d, 0xbb, 0x5d, 0xab, 0x06, 0xb6, 0x57, 0x46, 0xb0, 0xd8, 0xeb, 0x16, 0x32, 0xdb, + 0xed, 0x5a, 0x20, 0xf2, 0xe2, 0x79, 0x31, 0xc7, 0x33, 0xbe, 0x61, 0x1d, 0x88, 0xcd, 0x6c, 0x58, + 0xa6, 0x4b, 0x4c, 0x57, 0xcb, 0xd8, 0x7d, 0x53, 0x34, 0x07, 0x09, 0x43, 0xcf, 0x26, 0x3c, 0xb2, + 0xf2, 0x64, 0xaf, 0x5b, 0x48, 0x54, 0x36, 0xb5, 0x84, 0xa1, 0xa3, 0xd2, 0x40, 0x88, 0xc7, 0x99, + 0xc5, 0xff, 0xbc, 0x95, 0xc4, 0x59, 0x55, 0x36, 0xcf, 0xc5, 0x1c, 0xbd, 0x0f, 0x29, 0x9d, 0x60, + 0xbd, 0x69, 0x98, 0x24, 0x9b, 0x64, 0xbc, 0xb9, 0x21, 0xde, 0x9d, 0xe0, 0x72, 0x94, 0x53, 0x5e, + 0x14, 0x9f, 0xfe, 0x55, 0x90, 0x34, 0xe1, 0x25, 0xdf, 0x82, 0x1c, 0x0b, 0xc7, 0xc7, 0xe4, 0xc8, + 0x0d, 0x10, 0x2b, 0x9b, 0xc1, 0x45, 0x78, 0x0c, 0xaf, 0x5d, 0xf8, 0x95, 0x87, 0xec, 0x5d, 0x98, + 0x31, 0xc9, 0x91, 0x5b, 0x1d, 0x0a, 0x79, 0x19, 0xf5, 0xba, 0x85, 0xe9, 0x01, 0xaf, 0x69, 0x33, + 0xfc, 0xac, 0xcb, 0x5f, 0xc2, 0xff, 0x99, 0xf8, 0x67, 0x96, 0x2b, 0xae, 0x5e, 0xe4, 0x01, 0xa2, + 0x87, 0x00, 0xfd, 0xd2, 0xc3, 0xc2, 0x98, 0x29, 0xdd, 0x55, 0x78, 0xf0, 0xbd, 0x3a, 0xa5, 0xf8, + 0x85, 0x2d, 0x38, 0x83, 0x6d, 0xdc, 0x08, 0xae, 0x97, 0x16, 0xf2, 0x94, 0x7f, 0x92, 0x00, 0x85, + 0x97, 0xe7, 0x5b, 0xda, 0x82, 0x89, 0x03, 0xef, 0x05, 0xcf, 0xd3, 0x7b, 0x57, 0xe6, 0xa9, 0xe7, + 0x3a, 0x90, 0xa3, 0xbe, 0x37, 0xfa, 0xe0, 0x02, 0xca, 0x37, 0x22, 0x29, 0x7d, 0xa5, 0x73, 0x98, + 0x15, 0x98, 0x09, 0x2d, 0x15, 0x33, 0x46, 0xb3, 0xfe, 0x26, 0x1c, 0xb6, 0x70, 0xda, 0x67, 0x72, + 0xe4, 0x67, 0x52, 0x28, 0xe0, 0x62, 0xc3, 0xea, 0x05, 0x62, 0xe5, 0xe9, 0x5e, 0xb7, 0x00, 0xa1, + 0xa3, 0x8b, 0x14, 0x47, 0xeb, 0x90, 0xf6, 0xfe, 0x54, 0xdd, 0x8e, 0x4d, 0x58, 0xea, 0x4e, 0x97, + 0x16, 0x2e, 0x8b, 0x9d, 0xb7, 0xfe, 0x4e, 0xc7, 0x26, 0x5a, 0xea, 0x80, 0xff, 0x93, 0xdf, 0xe4, + 0x68, 0x3b, 0xb8, 0xd9, 0xec, 0xc4, 0xbe, 0xcc, 0xbf, 0x24, 0xf9, 0x19, 0x72, 0xb7, 0x51, 0xb7, + 0xf4, 0x11, 0xa4, 0x3b, 0x84, 0x56, 0xfd, 0x83, 0x67, 0xdb, 0x2a, 0x2b, 0xde, 0x69, 0xfe, 0xd9, + 0x2d, 0xdc, 0x6d, 0x18, 0xee, 0x6e, 0xbb, 0xe6, 0xed, 0x82, 0xf7, 0x34, 0xfe, 0x53, 0xa4, 0xfa, + 0x9e, 0xea, 0xed, 0x96, 0x2a, 0x9b, 0xa4, 0xae, 0xa5, 0x3a, 0x84, 0xb2, 0x4c, 0x42, 0x15, 0x48, + 0x99, 0x16, 0xd7, 0x1a, 0x1f, 0x49, 0xeb, 0x86, 0x69, 0xf9, 0x52, 0x9f, 0xc0, 0x54, 0xbd, 0xed, + 0x38, 0xc4, 0x74, 0xb9, 0x5e, 0x72, 0x24, 0xbd, 0x9b, 0x5c, 0xc4, 0x17, 0xfd, 0x14, 0xa6, 0x6d, + 0x8b, 0x52, 0xa3, 0xd6, 0x24, 0x5c, 0x75, 0x62, 0x24, 0xd5, 0xa9, 0x40, 0x45, 0xc8, 0xfa, 0x09, + 0xb0, 0xeb, 0x10, 0xba, 0x6b, 0x35, 0xf5, 0xec, 0xe4, 0x68, 0xb2, 0x2c, 0x27, 0x02, 0x11, 0xf4, + 0x10, 0x26, 0xf7, 0xdb, 0x96, 0xd3, 0x6e, 0x65, 0x6f, 0x8c, 0x24, 0xc7, 0xbd, 0xe5, 0x2d, 0x5e, + 0xf6, 0x35, 0x7c, 0xb8, 0x8d, 0x1d, 0xdc, 0x12, 0x05, 0x27, 0x07, 0x29, 0xda, 0xae, 0x51, 0x1b, + 0xd7, 0xfd, 0xa6, 0x99, 0xd6, 0xc4, 0x33, 0x9a, 0x81, 0xf1, 0x3d, 0xd2, 0xe1, 0x89, 0xee, 0xfd, + 0x95, 0x57, 0x79, 0x93, 0x0b, 0xc9, 0xf0, 0xa4, 0x9b, 0x87, 0x94, 0x83, 0x0f, 0xab, 0x3a, 0x76, + 0x31, 0xd7, 0xb9, 0xe1, 0xe0, 0xc3, 0x4d, 0xec, 0xe2, 0xd2, 0x6f, 0x19, 0x98, 0x60, 0x5e, 0xe8, + 0x99, 0x04, 0xd0, 0x1f, 0x2a, 0x90, 0x72, 0x65, 0x75, 0x19, 0x9a, 0x4b, 0x72, 0x6a, 0x6c, 0x7b, + 0x1f, 0x4a, 0x5e, 0xfa, 0xea, 0xf7, 0x7f, 0xbf, 0x49, 0xdc, 0x41, 0xb2, 0x7a, 0xc9, 0x44, 0xd4, + 0x1f, 0x4a, 0xd0, 0xcf, 0x12, 0xf4, 0x87, 0x02, 0x54, 0x8c, 0xb7, 0x54, 0x40, 0xa6, 0xc4, 0x35, + 0xe7, 0x60, 0x6f, 0x33, 0xb0, 0x55, 0xb4, 0x12, 0x0d, 0xa6, 0x1e, 0x87, 0xdb, 0xe2, 0x09, 0xfa, + 0x56, 0x82, 0xb4, 0x98, 0x31, 0x50, 0xbc, 0x41, 0x82, 0xc6, 0xe3, 0x1c, 0x1a, 0x5d, 0xe4, 0x7b, + 0x8c, 0xf3, 0x75, 0x74, 0xfb, 0x32, 0x4e, 0x31, 0x92, 0xa0, 0x1f, 0x24, 0x48, 0x89, 0x26, 0x7f, + 0x3f, 0xe6, 0x7c, 0xe3, 0x53, 0x5d, 0x6f, 0x1a, 0x92, 0xd7, 0x18, 0xd4, 0x0a, 0x52, 0x23, 0xa1, + 0xd4, 0xe3, 0x50, 0x21, 0x3c, 0x41, 0xbf, 0x4a, 0x30, 0xd0, 0x94, 0x51, 0xe9, 0xca, 0xa5, 0x2f, + 0x9c, 0x0a, 0x72, 0xab, 0xd7, 0xf2, 0xe1, 0xd0, 0xcb, 0x0c, 0x7a, 0x09, 0x2d, 0x5e, 0x06, 0xed, + 0x4d, 0x07, 0xc5, 0x00, 0xb7, 0x68, 0xe8, 0xe8, 0x7b, 0x09, 0x26, 0xfc, 0xda, 0x12, 0xdd, 0x85, + 0xc5, 0x01, 0x2f, 0xc5, 0x31, 0xe5, 0x48, 0xeb, 0x0c, 0x69, 0x0d, 0xbd, 0x75, 0xcd, 0x38, 0xaa, + 0x7e, 0x8f, 0xff, 0x51, 0x82, 0xa4, 0x27, 0x88, 0x16, 0x63, 0x0c, 0x09, 0x3e, 0x5d, 0xfc, 0x71, + 0x42, 0xde, 0x62, 0x70, 0xef, 0xa1, 0xf5, 0x91, 0xe0, 0xd4, 0x63, 0xd6, 0x96, 0x4f, 0x58, 0x10, + 0x59, 0x77, 0x8c, 0x08, 0x62, 0xb8, 0xf1, 0x46, 0x04, 0xf1, 0x5c, 0xb3, 0x1d, 0x3d, 0x88, 0x2e, + 0xa3, 0xfa, 0x4e, 0x82, 0xb4, 0x28, 0xa6, 0x11, 0xb7, 0x79, 0xb0, 0x76, 0x47, 0xdc, 0xe6, 0xa1, + 0x1a, 0x1d, 0x5d, 0x0e, 0x1d, 0x7c, 0x58, 0xb4, 0x99, 0x4f, 0xf9, 0xc3, 0xd3, 0x7f, 0xf2, 0x63, + 0xa7, 0xbd, 0xbc, 0xf4, 0xb2, 0x97, 0x97, 0xfe, 0xee, 0xe5, 0xa5, 0xa7, 0x67, 0xf9, 0xb1, 0x97, + 0x67, 0xf9, 0xb1, 0x3f, 0xce, 0xf2, 0x63, 0x9f, 0xdf, 0x0f, 0xb5, 0x9f, 0xe5, 0x46, 0x13, 0xd7, + 0xa8, 0xba, 0xdc, 0x28, 0xd6, 0x77, 0xb1, 0x61, 0xaa, 0x47, 0x21, 0x61, 0xd6, 0x88, 0x6a, 0x93, + 0x6c, 0x18, 0x5f, 0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x04, 0xf9, 0xa1, 0x50, 0x8b, 0x0f, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/committee/types/tx.pb.go b/x/committee/types/tx.pb.go index 7a3570e3..cf2b65e5 100644 --- a/x/committee/types/tx.pb.go +++ b/x/committee/types/tx.pb.go @@ -195,36 +195,36 @@ func init() { func init() { proto.RegisterFile("kava/committee/v1beta1/tx.proto", fileDescriptor_3f3857845b071606) } var fileDescriptor_3f3857845b071606 = []byte{ - // 455 bytes of a gzipped FileDescriptorProto + // 461 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcf, 0x6e, 0xd3, 0x40, 0x10, 0xc6, 0xb3, 0xb4, 0x40, 0x3b, 0xae, 0x52, 0xd5, 0x8a, 0x50, 0xe2, 0x83, 0x13, 0x45, 0x48, - 0x04, 0xa1, 0xee, 0x2a, 0xe1, 0xcc, 0x81, 0xb4, 0x17, 0x4b, 0x44, 0xaa, 0x0c, 0x02, 0x89, 0x4b, - 0x64, 0x37, 0xcb, 0x62, 0x91, 0x78, 0xac, 0xec, 0xda, 0xaa, 0x9f, 0x02, 0x1e, 0x86, 0x23, 0x77, - 0x2a, 0x4e, 0x3d, 0x72, 0xaa, 0xc0, 0x79, 0x11, 0xb4, 0xb6, 0xd7, 0x42, 0x94, 0xf0, 0xe7, 0x36, - 0x33, 0xfe, 0xcd, 0x37, 0xdf, 0x8c, 0x17, 0xfa, 0xef, 0x82, 0x2c, 0x60, 0xe7, 0xb8, 0x5a, 0x45, - 0x4a, 0x71, 0xce, 0xb2, 0x71, 0xc8, 0x55, 0x30, 0x66, 0xea, 0x82, 0x26, 0x6b, 0x54, 0x68, 0xdf, - 0xd3, 0x00, 0x6d, 0x00, 0x5a, 0x03, 0x4e, 0xef, 0x1c, 0xe5, 0x0a, 0xe5, 0xbc, 0xa4, 0x58, 0x95, - 0x54, 0x2d, 0x4e, 0x47, 0xa0, 0xc0, 0xaa, 0xae, 0xa3, 0xba, 0xda, 0x13, 0x88, 0x62, 0xc9, 0x59, - 0x99, 0x85, 0xe9, 0x1b, 0x16, 0xc4, 0x79, 0xfd, 0xe9, 0xfe, 0x16, 0x13, 0x82, 0xc7, 0x5c, 0x46, - 0xb5, 0xec, 0xf0, 0x13, 0x81, 0xa3, 0x99, 0x14, 0xcf, 0xd3, 0x70, 0x15, 0xa9, 0xb3, 0x35, 0x26, - 0x28, 0x83, 0xa5, 0xfd, 0x0a, 0x0e, 0x92, 0x34, 0xd4, 0x36, 0xca, 0xbc, 0x4b, 0x06, 0x64, 0x64, - 0x4d, 0x3a, 0xb4, 0x9a, 0x46, 0xcd, 0x34, 0xfa, 0x34, 0xce, 0xa7, 0xee, 0x97, 0x8f, 0xc7, 0x4e, - 0x6d, 0x55, 0x60, 0x66, 0x76, 0xa1, 0x27, 0x18, 0x2b, 0x1e, 0x2b, 0xdf, 0x4a, 0xd2, 0xb0, 0x11, - 0x76, 0x60, 0xaf, 0x12, 0xe5, 0xeb, 0xee, 0xad, 0x01, 0x19, 0xed, 0xfb, 0x4d, 0x6e, 0x4f, 0xe0, - 0xa0, 0x71, 0x3b, 0x8f, 0x16, 0xdd, 0x9d, 0x01, 0x19, 0xed, 0x4e, 0x0f, 0x8b, 0xeb, 0xbe, 0x75, - 0x62, 0xea, 0xde, 0xa9, 0x6f, 0x35, 0x90, 0xb7, 0x18, 0x3e, 0x83, 0xde, 0x0d, 0xf7, 0x3e, 0x97, - 0x09, 0xc6, 0x92, 0xdb, 0x0c, 0x2c, 0xb3, 0x81, 0xd6, 0x23, 0xa5, 0x5e, 0xbb, 0xb8, 0xee, 0x83, - 0x41, 0xbd, 0x53, 0x1f, 0x0c, 0xe2, 0x2d, 0x86, 0xef, 0x09, 0xdc, 0x9d, 0x49, 0xf1, 0x12, 0xd5, - 0xff, 0x37, 0xdb, 0x1d, 0xb8, 0x9d, 0xa1, 0x6a, 0xf6, 0xaa, 0x12, 0xfb, 0x09, 0xec, 0xeb, 0x60, - 0xae, 0xf2, 0x84, 0x97, 0x1b, 0xb5, 0x27, 0x03, 0xfa, 0xfb, 0xbf, 0x4f, 0xf5, 0xdc, 0x17, 0x79, - 0xc2, 0xfd, 0xbd, 0xac, 0x8e, 0x86, 0x47, 0x70, 0x58, 0x1b, 0x32, 0x5b, 0x4d, 0x3e, 0x13, 0xd8, - 0x99, 0x49, 0x61, 0xc7, 0xd0, 0xfe, 0xe5, 0xaf, 0x3d, 0xdc, 0x26, 0x7c, 0xe3, 0x44, 0xce, 0xf8, - 0x9f, 0xd1, 0xe6, 0x9a, 0x67, 0xb0, 0x5b, 0x1e, 0xa6, 0xff, 0x87, 0x56, 0x0d, 0x38, 0x0f, 0xfe, - 0x02, 0x18, 0xc5, 0xa9, 0x77, 0xf9, 0xdd, 0x6d, 0x5d, 0x16, 0x2e, 0xb9, 0x2a, 0x5c, 0xf2, 0xad, - 0x70, 0xc9, 0x87, 0x8d, 0xdb, 0xba, 0xda, 0xb8, 0xad, 0xaf, 0x1b, 0xb7, 0xf5, 0xfa, 0x91, 0x88, - 0xd4, 0xdb, 0x34, 0xd4, 0x3a, 0x4c, 0x0b, 0x1e, 0x2f, 0x83, 0x50, 0x96, 0x11, 0xbb, 0xf8, 0xe9, - 0x59, 0xeb, 0xc3, 0xca, 0xf0, 0x4e, 0xf9, 0x24, 0x1f, 0xff, 0x08, 0x00, 0x00, 0xff, 0xff, 0xe5, - 0x91, 0xbf, 0x3d, 0x7a, 0x03, 0x00, 0x00, + 0x04, 0x89, 0xee, 0x36, 0xe1, 0xcc, 0x81, 0xb4, 0x97, 0x20, 0x22, 0x55, 0x06, 0x81, 0xc4, 0x25, + 0xb2, 0x93, 0x65, 0x6b, 0x91, 0x78, 0xac, 0xec, 0xda, 0xaa, 0x9f, 0x02, 0x1e, 0x86, 0x23, 0x77, + 0x2a, 0x4e, 0x3d, 0x72, 0xaa, 0xc0, 0x79, 0x11, 0xb4, 0xb6, 0xd7, 0x42, 0x94, 0xf2, 0xe7, 0x36, + 0x33, 0xfe, 0xcd, 0x37, 0xdf, 0x8c, 0x17, 0xba, 0xef, 0xfc, 0xd4, 0x67, 0x73, 0x5c, 0xad, 0x42, + 0xa5, 0x38, 0x67, 0xe9, 0x30, 0xe0, 0xca, 0x1f, 0x32, 0x75, 0x4e, 0xe3, 0x35, 0x2a, 0xb4, 0xef, + 0x69, 0x80, 0xd6, 0x00, 0xad, 0x00, 0xa7, 0x33, 0x47, 0xb9, 0x42, 0x39, 0x2b, 0x28, 0x56, 0x26, + 0x65, 0x8b, 0xd3, 0x12, 0x28, 0xb0, 0xac, 0xeb, 0xa8, 0xaa, 0x76, 0x04, 0xa2, 0x58, 0x72, 0x56, + 0x64, 0x41, 0xf2, 0x96, 0xf9, 0x51, 0x56, 0x7d, 0xba, 0x7f, 0x83, 0x09, 0xc1, 0x23, 0x2e, 0xc3, + 0x4a, 0xb6, 0xff, 0x89, 0xc0, 0xc1, 0x54, 0x8a, 0x17, 0x49, 0xb0, 0x0a, 0xd5, 0xe9, 0x1a, 0x63, + 0x94, 0xfe, 0xd2, 0x7e, 0x0d, 0x7b, 0x71, 0x12, 0x68, 0x1b, 0x45, 0xde, 0x26, 0x3d, 0x32, 0xb0, + 0x46, 0x2d, 0x5a, 0x4e, 0xa3, 0x66, 0x1a, 0x7d, 0x1a, 0x65, 0x63, 0xf7, 0xcb, 0xc7, 0x43, 0xa7, + 0xb2, 0x2a, 0x30, 0x35, 0xbb, 0xd0, 0x63, 0x8c, 0x14, 0x8f, 0x94, 0x67, 0xc5, 0x49, 0x50, 0x0b, + 0x3b, 0xb0, 0x53, 0x8a, 0xf2, 0x75, 0xfb, 0x56, 0x8f, 0x0c, 0x76, 0xbd, 0x3a, 0xb7, 0x47, 0xb0, + 0x57, 0xbb, 0x9d, 0x85, 0x8b, 0xf6, 0x56, 0x8f, 0x0c, 0xb6, 0xc7, 0xfb, 0xf9, 0x55, 0xd7, 0x3a, + 0x36, 0xf5, 0xc9, 0x89, 0x67, 0xd5, 0xd0, 0x64, 0xd1, 0x7f, 0x0e, 0x9d, 0x6b, 0xee, 0x3d, 0x2e, + 0x63, 0x8c, 0x24, 0xb7, 0x19, 0x58, 0x66, 0x03, 0xad, 0x47, 0x0a, 0xbd, 0x66, 0x7e, 0xd5, 0x05, + 0x83, 0x4e, 0x4e, 0x3c, 0x30, 0xc8, 0x64, 0xd1, 0x7f, 0x4f, 0xe0, 0xee, 0x54, 0x8a, 0x57, 0xa8, + 0xfe, 0xbf, 0xd9, 0x6e, 0xc1, 0xed, 0x14, 0x55, 0xbd, 0x57, 0x99, 0xd8, 0x4f, 0x60, 0x57, 0x07, + 0x33, 0x95, 0xc5, 0xbc, 0xd8, 0xa8, 0x39, 0xea, 0xd1, 0xdf, 0xff, 0x7d, 0xaa, 0xe7, 0xbe, 0xcc, + 0x62, 0xee, 0xed, 0xa4, 0x55, 0xd4, 0x3f, 0x80, 0xfd, 0xca, 0x90, 0xd9, 0x6a, 0xf4, 0x99, 0xc0, + 0xd6, 0x54, 0x0a, 0x3b, 0x82, 0xe6, 0x2f, 0x7f, 0xed, 0xe1, 0x4d, 0xc2, 0xd7, 0x4e, 0xe4, 0x0c, + 0xff, 0x19, 0xad, 0xaf, 0x79, 0x0a, 0xdb, 0xc5, 0x61, 0xba, 0x7f, 0x68, 0xd5, 0x80, 0xf3, 0xe0, + 0x2f, 0x80, 0x51, 0x1c, 0x3f, 0xbb, 0xf8, 0xee, 0x36, 0x2e, 0x72, 0x97, 0x5c, 0xe6, 0x2e, 0xf9, + 0x96, 0xbb, 0xe4, 0xc3, 0xc6, 0x6d, 0x5c, 0x6e, 0xdc, 0xc6, 0xd7, 0x8d, 0xdb, 0x78, 0xf3, 0x48, + 0x84, 0xea, 0x2c, 0x09, 0xb4, 0x0e, 0x3b, 0x12, 0x4b, 0x3f, 0x90, 0xec, 0x48, 0x1c, 0xce, 0xcf, + 0xfc, 0x30, 0x62, 0xe7, 0x3f, 0xbd, 0x6b, 0x7d, 0x59, 0x19, 0xdc, 0x29, 0xde, 0xe4, 0xe3, 0x1f, + 0x01, 0x00, 0x00, 0xff, 0xff, 0x26, 0x7f, 0xfc, 0x4c, 0x7b, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/community/types/genesis.pb.go b/x/community/types/genesis.pb.go index 7f4674c0..8931aee8 100644 --- a/x/community/types/genesis.pb.go +++ b/x/community/types/genesis.pb.go @@ -88,7 +88,7 @@ func init() { } var fileDescriptor_ccf84d82ea3861e0 = []byte{ - // 255 bytes of a gzipped FileDescriptorProto + // 261 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xc9, 0x4e, 0x2c, 0x4b, 0xd4, 0x4f, 0xce, 0xcf, 0xcd, 0x2d, 0xcd, 0xcb, 0x2c, 0xa9, 0xd4, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, @@ -100,11 +100,12 @@ var fileDescriptor_ccf84d82ea3861e0 = []byte{ 0x60, 0x55, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x41, 0xf5, 0x08, 0xa5, 0x72, 0x89, 0x42, 0xcd, 0x8f, 0x2f, 0x4a, 0x2d, 0x4f, 0x2c, 0x4a, 0x29, 0x8e, 0x2f, 0x06, 0x19, 0x2b, 0xc1, 0x04, 0x36, 0x4c, 0x1b, 0x97, 0x61, 0xc1, 0x10, 0x4d, 0x41, 0x10, 0x3d, 0x60, 0x97, 0x40, 0x4d, 0x16, - 0x2e, 0xc6, 0x22, 0xe5, 0x7a, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, - 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0xda, - 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x20, 0x2b, 0xf4, 0x41, 0x76, 0xe9, 0xe6, 0x24, 0x26, 0x15, - 0x83, 0x59, 0xfa, 0x15, 0x48, 0x81, 0x51, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x0e, 0x03, - 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc5, 0x84, 0x31, 0x9f, 0xa4, 0x01, 0x00, 0x00, + 0x2e, 0xc6, 0x22, 0xe5, 0x76, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, + 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0x3a, + 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x20, 0x2b, 0xf4, 0x0d, 0xd2, 0x73, 0x12, 0x93, 0x8a, 0xf5, + 0x0d, 0xd2, 0x75, 0x93, 0x33, 0x12, 0x33, 0xf3, 0xf4, 0x2b, 0x90, 0x42, 0xa3, 0xa4, 0xb2, 0x20, + 0xb5, 0x38, 0x89, 0x0d, 0x1c, 0x08, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x10, 0xbe, 0x7c, + 0x73, 0xa5, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/community/types/params.pb.go b/x/community/types/params.pb.go index d84bf309..437eba26 100644 --- a/x/community/types/params.pb.go +++ b/x/community/types/params.pb.go @@ -90,32 +90,32 @@ func init() { } var fileDescriptor_0a48475520900507 = []byte{ - // 386 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0x41, 0x4b, 0xe3, 0x40, - 0x14, 0x80, 0x33, 0xdd, 0xa5, 0xec, 0x66, 0x6f, 0x61, 0xd9, 0xad, 0x29, 0x24, 0x45, 0x11, 0x0a, - 0xa5, 0x33, 0x54, 0x6f, 0x1e, 0x4b, 0x3d, 0x08, 0x1e, 0x4a, 0xeb, 0xc9, 0xcb, 0x30, 0x49, 0xa6, - 0xd3, 0xa1, 0x49, 0x26, 0x64, 0x26, 0xd5, 0xfe, 0x08, 0xa1, 0x3f, 0xc1, 0x1f, 0xe1, 0x8f, 0xe8, - 0xb1, 0x78, 0x12, 0x0f, 0x55, 0xda, 0x8b, 0x7f, 0xc1, 0x9b, 0x24, 0x93, 0x4a, 0x05, 0xf1, 0xe0, - 0xed, 0xbd, 0x97, 0x2f, 0xdf, 0xbc, 0x37, 0xf3, 0xcc, 0x83, 0x09, 0x99, 0x12, 0xe4, 0x8b, 0x28, - 0xca, 0x62, 0xae, 0x66, 0x68, 0xda, 0xf1, 0xa8, 0x22, 0x1d, 0x94, 0x90, 0x94, 0x44, 0x12, 0x26, - 0xa9, 0x50, 0xc2, 0xfa, 0x97, 0x43, 0xf0, 0x1d, 0x82, 0x25, 0x64, 0xef, 0xf9, 0x42, 0x46, 0x42, - 0xe2, 0x82, 0x42, 0x3a, 0xd1, 0xbf, 0xd8, 0x7f, 0x99, 0x60, 0x42, 0xd7, 0xf3, 0xa8, 0xac, 0xba, - 0x4c, 0x08, 0x16, 0x52, 0x54, 0x64, 0x5e, 0x36, 0x42, 0x8a, 0x47, 0x54, 0x2a, 0x12, 0x25, 0x1a, - 0xd8, 0x7f, 0xad, 0x98, 0xd5, 0x7e, 0x71, 0xb4, 0xc5, 0x4d, 0x27, 0x4b, 0x58, 0x4a, 0x02, 0x8a, - 0x73, 0x0a, 0x07, 0x5c, 0x12, 0x2f, 0xa4, 0x98, 0xc7, 0xa3, 0x90, 0x28, 0x2e, 0xe2, 0x1a, 0x68, - 0x80, 0xe6, 0x9f, 0x23, 0x1b, 0x6a, 0x29, 0xdc, 0x4a, 0xe1, 0xc5, 0x56, 0xda, 0xfd, 0xb5, 0x58, - 0xb9, 0xc6, 0xfc, 0xc9, 0x05, 0x83, 0x7a, 0xe9, 0xca, 0xbf, 0xf5, 0xb4, 0xe9, 0x6c, 0x2b, 0xb2, - 0x62, 0xd3, 0x96, 0x8a, 0x4c, 0x78, 0xcc, 0x70, 0x4a, 0xaf, 0x48, 0x1a, 0x48, 0x9c, 0xd0, 0x14, - 0x4b, 0xea, 0x8b, 0x38, 0xa8, 0x55, 0x1a, 0xa0, 0xf9, 0xbb, 0xdb, 0xc9, 0x55, 0x8f, 0x2b, 0xb7, - 0xae, 0xc7, 0x94, 0xc1, 0x04, 0x72, 0x81, 0x22, 0xa2, 0xc6, 0xf0, 0x9c, 0x32, 0xe2, 0xcf, 0x7a, - 0xd4, 0xbf, 0xbf, 0x6b, 0x9b, 0xe5, 0x2d, 0xf4, 0xa8, 0x3f, 0xf8, 0x5f, 0x4a, 0x07, 0xda, 0xd9, - 0xa7, 0xe9, 0xb0, 0x30, 0x5a, 0x37, 0xc0, 0x6c, 0x7d, 0x98, 0x4d, 0x52, 0x85, 0xbf, 0xe8, 0xe0, - 0xc7, 0x77, 0x3b, 0x38, 0xdc, 0x99, 0x7a, 0x48, 0xd5, 0xf0, 0xf3, 0x7e, 0x4e, 0x7e, 0xbe, 0xdc, - 0xba, 0xa0, 0x7b, 0xba, 0x58, 0x3b, 0x60, 0xb9, 0x76, 0xc0, 0xf3, 0xda, 0x01, 0xf3, 0x8d, 0x63, - 0x2c, 0x37, 0x8e, 0xf1, 0xb0, 0x71, 0x8c, 0xcb, 0x16, 0xe3, 0x6a, 0x9c, 0x79, 0xf9, 0x06, 0xa0, - 0x7c, 0x15, 0xda, 0x21, 0xf1, 0x64, 0x11, 0xa1, 0xeb, 0x9d, 0xdd, 0x51, 0xb3, 0x84, 0x4a, 0xaf, - 0x5a, 0xbc, 0xc3, 0xf1, 0x5b, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x03, 0x78, 0xe5, 0x5a, 0x02, - 0x00, 0x00, + // 390 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0xb1, 0x6a, 0xe3, 0x30, + 0x18, 0x80, 0xad, 0xdc, 0x11, 0xee, 0x7c, 0x9b, 0x39, 0xee, 0x72, 0x0e, 0xd8, 0xe1, 0x8e, 0x83, + 0x40, 0x1b, 0x29, 0x69, 0xb7, 0x8e, 0x21, 0x14, 0x0a, 0x1d, 0x42, 0xd2, 0xa9, 0x8b, 0x90, 0x6d, + 0x45, 0x11, 0xb1, 0x2d, 0x63, 0xc9, 0x69, 0xf3, 0x10, 0x85, 0x3c, 0x42, 0x1f, 0xa2, 0x0f, 0x91, + 0x31, 0x74, 0x2a, 0x1d, 0xd2, 0x92, 0x2c, 0x7d, 0x85, 0x6e, 0xc5, 0x96, 0x53, 0x52, 0x28, 0x1d, + 0xba, 0xe9, 0xff, 0xf5, 0xe9, 0xd3, 0xff, 0x4b, 0xbf, 0xf9, 0x6f, 0x42, 0xa6, 0x04, 0xf9, 0x22, + 0x8a, 0xb2, 0x98, 0xab, 0x19, 0x9a, 0x76, 0x3c, 0xaa, 0x48, 0x07, 0x25, 0x24, 0x25, 0x91, 0x84, + 0x49, 0x2a, 0x94, 0xb0, 0x7e, 0xe5, 0x10, 0x7c, 0x85, 0x60, 0x09, 0xd9, 0x7f, 0x7c, 0x21, 0x23, + 0x21, 0x71, 0x41, 0x21, 0x1d, 0xe8, 0x23, 0xf6, 0x4f, 0x26, 0x98, 0xd0, 0xf9, 0x7c, 0x55, 0x66, + 0x5d, 0x26, 0x04, 0x0b, 0x29, 0x2a, 0x22, 0x2f, 0x1b, 0x21, 0xc5, 0x23, 0x2a, 0x15, 0x89, 0x12, + 0x0d, 0xfc, 0x7d, 0xae, 0x98, 0xd5, 0x7e, 0x71, 0xb5, 0xc5, 0x4d, 0x27, 0x4b, 0x58, 0x4a, 0x02, + 0x8a, 0x73, 0x0a, 0x07, 0x5c, 0x12, 0x2f, 0xa4, 0x98, 0xc7, 0xa3, 0x90, 0x28, 0x2e, 0xe2, 0x1a, + 0x68, 0x80, 0xe6, 0x8f, 0x03, 0x1b, 0x6a, 0x29, 0xdc, 0x4a, 0xe1, 0xd9, 0x56, 0xda, 0xfd, 0xb6, + 0x58, 0xb9, 0xc6, 0xfc, 0xc1, 0x05, 0x83, 0x7a, 0xe9, 0xca, 0xf7, 0x7a, 0xda, 0x74, 0xb2, 0x15, + 0x59, 0xb1, 0x69, 0x4b, 0x45, 0x26, 0x3c, 0x66, 0x38, 0xa5, 0x17, 0x24, 0x0d, 0x24, 0x4e, 0x68, + 0x8a, 0x25, 0xf5, 0x45, 0x1c, 0xd4, 0x2a, 0x0d, 0xd0, 0xfc, 0xde, 0xed, 0xe4, 0xaa, 0xfb, 0x95, + 0x5b, 0xd7, 0x6d, 0xca, 0x60, 0x02, 0xb9, 0x40, 0x11, 0x51, 0x63, 0x78, 0x4a, 0x19, 0xf1, 0x67, + 0x3d, 0xea, 0xdf, 0xde, 0xb4, 0xcc, 0xf2, 0x15, 0x7a, 0xd4, 0x1f, 0xfc, 0x2e, 0xa5, 0x03, 0xed, + 0xec, 0xd3, 0x74, 0x58, 0x18, 0xad, 0x2b, 0x60, 0xee, 0xbd, 0xe9, 0x4d, 0x52, 0x85, 0x3f, 0xa8, + 0xe0, 0xcb, 0x67, 0x2b, 0xf8, 0xbf, 0xd3, 0xf5, 0x90, 0xaa, 0xe1, 0xfb, 0xf5, 0x1c, 0x7d, 0x7d, + 0xba, 0x76, 0x41, 0xf7, 0x78, 0xb1, 0x76, 0xc0, 0x72, 0xed, 0x80, 0xc7, 0xb5, 0x03, 0xe6, 0x1b, + 0xc7, 0x58, 0x6e, 0x1c, 0xe3, 0x6e, 0xe3, 0x18, 0xe7, 0xfb, 0x8c, 0xab, 0x71, 0xe6, 0xe5, 0x13, + 0x80, 0xda, 0x2c, 0x24, 0x9e, 0x44, 0x6d, 0xd6, 0xf2, 0xc7, 0x84, 0xc7, 0xe8, 0x72, 0x67, 0x78, + 0xd4, 0x2c, 0xa1, 0xd2, 0xab, 0x16, 0x1f, 0x71, 0xf8, 0x12, 0x00, 0x00, 0xff, 0xff, 0x68, 0x69, + 0x63, 0xfc, 0x5b, 0x02, 0x00, 0x00, } func (this *Params) Equal(that interface{}) bool { diff --git a/x/community/types/proposal.pb.go b/x/community/types/proposal.pb.go index 81c9f67d..b1b289ad 100644 --- a/x/community/types/proposal.pb.go +++ b/x/community/types/proposal.pb.go @@ -199,34 +199,34 @@ func init() { } var fileDescriptor_64aa83b2ed448ec1 = []byte{ - // 419 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x93, 0x3f, 0x0b, 0xd3, 0x40, - 0x18, 0xc6, 0x73, 0xb6, 0x56, 0xbd, 0x82, 0x42, 0x28, 0x12, 0x0b, 0x26, 0xb1, 0xa0, 0x16, 0xa4, - 0x39, 0xab, 0x93, 0x2e, 0x42, 0x53, 0x37, 0x87, 0x12, 0x04, 0xc1, 0x45, 0x2e, 0xc9, 0xd1, 0x1e, - 0x4d, 0xf2, 0x1e, 0xb9, 0x6b, 0x35, 0xdf, 0xc0, 0xd1, 0xd1, 0xb1, 0xb3, 0xdf, 0x43, 0xa8, 0x4e, - 0x1d, 0x1c, 0x9c, 0x54, 0xda, 0x2f, 0x22, 0xf9, 0xdb, 0x80, 0x20, 0x82, 0x20, 0x38, 0xe5, 0xcd, - 0x7b, 0xcf, 0x7b, 0xf7, 0xfc, 0x78, 0x78, 0xf1, 0xed, 0x35, 0xdd, 0x52, 0x12, 0x40, 0x1c, 0x6f, - 0x12, 0xae, 0x32, 0xb2, 0x9d, 0xfa, 0x4c, 0xd1, 0x29, 0x11, 0x29, 0x08, 0x90, 0x34, 0x72, 0x44, - 0x0a, 0x0a, 0xf4, 0xeb, 0xb9, 0xcc, 0x69, 0x64, 0x4e, 0x25, 0x1b, 0x9a, 0x01, 0xc8, 0x18, 0x24, - 0xf1, 0xa9, 0x64, 0xcd, 0x6c, 0x00, 0x3c, 0x29, 0xe7, 0x86, 0x83, 0x25, 0x2c, 0xa1, 0x28, 0x49, - 0x5e, 0x95, 0xdd, 0xd1, 0x27, 0x84, 0x6d, 0xb7, 0xbe, 0x6b, 0x01, 0x10, 0x3d, 0x63, 0x49, 0x38, - 0x67, 0x02, 0x24, 0x57, 0x8b, 0xea, 0x61, 0x7d, 0x80, 0x2f, 0x2a, 0xae, 0x22, 0x66, 0x20, 0x1b, - 0x8d, 0xaf, 0x78, 0xe5, 0x8f, 0x6e, 0xe3, 0x7e, 0xc8, 0x64, 0x90, 0x72, 0xa1, 0x38, 0x24, 0xc6, - 0x85, 0xe2, 0xac, 0xdd, 0xd2, 0x03, 0xdc, 0xa3, 0x31, 0x6c, 0x12, 0x65, 0x74, 0xec, 0xce, 0xb8, - 0xff, 0xe0, 0x86, 0x53, 0x7a, 0x74, 0x72, 0x8f, 0xb5, 0x71, 0xc7, 0x05, 0x9e, 0xcc, 0xee, 0xef, - 0xbf, 0x59, 0xda, 0x87, 0xef, 0xd6, 0x78, 0xc9, 0xd5, 0x6a, 0xe3, 0xe7, 0x7c, 0xa4, 0x02, 0x2a, - 0x3f, 0x13, 0x19, 0xae, 0x89, 0xca, 0x04, 0x93, 0xc5, 0x80, 0xf4, 0xaa, 0xab, 0x1f, 0x5f, 0x7e, - 0xbb, 0xb3, 0xb4, 0xf7, 0x3b, 0x4b, 0x1b, 0x7d, 0x46, 0xf8, 0xd6, 0x2f, 0x2c, 0x2f, 0xb8, 0x5a, - 0x85, 0x29, 0x7d, 0xfd, 0xbf, 0xc1, 0x7c, 0x44, 0xf8, 0x66, 0x03, 0xe3, 0xce, 0x17, 0x1e, 0x13, - 0x34, 0x9b, 0x33, 0xff, 0xef, 0x53, 0xb9, 0x8b, 0xaf, 0x05, 0x10, 0x45, 0x54, 0xb1, 0x94, 0x46, - 0xaf, 0x72, 0x17, 0x46, 0xa7, 0x50, 0x5d, 0x3d, 0xb7, 0x9f, 0x67, 0x82, 0xe9, 0x8f, 0xf0, 0x25, - 0x41, 0xb3, 0x98, 0x25, 0xca, 0xe8, 0xda, 0xe8, 0xf7, 0xc8, 0xdd, 0x1c, 0xd9, 0xab, 0xf5, 0x2d, - 0x8e, 0x2f, 0x08, 0xdf, 0x69, 0x73, 0xd4, 0x79, 0xb8, 0xcd, 0x5b, 0xff, 0x0e, 0xe8, 0x09, 0xc6, - 0xe7, 0xce, 0x9f, 0x32, 0xb5, 0x46, 0xce, 0x58, 0xb3, 0xa7, 0xfb, 0xa3, 0x89, 0x0e, 0x47, 0x13, - 0xfd, 0x38, 0x9a, 0xe8, 0xdd, 0xc9, 0xd4, 0x0e, 0x27, 0x53, 0xfb, 0x7a, 0x32, 0xb5, 0x97, 0xf7, - 0x5a, 0xa1, 0xe7, 0xab, 0x3a, 0x89, 0xa8, 0x2f, 0x8b, 0x8a, 0xbc, 0x69, 0x6d, 0x77, 0x91, 0xbe, - 0xdf, 0x2b, 0xb6, 0xf0, 0xe1, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xef, 0x58, 0xb9, 0x21, 0xfc, - 0x03, 0x00, 0x00, + // 426 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x93, 0x4f, 0x8b, 0xd3, 0x40, + 0x18, 0xc6, 0x33, 0x76, 0x5d, 0x75, 0x16, 0x14, 0xc2, 0x22, 0x71, 0xc1, 0x24, 0x2e, 0xa8, 0x3d, + 0xb8, 0x99, 0xae, 0x9e, 0xf4, 0x22, 0x34, 0xc5, 0x93, 0x87, 0x12, 0x04, 0xc1, 0x8b, 0x4c, 0x92, + 0x21, 0x1d, 0x9a, 0xcc, 0x3b, 0x64, 0xa6, 0xd5, 0x7c, 0x03, 0x8f, 0x1e, 0x3d, 0xf6, 0xec, 0xf7, + 0x10, 0xaa, 0xa7, 0x1e, 0x3c, 0x78, 0x52, 0x69, 0xbf, 0x88, 0xe4, 0x6f, 0x03, 0x82, 0x08, 0x82, + 0xb0, 0xa7, 0x4c, 0xde, 0x79, 0x9e, 0x99, 0xe7, 0xc7, 0xc3, 0xe0, 0xbb, 0x73, 0xba, 0xa4, 0x24, + 0x82, 0x2c, 0x5b, 0x08, 0xae, 0x0b, 0xb2, 0x3c, 0x0f, 0x99, 0xa6, 0xe7, 0x44, 0xe6, 0x20, 0x41, + 0xd1, 0xd4, 0x93, 0x39, 0x68, 0x30, 0x6f, 0x96, 0x32, 0xaf, 0x93, 0x79, 0x8d, 0xec, 0xc4, 0x8e, + 0x40, 0x65, 0xa0, 0x48, 0x48, 0x15, 0xeb, 0xbc, 0x11, 0x70, 0x51, 0xfb, 0x4e, 0x8e, 0x13, 0x48, + 0xa0, 0x5a, 0x92, 0x72, 0x55, 0x4f, 0x4f, 0x3f, 0x23, 0xec, 0xfa, 0xed, 0x59, 0x53, 0x80, 0xf4, + 0x39, 0x13, 0xf1, 0x84, 0x49, 0x50, 0x5c, 0x4f, 0x9b, 0x8b, 0xcd, 0x63, 0x7c, 0x59, 0x73, 0x9d, + 0x32, 0x0b, 0xb9, 0x68, 0x78, 0x2d, 0xa8, 0x7f, 0x4c, 0x17, 0x1f, 0xc5, 0x4c, 0x45, 0x39, 0x97, + 0x9a, 0x83, 0xb0, 0x2e, 0x55, 0x7b, 0xfd, 0x91, 0x19, 0xe1, 0x43, 0x9a, 0xc1, 0x42, 0x68, 0x6b, + 0xe0, 0x0e, 0x86, 0x47, 0x0f, 0x6f, 0x79, 0x75, 0x46, 0xaf, 0xcc, 0xd8, 0x06, 0xf7, 0x7c, 0xe0, + 0x62, 0x3c, 0x5a, 0x7f, 0x77, 0x8c, 0x8f, 0x3f, 0x9c, 0x61, 0xc2, 0xf5, 0x6c, 0x11, 0x96, 0x7c, + 0xa4, 0x01, 0xaa, 0x3f, 0x67, 0x2a, 0x9e, 0x13, 0x5d, 0x48, 0xa6, 0x2a, 0x83, 0x0a, 0x9a, 0xa3, + 0x9f, 0x5c, 0x7d, 0xb7, 0x72, 0x8c, 0x0f, 0x2b, 0xc7, 0x38, 0xfd, 0x82, 0xf0, 0x9d, 0xdf, 0x58, + 0x5e, 0x72, 0x3d, 0x8b, 0x73, 0xfa, 0xe6, 0xa2, 0xc1, 0x7c, 0x42, 0xf8, 0x76, 0x07, 0xe3, 0x4f, + 0xa6, 0x01, 0x93, 0xb4, 0x98, 0xb0, 0xf0, 0xdf, 0x5b, 0xb9, 0x8f, 0x6f, 0x44, 0x90, 0xa6, 0x54, + 0xb3, 0x9c, 0xa6, 0xaf, 0xcb, 0x14, 0xd6, 0xa0, 0x52, 0x5d, 0xdf, 0x8f, 0x5f, 0x14, 0x92, 0x99, + 0x8f, 0xf1, 0x15, 0x49, 0x8b, 0x8c, 0x09, 0x6d, 0x1d, 0xb8, 0xe8, 0xcf, 0xc8, 0x07, 0x25, 0x72, + 0xd0, 0xea, 0x7b, 0x1c, 0x5f, 0x11, 0xbe, 0xd7, 0xe7, 0x68, 0xfb, 0xf0, 0xbb, 0xbb, 0xfe, 0x1f, + 0xd0, 0x53, 0x8c, 0xf7, 0x93, 0xbf, 0x65, 0xea, 0x59, 0xf6, 0x58, 0xe3, 0x67, 0xeb, 0xad, 0x8d, + 0x36, 0x5b, 0x1b, 0xfd, 0xdc, 0xda, 0xe8, 0xfd, 0xce, 0x36, 0x36, 0x3b, 0xdb, 0xf8, 0xb6, 0xb3, + 0x8d, 0x57, 0x0f, 0x7a, 0xa5, 0x8f, 0x92, 0x94, 0x86, 0x8a, 0x8c, 0x92, 0xb3, 0x68, 0x46, 0xb9, + 0x20, 0x6f, 0x7b, 0xcf, 0xbb, 0xaa, 0x3f, 0x3c, 0xac, 0x9e, 0xe1, 0xa3, 0x5f, 0x01, 0x00, 0x00, + 0xff, 0xff, 0x1a, 0xff, 0x79, 0xa8, 0xfd, 0x03, 0x00, 0x00, } func (m *CommunityPoolLendDepositProposal) Marshal() (dAtA []byte, err error) { diff --git a/x/community/types/query.pb.go b/x/community/types/query.pb.go index c1451fd4..8c798579 100644 --- a/x/community/types/query.pb.go +++ b/x/community/types/query.pb.go @@ -374,45 +374,46 @@ func init() { } var fileDescriptor_f236f06c43149273 = []byte{ - // 606 bytes of a gzipped FileDescriptorProto + // 612 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x94, 0x31, 0x6f, 0xd3, 0x40, - 0x14, 0xc7, 0x63, 0x68, 0x8b, 0xb8, 0x22, 0x10, 0x47, 0x40, 0x8d, 0x29, 0x4e, 0x31, 0x82, 0x46, - 0x6d, 0x63, 0x37, 0xa9, 0x60, 0x62, 0x21, 0x84, 0x8d, 0x01, 0x0c, 0x53, 0x97, 0xe8, 0xec, 0x9c, - 0x5c, 0x2b, 0x8e, 0xcf, 0xcd, 0x5d, 0x0a, 0x41, 0x2c, 0x74, 0x63, 0x40, 0x42, 0xe2, 0x1b, 0x30, - 0x32, 0x23, 0x3e, 0x43, 0xc7, 0x0a, 0x16, 0xc4, 0x50, 0x50, 0xc2, 0x07, 0x41, 0x77, 0xf7, 0x12, - 0x25, 0x34, 0x8e, 0xd2, 0x29, 0xf1, 0xbb, 0xf7, 0x7f, 0xff, 0xdf, 0xbd, 0xf7, 0x6c, 0x64, 0xb7, - 0xc8, 0x01, 0x71, 0x03, 0xd6, 0x6e, 0x77, 0x93, 0x48, 0xf4, 0xdc, 0x83, 0x8a, 0x4f, 0x05, 0xa9, - 0xb8, 0xfb, 0x5d, 0xda, 0xe9, 0x39, 0x69, 0x87, 0x09, 0x86, 0x6f, 0xc8, 0x1c, 0x67, 0x94, 0xe3, - 0x40, 0x8e, 0x69, 0x05, 0x8c, 0xb7, 0x19, 0x77, 0x7d, 0xc2, 0xe9, 0x48, 0x18, 0xb0, 0x28, 0xd1, - 0x3a, 0xb3, 0xa0, 0xcf, 0x1b, 0xea, 0xc9, 0xd5, 0x0f, 0x70, 0x94, 0x0f, 0x59, 0xc8, 0x74, 0x5c, - 0xfe, 0x83, 0xe8, 0x6a, 0xc8, 0x58, 0x18, 0x53, 0x97, 0xa4, 0x91, 0x4b, 0x92, 0x84, 0x09, 0x22, - 0x22, 0x96, 0x0c, 0x35, 0x77, 0x32, 0x50, 0x53, 0xd2, 0x21, 0x6d, 0x48, 0xb2, 0xf3, 0x08, 0x3f, - 0x97, 0xe8, 0xcf, 0x54, 0xd0, 0xa3, 0xfb, 0x5d, 0xca, 0x85, 0xfd, 0x02, 0x5d, 0x9b, 0x88, 0xf2, - 0x94, 0x25, 0x9c, 0xe2, 0x87, 0x68, 0x49, 0x8b, 0x57, 0x8c, 0x35, 0xa3, 0xb4, 0x5c, 0xb5, 0x9c, - 0xe9, 0x37, 0x75, 0xb4, 0xae, 0xb6, 0x70, 0x74, 0x52, 0xcc, 0x79, 0xa0, 0xb1, 0xaf, 0x43, 0xd1, - 0x1a, 0x89, 0x49, 0x12, 0xd0, 0xa1, 0x57, 0x0f, 0xe5, 0x27, 0xc3, 0x60, 0x46, 0xd0, 0xa2, 0xec, - 0x8d, 0xf4, 0x3a, 0x5f, 0x5a, 0xae, 0x16, 0x1c, 0x68, 0x88, 0xec, 0xde, 0xc8, 0xe8, 0x31, 0x8b, - 0x92, 0xda, 0xb6, 0xb4, 0xf9, 0xf2, 0xbb, 0x58, 0x0a, 0x23, 0xb1, 0xd7, 0xf5, 0x25, 0x0f, 0x74, - 0x0f, 0x7e, 0xca, 0xbc, 0xd9, 0x72, 0x45, 0x2f, 0xa5, 0x5c, 0x09, 0xb8, 0xa7, 0x2b, 0xdb, 0x26, - 0x5a, 0x51, 0xd6, 0x2f, 0x99, 0x20, 0xf1, 0x7f, 0x58, 0x87, 0x06, 0x2a, 0x4c, 0x39, 0x04, 0x38, - 0x8a, 0x16, 0x52, 0xc6, 0x62, 0x60, 0x5b, 0x9d, 0xca, 0x56, 0xa7, 0x81, 0xc2, 0xdb, 0x01, 0xbc, - 0xcd, 0x39, 0xf0, 0x40, 0xc3, 0x3d, 0x55, 0xde, 0x2e, 0xa2, 0x5b, 0x8a, 0xe1, 0x51, 0x92, 0x74, - 0x49, 0x1c, 0xbd, 0xa1, 0x4d, 0x8f, 0xbe, 0x22, 0x9d, 0xe6, 0x68, 0x50, 0x6f, 0x91, 0x95, 0x95, - 0x00, 0xa4, 0xbb, 0xe8, 0x0a, 0x17, 0xa4, 0x15, 0x25, 0x61, 0xa3, 0xa3, 0x8f, 0xd4, 0xf0, 0x2e, - 0xd6, 0x2a, 0x12, 0xeb, 0xd7, 0x49, 0xf1, 0xa6, 0x86, 0xe0, 0xcd, 0x96, 0x13, 0x31, 0xb7, 0x4d, - 0xc4, 0x9e, 0xf3, 0x94, 0x86, 0x24, 0xe8, 0xd5, 0x69, 0xf0, 0xfd, 0x6b, 0x19, 0xc1, 0xd5, 0xea, - 0x34, 0xf0, 0x2e, 0x43, 0x25, 0xf0, 0xa8, 0xbe, 0x5b, 0x44, 0x8b, 0xca, 0x1e, 0xbf, 0x37, 0xd0, - 0x92, 0x1e, 0x3a, 0xde, 0xc8, 0x5a, 0x8a, 0xd3, 0x7b, 0x66, 0x6e, 0xce, 0x95, 0xab, 0x6f, 0x62, - 0xdf, 0x3b, 0xfc, 0xf1, 0xf7, 0xd3, 0xb9, 0x35, 0x6c, 0xb9, 0x33, 0x17, 0x1b, 0x7f, 0x30, 0xd0, - 0x05, 0x98, 0x17, 0x9e, 0x6d, 0x30, 0x39, 0x72, 0x73, 0x6b, 0xbe, 0x64, 0xc0, 0x59, 0x57, 0x38, - 0xb7, 0x71, 0x31, 0x0b, 0xc7, 0x07, 0x86, 0xcf, 0x06, 0xba, 0x34, 0xbe, 0x44, 0x78, 0x7b, 0xa6, - 0xcf, 0x94, 0x65, 0x34, 0x2b, 0x67, 0x50, 0x00, 0x5e, 0x59, 0xe1, 0xad, 0xe3, 0xbb, 0x59, 0x78, - 0x42, 0xaa, 0x1a, 0x43, 0xc8, 0x6f, 0x06, 0xba, 0x7a, 0x6a, 0x89, 0xf0, 0xfd, 0x99, 0xbe, 0x59, - 0x5b, 0x69, 0x3e, 0x38, 0xab, 0x0c, 0x98, 0xab, 0x8a, 0x79, 0x0b, 0x6f, 0x64, 0x31, 0x93, 0x91, - 0x74, 0xb8, 0xcc, 0xb5, 0x27, 0x47, 0x7d, 0xcb, 0x38, 0xee, 0x5b, 0xc6, 0x9f, 0xbe, 0x65, 0x7c, - 0x1c, 0x58, 0xb9, 0xe3, 0x81, 0x95, 0xfb, 0x39, 0xb0, 0x72, 0xbb, 0xe3, 0xef, 0x9b, 0xac, 0x57, - 0x8e, 0x89, 0xcf, 0x75, 0xe5, 0xd7, 0x63, 0xb5, 0xd5, 0x8b, 0xe7, 0x2f, 0xa9, 0xcf, 0xe1, 0xce, - 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2e, 0xb3, 0x12, 0x9f, 0xe0, 0x05, 0x00, 0x00, + 0x14, 0xc7, 0x63, 0x68, 0x8b, 0xb8, 0x22, 0x10, 0x47, 0x41, 0xad, 0x29, 0x4e, 0x31, 0x82, 0x56, + 0x6d, 0xe2, 0x4b, 0x52, 0xc1, 0xc4, 0x42, 0x88, 0x98, 0x18, 0xc0, 0x30, 0x75, 0x89, 0xce, 0xce, + 0xc9, 0xb1, 0xe2, 0xdc, 0xb9, 0xb9, 0x4b, 0x21, 0x88, 0x85, 0x6e, 0x0c, 0x48, 0x48, 0x7c, 0x03, + 0x46, 0x66, 0xc4, 0x67, 0xe8, 0x58, 0xc1, 0x82, 0x18, 0x0a, 0x4a, 0xf8, 0x20, 0xc8, 0xe7, 0x97, + 0x28, 0xa1, 0x71, 0x94, 0x4e, 0x89, 0xdf, 0xbd, 0xff, 0xfb, 0xff, 0xee, 0xbd, 0x67, 0x23, 0xbb, + 0x45, 0x0f, 0x28, 0xf1, 0x45, 0xbb, 0xdd, 0xe5, 0xa1, 0xea, 0x91, 0x83, 0xb2, 0xc7, 0x14, 0x2d, + 0x93, 0xfd, 0x2e, 0xeb, 0xf4, 0x9c, 0xb8, 0x23, 0x94, 0xc0, 0x37, 0x92, 0x1c, 0x67, 0x94, 0xe3, + 0x40, 0x8e, 0x69, 0xf9, 0x42, 0xb6, 0x85, 0x24, 0x1e, 0x95, 0x6c, 0x24, 0xf4, 0x45, 0xc8, 0x53, + 0x9d, 0xb9, 0x96, 0x9e, 0xd7, 0xf5, 0x13, 0x49, 0x1f, 0xe0, 0x68, 0x25, 0x10, 0x81, 0x48, 0xe3, + 0xc9, 0x3f, 0x88, 0xae, 0x07, 0x42, 0x04, 0x11, 0x23, 0x34, 0x0e, 0x09, 0xe5, 0x5c, 0x28, 0xaa, + 0x42, 0xc1, 0x87, 0x9a, 0x3b, 0x19, 0xa8, 0x31, 0xed, 0xd0, 0x36, 0x24, 0xd9, 0x2b, 0x08, 0x3f, + 0x4f, 0xd0, 0x9f, 0xe9, 0xa0, 0xcb, 0xf6, 0xbb, 0x4c, 0x2a, 0xfb, 0x05, 0xba, 0x36, 0x11, 0x95, + 0xb1, 0xe0, 0x92, 0xe1, 0x87, 0x68, 0x29, 0x15, 0xaf, 0x1a, 0x1b, 0xc6, 0xd6, 0x72, 0xc5, 0x72, + 0xa6, 0xdf, 0xd4, 0x49, 0x75, 0xd5, 0x85, 0xa3, 0x93, 0x7c, 0xce, 0x05, 0x8d, 0x7d, 0x1d, 0x8a, + 0x56, 0x69, 0x44, 0xb9, 0xcf, 0x86, 0x5e, 0x3d, 0xb4, 0x32, 0x19, 0x06, 0x33, 0x8a, 0x16, 0x93, + 0xde, 0x24, 0x5e, 0xe7, 0xb7, 0x96, 0x2b, 0x6b, 0x0e, 0x34, 0x24, 0xe9, 0xde, 0xc8, 0xe8, 0xb1, + 0x08, 0x79, 0xb5, 0x94, 0xd8, 0x7c, 0xf9, 0x9d, 0xdf, 0x0a, 0x42, 0xd5, 0xec, 0x7a, 0x09, 0x0f, + 0x74, 0x0f, 0x7e, 0x8a, 0xb2, 0xd1, 0x22, 0xaa, 0x17, 0x33, 0xa9, 0x05, 0xd2, 0x4d, 0x2b, 0xdb, + 0x26, 0x5a, 0xd5, 0xd6, 0x2f, 0x85, 0xa2, 0xd1, 0x7f, 0x58, 0x87, 0x06, 0x5a, 0x9b, 0x72, 0x08, + 0x70, 0x0c, 0x2d, 0xc4, 0x42, 0x44, 0xc0, 0xb6, 0x3e, 0x95, 0xad, 0xc6, 0x7c, 0x8d, 0xb7, 0x0b, + 0x78, 0x3b, 0x73, 0xe0, 0x81, 0x46, 0xba, 0xba, 0xbc, 0x9d, 0x47, 0xb7, 0x34, 0xc3, 0x23, 0xce, + 0xbb, 0x34, 0x0a, 0xdf, 0xb0, 0x86, 0xcb, 0x5e, 0xd1, 0x4e, 0x63, 0x34, 0xa8, 0xb7, 0xc8, 0xca, + 0x4a, 0x00, 0xd2, 0x3d, 0x74, 0x45, 0x2a, 0xda, 0x0a, 0x79, 0x50, 0xef, 0xa4, 0x47, 0x7a, 0x78, + 0x17, 0xab, 0xe5, 0x04, 0xeb, 0xd7, 0x49, 0xfe, 0x66, 0x0a, 0x21, 0x1b, 0x2d, 0x27, 0x14, 0xa4, + 0x4d, 0x55, 0xd3, 0x79, 0xca, 0x02, 0xea, 0xf7, 0x6a, 0xcc, 0xff, 0xfe, 0xb5, 0x88, 0xe0, 0x6a, + 0x35, 0xe6, 0xbb, 0x97, 0xa1, 0x12, 0x78, 0x54, 0xde, 0x2d, 0xa2, 0x45, 0x6d, 0x8f, 0xdf, 0x1b, + 0x68, 0x29, 0x1d, 0x3a, 0xde, 0xce, 0x5a, 0x8a, 0xd3, 0x7b, 0x66, 0xee, 0xcc, 0x95, 0x9b, 0xde, + 0xc4, 0xbe, 0x77, 0xf8, 0xe3, 0xef, 0xa7, 0x73, 0x1b, 0xd8, 0x22, 0x33, 0x17, 0x1b, 0x7f, 0x30, + 0xd0, 0x05, 0x98, 0x17, 0x9e, 0x6d, 0x30, 0x39, 0x72, 0xb3, 0x30, 0x5f, 0x32, 0xe0, 0x6c, 0x6a, + 0x9c, 0xdb, 0x38, 0x9f, 0x85, 0xe3, 0x01, 0xc3, 0x67, 0x03, 0x5d, 0x1a, 0x5f, 0x22, 0x5c, 0x9a, + 0xe9, 0x33, 0x65, 0x19, 0xcd, 0xf2, 0x19, 0x14, 0x80, 0x57, 0xd4, 0x78, 0x9b, 0xf8, 0x6e, 0x16, + 0x9e, 0x4a, 0x54, 0xf5, 0x21, 0xe4, 0x37, 0x03, 0x5d, 0x3d, 0xb5, 0x44, 0xf8, 0xfe, 0x4c, 0xdf, + 0xac, 0xad, 0x34, 0x1f, 0x9c, 0x55, 0x06, 0xcc, 0x15, 0xcd, 0x5c, 0xc0, 0xdb, 0x59, 0xcc, 0x74, + 0x24, 0x1d, 0x2e, 0x73, 0xf5, 0xc9, 0x51, 0xdf, 0x32, 0x8e, 0xfb, 0x96, 0xf1, 0xa7, 0x6f, 0x19, + 0x1f, 0x07, 0x56, 0xee, 0x78, 0x60, 0xe5, 0x7e, 0x0e, 0xac, 0xdc, 0x5e, 0x61, 0xec, 0x7d, 0x2b, + 0x05, 0x11, 0xf5, 0x24, 0x29, 0x05, 0x45, 0xbf, 0x49, 0x43, 0x4e, 0x5e, 0x8f, 0x15, 0xd7, 0x6f, + 0x9e, 0xb7, 0xa4, 0xbf, 0x87, 0xbb, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd7, 0xa6, 0xa4, 0x44, + 0xe1, 0x05, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/community/types/staking.pb.go b/x/community/types/staking.pb.go index 8b803366..2248bec5 100644 --- a/x/community/types/staking.pb.go +++ b/x/community/types/staking.pb.go @@ -88,28 +88,28 @@ func init() { } var fileDescriptor_fce59dad9b680fa3 = []byte{ - // 331 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x91, 0x31, 0x6e, 0x2a, 0x31, - 0x10, 0x86, 0xd7, 0xaf, 0x78, 0x7a, 0x6f, 0xd3, 0x01, 0x41, 0x84, 0x48, 0xbb, 0x28, 0x4a, 0x81, - 0x14, 0x61, 0x8b, 0xe4, 0x04, 0x41, 0xd0, 0xa5, 0x02, 0x2a, 0x1a, 0x34, 0x6b, 0x1c, 0xb3, 0x62, - 0xbd, 0x46, 0xeb, 0x59, 0x12, 0x6e, 0xc1, 0x61, 0x72, 0x08, 0x4a, 0x94, 0x0a, 0xa5, 0x20, 0x11, - 0x5c, 0x24, 0xf2, 0x1a, 0x10, 0xdd, 0xcc, 0xe8, 0x9b, 0xcf, 0xfa, 0xc7, 0xfe, 0xfd, 0x0c, 0x16, - 0xc0, 0xb8, 0x56, 0x2a, 0x4f, 0x63, 0x5c, 0xb2, 0x45, 0x3b, 0x12, 0x08, 0x6d, 0x66, 0x10, 0x66, - 0x71, 0x2a, 0xe9, 0x3c, 0xd3, 0xa8, 0x4b, 0x55, 0x4b, 0xd1, 0x33, 0x45, 0x8f, 0x54, 0xfd, 0x86, - 0x6b, 0xa3, 0xb4, 0x19, 0x17, 0x14, 0x73, 0x8d, 0x5b, 0xa9, 0x57, 0xa4, 0x96, 0xda, 0xcd, 0x6d, - 0x75, 0x9c, 0x86, 0x52, 0x6b, 0x99, 0x08, 0x56, 0x74, 0x51, 0xfe, 0xca, 0x30, 0x56, 0xc2, 0x20, - 0xa8, 0xb9, 0x03, 0xee, 0xb6, 0xc4, 0x2f, 0x0f, 0xdc, 0xdb, 0x7d, 0xf1, 0x06, 0xd9, 0xc4, 0x0c, - 0x10, 0x50, 0x94, 0x46, 0x7e, 0x35, 0x01, 0x83, 0x63, 0xe0, 0x3c, 0x57, 0x79, 0x02, 0x18, 0xeb, - 0x74, 0x6c, 0x97, 0x6b, 0xa4, 0x41, 0x9a, 0x57, 0x8f, 0x75, 0xea, 0xcc, 0xf4, 0x64, 0xa6, 0xc3, - 0x93, 0xb9, 0xf3, 0x6f, 0xbd, 0x0b, 0xbd, 0xd5, 0x77, 0x48, 0xfa, 0x15, 0xeb, 0x78, 0xbe, 0x50, - 0x58, 0xa8, 0x24, 0xfc, 0xeb, 0xc2, 0x8d, 0x59, 0x9e, 0x72, 0x67, 0x16, 0x59, 0xa6, 0xb3, 0xda, - 0x9f, 0x06, 0x69, 0xfe, 0xef, 0xb4, 0xed, 0xfa, 0xd7, 0x2e, 0xbc, 0x75, 0xf9, 0xcc, 0x64, 0x46, - 0x63, 0xcd, 0x14, 0xe0, 0x94, 0xbe, 0x08, 0x09, 0x7c, 0xd9, 0x15, 0xfc, 0xf3, 0xa3, 0xe5, 0x1f, - 0xe3, 0x77, 0x05, 0xef, 0x97, 0xad, 0x6f, 0x78, 0xd6, 0xf5, 0xac, 0xad, 0xd3, 0x5b, 0xef, 0x03, - 0xb2, 0xd9, 0x07, 0xe4, 0x67, 0x1f, 0x90, 0xd5, 0x21, 0xf0, 0x36, 0x87, 0xc0, 0xdb, 0x1e, 0x02, - 0x6f, 0xf4, 0x20, 0x63, 0x9c, 0xe6, 0x91, 0x3d, 0x30, 0xb3, 0x97, 0x6e, 0x25, 0x10, 0x99, 0xa2, - 0x62, 0xef, 0x17, 0x7f, 0x83, 0xcb, 0xb9, 0x30, 0xd1, 0xdf, 0x22, 0xe1, 0xd3, 0x6f, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x98, 0xd8, 0x77, 0x55, 0xba, 0x01, 0x00, 0x00, + // 333 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x91, 0x41, 0x4e, 0x02, 0x31, + 0x14, 0x86, 0xa7, 0x2e, 0x8c, 0x8e, 0x3b, 0x40, 0x82, 0x98, 0xcc, 0x10, 0xe3, 0x82, 0x85, 0xb4, + 0xa0, 0x27, 0x90, 0xa0, 0x2b, 0x57, 0xc0, 0x8a, 0x0d, 0x79, 0x53, 0x6a, 0x99, 0x30, 0x33, 0x25, + 0xd3, 0x37, 0x28, 0xb7, 0xe0, 0x30, 0x1e, 0x82, 0x25, 0x71, 0x45, 0x5c, 0xa0, 0x81, 0x8b, 0x98, + 0x4e, 0x81, 0xb0, 0xeb, 0x7b, 0xf9, 0xfe, 0xaf, 0xf9, 0x5b, 0xf7, 0x7e, 0x02, 0x33, 0x60, 0x5c, + 0xc5, 0x71, 0x96, 0x84, 0x38, 0x67, 0xb3, 0x56, 0x20, 0x10, 0x5a, 0x4c, 0x23, 0x4c, 0xc2, 0x44, + 0xd2, 0x69, 0xaa, 0x50, 0x15, 0xca, 0x86, 0xa2, 0x47, 0x8a, 0xee, 0xa9, 0xea, 0x0d, 0x57, 0x3a, + 0x56, 0x7a, 0x98, 0x53, 0xcc, 0x0e, 0x36, 0x52, 0x2d, 0x49, 0x25, 0x95, 0xdd, 0x9b, 0xd3, 0x7e, + 0xeb, 0x4b, 0xa5, 0x64, 0x24, 0x58, 0x3e, 0x05, 0xd9, 0x3b, 0xc3, 0x30, 0x16, 0x1a, 0x21, 0x9e, + 0x5a, 0xe0, 0x6e, 0x4d, 0xdc, 0x62, 0xcf, 0xde, 0xdd, 0x15, 0x1f, 0x90, 0x8e, 0x74, 0x0f, 0x01, + 0x45, 0x61, 0xe0, 0x96, 0x23, 0xd0, 0x38, 0x04, 0xce, 0xb3, 0x38, 0x8b, 0x00, 0x43, 0x95, 0x0c, + 0x4d, 0xb8, 0x42, 0x6a, 0xa4, 0x7e, 0xf5, 0x58, 0xa5, 0xd6, 0x4c, 0x0f, 0x66, 0xda, 0x3f, 0x98, + 0xdb, 0x17, 0xcb, 0x8d, 0xef, 0x2c, 0x7e, 0x7d, 0xd2, 0x2d, 0x19, 0xc7, 0xf3, 0x89, 0xc2, 0x40, + 0x05, 0xe1, 0x5e, 0xe7, 0x6e, 0x4c, 0xb3, 0x84, 0x5b, 0xb3, 0x48, 0x53, 0x95, 0x56, 0xce, 0x6a, + 0xa4, 0x7e, 0xd9, 0x6e, 0x99, 0xf8, 0xcf, 0xc6, 0xbf, 0xb5, 0xfd, 0xf4, 0x68, 0x42, 0x43, 0xc5, + 0x62, 0xc0, 0x31, 0x7d, 0x13, 0x12, 0xf8, 0xbc, 0x23, 0xf8, 0xf7, 0x57, 0xc3, 0xdd, 0xd7, 0xef, + 0x08, 0xde, 0x2d, 0x1a, 0x5f, 0xff, 0xa8, 0x7b, 0x31, 0xb6, 0xf6, 0xeb, 0x72, 0xeb, 0x91, 0xd5, + 0xd6, 0x23, 0x7f, 0x5b, 0x8f, 0x2c, 0x76, 0x9e, 0xb3, 0xda, 0x79, 0xce, 0x7a, 0xe7, 0x39, 0x83, + 0x07, 0x19, 0xe2, 0x38, 0x0b, 0xcc, 0x03, 0xb3, 0xa6, 0x8c, 0x20, 0xd0, 0xac, 0x29, 0x1b, 0x7c, + 0x0c, 0x61, 0xc2, 0x3e, 0x4f, 0x3e, 0x07, 0xe7, 0x53, 0xa1, 0x83, 0xf3, 0xbc, 0xe2, 0xd3, 0x7f, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x05, 0xd5, 0x6c, 0x66, 0xbb, 0x01, 0x00, 0x00, } func (m *StakingRewardsState) Marshal() (dAtA []byte, err error) { diff --git a/x/community/types/tx.pb.go b/x/community/types/tx.pb.go index 96e55333..a84797be 100644 --- a/x/community/types/tx.pb.go +++ b/x/community/types/tx.pb.go @@ -195,35 +195,36 @@ func init() { func init() { proto.RegisterFile("kava/community/v1beta1/tx.proto", fileDescriptor_e81067e0fbdaca18) } var fileDescriptor_e81067e0fbdaca18 = []byte{ - // 446 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcd, 0xaa, 0xd3, 0x40, - 0x14, 0xc7, 0x33, 0xde, 0x4b, 0xe1, 0xce, 0x15, 0xc4, 0x50, 0x34, 0x0d, 0x32, 0xb9, 0xd4, 0x85, - 0x05, 0x6d, 0xc6, 0x5b, 0xc5, 0x85, 0xb8, 0x31, 0x05, 0xc1, 0x45, 0xa1, 0x44, 0xdc, 0xb8, 0x91, - 0x49, 0x32, 0xa4, 0xa1, 0x4d, 0x4e, 0xc8, 0x4c, 0x6a, 0xfb, 0x06, 0x6e, 0x04, 0x1f, 0xc1, 0xa5, - 0xb8, 0x76, 0xe3, 0x1b, 0x74, 0x59, 0x5c, 0xb9, 0x52, 0x49, 0x37, 0x3e, 0x86, 0x24, 0x99, 0xd4, - 0xaa, 0xad, 0x1f, 0xab, 0xf9, 0xfa, 0x9f, 0xf3, 0xff, 0x9d, 0x33, 0x07, 0x5b, 0x53, 0x36, 0x67, - 0xd4, 0x87, 0x38, 0xce, 0x93, 0x48, 0x2e, 0xe9, 0xfc, 0xdc, 0xe3, 0x92, 0x9d, 0x53, 0xb9, 0xb0, - 0xd3, 0x0c, 0x24, 0xe8, 0x57, 0x4a, 0x81, 0xbd, 0x15, 0xd8, 0x4a, 0x60, 0x12, 0x1f, 0x44, 0x0c, - 0x82, 0x7a, 0x4c, 0xf0, 0x6d, 0x94, 0x0f, 0x51, 0x52, 0xc7, 0x99, 0x9d, 0xfa, 0xfd, 0x79, 0x75, - 0xa2, 0xf5, 0x41, 0x3d, 0xb5, 0x43, 0x08, 0xa1, 0xbe, 0x2f, 0x77, 0xea, 0xf6, 0xfa, 0x01, 0x92, - 0x94, 0x65, 0x2c, 0x56, 0xa1, 0xdd, 0x0f, 0x08, 0xb7, 0x47, 0x22, 0x7c, 0x94, 0x27, 0xc1, 0xb0, - 0x51, 0x8e, 0x01, 0x66, 0xba, 0x8f, 0x5b, 0x2c, 0x86, 0x3c, 0x91, 0x06, 0x3a, 0x3b, 0xea, 0x9d, - 0x0e, 0x3a, 0xb6, 0xb2, 0x2c, 0xf9, 0x1a, 0x68, 0x7b, 0x08, 0x51, 0xe2, 0xdc, 0x5e, 0x7d, 0xb6, - 0xb4, 0x77, 0x5f, 0xac, 0x5e, 0x18, 0xc9, 0x49, 0xee, 0x95, 0xb5, 0x29, 0x3e, 0xb5, 0xf4, 0x45, - 0x30, 0xa5, 0x72, 0x99, 0x72, 0x51, 0x05, 0x08, 0x57, 0xa5, 0xd6, 0xef, 0xe1, 0x93, 0x80, 0xa7, - 0x20, 0x22, 0x09, 0x99, 0x71, 0xe1, 0x0c, 0xf5, 0x4e, 0x1c, 0xe3, 0xe3, 0xfb, 0x7e, 0x5b, 0x59, - 0x3d, 0x0c, 0x82, 0x8c, 0x0b, 0xf1, 0x44, 0x66, 0x51, 0x12, 0xba, 0x3f, 0xa4, 0xf7, 0x8f, 0x5f, - 0xbe, 0xb1, 0xb4, 0x2e, 0xc1, 0xd7, 0xf6, 0xa1, 0xbb, 0x5c, 0xa4, 0x90, 0x08, 0xde, 0x7d, 0x85, - 0xf0, 0xa5, 0x91, 0x08, 0x9f, 0xa6, 0x01, 0x93, 0x7c, 0x5c, 0x55, 0x5d, 0x3a, 0xb2, 0x5c, 0x4e, - 0x20, 0x8b, 0xe4, 0xd2, 0x40, 0x7f, 0x73, 0xdc, 0x4a, 0xf5, 0x07, 0xb8, 0x55, 0xf7, 0xad, 0xc2, - 0x3c, 0x1d, 0x10, 0x7b, 0xff, 0x37, 0xda, 0xb5, 0x8f, 0x73, 0x5c, 0xf6, 0xc4, 0x55, 0x31, 0x8a, - 0xb7, 0x83, 0xaf, 0xfe, 0x82, 0xd3, 0xa0, 0x0e, 0xbe, 0x21, 0x7c, 0x34, 0x12, 0xa1, 0xfe, 0x02, - 0x5f, 0xfe, 0xfd, 0x2b, 0x6e, 0x1d, 0xf2, 0xda, 0x57, 0xbd, 0x79, 0xf7, 0x7f, 0xd4, 0x0d, 0x80, - 0x3e, 0xc1, 0x17, 0x7f, 0xea, 0xd3, 0x8d, 0x3f, 0x64, 0xd9, 0x15, 0x9a, 0xf4, 0x1f, 0x85, 0x8d, - 0x93, 0xf3, 0xf8, 0x6d, 0x41, 0xd0, 0xaa, 0x20, 0x68, 0x5d, 0x10, 0xf4, 0xb5, 0x20, 0xe8, 0xf5, - 0x86, 0x68, 0xeb, 0x0d, 0xd1, 0x3e, 0x6d, 0x88, 0xf6, 0xec, 0xe6, 0xce, 0x0c, 0x95, 0x89, 0xfb, - 0x33, 0xe6, 0x89, 0x6a, 0x47, 0x17, 0x3b, 0xb3, 0x5c, 0x0d, 0x93, 0xd7, 0xaa, 0x66, 0xf8, 0xce, - 0xf7, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x3a, 0x80, 0xec, 0x74, 0x03, 0x00, 0x00, + // 452 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xb1, 0x8e, 0xd3, 0x30, + 0x18, 0xc7, 0x63, 0xee, 0x54, 0xe9, 0x7c, 0x48, 0x88, 0xa8, 0x82, 0xb6, 0x42, 0xee, 0xa9, 0x0c, + 0x74, 0xb8, 0xc6, 0xbd, 0x82, 0x18, 0x10, 0x0b, 0x3d, 0x89, 0x01, 0xa9, 0xd2, 0x29, 0x88, 0x85, + 0x05, 0x39, 0x89, 0xe5, 0x58, 0x77, 0xf1, 0x17, 0xc5, 0xce, 0x71, 0x7d, 0x03, 0x16, 0x24, 0x1e, + 0x81, 0x11, 0x31, 0xb3, 0xf0, 0x06, 0x37, 0x9e, 0x98, 0x98, 0x00, 0xa5, 0x0b, 0x8f, 0x81, 0x92, + 0x38, 0xa5, 0x40, 0x0b, 0xdc, 0x94, 0xd8, 0xfe, 0xff, 0xfd, 0xff, 0x7d, 0x9f, 0x3f, 0xdc, 0x3f, + 0x66, 0xa7, 0x8c, 0x86, 0x90, 0x24, 0xb9, 0x92, 0x66, 0x4e, 0x4f, 0x0f, 0x02, 0x6e, 0xd8, 0x01, + 0x35, 0x67, 0x5e, 0x9a, 0x81, 0x01, 0xf7, 0x46, 0x29, 0xf0, 0x96, 0x02, 0xcf, 0x0a, 0x7a, 0x24, + 0x04, 0x9d, 0x80, 0xa6, 0x01, 0xd3, 0x7c, 0xe9, 0x0a, 0x41, 0xaa, 0xda, 0xd7, 0xeb, 0xd6, 0xe7, + 0x2f, 0xaa, 0x15, 0xad, 0x17, 0xf6, 0xa8, 0x2d, 0x40, 0x40, 0xbd, 0x5f, 0xfe, 0xd9, 0xdd, 0xdb, + 0x1b, 0x48, 0x52, 0x96, 0xb1, 0xc4, 0x5a, 0x07, 0x1f, 0x11, 0x6e, 0xcf, 0xb4, 0x78, 0x9c, 0xab, + 0xe8, 0xb0, 0x51, 0x1e, 0x01, 0x9c, 0xb8, 0x21, 0x6e, 0xb1, 0x04, 0x72, 0x65, 0x3a, 0x68, 0x6f, + 0x6b, 0xb8, 0x3b, 0xe9, 0x7a, 0x36, 0xb2, 0xe4, 0x6b, 0xa0, 0xbd, 0x43, 0x90, 0x6a, 0x3a, 0x3e, + 0xff, 0xd2, 0x77, 0xde, 0x7f, 0xed, 0x0f, 0x85, 0x34, 0x71, 0x1e, 0x94, 0xb5, 0x59, 0x3e, 0xfb, + 0x19, 0xe9, 0xe8, 0x98, 0x9a, 0x79, 0xca, 0x75, 0x65, 0xd0, 0xbe, 0xbd, 0xda, 0xbd, 0x8f, 0x77, + 0x22, 0x9e, 0x82, 0x96, 0x06, 0xb2, 0xce, 0x95, 0x3d, 0x34, 0xdc, 0x99, 0x76, 0x3e, 0x7d, 0x18, + 0xb5, 0x6d, 0xd4, 0xa3, 0x28, 0xca, 0xb8, 0xd6, 0x4f, 0x4d, 0x26, 0x95, 0xf0, 0x7f, 0x4a, 0x1f, + 0x6c, 0xbf, 0x7a, 0xdb, 0x77, 0x06, 0x04, 0xdf, 0x5a, 0x87, 0xee, 0x73, 0x9d, 0x82, 0xd2, 0x7c, + 0xf0, 0x1a, 0xe1, 0x6b, 0x33, 0x2d, 0x9e, 0xa5, 0x11, 0x33, 0xfc, 0xa8, 0xaa, 0xba, 0x4c, 0x64, + 0xb9, 0x89, 0x21, 0x93, 0x66, 0xde, 0x41, 0xff, 0x4a, 0x5c, 0x4a, 0xdd, 0x87, 0xb8, 0x55, 0xf7, + 0xad, 0xc2, 0xdc, 0x9d, 0x10, 0x6f, 0xfd, 0x33, 0x7a, 0x75, 0xce, 0x74, 0xbb, 0xec, 0x89, 0x6f, + 0x3d, 0x96, 0xb7, 0x8b, 0x6f, 0xfe, 0x86, 0xd3, 0xa0, 0x4e, 0xbe, 0x23, 0xbc, 0x35, 0xd3, 0xc2, + 0x7d, 0x89, 0xaf, 0xff, 0xf9, 0x14, 0xfb, 0x9b, 0xb2, 0xd6, 0x55, 0xdf, 0xbb, 0x77, 0x19, 0x75, + 0x03, 0xe0, 0xc6, 0xf8, 0xea, 0x2f, 0x7d, 0xba, 0xf3, 0x97, 0x5b, 0x56, 0x85, 0x3d, 0xfa, 0x9f, + 0xc2, 0x26, 0x69, 0xfa, 0xe4, 0x5d, 0x41, 0xd0, 0x79, 0x41, 0xd0, 0x45, 0x41, 0xd0, 0xb7, 0x82, + 0xa0, 0x37, 0x0b, 0xe2, 0x5c, 0x2c, 0x88, 0xf3, 0x79, 0x41, 0x9c, 0xe7, 0xfb, 0x2b, 0x33, 0x34, + 0x16, 0x27, 0x2c, 0xd0, 0x74, 0x2c, 0x46, 0x61, 0xcc, 0xa4, 0xa2, 0x67, 0x2b, 0xc3, 0x5c, 0x4d, + 0x53, 0xd0, 0xaa, 0x86, 0xf8, 0xee, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7c, 0x2f, 0x37, 0xf3, + 0x75, 0x03, 0x00, 0x00, } func (this *MsgFundCommunityPool) Equal(that interface{}) bool { diff --git a/x/council/v1/client/cli/query.go b/x/council/v1/client/cli/query.go new file mode 100644 index 00000000..50a5b14f --- /dev/null +++ b/x/council/v1/client/cli/query.go @@ -0,0 +1,87 @@ +package cli + +import ( + "context" + "fmt" + "strings" + + "github.com/spf13/cobra" + + "github.com/0glabs/0g-chain/x/council/v1/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" +) + +// GetQueryCmd returns the cli query commands for the inflation module. +func GetQueryCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: "Querying commands for the council module", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + cmd.AddCommand( + GetCurrentCouncilID(), + GetRegisteredVoters(), + ) + + return cmd +} + +func GetCurrentCouncilID() *cobra.Command { + cmd := &cobra.Command{ + Use: "current-council-id", + Short: "Query the current council ID", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryCurrentCouncilIDRequest{} + res, err := queryClient.CurrentCouncilID(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintString(fmt.Sprintf("%v\n", res.CurrentCouncilID)) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + +func GetRegisteredVoters() *cobra.Command { + cmd := &cobra.Command{ + Use: "registered-voters", + Short: "Query registered voters", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryRegisteredVotersRequest{} + res, err := queryClient.RegisteredVoters(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintString(fmt.Sprintf("%v\n", strings.Join(res.Voters, ","))) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/council/v1/client/cli/tx.go b/x/council/v1/client/cli/tx.go new file mode 100644 index 00000000..627e12a7 --- /dev/null +++ b/x/council/v1/client/cli/tx.go @@ -0,0 +1,196 @@ +package cli + +import ( + "bufio" + "bytes" + "encoding/hex" + "errors" + "fmt" + "strconv" + + sdkmath "cosmossdk.io/math" + "github.com/0glabs/0g-chain/crypto/vrf" + "github.com/0glabs/0g-chain/x/council/v1/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + sdkkr "github.com/cosmos/cosmos-sdk/crypto/keyring" + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + vrfalgo "github.com/coniks-sys/coniks-go/crypto/vrf" + "github.com/cosmos/cosmos-sdk/client/input" + "github.com/spf13/cobra" +) + +// GetTxCmd returns the transaction commands for this module +func GetTxCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: fmt.Sprintf("%s transactions subcommands", types.ModuleName), + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + cmd.AddCommand( + NewRegisterCmd(), + NewVoteCmd(), + ) + return cmd +} + +func NewRegisterCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "register", + Short: "Register a voter", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, args []string) error { + // bypass the restriction of set keyring options + ctx := client.GetClientContextFromCmd(cmd).WithKeyringOptions(vrf.VrfOption()) + client.SetCmdClientContext(cmd, ctx) + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + kr := clientCtx.Keyring + // get account name by address + accAddr := clientCtx.GetFromAddress() + accRecord, err := kr.KeyByAddress(accAddr) + if err != nil { + // not found record by address in keyring + return nil + } + + // check voter account record exists + voterAccName := accRecord.Name + "-voter" + _, err = kr.Key(voterAccName) + if err == nil { + // account exists, ask for user confirmation + response, err2 := input.GetConfirmation(fmt.Sprintf("override the existing name %s", voterAccName), bufio.NewReader(clientCtx.Input), cmd.ErrOrStderr()) + if err2 != nil { + return err2 + } + + if !response { + return errors.New("aborted") + } + + err2 = kr.Delete(voterAccName) + if err2 != nil { + return err2 + } + } + + keyringAlgos, _ := kr.SupportedAlgorithms() + algo, err := sdkkr.NewSigningAlgoFromString("vrf", keyringAlgos) + if err != nil { + return err + } + + newRecord, err := kr.NewAccount(voterAccName, "", "", "", algo) + if err != nil { + return err + } + + pubKey, err := newRecord.GetPubKey() + if err != nil { + return err + } + + valAddr, err := sdk.ValAddressFromHex(hex.EncodeToString(clientCtx.GetFromAddress().Bytes())) + if err != nil { + return err + } + + msg := &types.MsgRegister{ + Voter: valAddr.String(), + Key: pubKey.Bytes(), + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} + +func NewVoteCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "vote council-id", + Short: "Vote on a proposal", + Args: cobra.MinimumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + kr := clientCtx.Keyring + + // get account name by address + inAddr := clientCtx.GetFromAddress() + + valAddr, err := sdk.ValAddressFromHex(hex.EncodeToString(inAddr.Bytes())) + if err != nil { + return err + } + + inRecord, err := kr.KeyByAddress(inAddr) + if err != nil { + // not found record by address in keyring + return nil + } + + // check voter account record exists + voterAccName := inRecord.Name + "-voter" + voterRecord, err := kr.Key(voterAccName) + if err != nil { + // not found voter account + return err + } + sk := vrfalgo.PrivateKey(voterRecord.GetLocal().PrivKey.Value) + + councilID, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + votingStartHeight := types.DefaultVotingStartHeight + (councilID-1)*types.DefaultVotingPeriod + + rsp, err := stakingtypes.NewQueryClient(clientCtx).HistoricalInfo(cmd.Context(), &stakingtypes.QueryHistoricalInfoRequest{Height: int64(votingStartHeight)}) + if err != nil { + return err + } + + var tokens sdkmath.Int + for _, val := range rsp.Hist.Valset { + thisValAddr := val.GetOperator() + if thisValAddr.Equals(valAddr) { + tokens = val.GetTokens() + } + } + + // 1_000 0AGI token / vote + numBallots := tokens.Quo(sdk.NewInt(1_000_000_000_000_000_000)).Quo(sdk.NewInt(1_000)).Uint64() + ballots := make([]*types.Ballot, numBallots) + for i := range ballots { + ballotID := uint64(i) + ballots[i] = &types.Ballot{ + ID: ballotID, + Content: sk.Compute(bytes.Join([][]byte{rsp.Hist.Header.LastCommitHash, types.Uint64ToBytes(ballotID)}, nil)), + } + } + + msg := &types.MsgVote{ + CouncilID: councilID, + Voter: valAddr.String(), + Ballots: ballots, + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/council/v1/genesis.go b/x/council/v1/genesis.go new file mode 100644 index 00000000..03d99c3d --- /dev/null +++ b/x/council/v1/genesis.go @@ -0,0 +1,56 @@ +package council + +import ( + "fmt" + + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/0glabs/0g-chain/x/council/v1/keeper" + "github.com/0glabs/0g-chain/x/council/v1/types" +) + +// InitGenesis initializes the store state from a genesis state. +func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, gs types.GenesisState) { + if err := gs.Validate(); err != nil { + panic(fmt.Sprintf("failed to validate %s genesis state: %s", types.ModuleName, err)) + } + + params := gs.Params + err := keeper.SetParams(ctx, params) + if err != nil { + panic(errorsmod.Wrapf(err, "error setting params")) + } + + keeper.SetCurrentCouncilID(ctx, gs.CurrentCouncilID) + + for _, p := range gs.Councils { + keeper.SetCouncil(ctx, p) + } +} + +// ExportGenesis returns a GenesisState for a given context and keeper. +func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) *types.GenesisState { + startHeight, err := keeper.GetVotingStartHeight(ctx) + if err != nil { + panic(err) + } + + period, err := keeper.GetVotingPeriod(ctx) + if err != nil { + panic(err) + } + + currentID, err := keeper.GetCurrentCouncilID(ctx) + if err != nil { + panic(err) + } + + return types.NewGenesisState( + keeper.GetParams(ctx), + startHeight, + period, + currentID, + keeper.GetCouncils(ctx), + ) +} diff --git a/x/council/v1/keeper/abci.go b/x/council/v1/keeper/abci.go new file mode 100644 index 00000000..63adb5d3 --- /dev/null +++ b/x/council/v1/keeper/abci.go @@ -0,0 +1,72 @@ +package keeper + +import ( + "sort" + + abci "github.com/cometbft/cometbft/abci/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +type Ballot struct { + voter sdk.ValAddress + content string +} + +func (k *Keeper) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) { + councilID, err := k.GetCurrentCouncilID(ctx) + if err != nil { + // TODO: handle the case where councilID is not available + return + } + council, bz := k.GetCouncil(ctx, councilID) + if !bz { + return + } + + if ctx.BlockHeight() >= int64(council.StartHeight) { + // We are ready to accept votes for the next council + if err := k.StoreNewCouncil(ctx, council.StartHeight); err != nil { + return + } + } + + if ctx.BlockHeight() < int64(council.EndHeight) { + return + } + + k.IncrementCurrentCouncilID(ctx) + council, bz = k.GetCouncil(ctx, councilID+1) + if !bz { + return + } + + ballots := []Ballot{} + seen := make(map[string]struct{}) + for _, vote := range council.Votes { + for _, ballot := range vote.Ballots { + ballot := Ballot{ + voter: vote.Voter, + content: string(ballot.Content), + } + if _, ok := seen[ballot.content]; ok { + continue + } + ballots = append(ballots, ballot) + seen[ballot.content] = struct{}{} + } + } + sort.Slice(ballots, func(i, j int) bool { + return ballots[i].content < ballots[j].content + }) + + councilSize := k.GetParams(ctx).CouncilSize + council.Members = make([]sdk.ValAddress, councilSize) + for i := 0; i < int(councilSize); i = i + 1 { + council.Members[i] = ballots[i].voter + } + + k.SetCouncil(ctx, council) +} + +func (k *Keeper) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) { +} diff --git a/x/council/v1/keeper/grpc_query.go b/x/council/v1/keeper/grpc_query.go new file mode 100644 index 00000000..4dd0e69d --- /dev/null +++ b/x/council/v1/keeper/grpc_query.go @@ -0,0 +1,35 @@ +package keeper + +import ( + "context" + + "github.com/0glabs/0g-chain/x/council/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var _ types.QueryServer = Keeper{} + +func (k Keeper) CurrentCouncilID( + c context.Context, + _ *types.QueryCurrentCouncilIDRequest, +) (*types.QueryCurrentCouncilIDResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + currentCouncilID, err := k.GetCurrentCouncilID(ctx) + if err != nil { + return nil, err + } + return &types.QueryCurrentCouncilIDResponse{CurrentCouncilID: currentCouncilID}, nil +} + +func (k Keeper) RegisteredVoters( + c context.Context, + _ *types.QueryRegisteredVotersRequest, +) (*types.QueryRegisteredVotersResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + voterAddrs := k.GetVoters(ctx) + voters := make([]string, len(voterAddrs)) + for i, voterAddr := range voterAddrs { + voters[i] = voterAddr.String() + } + return &types.QueryRegisteredVotersResponse{Voters: voters}, nil +} diff --git a/x/council/v1/keeper/keeper.go b/x/council/v1/keeper/keeper.go new file mode 100644 index 00000000..33b8bbab --- /dev/null +++ b/x/council/v1/keeper/keeper.go @@ -0,0 +1,323 @@ +package keeper + +import ( + "fmt" + + errorsmod "cosmossdk.io/errors" + "github.com/cometbft/cometbft/libs/log" + "github.com/coniks-sys/coniks-go/crypto/vrf" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/store/prefix" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/0glabs/0g-chain/x/council/v1/types" +) + +// Keeper of the inflation store +type Keeper struct { + storeKey storetypes.StoreKey + cdc codec.BinaryCodec + stakingKeeper types.StakingKeeper +} + +// NewKeeper creates a new mint Keeper instance +func NewKeeper( + storeKey storetypes.StoreKey, + cdc codec.BinaryCodec, + stakingKeeper types.StakingKeeper, +) Keeper { + return Keeper{ + storeKey: storeKey, + cdc: cdc, + stakingKeeper: stakingKeeper, + } +} + +// Logger returns a module-specific logger. +func (k Keeper) Logger(ctx sdk.Context) log.Logger { + return ctx.Logger().With("module", "x/"+types.ModuleName) +} + +// ------------------------------------------ +// Councils +// ------------------------------------------ + +func (k Keeper) SetCurrentCouncilID(ctx sdk.Context, id uint64) { + store := ctx.KVStore(k.storeKey) + store.Set(types.CurrentCouncilIDKey, types.GetKeyFromID(id)) +} + +func (k Keeper) GetCurrentCouncilID(ctx sdk.Context) (uint64, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.CurrentCouncilIDKey) + if bz == nil { + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "current council ID not set at genesis") + } + return types.Uint64FromBytes(bz), nil +} + +func (k Keeper) IncrementCurrentCouncilID(ctx sdk.Context) error { + id, err := k.GetCurrentCouncilID(ctx) + if err != nil { + return err + } + k.SetCurrentCouncilID(ctx, id+1) + return nil +} + +func (k Keeper) SetVotingStartHeight(ctx sdk.Context, votingStartHeight uint64) { + store := ctx.KVStore(k.storeKey) + store.Set(types.VotingStartHeightKey, types.GetKeyFromID(votingStartHeight)) +} + +func (k Keeper) GetVotingStartHeight(ctx sdk.Context) (uint64, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.VotingStartHeightKey) + if bz == nil { + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "voting start height not set at genesis") + } + return types.Uint64FromBytes(bz), nil +} + +func (k Keeper) SetVotingPeriod(ctx sdk.Context, votingPeriod uint64) { + store := ctx.KVStore(k.storeKey) + store.Set(types.VotingPeriodKey, types.GetKeyFromID(votingPeriod)) +} + +func (k Keeper) GetVotingPeriod(ctx sdk.Context) (uint64, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.VotingPeriodKey) + if bz == nil { + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "voting period not set at genesis") + } + return types.Uint64FromBytes(bz), nil +} + +// StoreNewCouncil stores a council, adding a new ID +func (k Keeper) StoreNewCouncil(ctx sdk.Context, votingStartHeight uint64) error { + currentCouncilID, err := k.GetCurrentCouncilID(ctx) + if err != nil { + return err + } + + votingPeriod, err := k.GetVotingPeriod(ctx) + if err != nil { + return err + } + com := types.Council{ + ID: currentCouncilID + 1, + VotingStartHeight: votingStartHeight, + StartHeight: votingStartHeight + votingPeriod, + EndHeight: votingStartHeight + votingPeriod*2, + Votes: []types.Vote{}, + Members: []sdk.ValAddress{}, + } + k.SetCouncil(ctx, com) + + return nil +} + +func (k Keeper) GetCouncil(ctx sdk.Context, councilID uint64) (types.Council, bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.CouncilKeyPrefix) + bz := store.Get(types.GetKeyFromID(councilID)) + if bz == nil { + return types.Council{}, false + } + var com types.Council + k.cdc.MustUnmarshal(bz, &com) + return com, true +} + +// SetCouncil puts a council into the store. +func (k Keeper) SetCouncil(ctx sdk.Context, council types.Council) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.CouncilKeyPrefix) + bz := k.cdc.MustMarshal(&council) + store.Set(types.GetKeyFromID(council.ID), bz) +} + +// // DeleteProposal removes a proposal from the store. +// func (k Keeper) DeleteProposal(ctx sdk.Context, proposalID uint64) { +// store := prefix.NewStore(ctx.KVStore(k.storeKey), types.ProposalKeyPrefix) +// store.Delete(types.GetKeyFromID(proposalID)) +// } + +// IterateProposals provides an iterator over all stored proposals. +// For each proposal, cb will be called. If cb returns true, the iterator will close and stop. +func (k Keeper) IterateCouncil(ctx sdk.Context, cb func(proposal types.Council) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.CouncilKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var council types.Council + k.cdc.MustUnmarshal(iterator.Value(), &council) + if cb(council) { + break + } + } +} + +func (k Keeper) GetCouncils(ctx sdk.Context) types.Councils { + results := types.Councils{} + k.IterateCouncil(ctx, func(prop types.Council) bool { + results = append(results, prop) + return false + }) + return results +} + +// // DeleteProposalAndVotes removes a proposal and its associated votes. +// func (k Keeper) DeleteProposalAndVotes(ctx sdk.Context, proposalID uint64) { +// votes := k.GetVotesByProposal(ctx, proposalID) +// k.DeleteProposal(ctx, proposalID) +// for _, v := range votes { +// k.DeleteVote(ctx, v.ProposalID, v.Voter) +// } +// } + +// ------------------------------------------ +// Votes +// ------------------------------------------ + +// GetVote gets a vote from the store. +func (k Keeper) GetVote(ctx sdk.Context, epochID uint64, voter sdk.ValAddress) (types.Vote, bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VoteKeyPrefix) + bz := store.Get(types.GetVoteKey(epochID, voter)) + if bz == nil { + return types.Vote{}, false + } + var vote types.Vote + k.cdc.MustUnmarshal(bz, &vote) + return vote, true +} + +// SetVote puts a vote into the store. +func (k Keeper) SetVote(ctx sdk.Context, vote types.Vote) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VoteKeyPrefix) + bz := k.cdc.MustMarshal(&vote) + store.Set(types.GetVoteKey(vote.CouncilID, vote.Voter), bz) +} + +// DeleteVote removes a Vote from the store. +func (k Keeper) DeleteVote(ctx sdk.Context, councilID uint64, voter sdk.ValAddress) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VoteKeyPrefix) + store.Delete(types.GetVoteKey(councilID, voter)) +} + +// IterateVotes provides an iterator over all stored votes. +// For each vote, cb will be called. If cb returns true, the iterator will close and stop. +func (k Keeper) IterateVotes(ctx sdk.Context, cb func(vote types.Vote) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.VoteKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var vote types.Vote + k.cdc.MustUnmarshal(iterator.Value(), &vote) + + if cb(vote) { + break + } + } +} + +// GetVotes returns all stored votes. +func (k Keeper) GetVotes(ctx sdk.Context) []types.Vote { + results := []types.Vote{} + k.IterateVotes(ctx, func(vote types.Vote) bool { + results = append(results, vote) + return false + }) + return results +} + +// GetVotesByProposal returns all votes for one proposal. +func (k Keeper) GetVotesByCouncil(ctx sdk.Context, councilID uint64) []types.Vote { + results := []types.Vote{} + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), append(types.VoteKeyPrefix, types.GetKeyFromID(councilID)...)) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var vote types.Vote + k.cdc.MustUnmarshal(iterator.Value(), &vote) + results = append(results, vote) + } + + return results +} + +// ------------------------------------------ +// Voters +// ------------------------------------------ + +func (k Keeper) SetVoter(ctx sdk.Context, voter sdk.ValAddress, pk vrf.PublicKey) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VoterKeyPrefix) + store.Set(types.GetVoterKey(voter), pk) + fmt.Printf("voterStoreKey: %v, publicKey: %v\n", types.GetVoterKey(voter), pk) +} + +func (k Keeper) IterateVoters(ctx sdk.Context, cb func(voter sdk.ValAddress, pk vrf.PublicKey) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.VoterKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + if cb(sdk.ValAddress(iterator.Key()[1:]), vrf.PublicKey(iterator.Value())) { + break + } + } +} + +// GetVotes returns all stored voters +func (k Keeper) GetVoters(ctx sdk.Context) []sdk.ValAddress { + results := []sdk.ValAddress{} + k.IterateVoters(ctx, func(voter sdk.ValAddress, _ vrf.PublicKey) bool { + results = append(results, voter) + return false + }) + return results +} + +func (k Keeper) AddVoter(ctx sdk.Context, voter sdk.ValAddress, key []byte) error { + if len(key) != vrf.PublicKeySize { + return types.ErrInvalidPublicKey + } + + k.SetVoter(ctx, voter, vrf.PublicKey(key)) + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeRegister, + sdk.NewAttribute(types.AttributeKeyVoter, voter.String()), + // TODO: types.AttributeKeyPublicKey + ), + ) + + return nil +} + +func (k Keeper) AddVote(ctx sdk.Context, councilID uint64, voter sdk.ValAddress, ballots []*types.Ballot) error { + // Validate + com, found := k.GetCouncil(ctx, councilID) + if !found { + return errorsmod.Wrapf(types.ErrUnknownCouncil, "%d", councilID) + } + if com.HasVotingEndedBy(ctx.BlockHeight()) { + return errorsmod.Wrapf(types.ErrProposalExpired, "%d ≥ %d", ctx.BlockHeight(), com.StartHeight) + } + + // TODO: verify if the voter is registered + // TODO: verify whether ballots are valid or not + + // Store vote, overwriting any prior vote + k.SetVote(ctx, types.NewVote(councilID, voter, ballots)) + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeVote, + sdk.NewAttribute(types.AttributeKeyCouncilID, fmt.Sprintf("%d", com.ID)), + sdk.NewAttribute(types.AttributeKeyVoter, voter.String()), + // TODO: types.AttributeKeyBallots + ), + ) + + return nil +} diff --git a/x/council/v1/keeper/msg_server.go b/x/council/v1/keeper/msg_server.go new file mode 100644 index 00000000..6dbf56f0 --- /dev/null +++ b/x/council/v1/keeper/msg_server.go @@ -0,0 +1,51 @@ +// Copyright Tharsis Labs Ltd.(Evmos) +// SPDX-License-Identifier:ENCL-1.0(https://github.com/evmos/evmos/blob/main/LICENSE) + +package keeper + +import ( + "context" + + "github.com/0glabs/0g-chain/x/council/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +var _ types.MsgServer = &Keeper{} + +// Register handles MsgRegister messages +func (k Keeper) Register(goCtx context.Context, msg *types.MsgRegister) (*types.MsgRegisterResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + valAddr, err := sdk.ValAddressFromBech32(msg.Voter) + if err != nil { + return nil, err + } + + _, found := k.stakingKeeper.GetValidator(ctx, valAddr) + if !found { + return nil, stakingtypes.ErrNoValidatorFound + } + + if err := k.AddVoter(ctx, valAddr, msg.Key); err != nil { + return nil, err + } + + return &types.MsgRegisterResponse{}, nil +} + +// Vote handles MsgVote messages +func (k Keeper) Vote(goCtx context.Context, msg *types.MsgVote) (*types.MsgVoteResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + voter, err := sdk.ValAddressFromBech32(msg.Voter) + if err != nil { + return nil, err + } + + if err := k.AddVote(ctx, msg.CouncilID, voter, msg.Ballots); err != nil { + return nil, err + } + + return &types.MsgVoteResponse{}, nil +} diff --git a/x/council/v1/keeper/params.go b/x/council/v1/keeper/params.go new file mode 100644 index 00000000..9294fc19 --- /dev/null +++ b/x/council/v1/keeper/params.go @@ -0,0 +1,29 @@ +package keeper + +import ( + "github.com/0glabs/0g-chain/x/council/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.ParamsKey) + if len(bz) == 0 { + return params + } + + k.cdc.MustUnmarshal(bz, ¶ms) + return params +} + +func (k Keeper) SetParams(ctx sdk.Context, params types.Params) error { + store := ctx.KVStore(k.storeKey) + bz, err := k.cdc.Marshal(¶ms) + if err != nil { + return err + } + + store.Set(types.ParamsKey, bz) + + return nil +} diff --git a/x/council/v1/module.go b/x/council/v1/module.go new file mode 100644 index 00000000..2613f11b --- /dev/null +++ b/x/council/v1/module.go @@ -0,0 +1,171 @@ +package council + +import ( + "context" + "encoding/json" + "fmt" + + abci "github.com/cometbft/cometbft/abci/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + "github.com/gorilla/mux" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/spf13/cobra" + + "github.com/0glabs/0g-chain/x/council/v1/client/cli" + "github.com/0glabs/0g-chain/x/council/v1/keeper" + "github.com/0glabs/0g-chain/x/council/v1/types" +) + +// consensusVersion defines the current x/council module consensus version. +const consensusVersion = 1 + +// type check to ensure the interface is properly implemented +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} + _ module.AppModuleSimulation = AppModule{} + _ module.BeginBlockAppModule = AppModule{} + _ module.EndBlockAppModule = AppModule{} +) + +// app module Basics object +type AppModuleBasic struct{} + +// Name returns the inflation module's name. +func (AppModuleBasic) Name() string { + return types.ModuleName +} + +// RegisterLegacyAminoCodec registers the inflation module's types on the given LegacyAmino codec. +func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {} + +// ConsensusVersion returns the consensus state-breaking version for the module. +func (AppModuleBasic) ConsensusVersion() uint64 { + return consensusVersion +} + +// RegisterInterfaces registers interfaces and implementations of the incentives +// module. +func (AppModuleBasic) RegisterInterfaces(interfaceRegistry codectypes.InterfaceRegistry) { + types.RegisterInterfaces(interfaceRegistry) +} + +// DefaultGenesis returns default genesis state as raw bytes for the incentives +// module. +func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { + return cdc.MustMarshalJSON(types.DefaultGenesisState()) +} + +// ValidateGenesis performs genesis state validation for the inflation module. +func (b AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, _ client.TxEncodingConfig, bz json.RawMessage) error { + var genesisState types.GenesisState + if err := cdc.UnmarshalJSON(bz, &genesisState); err != nil { + return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) + } + + return genesisState.Validate() +} + +// RegisterRESTRoutes performs a no-op as the inflation module doesn't expose REST +// endpoints +func (AppModuleBasic) RegisterRESTRoutes(_ client.Context, _ *mux.Router) {} + +// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the inflation module. +func (b AppModuleBasic) RegisterGRPCGatewayRoutes(c client.Context, serveMux *runtime.ServeMux) { + if err := types.RegisterQueryHandlerClient(context.Background(), serveMux, types.NewQueryClient(c)); err != nil { + panic(err) + } +} + +// GetTxCmd returns the root tx command for the inflation module. +func (AppModuleBasic) GetTxCmd() *cobra.Command { return cli.GetTxCmd() } + +// GetQueryCmd returns no root query command for the inflation module. +func (AppModuleBasic) GetQueryCmd() *cobra.Command { + return cli.GetQueryCmd() +} + +// ___________________________________________________________________________ + +// AppModule implements an application module for the inflation module. +type AppModule struct { + AppModuleBasic + keeper keeper.Keeper + sk *stakingkeeper.Keeper +} + +// NewAppModule creates a new AppModule Object +func NewAppModule( + k keeper.Keeper, + sk *stakingkeeper.Keeper, +) AppModule { + return AppModule{ + AppModuleBasic: AppModuleBasic{}, + keeper: k, + sk: sk, + } +} + +// Name returns the inflation module's name. +func (AppModule) Name() string { + return types.ModuleName +} + +// RegisterInvariants registers the inflation module invariants. +func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {} + +// RegisterServices registers a gRPC query service to respond to the +// module-specific gRPC queries. +func (am AppModule) RegisterServices(cfg module.Configurator) { + types.RegisterMsgServer(cfg.MsgServer(), am.keeper) + types.RegisterQueryServer(cfg.QueryServer(), am.keeper) +} + +func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) { + am.keeper.BeginBlock(ctx, req) +} + +func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate { + am.keeper.EndBlock(ctx, req) + return []abci.ValidatorUpdate{} +} + +// InitGenesis performs genesis initialization for the inflation module. It returns +// no validator updates. +func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate { + var genesisState types.GenesisState + + cdc.MustUnmarshalJSON(data, &genesisState) + InitGenesis(ctx, am.keeper, genesisState) + return []abci.ValidatorUpdate{} +} + +// ExportGenesis returns the exported genesis state as raw bytes for the inflation +// module. +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + gs := ExportGenesis(ctx, am.keeper) + return cdc.MustMarshalJSON(gs) +} + +// ___________________________________________________________________________ + +// AppModuleSimulation functions + +// GenerateGenesisState creates a randomized GenState of the inflation module. +func (am AppModule) GenerateGenesisState(_ *module.SimulationState) { +} + +// RegisterStoreDecoder registers a decoder for inflation module's types. +func (am AppModule) RegisterStoreDecoder(_ sdk.StoreDecoderRegistry) { +} + +// WeightedOperations doesn't return any inflation module operation. +func (am AppModule) WeightedOperations(_ module.SimulationState) []simtypes.WeightedOperation { + return []simtypes.WeightedOperation{} +} diff --git a/x/council/v1/types/codec.go b/x/council/v1/types/codec.go new file mode 100644 index 00000000..fd2b1071 --- /dev/null +++ b/x/council/v1/types/codec.go @@ -0,0 +1,52 @@ +package types + +import ( + "github.com/0glabs/0g-chain/crypto/vrf" + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/msgservice" +) + +var ( + amino = codec.NewLegacyAmino() + // ModuleCdc references the global evm module codec. Note, the codec should + // ONLY be used in certain instances of tests and for JSON encoding. + ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry()) + + // AminoCdc is a amino codec created to support amino JSON compatible msgs. + AminoCdc = codec.NewAminoCodec(amino) +) + +const ( + // Amino names + registerName = "evmos/council/MsgRegister" + voteName = "evmos/council/MsgVote" +) + +// NOTE: This is required for the GetSignBytes function +func init() { + RegisterLegacyAminoCodec(amino) + amino.Seal() +} + +// RegisterInterfaces register implementations +func RegisterInterfaces(registry codectypes.InterfaceRegistry) { + registry.RegisterImplementations( + (*sdk.Msg)(nil), + &MsgRegister{}, + &MsgVote{}, + ) + + registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &vrf.PubKey{}) + registry.RegisterImplementations((*cryptotypes.PrivKey)(nil), &vrf.PrivKey{}) + + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) +} + +// RegisterLegacyAminoCodec required for EIP-712 +func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgRegister{}, registerName, nil) + cdc.RegisterConcrete(&MsgVote{}, voteName, nil) +} diff --git a/x/council/v1/types/council.go b/x/council/v1/types/council.go new file mode 100644 index 00000000..b422974d --- /dev/null +++ b/x/council/v1/types/council.go @@ -0,0 +1,21 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) + +type Councils []Council +type Votes []Vote + +func (c Council) HasVotingEndedBy(height int64) bool { + return height >= int64(c.StartHeight) +} + +// NewVote instantiates a new instance of Vote +func NewVote(councilID uint64, voter sdk.ValAddress, ballots []*Ballot) Vote { + return Vote{ + CouncilID: councilID, + Voter: voter, + Ballots: ballots, + } +} diff --git a/x/council/v1/types/epoch.go b/x/council/v1/types/epoch.go new file mode 100644 index 00000000..d44612a1 --- /dev/null +++ b/x/council/v1/types/epoch.go @@ -0,0 +1,3 @@ +package types + +type Epoch struct{} diff --git a/x/council/v1/types/errors.go b/x/council/v1/types/errors.go new file mode 100644 index 00000000..75f54e93 --- /dev/null +++ b/x/council/v1/types/errors.go @@ -0,0 +1,19 @@ +package types + +import errorsmod "cosmossdk.io/errors" + +var ( + ErrUnknownCouncil = errorsmod.Register(ModuleName, 2, "council not found") + ErrInvalidCouncil = errorsmod.Register(ModuleName, 3, "invalid council") + ErrUnknownProposal = errorsmod.Register(ModuleName, 4, "proposal not found") + ErrProposalExpired = errorsmod.Register(ModuleName, 5, "proposal expired") + ErrInvalidPubProposal = errorsmod.Register(ModuleName, 6, "invalid pubproposal") + ErrUnknownVote = errorsmod.Register(ModuleName, 7, "vote not found") + ErrInvalidGenesis = errorsmod.Register(ModuleName, 8, "invalid genesis") + ErrNoProposalHandlerExists = errorsmod.Register(ModuleName, 9, "pubproposal has no corresponding handler") + ErrUnknownSubspace = errorsmod.Register(ModuleName, 10, "subspace not found") + ErrInvalidVoteType = errorsmod.Register(ModuleName, 11, "invalid vote type") + ErrNotFoundProposalTally = errorsmod.Register(ModuleName, 12, "proposal tally not found") + ErrInvalidPublicKey = errorsmod.Register(ModuleName, 13, "invalid public key") + ErrInvalidValidatorAddress = errorsmod.Register(ModuleName, 14, "invalid validator address") +) diff --git a/x/council/v1/types/events.go b/x/council/v1/types/events.go new file mode 100644 index 00000000..99485e5a --- /dev/null +++ b/x/council/v1/types/events.go @@ -0,0 +1,19 @@ +package types + +// Module event types +const ( + EventTypeRegister = "register" + EventTypeVote = "vote" + + AttributeValueCategory = "council" + AttributeKeyCouncilID = "council_id" + AttributeKeyProposalID = "proposal_id" + AttributeKeyVotingStartHeight = "voting_start_height" + AttributeKeyVotingEndHeight = "voting_end_height" + AttributeKeyProposalCloseStatus = "status" + AttributeKeyVoter = "voter" + AttributeKeyBallots = "ballots" + AttributeKeyPublicKey = "public_key" + AttributeKeyProposalOutcome = "proposal_outcome" + AttributeKeyProposalTally = "proposal_tally" +) diff --git a/x/council/v1/types/genesis.go b/x/council/v1/types/genesis.go new file mode 100644 index 00000000..ae187511 --- /dev/null +++ b/x/council/v1/types/genesis.go @@ -0,0 +1,42 @@ +package types + +const ( + DefaultVotingStartHeight = 1 + DefaultVotingPeriod = 200 +) + +// NewGenesisState returns a new genesis state object for the module. +func NewGenesisState(params Params, votingStartHeight uint64, votingPeriod uint64, currentCouncilID uint64, councils Councils) *GenesisState { + return &GenesisState{ + Params: params, + VotingStartHeight: votingStartHeight, + VotingPeriod: votingPeriod, + CurrentCouncilID: currentCouncilID, + Councils: councils, + } +} + +// DefaultGenesisState returns the default genesis state for the module. +func DefaultGenesisState() *GenesisState { + return NewGenesisState( + Params{ + CouncilSize: 1, + }, + DefaultVotingStartHeight, + DefaultVotingPeriod, + 1, + []Council{ + { + ID: 1, + VotingStartHeight: DefaultVotingStartHeight, + StartHeight: DefaultVotingStartHeight + DefaultVotingPeriod, + EndHeight: DefaultVotingStartHeight + DefaultVotingPeriod*2, + Votes: Votes{}, + }}, + ) +} + +// Validate performs basic validation of genesis data. +func (gs GenesisState) Validate() error { + return nil +} diff --git a/x/council/v1/types/genesis.pb.go b/x/council/v1/types/genesis.pb.go new file mode 100644 index 00000000..e74d476e --- /dev/null +++ b/x/council/v1/types/genesis.pb.go @@ -0,0 +1,1467 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgchain/council/v1/genesis.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" + _ "google.golang.org/protobuf/types/known/timestamppb" + 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 + +type Params struct { + CouncilSize uint64 `protobuf:"varint,1,opt,name=council_size,json=councilSize,proto3" json:"council_size,omitempty"` +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_797025d12687ea75, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +func (m *Params) GetCouncilSize() uint64 { + if m != nil { + return m.CouncilSize + } + return 0 +} + +// GenesisState defines the council module's genesis state. +type GenesisState struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + VotingStartHeight uint64 `protobuf:"varint,2,opt,name=voting_start_height,json=votingStartHeight,proto3" json:"voting_start_height,omitempty"` + VotingPeriod uint64 `protobuf:"varint,3,opt,name=voting_period,json=votingPeriod,proto3" json:"voting_period,omitempty"` + CurrentCouncilID uint64 `protobuf:"varint,4,opt,name=current_council_id,json=currentCouncilId,proto3" json:"current_council_id,omitempty"` + Councils []Council `protobuf:"bytes,5,rep,name=councils,proto3" json:"councils"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_797025d12687ea75, []int{1} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +type Council struct { + ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + VotingStartHeight uint64 `protobuf:"varint,2,opt,name=voting_start_height,json=votingStartHeight,proto3" json:"voting_start_height,omitempty"` + StartHeight uint64 `protobuf:"varint,3,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` + EndHeight uint64 `protobuf:"varint,4,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"` + Votes []Vote `protobuf:"bytes,5,rep,name=votes,proto3" json:"votes"` + Members []github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,6,rep,name=members,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"members,omitempty"` +} + +func (m *Council) Reset() { *m = Council{} } +func (m *Council) String() string { return proto.CompactTextString(m) } +func (*Council) ProtoMessage() {} +func (*Council) Descriptor() ([]byte, []int) { + return fileDescriptor_797025d12687ea75, []int{2} +} +func (m *Council) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Council) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Council.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 *Council) XXX_Merge(src proto.Message) { + xxx_messageInfo_Council.Merge(m, src) +} +func (m *Council) XXX_Size() int { + return m.Size() +} +func (m *Council) XXX_DiscardUnknown() { + xxx_messageInfo_Council.DiscardUnknown(m) +} + +var xxx_messageInfo_Council proto.InternalMessageInfo + +func (m *Council) GetID() uint64 { + if m != nil { + return m.ID + } + return 0 +} + +func (m *Council) GetVotingStartHeight() uint64 { + if m != nil { + return m.VotingStartHeight + } + return 0 +} + +func (m *Council) GetStartHeight() uint64 { + if m != nil { + return m.StartHeight + } + return 0 +} + +func (m *Council) GetEndHeight() uint64 { + if m != nil { + return m.EndHeight + } + return 0 +} + +func (m *Council) GetVotes() []Vote { + if m != nil { + return m.Votes + } + return nil +} + +func (m *Council) GetMembers() []github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.Members + } + return nil +} + +type Vote struct { + CouncilID uint64 `protobuf:"varint,1,opt,name=council_id,json=councilId,proto3" json:"council_id,omitempty"` + Voter github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=voter,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"voter,omitempty"` + Ballots []*Ballot `protobuf:"bytes,3,rep,name=ballots,proto3" json:"ballots,omitempty"` +} + +func (m *Vote) Reset() { *m = Vote{} } +func (m *Vote) String() string { return proto.CompactTextString(m) } +func (*Vote) ProtoMessage() {} +func (*Vote) Descriptor() ([]byte, []int) { + return fileDescriptor_797025d12687ea75, []int{3} +} +func (m *Vote) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Vote.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 *Vote) XXX_Merge(src proto.Message) { + xxx_messageInfo_Vote.Merge(m, src) +} +func (m *Vote) XXX_Size() int { + return m.Size() +} +func (m *Vote) XXX_DiscardUnknown() { + xxx_messageInfo_Vote.DiscardUnknown(m) +} + +var xxx_messageInfo_Vote proto.InternalMessageInfo + +type Ballot struct { + ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` +} + +func (m *Ballot) Reset() { *m = Ballot{} } +func (m *Ballot) String() string { return proto.CompactTextString(m) } +func (*Ballot) ProtoMessage() {} +func (*Ballot) Descriptor() ([]byte, []int) { + return fileDescriptor_797025d12687ea75, []int{4} +} +func (m *Ballot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Ballot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Ballot.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 *Ballot) XXX_Merge(src proto.Message) { + xxx_messageInfo_Ballot.Merge(m, src) +} +func (m *Ballot) XXX_Size() int { + return m.Size() +} +func (m *Ballot) XXX_DiscardUnknown() { + xxx_messageInfo_Ballot.DiscardUnknown(m) +} + +var xxx_messageInfo_Ballot proto.InternalMessageInfo + +func (m *Ballot) GetID() uint64 { + if m != nil { + return m.ID + } + return 0 +} + +func (m *Ballot) GetContent() []byte { + if m != nil { + return m.Content + } + return nil +} + +func init() { + proto.RegisterType((*Params)(nil), "zgchain.council.v1.Params") + proto.RegisterType((*GenesisState)(nil), "zgchain.council.v1.GenesisState") + proto.RegisterType((*Council)(nil), "zgchain.council.v1.Council") + proto.RegisterType((*Vote)(nil), "zgchain.council.v1.Vote") + proto.RegisterType((*Ballot)(nil), "zgchain.council.v1.Ballot") +} + +func init() { proto.RegisterFile("zgchain/council/v1/genesis.proto", fileDescriptor_797025d12687ea75) } + +var fileDescriptor_797025d12687ea75 = []byte{ + // 595 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x3f, 0x6f, 0xd3, 0x40, + 0x18, 0xc6, 0x63, 0x27, 0x75, 0xe8, 0xc5, 0x95, 0xca, 0xb5, 0x42, 0x6e, 0x10, 0x76, 0x1a, 0x96, + 0x48, 0x10, 0xbb, 0x2d, 0x1d, 0x50, 0x25, 0x06, 0xdc, 0x4a, 0x6d, 0xb7, 0xca, 0x91, 0x3a, 0x30, + 0x10, 0xf9, 0xcf, 0xe1, 0x9c, 0xb0, 0x7d, 0x91, 0xef, 0x12, 0x91, 0x7c, 0x02, 0x46, 0x3e, 0x02, + 0x13, 0x1b, 0x1b, 0x1f, 0xa2, 0x63, 0xc4, 0xc4, 0x14, 0x21, 0xe7, 0x5b, 0x30, 0xa1, 0xdc, 0x9d, + 0x4b, 0x0a, 0x61, 0x40, 0x62, 0x4a, 0xee, 0x7d, 0x7e, 0xef, 0xdd, 0x3d, 0xef, 0xfb, 0xfa, 0x40, + 0x6b, 0x1a, 0x87, 0x03, 0x1f, 0x67, 0x4e, 0x48, 0x46, 0x59, 0x88, 0x13, 0x67, 0x7c, 0xe8, 0xc4, + 0x28, 0x43, 0x14, 0x53, 0x7b, 0x98, 0x13, 0x46, 0x20, 0x94, 0x84, 0x2d, 0x09, 0x7b, 0x7c, 0xd8, + 0xdc, 0x0b, 0x09, 0x4d, 0x09, 0xed, 0x73, 0xc2, 0x11, 0x0b, 0x81, 0x37, 0x77, 0x63, 0x12, 0x13, + 0x11, 0x5f, 0xfe, 0x93, 0xd1, 0xbd, 0x98, 0x90, 0x38, 0x41, 0x0e, 0x5f, 0x05, 0xa3, 0x37, 0x8e, + 0x9f, 0x4d, 0xa4, 0x64, 0xfd, 0x2e, 0x31, 0x9c, 0x22, 0xca, 0xfc, 0x74, 0x28, 0x80, 0xf6, 0x13, + 0xa0, 0x5d, 0xf9, 0xb9, 0x9f, 0x52, 0xb8, 0x0f, 0x74, 0x79, 0x89, 0x3e, 0xc5, 0x53, 0x64, 0x28, + 0x2d, 0xa5, 0x53, 0xf3, 0x1a, 0x32, 0xd6, 0xc3, 0x53, 0xd4, 0xfe, 0xa4, 0x02, 0xfd, 0x5c, 0xdc, + 0xbf, 0xc7, 0x7c, 0x86, 0xe0, 0x73, 0xa0, 0x0d, 0x79, 0x36, 0xa7, 0x1b, 0x47, 0x4d, 0xfb, 0x4f, + 0x3f, 0xb6, 0xd8, 0xdf, 0xad, 0xdd, 0xcc, 0xad, 0x8a, 0x27, 0x79, 0x68, 0x83, 0x9d, 0x31, 0x61, + 0x38, 0x8b, 0xfb, 0x94, 0xf9, 0x39, 0xeb, 0x0f, 0x10, 0x8e, 0x07, 0xcc, 0x50, 0xf9, 0xa1, 0xf7, + 0x85, 0xd4, 0x5b, 0x2a, 0x17, 0x5c, 0x80, 0x8f, 0xc1, 0x96, 0xe4, 0x87, 0x28, 0xc7, 0x24, 0x32, + 0xaa, 0x9c, 0xd4, 0x45, 0xf0, 0x8a, 0xc7, 0xa0, 0x0b, 0x60, 0x38, 0xca, 0x73, 0x94, 0xb1, 0x7e, + 0x69, 0x05, 0x47, 0x46, 0x6d, 0x49, 0xba, 0xbb, 0xc5, 0xdc, 0xda, 0x3e, 0x15, 0xea, 0xa9, 0x10, + 0x2f, 0xcf, 0xbc, 0xed, 0xf0, 0x6e, 0x24, 0x82, 0x2f, 0xc0, 0x3d, 0x99, 0x4b, 0x8d, 0x8d, 0x56, + 0xb5, 0xd3, 0x38, 0x7a, 0xb8, 0xce, 0x94, 0x4c, 0x90, 0xae, 0x6e, 0x53, 0x4e, 0x6a, 0xef, 0x3f, + 0x5a, 0x95, 0xf6, 0x67, 0x15, 0xd4, 0x25, 0x01, 0x1f, 0x00, 0x15, 0x47, 0xa2, 0x9a, 0xae, 0x56, + 0xcc, 0x2d, 0xf5, 0xf2, 0xcc, 0x53, 0x71, 0xf4, 0xcf, 0x15, 0xd8, 0x07, 0xfa, 0x1d, 0x50, 0x14, + 0xa0, 0x41, 0x57, 0x90, 0x47, 0x00, 0xa0, 0x2c, 0x2a, 0x01, 0xee, 0xdb, 0xdb, 0x44, 0x59, 0x24, + 0xe5, 0x63, 0xb0, 0x31, 0x26, 0x0c, 0x95, 0xbe, 0x8c, 0x75, 0xbe, 0xae, 0x09, 0x43, 0xd2, 0x94, + 0x80, 0x61, 0x00, 0xea, 0x29, 0x4a, 0x03, 0x94, 0x53, 0x43, 0x6b, 0x55, 0x3b, 0xba, 0x7b, 0xf1, + 0x63, 0x6e, 0x75, 0x63, 0xcc, 0x06, 0xa3, 0xc0, 0x0e, 0x49, 0x2a, 0x27, 0x54, 0xfe, 0x74, 0x69, + 0xf4, 0xd6, 0x61, 0x93, 0x21, 0xa2, 0xf6, 0xb5, 0x9f, 0xbc, 0x8c, 0xa2, 0x1c, 0x51, 0xfa, 0xf5, + 0x4b, 0x77, 0x47, 0xce, 0xb1, 0x8c, 0xb8, 0x13, 0x86, 0xa8, 0x57, 0x6e, 0xdc, 0x9e, 0x29, 0xa0, + 0xb6, 0x3c, 0x19, 0x3e, 0x05, 0x60, 0xa5, 0x73, 0xa2, 0x68, 0x5b, 0xc5, 0xdc, 0xda, 0xfc, 0xd5, + 0xb2, 0xcd, 0xf0, 0xb6, 0x57, 0xaf, 0x85, 0xa1, 0x9c, 0x17, 0xed, 0x7f, 0x5e, 0x4c, 0x6c, 0x0b, + 0x8f, 0x41, 0x3d, 0xf0, 0x93, 0x84, 0x30, 0x6a, 0x54, 0x79, 0xc9, 0xd6, 0xce, 0xb7, 0xcb, 0x11, + 0xaf, 0x44, 0xe5, 0x08, 0x9c, 0x00, 0x4d, 0x08, 0x7f, 0x1d, 0x00, 0x03, 0xd4, 0x43, 0x92, 0x31, + 0x94, 0x89, 0xa6, 0xeb, 0x5e, 0xb9, 0x74, 0xcf, 0x6f, 0x0a, 0x53, 0x99, 0x15, 0xa6, 0xf2, 0xbd, + 0x30, 0x95, 0x0f, 0x0b, 0xb3, 0x32, 0x5b, 0x98, 0x95, 0x6f, 0x0b, 0xb3, 0xf2, 0x6a, 0xd5, 0xde, + 0x41, 0x9c, 0xf8, 0x01, 0x75, 0x0e, 0xe2, 0xae, 0x78, 0x64, 0xde, 0xad, 0x3e, 0x33, 0xdc, 0x69, + 0xa0, 0xf1, 0x8f, 0xfc, 0xd9, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xeb, 0x6b, 0x8a, 0x46, 0x89, + 0x04, 0x00, 0x00, +} + +func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CouncilSize != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.CouncilSize)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Councils) > 0 { + for iNdEx := len(m.Councils) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Councils[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.CurrentCouncilID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.CurrentCouncilID)) + i-- + dAtA[i] = 0x20 + } + if m.VotingPeriod != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.VotingPeriod)) + i-- + dAtA[i] = 0x18 + } + if m.VotingStartHeight != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.VotingStartHeight)) + i-- + dAtA[i] = 0x10 + } + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Council) 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 *Council) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Council) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Members) > 0 { + for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Members[iNdEx]) + copy(dAtA[i:], m.Members[iNdEx]) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Members[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(m.Votes) > 0 { + for iNdEx := len(m.Votes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Votes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.EndHeight != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.EndHeight)) + i-- + dAtA[i] = 0x20 + } + if m.StartHeight != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.StartHeight)) + i-- + dAtA[i] = 0x18 + } + if m.VotingStartHeight != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.VotingStartHeight)) + i-- + dAtA[i] = 0x10 + } + if m.ID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Vote) 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 *Vote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ballots) > 0 { + for iNdEx := len(m.Ballots) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ballots[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Voter) > 0 { + i -= len(m.Voter) + copy(dAtA[i:], m.Voter) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Voter))) + i-- + dAtA[i] = 0x12 + } + if m.CouncilID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.CouncilID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Ballot) 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 *Ballot) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Ballot) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Content) > 0 { + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0x12 + } + if m.ID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CouncilSize != 0 { + n += 1 + sovGenesis(uint64(m.CouncilSize)) + } + return n +} + +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + if m.VotingStartHeight != 0 { + n += 1 + sovGenesis(uint64(m.VotingStartHeight)) + } + if m.VotingPeriod != 0 { + n += 1 + sovGenesis(uint64(m.VotingPeriod)) + } + if m.CurrentCouncilID != 0 { + n += 1 + sovGenesis(uint64(m.CurrentCouncilID)) + } + if len(m.Councils) > 0 { + for _, e := range m.Councils { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *Council) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovGenesis(uint64(m.ID)) + } + if m.VotingStartHeight != 0 { + n += 1 + sovGenesis(uint64(m.VotingStartHeight)) + } + if m.StartHeight != 0 { + n += 1 + sovGenesis(uint64(m.StartHeight)) + } + if m.EndHeight != 0 { + n += 1 + sovGenesis(uint64(m.EndHeight)) + } + if len(m.Votes) > 0 { + for _, e := range m.Votes { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.Members) > 0 { + for _, b := range m.Members { + l = len(b) + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *Vote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CouncilID != 0 { + n += 1 + sovGenesis(uint64(m.CouncilID)) + } + l = len(m.Voter) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + if len(m.Ballots) > 0 { + for _, e := range m.Ballots { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *Ballot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovGenesis(uint64(m.ID)) + } + l = len(m.Content) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) 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 ErrIntOverflowGenesis + } + 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: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CouncilSize", wireType) + } + m.CouncilSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CouncilSize |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisState) 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 ErrIntOverflowGenesis + } + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingStartHeight", wireType) + } + m.VotingStartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VotingStartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingPeriod", wireType) + } + m.VotingPeriod = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VotingPeriod |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentCouncilID", wireType) + } + m.CurrentCouncilID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CurrentCouncilID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Councils", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Councils = append(m.Councils, Council{}) + if err := m.Councils[len(m.Councils)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Council) 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 ErrIntOverflowGenesis + } + 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: Council: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Council: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingStartHeight", wireType) + } + m.VotingStartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VotingStartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType) + } + m.StartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndHeight", wireType) + } + m.EndHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Votes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Votes = append(m.Votes, Vote{}) + if err := m.Votes[len(m.Votes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Members = append(m.Members, make([]byte, postIndex-iNdEx)) + copy(m.Members[len(m.Members)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Vote) 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 ErrIntOverflowGenesis + } + 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: Vote: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CouncilID", wireType) + } + m.CouncilID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CouncilID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Voter = append(m.Voter[:0], dAtA[iNdEx:postIndex]...) + if m.Voter == nil { + m.Voter = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ballots", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ballots = append(m.Ballots, &Ballot{}) + if err := m.Ballots[len(m.Ballots)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Ballot) 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 ErrIntOverflowGenesis + } + 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: Ballot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Ballot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...) + if m.Content == nil { + m.Content = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenesis(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, ErrIntOverflowGenesis + } + 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, ErrIntOverflowGenesis + } + 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, ErrIntOverflowGenesis + } + 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, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/council/v1/types/interfaces.go b/x/council/v1/types/interfaces.go new file mode 100644 index 00000000..c48ad7f0 --- /dev/null +++ b/x/council/v1/types/interfaces.go @@ -0,0 +1,23 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +// AccountKeeper defines the expected account keeper +type AccountKeeper interface { + GetAccount(sdk.Context, sdk.AccAddress) authtypes.AccountI +} + +// BankKeeper defines the expected bank keeper interface +type BankKeeper interface { + GetSupply(ctx sdk.Context, denom string) sdk.Coin + GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Coin +} + +type StakingKeeper interface { + BondDenom(ctx sdk.Context) (res string) + GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator stakingtypes.Validator, found bool) +} diff --git a/x/council/v1/types/keys.go b/x/council/v1/types/keys.go new file mode 100644 index 00000000..a5e3c18e --- /dev/null +++ b/x/council/v1/types/keys.go @@ -0,0 +1,52 @@ +package types + +import ( + "encoding/binary" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +const ( + // ModuleName The name that will be used throughout the module + ModuleName = "council" + + // StoreKey Top level store key where all module items will be stored + StoreKey = ModuleName +) + +// Key prefixes +var ( + CouncilKeyPrefix = []byte{0x00} // prefix for keys that store councils + VoteKeyPrefix = []byte{0x01} // prefix for keys that store votes + VoterKeyPrefix = []byte{0x02} // prefix for keys that store voters + + ParamsKey = []byte{0x03} + VotingStartHeightKey = []byte{0x04} + VotingPeriodKey = []byte{0x05} + CurrentCouncilIDKey = []byte{0x06} +) + +// GetKeyFromID returns the bytes to use as a key for a uint64 id +func GetKeyFromID(id uint64) []byte { + return Uint64ToBytes(id) +} + +func GetVoteKey(councilID uint64, voter sdk.ValAddress) []byte { + return append(GetKeyFromID(councilID), voter.Bytes()...) +} + +func GetVoterKey(voter sdk.ValAddress) []byte { + return voter.Bytes() +} + +// Uint64ToBytes converts a uint64 into fixed length bytes for use in store keys. +func Uint64ToBytes(id uint64) []byte { + bz := make([]byte, 8) + binary.BigEndian.PutUint64(bz, uint64(id)) + return bz +} + +// Uint64FromBytes converts some fixed length bytes back into a uint64. +func Uint64FromBytes(bz []byte) uint64 { + return binary.BigEndian.Uint64(bz) +} diff --git a/x/council/v1/types/msg.go b/x/council/v1/types/msg.go new file mode 100644 index 00000000..640cdf6f --- /dev/null +++ b/x/council/v1/types/msg.go @@ -0,0 +1,65 @@ +package types + +import ( + "encoding/hex" + + "github.com/coniks-sys/coniks-go/crypto/vrf" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var _, _ sdk.Msg = &MsgRegister{}, &MsgVote{} + +// GetSigners returns the expected signers for a MsgRegister message. +func (msg *MsgRegister) GetSigners() []sdk.AccAddress { + valAddr, err := sdk.ValAddressFromBech32(msg.Voter) + if err != nil { + panic(err) + } + accAddr, err := sdk.AccAddressFromHexUnsafe(hex.EncodeToString(valAddr.Bytes())) + if err != nil { + panic(err) + } + return []sdk.AccAddress{accAddr} +} + +// ValidateBasic does a sanity check of the provided data +func (msg *MsgRegister) ValidateBasic() error { + if _, err := sdk.ValAddressFromBech32(msg.Voter); err != nil { + return ErrInvalidValidatorAddress + } + if len(msg.Key) != vrf.PublicKeySize { + return ErrInvalidPublicKey + } + return nil +} + +// GetSignBytes implements the LegacyMsg interface. +func (msg MsgRegister) GetSignBytes() []byte { + return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg)) +} + +// GetSigners returns the expected signers for a MsgVote message. +func (msg *MsgVote) GetSigners() []sdk.AccAddress { + valAddr, err := sdk.ValAddressFromBech32(msg.Voter) + if err != nil { + panic(err) + } + accAddr, err := sdk.AccAddressFromHexUnsafe(hex.EncodeToString(valAddr.Bytes())) + if err != nil { + panic(err) + } + return []sdk.AccAddress{accAddr} +} + +// ValidateBasic does a sanity check of the provided data +func (msg *MsgVote) ValidateBasic() error { + if _, err := sdk.ValAddressFromBech32(msg.Voter); err != nil { + return ErrInvalidValidatorAddress + } + return nil +} + +// GetSignBytes implements the LegacyMsg interface. +func (msg MsgVote) GetSignBytes() []byte { + return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg)) +} diff --git a/x/council/v1/types/query.pb.go b/x/council/v1/types/query.pb.go new file mode 100644 index 00000000..3617b759 --- /dev/null +++ b/x/council/v1/types/query.pb.go @@ -0,0 +1,838 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgchain/council/v1/query.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + _ "google.golang.org/protobuf/types/known/timestamppb" + 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 + +type QueryCurrentCouncilIDRequest struct { +} + +func (m *QueryCurrentCouncilIDRequest) Reset() { *m = QueryCurrentCouncilIDRequest{} } +func (m *QueryCurrentCouncilIDRequest) String() string { return proto.CompactTextString(m) } +func (*QueryCurrentCouncilIDRequest) ProtoMessage() {} +func (*QueryCurrentCouncilIDRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_c9a5a442f4ef0db3, []int{0} +} +func (m *QueryCurrentCouncilIDRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryCurrentCouncilIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryCurrentCouncilIDRequest.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 *QueryCurrentCouncilIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryCurrentCouncilIDRequest.Merge(m, src) +} +func (m *QueryCurrentCouncilIDRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryCurrentCouncilIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryCurrentCouncilIDRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryCurrentCouncilIDRequest proto.InternalMessageInfo + +type QueryCurrentCouncilIDResponse struct { + CurrentCouncilID uint64 `protobuf:"varint,1,opt,name=current_council_id,json=currentCouncilId,proto3" json:"current_council_id,omitempty"` +} + +func (m *QueryCurrentCouncilIDResponse) Reset() { *m = QueryCurrentCouncilIDResponse{} } +func (m *QueryCurrentCouncilIDResponse) String() string { return proto.CompactTextString(m) } +func (*QueryCurrentCouncilIDResponse) ProtoMessage() {} +func (*QueryCurrentCouncilIDResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_c9a5a442f4ef0db3, []int{1} +} +func (m *QueryCurrentCouncilIDResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryCurrentCouncilIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryCurrentCouncilIDResponse.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 *QueryCurrentCouncilIDResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryCurrentCouncilIDResponse.Merge(m, src) +} +func (m *QueryCurrentCouncilIDResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryCurrentCouncilIDResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryCurrentCouncilIDResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryCurrentCouncilIDResponse proto.InternalMessageInfo + +type QueryRegisteredVotersRequest struct { +} + +func (m *QueryRegisteredVotersRequest) Reset() { *m = QueryRegisteredVotersRequest{} } +func (m *QueryRegisteredVotersRequest) String() string { return proto.CompactTextString(m) } +func (*QueryRegisteredVotersRequest) ProtoMessage() {} +func (*QueryRegisteredVotersRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_c9a5a442f4ef0db3, []int{2} +} +func (m *QueryRegisteredVotersRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryRegisteredVotersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryRegisteredVotersRequest.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 *QueryRegisteredVotersRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRegisteredVotersRequest.Merge(m, src) +} +func (m *QueryRegisteredVotersRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryRegisteredVotersRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRegisteredVotersRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRegisteredVotersRequest proto.InternalMessageInfo + +type QueryRegisteredVotersResponse struct { + Voters []string `protobuf:"bytes,1,rep,name=voters,proto3" json:"voters,omitempty"` +} + +func (m *QueryRegisteredVotersResponse) Reset() { *m = QueryRegisteredVotersResponse{} } +func (m *QueryRegisteredVotersResponse) String() string { return proto.CompactTextString(m) } +func (*QueryRegisteredVotersResponse) ProtoMessage() {} +func (*QueryRegisteredVotersResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_c9a5a442f4ef0db3, []int{3} +} +func (m *QueryRegisteredVotersResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryRegisteredVotersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryRegisteredVotersResponse.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 *QueryRegisteredVotersResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRegisteredVotersResponse.Merge(m, src) +} +func (m *QueryRegisteredVotersResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryRegisteredVotersResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRegisteredVotersResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRegisteredVotersResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*QueryCurrentCouncilIDRequest)(nil), "zgchain.council.v1.QueryCurrentCouncilIDRequest") + proto.RegisterType((*QueryCurrentCouncilIDResponse)(nil), "zgchain.council.v1.QueryCurrentCouncilIDResponse") + proto.RegisterType((*QueryRegisteredVotersRequest)(nil), "zgchain.council.v1.QueryRegisteredVotersRequest") + proto.RegisterType((*QueryRegisteredVotersResponse)(nil), "zgchain.council.v1.QueryRegisteredVotersResponse") +} + +func init() { proto.RegisterFile("zgchain/council/v1/query.proto", fileDescriptor_c9a5a442f4ef0db3) } + +var fileDescriptor_c9a5a442f4ef0db3 = []byte{ + // 416 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xb1, 0x8e, 0xd3, 0x30, + 0x18, 0xc7, 0xe3, 0x03, 0x4e, 0xc2, 0x53, 0x65, 0x9d, 0xd0, 0x5d, 0x74, 0xf8, 0xaa, 0x48, 0x40, + 0x97, 0xc4, 0x29, 0x0c, 0xec, 0x2d, 0x0b, 0x62, 0xa2, 0x03, 0x03, 0x4b, 0x95, 0x38, 0xc6, 0xb5, + 0xd4, 0xd8, 0x69, 0xec, 0x54, 0x94, 0x91, 0x27, 0x40, 0xe2, 0x1d, 0xe0, 0x55, 0x3a, 0x56, 0x62, + 0x41, 0x0c, 0x08, 0x52, 0x1e, 0x04, 0x35, 0x76, 0x2b, 0x68, 0xda, 0x4a, 0xb7, 0xe5, 0xfb, 0xfe, + 0xdf, 0xff, 0xf3, 0xcf, 0x7f, 0x07, 0xe2, 0x0f, 0x9c, 0x4e, 0x12, 0x21, 0x09, 0x55, 0x95, 0xa4, + 0x62, 0x4a, 0xe6, 0x7d, 0x32, 0xab, 0x58, 0xb9, 0x88, 0x8a, 0x52, 0x19, 0x85, 0x90, 0xd3, 0x23, + 0xa7, 0x47, 0xf3, 0xbe, 0x7f, 0x45, 0x95, 0xce, 0x95, 0x1e, 0x37, 0x13, 0xc4, 0x16, 0x76, 0xdc, + 0xbf, 0xe0, 0x8a, 0x2b, 0xdb, 0xdf, 0x7c, 0xb9, 0xee, 0x35, 0x57, 0x8a, 0x4f, 0x19, 0x49, 0x0a, + 0x41, 0x12, 0x29, 0x95, 0x49, 0x8c, 0x50, 0x72, 0xeb, 0xb9, 0x72, 0x6a, 0x53, 0xa5, 0xd5, 0x3b, + 0x92, 0x48, 0x77, 0xba, 0x7f, 0xb3, 0x2f, 0x19, 0x91, 0x33, 0x6d, 0x92, 0xbc, 0x70, 0x03, 0xdd, + 0x03, 0xf8, 0x9c, 0x49, 0xa6, 0x85, 0xdb, 0x1e, 0x60, 0x78, 0xfd, 0x7a, 0x73, 0x9f, 0x61, 0x55, + 0x96, 0x4c, 0x9a, 0xa1, 0x9d, 0x7b, 0xf9, 0x62, 0xc4, 0x66, 0x15, 0xd3, 0x26, 0xa0, 0xf0, 0xe1, + 0x11, 0x5d, 0x17, 0x4a, 0x6a, 0x86, 0x06, 0x10, 0x51, 0xab, 0x8d, 0xdd, 0x21, 0x63, 0x91, 0x5d, + 0x82, 0x2e, 0xe8, 0xdd, 0x1d, 0x5c, 0xd4, 0x3f, 0x6f, 0x3a, 0x2d, 0x67, 0x87, 0xfe, 0xdf, 0xc9, + 0x76, 0x10, 0x23, 0xc6, 0x85, 0x36, 0xac, 0x64, 0xd9, 0x1b, 0x65, 0x58, 0xa9, 0xb7, 0x10, 0xcf, + 0x1d, 0x44, 0x5b, 0x77, 0x10, 0x0f, 0xe0, 0xf9, 0xbc, 0xe9, 0x5c, 0x82, 0xee, 0x9d, 0xde, 0xfd, + 0x91, 0xab, 0x9e, 0xfe, 0x38, 0x83, 0xf7, 0x1a, 0x27, 0xfa, 0x0a, 0x60, 0x8b, 0x04, 0xc5, 0x51, + 0xfb, 0xf9, 0xa2, 0x53, 0x71, 0xf8, 0xfd, 0x5b, 0x38, 0x2c, 0x5b, 0x10, 0x7d, 0xfc, 0xf6, 0xe7, + 0xf3, 0x59, 0x0f, 0x3d, 0x26, 0x71, 0xfb, 0x31, 0x5c, 0x14, 0xa1, 0x6b, 0x85, 0x22, 0x43, 0x5f, + 0x00, 0xec, 0xec, 0x5f, 0xf4, 0x04, 0xe9, 0x91, 0xcc, 0x4e, 0x90, 0x1e, 0x4b, 0x31, 0x08, 0x1b, + 0xd2, 0x27, 0xe8, 0xd1, 0x21, 0xd2, 0x72, 0xe7, 0x0a, 0x6d, 0xb8, 0x83, 0x57, 0xcb, 0xdf, 0xd8, + 0x5b, 0xd6, 0x18, 0xac, 0x6a, 0x0c, 0x7e, 0xd5, 0x18, 0x7c, 0x5a, 0x63, 0x6f, 0xb5, 0xc6, 0xde, + 0xf7, 0x35, 0xf6, 0xde, 0x86, 0x5c, 0x98, 0x49, 0x95, 0x46, 0x54, 0xe5, 0x24, 0xe6, 0xd3, 0x24, + 0xd5, 0x24, 0xe6, 0xa1, 0x5d, 0xfb, 0xfe, 0xdf, 0xc5, 0x66, 0x51, 0x30, 0x9d, 0x9e, 0x37, 0xbf, + 0xe3, 0xb3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd9, 0xf8, 0x2e, 0xc3, 0x71, 0x03, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + CurrentCouncilID(ctx context.Context, in *QueryCurrentCouncilIDRequest, opts ...grpc.CallOption) (*QueryCurrentCouncilIDResponse, error) + RegisteredVoters(ctx context.Context, in *QueryRegisteredVotersRequest, opts ...grpc.CallOption) (*QueryRegisteredVotersResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) CurrentCouncilID(ctx context.Context, in *QueryCurrentCouncilIDRequest, opts ...grpc.CallOption) (*QueryCurrentCouncilIDResponse, error) { + out := new(QueryCurrentCouncilIDResponse) + err := c.cc.Invoke(ctx, "/zgchain.council.v1.Query/CurrentCouncilID", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) RegisteredVoters(ctx context.Context, in *QueryRegisteredVotersRequest, opts ...grpc.CallOption) (*QueryRegisteredVotersResponse, error) { + out := new(QueryRegisteredVotersResponse) + err := c.cc.Invoke(ctx, "/zgchain.council.v1.Query/RegisteredVoters", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + CurrentCouncilID(context.Context, *QueryCurrentCouncilIDRequest) (*QueryCurrentCouncilIDResponse, error) + RegisteredVoters(context.Context, *QueryRegisteredVotersRequest) (*QueryRegisteredVotersResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) CurrentCouncilID(ctx context.Context, req *QueryCurrentCouncilIDRequest) (*QueryCurrentCouncilIDResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CurrentCouncilID not implemented") +} +func (*UnimplementedQueryServer) RegisteredVoters(ctx context.Context, req *QueryRegisteredVotersRequest) (*QueryRegisteredVotersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RegisteredVoters not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_CurrentCouncilID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryCurrentCouncilIDRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).CurrentCouncilID(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgchain.council.v1.Query/CurrentCouncilID", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).CurrentCouncilID(ctx, req.(*QueryCurrentCouncilIDRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_RegisteredVoters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryRegisteredVotersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).RegisteredVoters(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgchain.council.v1.Query/RegisteredVoters", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).RegisteredVoters(ctx, req.(*QueryRegisteredVotersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "zgchain.council.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CurrentCouncilID", + Handler: _Query_CurrentCouncilID_Handler, + }, + { + MethodName: "RegisteredVoters", + Handler: _Query_RegisteredVoters_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "zgchain/council/v1/query.proto", +} + +func (m *QueryCurrentCouncilIDRequest) 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 *QueryCurrentCouncilIDRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryCurrentCouncilIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryCurrentCouncilIDResponse) 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 *QueryCurrentCouncilIDResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryCurrentCouncilIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CurrentCouncilID != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.CurrentCouncilID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *QueryRegisteredVotersRequest) 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 *QueryRegisteredVotersRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryRegisteredVotersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryRegisteredVotersResponse) 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 *QueryRegisteredVotersResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryRegisteredVotersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Voters) > 0 { + for iNdEx := len(m.Voters) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Voters[iNdEx]) + copy(dAtA[i:], m.Voters[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Voters[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryCurrentCouncilIDRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryCurrentCouncilIDResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CurrentCouncilID != 0 { + n += 1 + sovQuery(uint64(m.CurrentCouncilID)) + } + return n +} + +func (m *QueryRegisteredVotersRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryRegisteredVotersResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Voters) > 0 { + for _, s := range m.Voters { + l = len(s) + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryCurrentCouncilIDRequest) 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 ErrIntOverflowQuery + } + 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: QueryCurrentCouncilIDRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryCurrentCouncilIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryCurrentCouncilIDResponse) 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 ErrIntOverflowQuery + } + 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: QueryCurrentCouncilIDResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryCurrentCouncilIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentCouncilID", wireType) + } + m.CurrentCouncilID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CurrentCouncilID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryRegisteredVotersRequest) 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 ErrIntOverflowQuery + } + 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: QueryRegisteredVotersRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryRegisteredVotersRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryRegisteredVotersResponse) 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 ErrIntOverflowQuery + } + 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: QueryRegisteredVotersResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryRegisteredVotersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voters", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Voters = append(m.Voters, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(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, ErrIntOverflowQuery + } + 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, ErrIntOverflowQuery + } + 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, ErrIntOverflowQuery + } + 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, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/council/v1/types/query.pb.gw.go b/x/council/v1/types/query.pb.gw.go new file mode 100644 index 00000000..7e8d117a --- /dev/null +++ b/x/council/v1/types/query.pb.gw.go @@ -0,0 +1,218 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: zgchain/council/v1/query.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage +var _ = metadata.Join + +func request_Query_CurrentCouncilID_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryCurrentCouncilIDRequest + var metadata runtime.ServerMetadata + + msg, err := client.CurrentCouncilID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_CurrentCouncilID_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryCurrentCouncilIDRequest + var metadata runtime.ServerMetadata + + msg, err := server.CurrentCouncilID(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_RegisteredVoters_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryRegisteredVotersRequest + var metadata runtime.ServerMetadata + + msg, err := client.RegisteredVoters(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_RegisteredVoters_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryRegisteredVotersRequest + var metadata runtime.ServerMetadata + + msg, err := server.RegisteredVoters(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_CurrentCouncilID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_CurrentCouncilID_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_CurrentCouncilID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_RegisteredVoters_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_RegisteredVoters_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_RegisteredVoters_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_CurrentCouncilID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_CurrentCouncilID_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_CurrentCouncilID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_RegisteredVoters_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_RegisteredVoters_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_RegisteredVoters_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_CurrentCouncilID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0gchain", "council", "v1", "current-council-id"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_RegisteredVoters_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0gchain", "council", "v1", "registered-voters"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_CurrentCouncilID_0 = runtime.ForwardResponseMessage + + forward_Query_RegisteredVoters_0 = runtime.ForwardResponseMessage +) diff --git a/x/council/v1/types/tx.pb.go b/x/council/v1/types/tx.pb.go new file mode 100644 index 00000000..fe96f9f9 --- /dev/null +++ b/x/council/v1/types/tx.pb.go @@ -0,0 +1,975 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgchain/council/v1/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +type MsgRegister struct { + Voter string `protobuf:"bytes,1,opt,name=voter,proto3" json:"voter,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *MsgRegister) Reset() { *m = MsgRegister{} } +func (m *MsgRegister) String() string { return proto.CompactTextString(m) } +func (*MsgRegister) ProtoMessage() {} +func (*MsgRegister) Descriptor() ([]byte, []int) { + return fileDescriptor_393766362450e289, []int{0} +} +func (m *MsgRegister) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRegister) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRegister.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 *MsgRegister) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRegister.Merge(m, src) +} +func (m *MsgRegister) XXX_Size() int { + return m.Size() +} +func (m *MsgRegister) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRegister.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRegister proto.InternalMessageInfo + +type MsgRegisterResponse struct { +} + +func (m *MsgRegisterResponse) Reset() { *m = MsgRegisterResponse{} } +func (m *MsgRegisterResponse) String() string { return proto.CompactTextString(m) } +func (*MsgRegisterResponse) ProtoMessage() {} +func (*MsgRegisterResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_393766362450e289, []int{1} +} +func (m *MsgRegisterResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRegisterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRegisterResponse.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 *MsgRegisterResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRegisterResponse.Merge(m, src) +} +func (m *MsgRegisterResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgRegisterResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRegisterResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRegisterResponse proto.InternalMessageInfo + +type MsgVote struct { + CouncilID uint64 `protobuf:"varint,1,opt,name=council_id,json=councilId,proto3" json:"council_id,omitempty"` + Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"` + Ballots []*Ballot `protobuf:"bytes,3,rep,name=ballots,proto3" json:"ballots,omitempty"` +} + +func (m *MsgVote) Reset() { *m = MsgVote{} } +func (m *MsgVote) String() string { return proto.CompactTextString(m) } +func (*MsgVote) ProtoMessage() {} +func (*MsgVote) Descriptor() ([]byte, []int) { + return fileDescriptor_393766362450e289, []int{2} +} +func (m *MsgVote) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgVote.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 *MsgVote) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgVote.Merge(m, src) +} +func (m *MsgVote) XXX_Size() int { + return m.Size() +} +func (m *MsgVote) XXX_DiscardUnknown() { + xxx_messageInfo_MsgVote.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgVote proto.InternalMessageInfo + +type MsgVoteResponse struct { +} + +func (m *MsgVoteResponse) Reset() { *m = MsgVoteResponse{} } +func (m *MsgVoteResponse) String() string { return proto.CompactTextString(m) } +func (*MsgVoteResponse) ProtoMessage() {} +func (*MsgVoteResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_393766362450e289, []int{3} +} +func (m *MsgVoteResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgVoteResponse.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 *MsgVoteResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgVoteResponse.Merge(m, src) +} +func (m *MsgVoteResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgVoteResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgVoteResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgVoteResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgRegister)(nil), "zgchain.council.v1.MsgRegister") + proto.RegisterType((*MsgRegisterResponse)(nil), "zgchain.council.v1.MsgRegisterResponse") + proto.RegisterType((*MsgVote)(nil), "zgchain.council.v1.MsgVote") + proto.RegisterType((*MsgVoteResponse)(nil), "zgchain.council.v1.MsgVoteResponse") +} + +func init() { proto.RegisterFile("zgchain/council/v1/tx.proto", fileDescriptor_393766362450e289) } + +var fileDescriptor_393766362450e289 = []byte{ + // 377 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0xc1, 0x4e, 0xf2, 0x40, + 0x10, 0xee, 0x52, 0xfe, 0x1f, 0x59, 0x34, 0x6a, 0xc5, 0x04, 0x4a, 0x52, 0x9a, 0x7a, 0x90, 0x83, + 0x74, 0x01, 0xf5, 0x05, 0xd0, 0x83, 0xc4, 0x70, 0x69, 0x8c, 0x07, 0x2f, 0xa4, 0x2d, 0xeb, 0xd2, + 0x58, 0xba, 0x84, 0x5d, 0x08, 0x78, 0xf5, 0x05, 0x7c, 0x09, 0xdf, 0x85, 0x23, 0x47, 0x4f, 0x46, + 0xcb, 0x8b, 0x18, 0xda, 0xad, 0x62, 0x44, 0xbd, 0xcd, 0xcc, 0xf7, 0xcd, 0xf7, 0xcd, 0xec, 0x2c, + 0x2c, 0xdd, 0x13, 0xb7, 0x67, 0x7b, 0x01, 0x72, 0xe9, 0x28, 0x70, 0x3d, 0x1f, 0x8d, 0xeb, 0x88, + 0x4f, 0xcc, 0xc1, 0x90, 0x72, 0xaa, 0x28, 0x02, 0x34, 0x05, 0x68, 0x8e, 0xeb, 0x6a, 0xd1, 0xa5, + 0xac, 0x4f, 0x59, 0x27, 0x62, 0xa0, 0x38, 0x89, 0xe9, 0x6a, 0x9e, 0x50, 0x42, 0xe3, 0xfa, 0x32, + 0x12, 0xd5, 0x22, 0xa1, 0x94, 0xf8, 0x18, 0x45, 0x99, 0x33, 0xba, 0x45, 0x76, 0x30, 0x15, 0x90, + 0xbe, 0xc6, 0x9c, 0xe0, 0x00, 0x33, 0x4f, 0x48, 0x1a, 0xa7, 0x30, 0xd7, 0x66, 0xc4, 0xc2, 0xc4, + 0x63, 0x1c, 0x0f, 0x95, 0x3c, 0xfc, 0x37, 0xa6, 0x1c, 0x0f, 0x0b, 0x40, 0x07, 0x95, 0xac, 0x15, + 0x27, 0xca, 0x0e, 0x94, 0xef, 0xf0, 0xb4, 0x90, 0xd2, 0x41, 0x65, 0xd3, 0x5a, 0x86, 0xc6, 0x3e, + 0xdc, 0x5b, 0x69, 0xb3, 0x30, 0x1b, 0xd0, 0x80, 0x61, 0xe3, 0x01, 0xc0, 0x4c, 0x9b, 0x91, 0x6b, + 0xca, 0xb1, 0x72, 0x04, 0xa1, 0x70, 0xed, 0x78, 0xdd, 0x48, 0x2f, 0xdd, 0xdc, 0x0a, 0x5f, 0xca, + 0xd9, 0xb3, 0xb8, 0xda, 0x3a, 0xb7, 0xb2, 0x82, 0xd0, 0xea, 0x7e, 0x1a, 0xa7, 0x56, 0x8d, 0x4f, + 0x60, 0xc6, 0xb1, 0x7d, 0x9f, 0x72, 0x56, 0x90, 0x75, 0xb9, 0x92, 0x6b, 0xa8, 0xe6, 0xf7, 0x17, + 0x33, 0x9b, 0x11, 0xc5, 0x4a, 0xa8, 0xc6, 0x2e, 0xdc, 0x16, 0x43, 0x24, 0x83, 0x35, 0x9e, 0x00, + 0x94, 0xdb, 0x8c, 0x28, 0x57, 0x70, 0xe3, 0x63, 0xd7, 0xf2, 0x3a, 0xad, 0x95, 0xad, 0xd4, 0xc3, + 0x3f, 0x08, 0x89, 0xba, 0x72, 0x01, 0xd3, 0xd1, 0xca, 0xa5, 0x1f, 0x1a, 0x96, 0xa0, 0x7a, 0xf0, + 0x0b, 0x98, 0x28, 0x35, 0x2f, 0x67, 0x6f, 0x9a, 0x34, 0x0b, 0x35, 0x30, 0x0f, 0x35, 0xf0, 0x1a, + 0x6a, 0xe0, 0x71, 0xa1, 0x49, 0xf3, 0x85, 0x26, 0x3d, 0x2f, 0x34, 0xe9, 0xa6, 0x4a, 0x3c, 0xde, + 0x1b, 0x39, 0xa6, 0x4b, 0xfb, 0xa8, 0x46, 0x7c, 0xdb, 0x61, 0xa8, 0x46, 0xaa, 0xf1, 0x85, 0x27, + 0x5f, 0x3e, 0xd8, 0x74, 0x80, 0x99, 0xf3, 0x3f, 0x3a, 0xf1, 0xf1, 0x7b, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x6b, 0xcb, 0x48, 0xba, 0x83, 0x02, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + Register(ctx context.Context, in *MsgRegister, opts ...grpc.CallOption) (*MsgRegisterResponse, error) + Vote(ctx context.Context, in *MsgVote, opts ...grpc.CallOption) (*MsgVoteResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) Register(ctx context.Context, in *MsgRegister, opts ...grpc.CallOption) (*MsgRegisterResponse, error) { + out := new(MsgRegisterResponse) + err := c.cc.Invoke(ctx, "/zgchain.council.v1.Msg/Register", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) Vote(ctx context.Context, in *MsgVote, opts ...grpc.CallOption) (*MsgVoteResponse, error) { + out := new(MsgVoteResponse) + err := c.cc.Invoke(ctx, "/zgchain.council.v1.Msg/Vote", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + Register(context.Context, *MsgRegister) (*MsgRegisterResponse, error) + Vote(context.Context, *MsgVote) (*MsgVoteResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) Register(ctx context.Context, req *MsgRegister) (*MsgRegisterResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Register not implemented") +} +func (*UnimplementedMsgServer) Vote(ctx context.Context, req *MsgVote) (*MsgVoteResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Vote not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRegister) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).Register(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgchain.council.v1.Msg/Register", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Register(ctx, req.(*MsgRegister)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_Vote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgVote) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).Vote(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgchain.council.v1.Msg/Vote", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Vote(ctx, req.(*MsgVote)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "zgchain.council.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Register", + Handler: _Msg_Register_Handler, + }, + { + MethodName: "Vote", + Handler: _Msg_Vote_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "zgchain/council/v1/tx.proto", +} + +func (m *MsgRegister) 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 *MsgRegister) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRegister) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintTx(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if len(m.Voter) > 0 { + i -= len(m.Voter) + copy(dAtA[i:], m.Voter) + i = encodeVarintTx(dAtA, i, uint64(len(m.Voter))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRegisterResponse) 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 *MsgRegisterResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRegisterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgVote) 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 *MsgVote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ballots) > 0 { + for iNdEx := len(m.Ballots) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ballots[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Voter) > 0 { + i -= len(m.Voter) + copy(dAtA[i:], m.Voter) + i = encodeVarintTx(dAtA, i, uint64(len(m.Voter))) + i-- + dAtA[i] = 0x12 + } + if m.CouncilID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CouncilID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgVoteResponse) 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 *MsgVoteResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgVoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgRegister) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Voter) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgRegisterResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgVote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CouncilID != 0 { + n += 1 + sovTx(uint64(m.CouncilID)) + } + l = len(m.Voter) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Ballots) > 0 { + for _, e := range m.Ballots { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgVoteResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgRegister) 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 ErrIntOverflowTx + } + 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: MsgRegister: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRegister: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Voter = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRegisterResponse) 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 ErrIntOverflowTx + } + 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: MsgRegisterResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRegisterResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgVote) 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 ErrIntOverflowTx + } + 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: MsgVote: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgVote: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CouncilID", wireType) + } + m.CouncilID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CouncilID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Voter = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ballots", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ballots = append(m.Ballots, &Ballot{}) + if err := m.Ballots[len(m.Ballots)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgVoteResponse) 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 ErrIntOverflowTx + } + 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: MsgVoteResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgVoteResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(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, ErrIntOverflowTx + } + 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, ErrIntOverflowTx + } + 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, ErrIntOverflowTx + } + 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, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/das/v1/client/cli/query.go b/x/das/v1/client/cli/query.go new file mode 100644 index 00000000..b7a715e3 --- /dev/null +++ b/x/das/v1/client/cli/query.go @@ -0,0 +1,57 @@ +package cli + +import ( + "context" + "fmt" + + "github.com/spf13/cobra" + + "github.com/0glabs/0g-chain/x/das/v1/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" +) + +// GetQueryCmd returns the cli query commands for the inflation module. +func GetQueryCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: "Querying commands for the das module", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + cmd.AddCommand( + GetNextRequestID(), + ) + + return cmd +} + +func GetNextRequestID() *cobra.Command { + cmd := &cobra.Command{ + Use: "next-request-id", + Short: "Query the next request ID", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryNextRequestIDRequest{} + res, err := queryClient.NextRequestID(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintString(fmt.Sprintf("%v\n", res.NextRequestID)) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/das/v1/client/cli/tx.go b/x/das/v1/client/cli/tx.go new file mode 100644 index 00000000..1a97c959 --- /dev/null +++ b/x/das/v1/client/cli/tx.go @@ -0,0 +1,103 @@ +package cli + +import ( + "encoding/hex" + "fmt" + "strconv" + + "github.com/0glabs/0g-chain/x/das/v1/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/spf13/cobra" +) + +// GetTxCmd returns the transaction commands for this module +func GetTxCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: fmt.Sprintf("%s transactions subcommands", types.ModuleName), + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + cmd.AddCommand( + NewRequestDASCmd(), + NewReportDASResultCmd(), + ) + return cmd +} + +func NewRequestDASCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "request-das steram-id batch-header-hash num-blobs", + Short: "Request data-availability-sampling", + Args: cobra.ExactArgs(3), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + numBlobs, err := strconv.Atoi(args[2]) + if err != nil { + return err + } + + msg := types.NewMsgRequestDAS(clientCtx.GetFromAddress(), args[0], args[1], uint32(numBlobs)) + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd + +} + +func NewReportDASResultCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "report-das-result request-id results", + Short: "Report data-availability-sampling result", + Args: cobra.MinimumNArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + requestID, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + n := len(args) - 1 + results := make([]bool, n) + for i := 0; i < n; i++ { + var err error + results[i], err = strconv.ParseBool(args[i+1]) + if err != nil { + return err + } + } + + // get account name by address + accAddr := clientCtx.GetFromAddress() + + samplerAddr, err := sdk.ValAddressFromHex(hex.EncodeToString(accAddr.Bytes())) + if err != nil { + return err + } + + msg := &types.MsgReportDASResult{ + RequestID: requestID, + Sampler: samplerAddr.String(), + Results: results, + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/das/v1/genesis.go b/x/das/v1/genesis.go new file mode 100644 index 00000000..4780b693 --- /dev/null +++ b/x/das/v1/genesis.go @@ -0,0 +1,39 @@ +package das + +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/0glabs/0g-chain/x/das/v1/keeper" + "github.com/0glabs/0g-chain/x/das/v1/types" +) + +// InitGenesis initializes the store state from a genesis state. +func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, gs types.GenesisState) { + if err := gs.Validate(); err != nil { + panic(fmt.Sprintf("failed to validate %s genesis state: %s", types.ModuleName, err)) + } + + keeper.SetNextRequestID(ctx, gs.NextRequestID) + for _, req := range gs.Requests { + keeper.SetDASRequest(ctx, req) + } + for _, resp := range gs.Responses { + keeper.SetDASResponse(ctx, resp) + } +} + +// ExportGenesis returns a GenesisState for a given context and keeper. +func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) *types.GenesisState { + nextRequestID, err := keeper.GetNextRequestID(ctx) + if err != nil { + panic(err) + } + + return types.NewGenesisState( + nextRequestID, + keeper.GetDASRequests(ctx), + keeper.GetDASResponses(ctx), + ) +} diff --git a/x/das/v1/keeper/grpc_query.go b/x/das/v1/keeper/grpc_query.go new file mode 100644 index 00000000..e4fddea2 --- /dev/null +++ b/x/das/v1/keeper/grpc_query.go @@ -0,0 +1,22 @@ +package keeper + +import ( + "context" + + "github.com/0glabs/0g-chain/x/das/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var _ types.QueryServer = Keeper{} + +func (k Keeper) NextRequestID( + c context.Context, + _ *types.QueryNextRequestIDRequest, +) (*types.QueryNextRequestIDResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + nextRequestID, err := k.GetNextRequestID(ctx) + if err != nil { + return nil, err + } + return &types.QueryNextRequestIDResponse{NextRequestID: nextRequestID}, nil +} diff --git a/x/das/v1/keeper/keeper.go b/x/das/v1/keeper/keeper.go new file mode 100644 index 00000000..5dcedad5 --- /dev/null +++ b/x/das/v1/keeper/keeper.go @@ -0,0 +1,198 @@ +package keeper + +import ( + "encoding/hex" + "strconv" + + errorsmod "cosmossdk.io/errors" + "github.com/cometbft/cometbft/libs/log" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/store/prefix" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/0glabs/0g-chain/x/das/v1/types" +) + +type Keeper struct { + storeKey storetypes.StoreKey + cdc codec.BinaryCodec + stakingKeeperRef types.StakingKeeperRef +} + +// NewKeeper creates a new das Keeper instance +func NewKeeper( + storeKey storetypes.StoreKey, + cdc codec.BinaryCodec, + stakingKeeper types.StakingKeeperRef, +) Keeper { + return Keeper{ + storeKey: storeKey, + cdc: cdc, + stakingKeeperRef: stakingKeeper, + } +} + +// Logger returns a module-specific logger. +func (k Keeper) Logger(ctx sdk.Context) log.Logger { + return ctx.Logger().With("module", "x/"+types.ModuleName) +} + +func (k Keeper) SetNextRequestID(ctx sdk.Context, id uint64) { + store := ctx.KVStore(k.storeKey) + store.Set(types.NextRequestIDKey, types.GetKeyFromID(id)) +} + +func (k Keeper) GetNextRequestID(ctx sdk.Context) (uint64, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.NextRequestIDKey) + if bz == nil { + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "next request ID not set at genesis") + } + return types.Uint64FromBytes(bz), nil +} + +func (k Keeper) IncrementNextRequestID(ctx sdk.Context) error { + id, err := k.GetNextRequestID(ctx) + if err != nil { + return err + } + k.SetNextRequestID(ctx, id+1) + return nil +} + +func (k Keeper) GetDASRequest(ctx sdk.Context, requestID uint64) (types.DASRequest, bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.RequestKeyPrefix) + bz := store.Get(types.GetKeyFromID(requestID)) + if bz == nil { + return types.DASRequest{}, false + } + var req types.DASRequest + k.cdc.MustUnmarshal(bz, &req) + return req, true +} + +func (k Keeper) SetDASRequest(ctx sdk.Context, req types.DASRequest) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.RequestKeyPrefix) + bz := k.cdc.MustMarshal(&req) + store.Set(types.GetKeyFromID(req.ID), bz) +} + +func (k Keeper) IterateDASRequest(ctx sdk.Context, cb func(req types.DASRequest) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.RequestKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var req types.DASRequest + k.cdc.MustUnmarshal(iterator.Value(), &req) + if cb(req) { + break + } + } +} + +func (k Keeper) GetDASRequests(ctx sdk.Context) []types.DASRequest { + results := []types.DASRequest{} + k.IterateDASRequest(ctx, func(req types.DASRequest) bool { + results = append(results, req) + return false + }) + return results +} + +func (k Keeper) StoreNewDASRequest( + ctx sdk.Context, + streamIDHexStr string, + batchHeaderHashHexStr string, + numBlobs uint32) (uint64, error) { + requestID, err := k.GetNextRequestID(ctx) + if err != nil { + return 0, err + } + + streamID, err := hex.DecodeString(streamIDHexStr) + if err != nil { + return 0, err + } + + batchHeaderHash, err := hex.DecodeString(batchHeaderHashHexStr) + if err != nil { + return 0, err + } + + req := types.DASRequest{ + ID: requestID, + StreamID: streamID, + BatchHeaderHash: batchHeaderHash, + NumBlobs: numBlobs, + } + k.SetDASRequest(ctx, req) + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeDASRequest, + sdk.NewAttribute(types.AttributeKeyRequestID, strconv.FormatUint(requestID, 10)), + sdk.NewAttribute(types.AttributeKeyStreamID, streamIDHexStr), + sdk.NewAttribute(types.AttributeKeyBatchHeaderHash, batchHeaderHashHexStr), + sdk.NewAttribute(types.AttributeKeyNumBlobs, strconv.FormatUint(uint64(numBlobs), 10)), + ), + ) + + return requestID, nil +} + +func (k Keeper) GetDASResponse( + ctx sdk.Context, requestID uint64, sampler sdk.ValAddress, +) (types.DASResponse, bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.ResponseKeyPrefix) + bz := store.Get(types.GetResponseKey(requestID, sampler)) + if bz == nil { + return types.DASResponse{}, false + } + var vote types.DASResponse + k.cdc.MustUnmarshal(bz, &vote) + return vote, true +} + +func (k Keeper) SetDASResponse(ctx sdk.Context, resp types.DASResponse) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.ResponseKeyPrefix) + bz := k.cdc.MustMarshal(&resp) + store.Set(types.GetResponseKey(resp.ID, resp.Sampler), bz) +} + +func (k Keeper) IterateDASResponse(ctx sdk.Context, cb func(resp types.DASResponse) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.ResponseKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var resp types.DASResponse + k.cdc.MustUnmarshal(iterator.Value(), &resp) + if cb(resp) { + break + } + } +} + +func (k Keeper) GetDASResponses(ctx sdk.Context) []types.DASResponse { + results := []types.DASResponse{} + k.IterateDASResponse(ctx, func(resp types.DASResponse) bool { + results = append(results, resp) + return false + }) + return results +} + +func (k Keeper) StoreNewDASResponse( + ctx sdk.Context, requestID uint64, sampler sdk.ValAddress, results []bool) error { + if _, found := k.GetDASRequest(ctx, requestID); !found { + return errorsmod.Wrapf(types.ErrUnknownRequest, "%d", requestID) + } + + k.SetDASResponse(ctx, types.DASResponse{ + ID: requestID, + Sampler: sampler, + Results: results, + }) + + return nil +} diff --git a/x/das/v1/keeper/msg_server.go b/x/das/v1/keeper/msg_server.go new file mode 100644 index 00000000..4109f90a --- /dev/null +++ b/x/das/v1/keeper/msg_server.go @@ -0,0 +1,49 @@ +package keeper + +import ( + "context" + + "github.com/0glabs/0g-chain/x/das/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +var _ types.MsgServer = &Keeper{} + +// RequestDAS handles MsgRequestDAS messages +func (k Keeper) RequestDAS( + goCtx context.Context, msg *types.MsgRequestDAS, +) (*types.MsgRequestDASResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + requestID, err := k.StoreNewDASRequest(ctx, msg.StreamID, msg.BatchHeaderHash, msg.NumBlobs) + if err != nil { + return nil, err + } + k.IncrementNextRequestID(ctx) + return &types.MsgRequestDASResponse{ + RequestID: requestID, + }, nil +} + +// ReportDASResult handles MsgReportDASResult messages +func (k Keeper) ReportDASResult( + goCtx context.Context, msg *types.MsgReportDASResult, +) (*types.MsgReportDASResultResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + sampler, err := sdk.ValAddressFromBech32(msg.Sampler) + if err != nil { + return nil, err + } + + if _, found := k.stakingKeeperRef.GetValidator(ctx, sampler); !found { + return nil, stakingtypes.ErrNoValidatorFound + } + + if err := k.StoreNewDASResponse(ctx, msg.RequestID, sampler, msg.Results); err != nil { + return nil, err + } + + return &types.MsgReportDASResultResponse{}, nil +} diff --git a/x/das/v1/module.go b/x/das/v1/module.go new file mode 100644 index 00000000..288c00bd --- /dev/null +++ b/x/das/v1/module.go @@ -0,0 +1,169 @@ +package das + +import ( + "context" + "encoding/json" + "fmt" + + abci "github.com/cometbft/cometbft/abci/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + "github.com/gorilla/mux" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/spf13/cobra" + + "github.com/0glabs/0g-chain/x/das/v1/client/cli" + "github.com/0glabs/0g-chain/x/das/v1/keeper" + "github.com/0glabs/0g-chain/x/das/v1/types" +) + +// consensusVersion defines the current x/committee module consensus version. +const consensusVersion = 1 + +// type check to ensure the interface is properly implemented +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} + _ module.AppModuleSimulation = AppModule{} + _ module.BeginBlockAppModule = AppModule{} + _ module.EndBlockAppModule = AppModule{} +) + +// app module Basics object +type AppModuleBasic struct{} + +// Name returns the inflation module's name. +func (AppModuleBasic) Name() string { + return types.ModuleName +} + +// RegisterLegacyAminoCodec registers the inflation module's types on the given LegacyAmino codec. +func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {} + +// ConsensusVersion returns the consensus state-breaking version for the module. +func (AppModuleBasic) ConsensusVersion() uint64 { + return consensusVersion +} + +// RegisterInterfaces registers interfaces and implementations of the incentives +// module. +func (AppModuleBasic) RegisterInterfaces(interfaceRegistry codectypes.InterfaceRegistry) { + types.RegisterInterfaces(interfaceRegistry) +} + +// DefaultGenesis returns default genesis state as raw bytes for the incentives +// module. +func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { + return cdc.MustMarshalJSON(types.DefaultGenesisState()) +} + +// ValidateGenesis performs genesis state validation for the inflation module. +func (b AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, _ client.TxEncodingConfig, bz json.RawMessage) error { + var genesisState types.GenesisState + if err := cdc.UnmarshalJSON(bz, &genesisState); err != nil { + return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) + } + + return genesisState.Validate() +} + +// RegisterRESTRoutes performs a no-op as the inflation module doesn't expose REST +// endpoints +func (AppModuleBasic) RegisterRESTRoutes(_ client.Context, _ *mux.Router) {} + +// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the inflation module. +func (b AppModuleBasic) RegisterGRPCGatewayRoutes(c client.Context, serveMux *runtime.ServeMux) { + if err := types.RegisterQueryHandlerClient(context.Background(), serveMux, types.NewQueryClient(c)); err != nil { + panic(err) + } +} + +// GetTxCmd returns the root tx command for the inflation module. +func (AppModuleBasic) GetTxCmd() *cobra.Command { + return cli.GetTxCmd() +} + +// GetQueryCmd returns no root query command for the inflation module. +func (AppModuleBasic) GetQueryCmd() *cobra.Command { + return cli.GetQueryCmd() +} + +// ___________________________________________________________________________ + +// AppModule implements an application module for the inflation module. +type AppModule struct { + AppModuleBasic + keeper keeper.Keeper +} + +// NewAppModule creates a new AppModule Object +func NewAppModule( + k keeper.Keeper, +) AppModule { + return AppModule{ + AppModuleBasic: AppModuleBasic{}, + keeper: k, + } +} + +// Name returns the inflation module's name. +func (AppModule) Name() string { + return types.ModuleName +} + +// RegisterInvariants registers the inflation module invariants. +func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {} + +// RegisterServices registers a gRPC query service to respond to the +// module-specific gRPC queries. +func (am AppModule) RegisterServices(cfg module.Configurator) { + types.RegisterMsgServer(cfg.MsgServer(), am.keeper) + types.RegisterQueryServer(cfg.QueryServer(), am.keeper) +} + +func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) { + // am.keeper.BeginBlock(ctx, req) +} + +func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate { + // am.keeper.EndBlock(ctx, req) + return []abci.ValidatorUpdate{} +} + +// InitGenesis performs genesis initialization for the inflation module. It returns +// no validator updates. +func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate { + var genesisState types.GenesisState + + cdc.MustUnmarshalJSON(data, &genesisState) + InitGenesis(ctx, am.keeper, genesisState) + return []abci.ValidatorUpdate{} +} + +// ExportGenesis returns the exported genesis state as raw bytes for the inflation +// module. +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + gs := ExportGenesis(ctx, am.keeper) + return cdc.MustMarshalJSON(gs) +} + +// ___________________________________________________________________________ + +// AppModuleSimulation functions + +// GenerateGenesisState creates a randomized GenState of the inflation module. +func (am AppModule) GenerateGenesisState(_ *module.SimulationState) { +} + +// RegisterStoreDecoder registers a decoder for inflation module's types. +func (am AppModule) RegisterStoreDecoder(_ sdk.StoreDecoderRegistry) { +} + +// WeightedOperations doesn't return any inflation module operation. +func (am AppModule) WeightedOperations(_ module.SimulationState) []simtypes.WeightedOperation { + return []simtypes.WeightedOperation{} +} diff --git a/x/das/v1/types/codec.go b/x/das/v1/types/codec.go new file mode 100644 index 00000000..883a699e --- /dev/null +++ b/x/das/v1/types/codec.go @@ -0,0 +1,47 @@ +package types + +import ( + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/msgservice" +) + +var ( + amino = codec.NewLegacyAmino() + // ModuleCdc references the global evm module codec. Note, the codec should + // ONLY be used in certain instances of tests and for JSON encoding. + ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry()) + + // AminoCdc is a amino codec created to support amino JSON compatible msgs. + AminoCdc = codec.NewAminoCodec(amino) +) + +const ( + // Amino names + requestDASName = "evmos/das/MsgRequestDAS" + reportDASResultName = "evmos/das/MsgReportDASResult" +) + +// NOTE: This is required for the GetSignBytes function +func init() { + RegisterLegacyAminoCodec(amino) + amino.Seal() +} + +// RegisterInterfaces register implementations +func RegisterInterfaces(registry codectypes.InterfaceRegistry) { + registry.RegisterImplementations( + (*sdk.Msg)(nil), + &MsgRequestDAS{}, + &MsgReportDASResult{}, + ) + + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) +} + +// RegisterLegacyAminoCodec required for EIP-712 +func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgRequestDAS{}, requestDASName, nil) + cdc.RegisterConcrete(&MsgReportDASResult{}, reportDASResultName, nil) +} diff --git a/x/das/v1/types/errors.go b/x/das/v1/types/errors.go new file mode 100644 index 00000000..77469e4a --- /dev/null +++ b/x/das/v1/types/errors.go @@ -0,0 +1,8 @@ +package types + +import errorsmod "cosmossdk.io/errors" + +var ( + ErrUnknownRequest = errorsmod.Register(ModuleName, 0, "request not found") + ErrInvalidGenesis = errorsmod.Register(ModuleName, 1, "invalid genesis") +) diff --git a/x/das/v1/types/events.go b/x/das/v1/types/events.go new file mode 100644 index 00000000..3a7159a4 --- /dev/null +++ b/x/das/v1/types/events.go @@ -0,0 +1,11 @@ +package types + +// Module event types +const ( + EventTypeDASRequest = "das_request" + + AttributeKeyRequestID = "request_id" + AttributeKeyStreamID = "stream_id" + AttributeKeyBatchHeaderHash = "batch_header_hash" + AttributeKeyNumBlobs = "num_blobs" +) diff --git a/x/das/v1/types/genesis.go b/x/das/v1/types/genesis.go new file mode 100644 index 00000000..fd0c6fde --- /dev/null +++ b/x/das/v1/types/genesis.go @@ -0,0 +1,28 @@ +package types + +const ( + DefaultNextRequestID = 0 +) + +// NewGenesisState returns a new genesis state object for the module. +func NewGenesisState(nextRequestID uint64, requests []DASRequest, responses []DASResponse) *GenesisState { + return &GenesisState{ + NextRequestID: nextRequestID, + Requests: requests, + Responses: responses, + } +} + +// DefaultGenesisState returns the default genesis state for the module. +func DefaultGenesisState() *GenesisState { + return NewGenesisState( + DefaultNextRequestID, + []DASRequest{}, + []DASResponse{}, + ) +} + +// Validate performs basic validation of genesis data. +func (gs GenesisState) Validate() error { + return nil +} diff --git a/x/das/v1/types/genesis.pb.go b/x/das/v1/types/genesis.pb.go new file mode 100644 index 00000000..eeeccac2 --- /dev/null +++ b/x/das/v1/types/genesis.pb.go @@ -0,0 +1,1191 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgchain/das/v1/genesis.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" + _ "google.golang.org/protobuf/types/known/timestamppb" + 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 + +type Params struct { +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_96b4f57b6fa50fe6, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +// GenesisState defines the das module's genesis state. +type GenesisState struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + NextRequestID uint64 `protobuf:"varint,2,opt,name=next_request_id,json=nextRequestId,proto3" json:"next_request_id,omitempty"` + Requests []DASRequest `protobuf:"bytes,3,rep,name=requests,proto3" json:"requests"` + Responses []DASResponse `protobuf:"bytes,4,rep,name=responses,proto3" json:"responses"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_96b4f57b6fa50fe6, []int{1} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +type DASRequest struct { + ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + StreamID []byte `protobuf:"bytes,2,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"` + BatchHeaderHash []byte `protobuf:"bytes,3,opt,name=batch_header_hash,json=batchHeaderHash,proto3" json:"batch_header_hash,omitempty"` + NumBlobs uint32 `protobuf:"varint,4,opt,name=num_blobs,json=numBlobs,proto3" json:"num_blobs,omitempty"` +} + +func (m *DASRequest) Reset() { *m = DASRequest{} } +func (m *DASRequest) String() string { return proto.CompactTextString(m) } +func (*DASRequest) ProtoMessage() {} +func (*DASRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_96b4f57b6fa50fe6, []int{2} +} +func (m *DASRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DASRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DASRequest.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 *DASRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DASRequest.Merge(m, src) +} +func (m *DASRequest) XXX_Size() int { + return m.Size() +} +func (m *DASRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DASRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DASRequest proto.InternalMessageInfo + +func (m *DASRequest) GetID() uint64 { + if m != nil { + return m.ID + } + return 0 +} + +func (m *DASRequest) GetStreamID() []byte { + if m != nil { + return m.StreamID + } + return nil +} + +func (m *DASRequest) GetBatchHeaderHash() []byte { + if m != nil { + return m.BatchHeaderHash + } + return nil +} + +func (m *DASRequest) GetNumBlobs() uint32 { + if m != nil { + return m.NumBlobs + } + return 0 +} + +type DASResponse struct { + ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Sampler github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=sampler,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"sampler,omitempty"` + Results []bool `protobuf:"varint,3,rep,packed,name=results,proto3" json:"results,omitempty"` +} + +func (m *DASResponse) Reset() { *m = DASResponse{} } +func (m *DASResponse) String() string { return proto.CompactTextString(m) } +func (*DASResponse) ProtoMessage() {} +func (*DASResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_96b4f57b6fa50fe6, []int{3} +} +func (m *DASResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DASResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DASResponse.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 *DASResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DASResponse.Merge(m, src) +} +func (m *DASResponse) XXX_Size() int { + return m.Size() +} +func (m *DASResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DASResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DASResponse proto.InternalMessageInfo + +func (m *DASResponse) GetID() uint64 { + if m != nil { + return m.ID + } + return 0 +} + +func (m *DASResponse) GetSampler() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.Sampler + } + return nil +} + +func (m *DASResponse) GetResults() []bool { + if m != nil { + return m.Results + } + return nil +} + +func init() { + proto.RegisterType((*Params)(nil), "zgchain.das.v1.Params") + proto.RegisterType((*GenesisState)(nil), "zgchain.das.v1.GenesisState") + proto.RegisterType((*DASRequest)(nil), "zgchain.das.v1.DASRequest") + proto.RegisterType((*DASResponse)(nil), "zgchain.das.v1.DASResponse") +} + +func init() { proto.RegisterFile("zgchain/das/v1/genesis.proto", fileDescriptor_96b4f57b6fa50fe6) } + +var fileDescriptor_96b4f57b6fa50fe6 = []byte{ + // 526 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x53, 0xbf, 0x6f, 0xd3, 0x4e, + 0x14, 0x8f, 0x93, 0x28, 0x75, 0x2e, 0xc9, 0xb7, 0xaa, 0xbf, 0xa8, 0x72, 0x53, 0x64, 0x47, 0x99, + 0x52, 0xa4, 0xd8, 0x6d, 0x61, 0x01, 0x21, 0xa1, 0x9a, 0x48, 0x24, 0x0b, 0x42, 0x8e, 0xc4, 0xc0, + 0x62, 0x9d, 0x73, 0x87, 0x6d, 0x61, 0xfb, 0x8c, 0xdf, 0xb9, 0x4a, 0x98, 0x19, 0x18, 0x19, 0x19, + 0x91, 0xf8, 0x17, 0xf8, 0x23, 0x3a, 0x56, 0x4c, 0x4c, 0x16, 0x72, 0xfe, 0x0b, 0x26, 0x14, 0xfb, + 0x42, 0x43, 0x05, 0x93, 0xfd, 0x3e, 0x3f, 0xfc, 0x3e, 0xcf, 0xf7, 0x0e, 0xdd, 0x7d, 0xe7, 0x2d, + 0x7c, 0x1c, 0xc4, 0x26, 0xc1, 0x60, 0x5e, 0x9e, 0x99, 0x1e, 0x8d, 0x29, 0x04, 0x60, 0x24, 0x29, + 0xe3, 0x4c, 0xf9, 0x4f, 0xb0, 0x06, 0xc1, 0x60, 0x5c, 0x9e, 0xf5, 0x8f, 0x16, 0x0c, 0x22, 0x06, + 0x4e, 0xc9, 0x9a, 0x55, 0x51, 0x49, 0xfb, 0x77, 0x3c, 0xe6, 0xb1, 0x0a, 0xdf, 0xbc, 0x09, 0xf4, + 0xc8, 0x63, 0xcc, 0x0b, 0xa9, 0x59, 0x56, 0x6e, 0xf6, 0xda, 0xc4, 0xf1, 0x4a, 0x50, 0xfa, 0x6d, + 0x8a, 0x07, 0x11, 0x05, 0x8e, 0xa3, 0xa4, 0x12, 0x0c, 0x65, 0xd4, 0x7a, 0x81, 0x53, 0x1c, 0xc1, + 0xf0, 0x7d, 0x1d, 0x75, 0x9f, 0x55, 0xc1, 0xe6, 0x1c, 0x73, 0xaa, 0x3c, 0x40, 0xad, 0xa4, 0xa4, + 0x54, 0x69, 0x20, 0x8d, 0x3a, 0xe7, 0x87, 0xc6, 0x9f, 0x41, 0x8d, 0xca, 0x68, 0x35, 0xaf, 0x72, + 0xbd, 0x66, 0x0b, 0xad, 0xf2, 0x10, 0xed, 0xc7, 0x74, 0xc9, 0x9d, 0x94, 0xbe, 0xcd, 0x28, 0x70, + 0x27, 0x20, 0x6a, 0x7d, 0x20, 0x8d, 0x9a, 0xd6, 0x41, 0x91, 0xeb, 0xbd, 0xe7, 0x74, 0xc9, 0xed, + 0x8a, 0x99, 0x4d, 0xec, 0x5e, 0xbc, 0x53, 0x12, 0xe5, 0x31, 0x92, 0x85, 0x0b, 0xd4, 0xc6, 0xa0, + 0x31, 0xea, 0x9c, 0xf7, 0x6f, 0xb7, 0x9c, 0x5c, 0xcc, 0x85, 0x5e, 0xb4, 0xfd, 0xed, 0x50, 0x9e, + 0xa0, 0x76, 0x4a, 0x21, 0x61, 0x31, 0x50, 0x50, 0x9b, 0xa5, 0xfd, 0xf8, 0xaf, 0xf6, 0x4a, 0x23, + 0xfc, 0x37, 0x9e, 0x47, 0xcd, 0x0f, 0x9f, 0xf5, 0xda, 0xf0, 0x93, 0x84, 0xd0, 0x4d, 0x17, 0xe5, + 0x10, 0xd5, 0x03, 0x52, 0xfe, 0x80, 0xa6, 0xd5, 0x2a, 0x72, 0xbd, 0x3e, 0x9b, 0xd8, 0xf5, 0x80, + 0x28, 0x27, 0xa8, 0x0d, 0x3c, 0xa5, 0x38, 0xda, 0x0e, 0xd8, 0xb5, 0xba, 0x45, 0xae, 0xcb, 0xf3, + 0x12, 0x9c, 0x4d, 0x6c, 0xb9, 0xa2, 0x67, 0x44, 0xb9, 0x87, 0x0e, 0x5c, 0xcc, 0x17, 0xbe, 0xe3, + 0x53, 0x4c, 0x68, 0xea, 0xf8, 0x18, 0x7c, 0xb5, 0xb1, 0xb1, 0xd8, 0xfb, 0x25, 0x31, 0x2d, 0xf1, + 0x29, 0x06, 0x5f, 0x39, 0x46, 0xed, 0x38, 0x8b, 0x1c, 0x37, 0x64, 0xee, 0x66, 0x08, 0x69, 0xd4, + 0xb3, 0xe5, 0x38, 0x8b, 0xac, 0x4d, 0x3d, 0xfc, 0x22, 0xa1, 0xce, 0xce, 0x04, 0xff, 0xcc, 0xe6, + 0xa2, 0x3d, 0xc0, 0x51, 0x12, 0xd2, 0x54, 0x24, 0x9b, 0xfe, 0xcc, 0xf5, 0xb1, 0x17, 0x70, 0x3f, + 0x73, 0x8d, 0x05, 0x8b, 0xc4, 0x4e, 0x89, 0xc7, 0x18, 0xc8, 0x1b, 0x93, 0xaf, 0x12, 0x0a, 0xc6, + 0x4b, 0x1c, 0x5e, 0x10, 0x92, 0x52, 0x80, 0x6f, 0x5f, 0xc7, 0xff, 0x8b, 0xcd, 0x13, 0x88, 0xb5, + 0xe2, 0x14, 0xec, 0xed, 0x87, 0x15, 0x15, 0xed, 0xa5, 0x14, 0xb2, 0x50, 0x1c, 0x95, 0x6c, 0x6f, + 0x4b, 0xeb, 0xe9, 0x55, 0xa1, 0x49, 0xd7, 0x85, 0x26, 0xfd, 0x28, 0x34, 0xe9, 0xe3, 0x5a, 0xab, + 0x5d, 0xaf, 0xb5, 0xda, 0xf7, 0xb5, 0x56, 0x7b, 0x75, 0xb2, 0x13, 0xe1, 0xd4, 0x0b, 0xb1, 0x0b, + 0xe6, 0xa9, 0x37, 0xae, 0x6e, 0xc6, 0x72, 0x7b, 0x37, 0xca, 0x24, 0x6e, 0xab, 0xdc, 0xce, 0xfb, + 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0xca, 0x4c, 0x89, 0x68, 0x3a, 0x03, 0x00, 0x00, +} + +func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Responses) > 0 { + for iNdEx := len(m.Responses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Responses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.Requests) > 0 { + for iNdEx := len(m.Requests) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Requests[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if m.NextRequestID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.NextRequestID)) + i-- + dAtA[i] = 0x10 + } + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *DASRequest) 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 *DASRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DASRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NumBlobs != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.NumBlobs)) + i-- + dAtA[i] = 0x20 + } + if len(m.BatchHeaderHash) > 0 { + i -= len(m.BatchHeaderHash) + copy(dAtA[i:], m.BatchHeaderHash) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.BatchHeaderHash))) + i-- + dAtA[i] = 0x1a + } + if len(m.StreamID) > 0 { + i -= len(m.StreamID) + copy(dAtA[i:], m.StreamID) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.StreamID))) + i-- + dAtA[i] = 0x12 + } + if m.ID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *DASResponse) 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 *DASResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DASResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Results) > 0 { + for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- { + i-- + if m.Results[iNdEx] { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + } + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Results))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sampler) > 0 { + i -= len(m.Sampler) + copy(dAtA[i:], m.Sampler) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Sampler))) + i-- + dAtA[i] = 0x12 + } + if m.ID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + if m.NextRequestID != 0 { + n += 1 + sovGenesis(uint64(m.NextRequestID)) + } + if len(m.Requests) > 0 { + for _, e := range m.Requests { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.Responses) > 0 { + for _, e := range m.Responses { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *DASRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovGenesis(uint64(m.ID)) + } + l = len(m.StreamID) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + l = len(m.BatchHeaderHash) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + if m.NumBlobs != 0 { + n += 1 + sovGenesis(uint64(m.NumBlobs)) + } + return n +} + +func (m *DASResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovGenesis(uint64(m.ID)) + } + l = len(m.Sampler) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + if len(m.Results) > 0 { + n += 1 + sovGenesis(uint64(len(m.Results))) + len(m.Results)*1 + } + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) 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 ErrIntOverflowGenesis + } + 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: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisState) 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 ErrIntOverflowGenesis + } + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NextRequestID", wireType) + } + m.NextRequestID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NextRequestID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Requests = append(m.Requests, DASRequest{}) + if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Responses = append(m.Responses, DASResponse{}) + if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DASRequest) 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 ErrIntOverflowGenesis + } + 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: DASRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DASRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StreamID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StreamID = append(m.StreamID[:0], dAtA[iNdEx:postIndex]...) + if m.StreamID == nil { + m.StreamID = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BatchHeaderHash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BatchHeaderHash = append(m.BatchHeaderHash[:0], dAtA[iNdEx:postIndex]...) + if m.BatchHeaderHash == nil { + m.BatchHeaderHash = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NumBlobs", wireType) + } + m.NumBlobs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NumBlobs |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DASResponse) 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 ErrIntOverflowGenesis + } + 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: DASResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DASResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sampler", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sampler = append(m.Sampler[:0], dAtA[iNdEx:postIndex]...) + if m.Sampler == nil { + m.Sampler = []byte{} + } + iNdEx = postIndex + case 3: + if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + elementCount = packedLen + if elementCount != 0 && len(m.Results) == 0 { + m.Results = make([]bool, 0, elementCount) + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenesis(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, ErrIntOverflowGenesis + } + 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, ErrIntOverflowGenesis + } + 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, ErrIntOverflowGenesis + } + 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, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/das/v1/types/interfaces.go b/x/das/v1/types/interfaces.go new file mode 100644 index 00000000..ff56b322 --- /dev/null +++ b/x/das/v1/types/interfaces.go @@ -0,0 +1,10 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +type StakingKeeperRef interface { + GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator stakingtypes.Validator, found bool) +} diff --git a/x/das/v1/types/keys.go b/x/das/v1/types/keys.go new file mode 100644 index 00000000..06846cb9 --- /dev/null +++ b/x/das/v1/types/keys.go @@ -0,0 +1,44 @@ +package types + +import ( + "encoding/binary" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +const ( + // ModuleName The name that will be used throughout the module + ModuleName = "das" + + // StoreKey Top level store key where all module items will be stored + StoreKey = ModuleName +) + +// Key prefixes +var ( + RequestKeyPrefix = []byte{0x00} // prefix for keys that store requests + ResponseKeyPrefix = []byte{0x01} // prefix for keys that store responses + + NextRequestIDKey = []byte{0x02} +) + +// GetKeyFromID returns the bytes to use as a key for a uint64 id +func GetKeyFromID(id uint64) []byte { + return Uint64ToBytes(id) +} + +func GetResponseKey(requestID uint64, sampler sdk.ValAddress) []byte { + return append(GetKeyFromID(requestID), sampler.Bytes()...) +} + +// Uint64ToBytes converts a uint64 into fixed length bytes for use in store keys. +func Uint64ToBytes(id uint64) []byte { + bz := make([]byte, 8) + binary.BigEndian.PutUint64(bz, uint64(id)) + return bz +} + +// Uint64FromBytes converts some fixed length bytes back into a uint64. +func Uint64FromBytes(bz []byte) uint64 { + return binary.BigEndian.Uint64(bz) +} diff --git a/x/das/v1/types/msg.go b/x/das/v1/types/msg.go new file mode 100644 index 00000000..f1c07ce4 --- /dev/null +++ b/x/das/v1/types/msg.go @@ -0,0 +1,57 @@ +package types + +import ( + "encoding/hex" + + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +var _, _ sdk.Msg = &MsgRequestDAS{}, &MsgReportDASResult{} + +func NewMsgRequestDAS(fromAddr sdk.AccAddress, streamID, hash string, numBlobs uint32) *MsgRequestDAS { + return &MsgRequestDAS{ + Requester: fromAddr.String(), + StreamID: streamID, + BatchHeaderHash: hash, + NumBlobs: numBlobs, + } +} + +func (msg MsgRequestDAS) GetSigners() []sdk.AccAddress { + from, err := sdk.AccAddressFromBech32(msg.Requester) + if err != nil { + panic(err) + } + return []sdk.AccAddress{from} +} + +func (msg MsgRequestDAS) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Requester) + if err != nil { + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid requester account address (%s)", err) + } + + return nil +} + +func (msg *MsgReportDASResult) GetSigners() []sdk.AccAddress { + samplerValAddr, err := sdk.ValAddressFromBech32(msg.Sampler) + if err != nil { + panic(err) + } + accAddr, err := sdk.AccAddressFromHexUnsafe(hex.EncodeToString(samplerValAddr.Bytes())) + if err != nil { + panic(err) + } + return []sdk.AccAddress{accAddr} +} + +func (msg *MsgReportDASResult) ValidateBasic() error { + _, err := sdk.ValAddressFromBech32(msg.Sampler) + if err != nil { + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sampler validator address (%s)", err) + } + return nil +} diff --git a/x/das/v1/types/query.pb.go b/x/das/v1/types/query.pb.go new file mode 100644 index 00000000..85c43256 --- /dev/null +++ b/x/das/v1/types/query.pb.go @@ -0,0 +1,511 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgchain/das/v1/query.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + _ "google.golang.org/protobuf/types/known/timestamppb" + 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 + +type QueryNextRequestIDRequest struct { +} + +func (m *QueryNextRequestIDRequest) Reset() { *m = QueryNextRequestIDRequest{} } +func (m *QueryNextRequestIDRequest) String() string { return proto.CompactTextString(m) } +func (*QueryNextRequestIDRequest) ProtoMessage() {} +func (*QueryNextRequestIDRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_85f6a3b908e82771, []int{0} +} +func (m *QueryNextRequestIDRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryNextRequestIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryNextRequestIDRequest.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 *QueryNextRequestIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryNextRequestIDRequest.Merge(m, src) +} +func (m *QueryNextRequestIDRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryNextRequestIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryNextRequestIDRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryNextRequestIDRequest proto.InternalMessageInfo + +type QueryNextRequestIDResponse struct { + NextRequestID uint64 `protobuf:"varint,1,opt,name=next_request_id,json=nextRequestId,proto3" json:"next_request_id,omitempty"` +} + +func (m *QueryNextRequestIDResponse) Reset() { *m = QueryNextRequestIDResponse{} } +func (m *QueryNextRequestIDResponse) String() string { return proto.CompactTextString(m) } +func (*QueryNextRequestIDResponse) ProtoMessage() {} +func (*QueryNextRequestIDResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_85f6a3b908e82771, []int{1} +} +func (m *QueryNextRequestIDResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryNextRequestIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryNextRequestIDResponse.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 *QueryNextRequestIDResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryNextRequestIDResponse.Merge(m, src) +} +func (m *QueryNextRequestIDResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryNextRequestIDResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryNextRequestIDResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryNextRequestIDResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*QueryNextRequestIDRequest)(nil), "zgchain.das.v1.QueryNextRequestIDRequest") + proto.RegisterType((*QueryNextRequestIDResponse)(nil), "zgchain.das.v1.QueryNextRequestIDResponse") +} + +func init() { proto.RegisterFile("zgchain/das/v1/query.proto", fileDescriptor_85f6a3b908e82771) } + +var fileDescriptor_85f6a3b908e82771 = []byte{ + // 333 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xaa, 0x4a, 0x4f, 0xce, + 0x48, 0xcc, 0xcc, 0xd3, 0x4f, 0x49, 0x2c, 0xd6, 0x2f, 0x33, 0xd4, 0x2f, 0x2c, 0x4d, 0x2d, 0xaa, + 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x83, 0xca, 0xe9, 0xa5, 0x24, 0x16, 0xeb, 0x95, + 0x19, 0x4a, 0x49, 0x26, 0xe7, 0x17, 0xe7, 0xe6, 0x17, 0xc7, 0x83, 0x65, 0xf5, 0x21, 0x1c, 0x88, + 0x52, 0x29, 0x91, 0xf4, 0xfc, 0xf4, 0x7c, 0x88, 0x38, 0x88, 0x05, 0x15, 0x95, 0x49, 0xcf, 0xcf, + 0x4f, 0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xcc, 0xcb, 0xcb, 0x2f, 0x49, 0x2c, 0xc9, + 0xcc, 0xcf, 0x83, 0xe9, 0x91, 0x84, 0xca, 0x82, 0x79, 0x49, 0xa5, 0x69, 0xfa, 0x89, 0x79, 0x50, + 0x9b, 0xa5, 0xe4, 0xd1, 0xa5, 0x4a, 0x32, 0x73, 0x53, 0x8b, 0x4b, 0x12, 0x73, 0x0b, 0x20, 0x0a, + 0x94, 0xa4, 0xb9, 0x24, 0x03, 0x41, 0x2e, 0xf5, 0x4b, 0xad, 0x28, 0x09, 0x4a, 0x2d, 0x2c, 0x4d, + 0x2d, 0x2e, 0xf1, 0x74, 0x81, 0x32, 0x94, 0xc2, 0xb9, 0xa4, 0xb0, 0x49, 0x16, 0x17, 0xe4, 0xe7, + 0x15, 0xa7, 0x0a, 0x59, 0x72, 0xf1, 0xe7, 0xa5, 0x56, 0x94, 0xc4, 0x17, 0x41, 0x64, 0xe2, 0x33, + 0x53, 0x24, 0x18, 0x15, 0x18, 0x35, 0x58, 0x9c, 0x04, 0x1f, 0xdd, 0x93, 0xe7, 0x45, 0xd5, 0xc3, + 0x9b, 0x87, 0xc4, 0x4d, 0x31, 0x9a, 0xc9, 0xc8, 0xc5, 0x0a, 0x36, 0x59, 0xa8, 0x9f, 0x91, 0x0b, + 0x55, 0xa9, 0x90, 0xa6, 0x1e, 0x6a, 0x68, 0xe9, 0xe1, 0x74, 0x9f, 0x94, 0x16, 0x31, 0x4a, 0x21, + 0xae, 0x55, 0x52, 0x6f, 0xba, 0xfc, 0x64, 0x32, 0x93, 0xa2, 0x90, 0xbc, 0xbe, 0x01, 0x6a, 0x44, + 0x81, 0x5c, 0xa6, 0x0b, 0xf5, 0x83, 0x6e, 0x66, 0x8a, 0x93, 0xfb, 0x89, 0x87, 0x72, 0x0c, 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, 0x99, 0x9e, 0x59, 0x92, 0x51, 0x9a, + 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x6f, 0x90, 0x9e, 0x93, 0x98, 0x54, 0xac, 0x6f, 0x90, 0xae, 0x0b, + 0x31, 0xb0, 0x02, 0x66, 0x64, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0x38, 0x84, 0x8d, 0x01, + 0x01, 0x00, 0x00, 0xff, 0xff, 0x28, 0x1d, 0xab, 0x40, 0x1a, 0x02, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + NextRequestID(ctx context.Context, in *QueryNextRequestIDRequest, opts ...grpc.CallOption) (*QueryNextRequestIDResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) NextRequestID(ctx context.Context, in *QueryNextRequestIDRequest, opts ...grpc.CallOption) (*QueryNextRequestIDResponse, error) { + out := new(QueryNextRequestIDResponse) + err := c.cc.Invoke(ctx, "/zgchain.das.v1.Query/NextRequestID", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + NextRequestID(context.Context, *QueryNextRequestIDRequest) (*QueryNextRequestIDResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) NextRequestID(ctx context.Context, req *QueryNextRequestIDRequest) (*QueryNextRequestIDResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method NextRequestID not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_NextRequestID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryNextRequestIDRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).NextRequestID(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgchain.das.v1.Query/NextRequestID", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).NextRequestID(ctx, req.(*QueryNextRequestIDRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "zgchain.das.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "NextRequestID", + Handler: _Query_NextRequestID_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "zgchain/das/v1/query.proto", +} + +func (m *QueryNextRequestIDRequest) 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 *QueryNextRequestIDRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryNextRequestIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryNextRequestIDResponse) 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 *QueryNextRequestIDResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryNextRequestIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NextRequestID != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.NextRequestID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryNextRequestIDRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryNextRequestIDResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NextRequestID != 0 { + n += 1 + sovQuery(uint64(m.NextRequestID)) + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryNextRequestIDRequest) 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 ErrIntOverflowQuery + } + 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: QueryNextRequestIDRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryNextRequestIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryNextRequestIDResponse) 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 ErrIntOverflowQuery + } + 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: QueryNextRequestIDResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryNextRequestIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NextRequestID", wireType) + } + m.NextRequestID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NextRequestID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(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, ErrIntOverflowQuery + } + 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, ErrIntOverflowQuery + } + 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, ErrIntOverflowQuery + } + 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, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/das/v1/types/query.pb.gw.go b/x/das/v1/types/query.pb.gw.go new file mode 100644 index 00000000..657b95d4 --- /dev/null +++ b/x/das/v1/types/query.pb.gw.go @@ -0,0 +1,153 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: zgchain/das/v1/query.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage +var _ = metadata.Join + +func request_Query_NextRequestID_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryNextRequestIDRequest + var metadata runtime.ServerMetadata + + msg, err := client.NextRequestID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_NextRequestID_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryNextRequestIDRequest + var metadata runtime.ServerMetadata + + msg, err := server.NextRequestID(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_NextRequestID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_NextRequestID_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_NextRequestID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_NextRequestID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_NextRequestID_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_NextRequestID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_NextRequestID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0gchain", "das", "v1", "next-request-id"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_NextRequestID_0 = runtime.ForwardResponseMessage +) diff --git a/x/das/v1/types/tx.pb.go b/x/das/v1/types/tx.pb.go new file mode 100644 index 00000000..4192668e --- /dev/null +++ b/x/das/v1/types/tx.pb.go @@ -0,0 +1,1110 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgchain/das/v1/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +type MsgRequestDAS struct { + Requester string `protobuf:"bytes,1,opt,name=requester,proto3" json:"requester,omitempty" Requester` + StreamID string `protobuf:"bytes,2,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"` + BatchHeaderHash string `protobuf:"bytes,3,opt,name=batch_header_hash,json=batchHeaderHash,proto3" json:"batch_header_hash,omitempty"` + NumBlobs uint32 `protobuf:"varint,4,opt,name=num_blobs,json=numBlobs,proto3" json:"num_blobs,omitempty"` +} + +func (m *MsgRequestDAS) Reset() { *m = MsgRequestDAS{} } +func (m *MsgRequestDAS) String() string { return proto.CompactTextString(m) } +func (*MsgRequestDAS) ProtoMessage() {} +func (*MsgRequestDAS) Descriptor() ([]byte, []int) { + return fileDescriptor_9cdd2d5d7454aa75, []int{0} +} +func (m *MsgRequestDAS) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRequestDAS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRequestDAS.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 *MsgRequestDAS) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRequestDAS.Merge(m, src) +} +func (m *MsgRequestDAS) XXX_Size() int { + return m.Size() +} +func (m *MsgRequestDAS) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRequestDAS.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRequestDAS proto.InternalMessageInfo + +type MsgRequestDASResponse struct { + RequestID uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` +} + +func (m *MsgRequestDASResponse) Reset() { *m = MsgRequestDASResponse{} } +func (m *MsgRequestDASResponse) String() string { return proto.CompactTextString(m) } +func (*MsgRequestDASResponse) ProtoMessage() {} +func (*MsgRequestDASResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_9cdd2d5d7454aa75, []int{1} +} +func (m *MsgRequestDASResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRequestDASResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRequestDASResponse.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 *MsgRequestDASResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRequestDASResponse.Merge(m, src) +} +func (m *MsgRequestDASResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgRequestDASResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRequestDASResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRequestDASResponse proto.InternalMessageInfo + +type MsgReportDASResult struct { + RequestID uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + Sampler string `protobuf:"bytes,2,opt,name=sampler,proto3" json:"sampler,omitempty"` + Results []bool `protobuf:"varint,3,rep,packed,name=results,proto3" json:"results,omitempty"` +} + +func (m *MsgReportDASResult) Reset() { *m = MsgReportDASResult{} } +func (m *MsgReportDASResult) String() string { return proto.CompactTextString(m) } +func (*MsgReportDASResult) ProtoMessage() {} +func (*MsgReportDASResult) Descriptor() ([]byte, []int) { + return fileDescriptor_9cdd2d5d7454aa75, []int{2} +} +func (m *MsgReportDASResult) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgReportDASResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgReportDASResult.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 *MsgReportDASResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgReportDASResult.Merge(m, src) +} +func (m *MsgReportDASResult) XXX_Size() int { + return m.Size() +} +func (m *MsgReportDASResult) XXX_DiscardUnknown() { + xxx_messageInfo_MsgReportDASResult.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgReportDASResult proto.InternalMessageInfo + +type MsgReportDASResultResponse struct { +} + +func (m *MsgReportDASResultResponse) Reset() { *m = MsgReportDASResultResponse{} } +func (m *MsgReportDASResultResponse) String() string { return proto.CompactTextString(m) } +func (*MsgReportDASResultResponse) ProtoMessage() {} +func (*MsgReportDASResultResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_9cdd2d5d7454aa75, []int{3} +} +func (m *MsgReportDASResultResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgReportDASResultResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgReportDASResultResponse.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 *MsgReportDASResultResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgReportDASResultResponse.Merge(m, src) +} +func (m *MsgReportDASResultResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgReportDASResultResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgReportDASResultResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgReportDASResultResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgRequestDAS)(nil), "zgchain.das.v1.MsgRequestDAS") + proto.RegisterType((*MsgRequestDASResponse)(nil), "zgchain.das.v1.MsgRequestDASResponse") + proto.RegisterType((*MsgReportDASResult)(nil), "zgchain.das.v1.MsgReportDASResult") + proto.RegisterType((*MsgReportDASResultResponse)(nil), "zgchain.das.v1.MsgReportDASResultResponse") +} + +func init() { proto.RegisterFile("zgchain/das/v1/tx.proto", fileDescriptor_9cdd2d5d7454aa75) } + +var fileDescriptor_9cdd2d5d7454aa75 = []byte{ + // 453 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0x41, 0x6e, 0xd3, 0x40, + 0x14, 0x8d, 0x49, 0x05, 0xf1, 0x17, 0xa1, 0x62, 0x04, 0xc2, 0x35, 0xc5, 0x8d, 0x2c, 0x21, 0xa5, + 0x05, 0xec, 0x16, 0x4e, 0x40, 0x14, 0x44, 0xb3, 0xe8, 0x66, 0xba, 0x63, 0x63, 0x8d, 0xe3, 0x61, + 0x1c, 0xc9, 0xf6, 0x98, 0xf9, 0x76, 0xd4, 0x72, 0x0a, 0x8e, 0xc2, 0x01, 0x38, 0x40, 0x97, 0x5d, + 0xb2, 0xaa, 0xc0, 0xb9, 0x01, 0x27, 0x40, 0x1e, 0xdb, 0x29, 0x29, 0x08, 0xc4, 0xce, 0xef, 0xbd, + 0x3f, 0xef, 0xbf, 0x3f, 0xfe, 0x03, 0x8f, 0x3e, 0x8a, 0x79, 0xcc, 0x16, 0x99, 0x1f, 0x31, 0xf4, + 0x97, 0x47, 0x7e, 0x71, 0xe6, 0xe5, 0x4a, 0x16, 0x92, 0xdc, 0x6b, 0x05, 0x2f, 0x62, 0xe8, 0x2d, + 0x8f, 0xec, 0x9d, 0xb9, 0xc4, 0x54, 0x62, 0xa0, 0x55, 0xbf, 0x01, 0x4d, 0xa9, 0xfd, 0x40, 0x48, + 0x21, 0x1b, 0xbe, 0xfe, 0x6a, 0xd9, 0x1d, 0x21, 0xa5, 0x48, 0xb8, 0xaf, 0x51, 0x58, 0xbe, 0xf7, + 0x59, 0x76, 0xde, 0x4a, 0xbb, 0x37, 0x9a, 0x0a, 0x9e, 0x71, 0x5c, 0xb4, 0x76, 0xee, 0x67, 0x03, + 0x86, 0x27, 0x28, 0x28, 0xff, 0x50, 0x72, 0x2c, 0xa6, 0xaf, 0x4f, 0xc9, 0x33, 0x30, 0x55, 0x83, + 0xb8, 0xb2, 0x8c, 0x91, 0x31, 0x36, 0x27, 0xc3, 0x1f, 0x57, 0x7b, 0x26, 0xed, 0x48, 0x7a, 0xad, + 0x93, 0x7d, 0x30, 0xb1, 0x50, 0x9c, 0xa5, 0xc1, 0x22, 0xb2, 0x6e, 0xe9, 0xe2, 0xbb, 0xd5, 0xd5, + 0xde, 0xe0, 0x54, 0x93, 0xb3, 0x29, 0x1d, 0x34, 0xf2, 0x2c, 0x22, 0x07, 0x70, 0x3f, 0x64, 0xc5, + 0x3c, 0x0e, 0x62, 0xce, 0x22, 0xae, 0x82, 0x98, 0x61, 0x6c, 0xf5, 0xeb, 0x23, 0x74, 0x5b, 0x0b, + 0xc7, 0x9a, 0x3f, 0x66, 0x18, 0x93, 0xc7, 0x60, 0x66, 0x65, 0x1a, 0x84, 0x89, 0x0c, 0xd1, 0xda, + 0x1a, 0x19, 0xe3, 0x21, 0x1d, 0x64, 0x65, 0x3a, 0xa9, 0xb1, 0xfb, 0x06, 0x1e, 0x6e, 0x24, 0xa6, + 0x1c, 0x73, 0x99, 0x21, 0x27, 0xcf, 0x01, 0xda, 0x64, 0x75, 0x9a, 0x3a, 0xfa, 0xd6, 0x64, 0x58, + 0x5d, 0x47, 0x9f, 0x4d, 0xd7, 0xd1, 0x67, 0x91, 0xbb, 0x04, 0xa2, 0x6d, 0x72, 0xa9, 0x5a, 0x97, + 0x32, 0x29, 0xfe, 0xcf, 0x83, 0x58, 0x70, 0x07, 0x59, 0x9a, 0x27, 0x5c, 0x35, 0xc3, 0xd3, 0x0e, + 0xd6, 0x8a, 0xd2, 0x8e, 0x68, 0xf5, 0x47, 0xfd, 0xf1, 0x80, 0x76, 0xd0, 0xdd, 0x05, 0xfb, 0xf7, + 0xbe, 0xdd, 0x0c, 0x2f, 0xbf, 0x18, 0xd0, 0x3f, 0x41, 0x41, 0x28, 0xc0, 0x2f, 0xff, 0xe4, 0x89, + 0xb7, 0xb9, 0x20, 0xde, 0xc6, 0x05, 0xd8, 0x4f, 0xff, 0x2a, 0xaf, 0xef, 0x87, 0xc1, 0xf6, 0xcd, + 0x71, 0xdd, 0x3f, 0x9e, 0xdc, 0xa8, 0xb1, 0x0f, 0xfe, 0x5d, 0xd3, 0xb5, 0x98, 0xbc, 0xbd, 0xf8, + 0xee, 0xf4, 0x2e, 0x2a, 0xc7, 0xb8, 0xac, 0x1c, 0xe3, 0x5b, 0xe5, 0x18, 0x9f, 0x56, 0x4e, 0xef, + 0x72, 0xe5, 0xf4, 0xbe, 0xae, 0x9c, 0xde, 0xbb, 0x7d, 0xb1, 0x28, 0xe2, 0x32, 0xf4, 0xe6, 0x32, + 0xf5, 0x0f, 0x45, 0xc2, 0x42, 0xf4, 0x0f, 0xc5, 0x8b, 0x66, 0x3b, 0xcf, 0xd6, 0x8f, 0xe2, 0x3c, + 0xe7, 0x18, 0xde, 0xd6, 0xeb, 0xf9, 0xea, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa7, 0x8e, 0xe7, + 0xc9, 0x33, 0x03, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + RequestDAS(ctx context.Context, in *MsgRequestDAS, opts ...grpc.CallOption) (*MsgRequestDASResponse, error) + ReportDASResult(ctx context.Context, in *MsgReportDASResult, opts ...grpc.CallOption) (*MsgReportDASResultResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) RequestDAS(ctx context.Context, in *MsgRequestDAS, opts ...grpc.CallOption) (*MsgRequestDASResponse, error) { + out := new(MsgRequestDASResponse) + err := c.cc.Invoke(ctx, "/zgchain.das.v1.Msg/RequestDAS", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) ReportDASResult(ctx context.Context, in *MsgReportDASResult, opts ...grpc.CallOption) (*MsgReportDASResultResponse, error) { + out := new(MsgReportDASResultResponse) + err := c.cc.Invoke(ctx, "/zgchain.das.v1.Msg/ReportDASResult", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + RequestDAS(context.Context, *MsgRequestDAS) (*MsgRequestDASResponse, error) + ReportDASResult(context.Context, *MsgReportDASResult) (*MsgReportDASResultResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) RequestDAS(ctx context.Context, req *MsgRequestDAS) (*MsgRequestDASResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RequestDAS not implemented") +} +func (*UnimplementedMsgServer) ReportDASResult(ctx context.Context, req *MsgReportDASResult) (*MsgReportDASResultResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReportDASResult not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_RequestDAS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRequestDAS) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RequestDAS(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgchain.das.v1.Msg/RequestDAS", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RequestDAS(ctx, req.(*MsgRequestDAS)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_ReportDASResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgReportDASResult) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).ReportDASResult(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgchain.das.v1.Msg/ReportDASResult", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ReportDASResult(ctx, req.(*MsgReportDASResult)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "zgchain.das.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "RequestDAS", + Handler: _Msg_RequestDAS_Handler, + }, + { + MethodName: "ReportDASResult", + Handler: _Msg_ReportDASResult_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "zgchain/das/v1/tx.proto", +} + +func (m *MsgRequestDAS) 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 *MsgRequestDAS) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRequestDAS) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NumBlobs != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.NumBlobs)) + i-- + dAtA[i] = 0x20 + } + if len(m.BatchHeaderHash) > 0 { + i -= len(m.BatchHeaderHash) + copy(dAtA[i:], m.BatchHeaderHash) + i = encodeVarintTx(dAtA, i, uint64(len(m.BatchHeaderHash))) + i-- + dAtA[i] = 0x1a + } + if len(m.StreamID) > 0 { + i -= len(m.StreamID) + copy(dAtA[i:], m.StreamID) + i = encodeVarintTx(dAtA, i, uint64(len(m.StreamID))) + i-- + dAtA[i] = 0x12 + } + if len(m.Requester) > 0 { + i -= len(m.Requester) + copy(dAtA[i:], m.Requester) + i = encodeVarintTx(dAtA, i, uint64(len(m.Requester))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRequestDASResponse) 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 *MsgRequestDASResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRequestDASResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RequestID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.RequestID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgReportDASResult) 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 *MsgReportDASResult) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgReportDASResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Results) > 0 { + for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- { + i-- + if m.Results[iNdEx] { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + } + i = encodeVarintTx(dAtA, i, uint64(len(m.Results))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sampler) > 0 { + i -= len(m.Sampler) + copy(dAtA[i:], m.Sampler) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sampler))) + i-- + dAtA[i] = 0x12 + } + if m.RequestID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.RequestID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgReportDASResultResponse) 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 *MsgReportDASResultResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgReportDASResultResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgRequestDAS) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Requester) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.StreamID) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.BatchHeaderHash) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.NumBlobs != 0 { + n += 1 + sovTx(uint64(m.NumBlobs)) + } + return n +} + +func (m *MsgRequestDASResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestID != 0 { + n += 1 + sovTx(uint64(m.RequestID)) + } + return n +} + +func (m *MsgReportDASResult) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestID != 0 { + n += 1 + sovTx(uint64(m.RequestID)) + } + l = len(m.Sampler) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Results) > 0 { + n += 1 + sovTx(uint64(len(m.Results))) + len(m.Results)*1 + } + return n +} + +func (m *MsgReportDASResultResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgRequestDAS) 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 ErrIntOverflowTx + } + 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: MsgRequestDAS: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRequestDAS: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Requester = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StreamID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StreamID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BatchHeaderHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BatchHeaderHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NumBlobs", wireType) + } + m.NumBlobs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NumBlobs |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRequestDASResponse) 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 ErrIntOverflowTx + } + 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: MsgRequestDASResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRequestDASResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestID", wireType) + } + m.RequestID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgReportDASResult) 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 ErrIntOverflowTx + } + 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: MsgReportDASResult: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgReportDASResult: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestID", wireType) + } + m.RequestID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sampler", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sampler = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + elementCount = packedLen + if elementCount != 0 && len(m.Results) == 0 { + m.Results = make([]bool, 0, elementCount) + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgReportDASResultResponse) 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 ErrIntOverflowTx + } + 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: MsgReportDASResultResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgReportDASResultResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(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, ErrIntOverflowTx + } + 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, ErrIntOverflowTx + } + 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, ErrIntOverflowTx + } + 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, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/earn/types/genesis.pb.go b/x/earn/types/genesis.pb.go index ff3b0779..791e5df4 100644 --- a/x/earn/types/genesis.pb.go +++ b/x/earn/types/genesis.pb.go @@ -94,7 +94,7 @@ func init() { func init() { proto.RegisterFile("kava/earn/v1beta1/genesis.proto", fileDescriptor_514fe130cb964f8c) } var fileDescriptor_514fe130cb964f8c = []byte{ - // 294 bytes of a gzipped FileDescriptorProto + // 300 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcf, 0x4e, 0x2c, 0x4b, 0xd4, 0x4f, 0x4d, 0x2c, 0xca, 0xd3, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x04, 0x29, 0xd0, @@ -108,12 +108,12 @@ var fileDescriptor_514fe130cb964f8c = []byte{ 0x04, 0x56, 0xe6, 0x24, 0x02, 0x32, 0x64, 0xd5, 0x7d, 0x79, 0x1e, 0x24, 0xc1, 0xe2, 0x20, 0x9e, 0x32, 0x24, 0x9e, 0x50, 0x1e, 0x97, 0x30, 0xc4, 0xe8, 0xe2, 0x8c, 0xc4, 0xa2, 0x54, 0xb8, 0x05, 0xcc, 0x60, 0x0b, 0x94, 0x71, 0x59, 0x10, 0x0c, 0x52, 0x0c, 0xb5, 0x45, 0x12, 0x6a, 0x8b, 0x20, - 0xba, 0x4c, 0x71, 0x90, 0x60, 0x19, 0xba, 0x90, 0x93, 0xc3, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, + 0xba, 0x4c, 0x71, 0x90, 0x60, 0x19, 0xba, 0x90, 0x93, 0xe3, 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, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, - 0x83, 0xac, 0xd5, 0xcd, 0x49, 0x4c, 0x2a, 0x06, 0xb3, 0xf4, 0x2b, 0x20, 0x81, 0x5c, 0x52, 0x59, - 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x0e, 0x5d, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8d, 0x54, - 0x3b, 0x56, 0xe8, 0x01, 0x00, 0x00, + 0x1e, 0xcb, 0x31, 0x44, 0xa9, 0xa7, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, + 0x1b, 0xa4, 0xe7, 0x24, 0x26, 0x15, 0xeb, 0x1b, 0xa4, 0xeb, 0x26, 0x67, 0x24, 0x66, 0xe6, 0xe9, + 0x57, 0x40, 0x42, 0xb9, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c, 0xbc, 0xc6, 0x80, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xb7, 0xb3, 0xac, 0xee, 0xe9, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/earn/types/params.pb.go b/x/earn/types/params.pb.go index da8b8274..51e28945 100644 --- a/x/earn/types/params.pb.go +++ b/x/earn/types/params.pb.go @@ -75,7 +75,7 @@ func init() { func init() { proto.RegisterFile("kava/earn/v1beta1/params.proto", fileDescriptor_b9b515f90f68dc5a) } var fileDescriptor_b9b515f90f68dc5a = []byte{ - // 212 bytes of a gzipped FileDescriptorProto + // 218 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcb, 0x4e, 0x2c, 0x4b, 0xd4, 0x4f, 0x4d, 0x2c, 0xca, 0xd3, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x2f, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x04, 0xc9, 0xeb, 0x81, @@ -84,12 +84,12 @@ var fileDescriptor_b9b515f90f68dc5a = []byte{ 0x00, 0xd8, 0x5c, 0xa1, 0x58, 0x2e, 0xbe, 0xc4, 0x9c, 0x9c, 0xfc, 0xf2, 0xd4, 0x94, 0x78, 0xb0, 0x82, 0x62, 0x09, 0x46, 0x05, 0x66, 0x0d, 0x6e, 0x23, 0x79, 0x3d, 0x0c, 0xab, 0xf4, 0x1c, 0x21, 0x0a, 0xc3, 0x40, 0xea, 0x9c, 0x44, 0x4f, 0xdc, 0x93, 0x67, 0x58, 0x75, 0x5f, 0x9e, 0x17, 0x59, - 0xb4, 0x38, 0x88, 0x37, 0x11, 0x99, 0xeb, 0xe4, 0x70, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, + 0xb4, 0x38, 0x88, 0x37, 0x11, 0x99, 0xeb, 0xe4, 0x78, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, - 0x72, 0x0c, 0x51, 0x6a, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x20, - 0xab, 0x74, 0x73, 0x12, 0x93, 0x8a, 0xc1, 0x2c, 0xfd, 0x0a, 0x88, 0xc3, 0x4b, 0x2a, 0x0b, 0x52, - 0x8b, 0x93, 0xd8, 0xc0, 0x2e, 0x36, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x93, 0xe4, 0x56, 0x4c, - 0x1b, 0x01, 0x00, 0x00, + 0x72, 0x0c, 0x51, 0xea, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x06, + 0xe9, 0x39, 0x89, 0x49, 0xc5, 0xfa, 0x06, 0xe9, 0xba, 0xc9, 0x19, 0x89, 0x99, 0x79, 0xfa, 0x15, + 0x10, 0x97, 0x97, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x9d, 0x6c, 0x0c, 0x08, 0x00, 0x00, + 0xff, 0xff, 0x64, 0xe3, 0xb9, 0x14, 0x1c, 0x01, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { diff --git a/x/earn/types/proposal.pb.go b/x/earn/types/proposal.pb.go index 8a4408c5..8228d76b 100644 --- a/x/earn/types/proposal.pb.go +++ b/x/earn/types/proposal.pb.go @@ -195,7 +195,7 @@ func init() { func init() { proto.RegisterFile("kava/earn/v1beta1/proposal.proto", fileDescriptor_c374f1a8c57e13e2) } var fileDescriptor_c374f1a8c57e13e2 = []byte{ - // 371 bytes of a gzipped FileDescriptorProto + // 376 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xc8, 0x4e, 0x2c, 0x4b, 0xd4, 0x4f, 0x4d, 0x2c, 0xca, 0xd3, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x2f, 0x28, 0xca, 0x2f, 0xc8, 0x2f, 0x4e, 0xcc, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x04, 0xa9, @@ -215,11 +215,11 @@ var fileDescriptor_c374f1a8c57e13e2 = []byte{ 0xba, 0xc5, 0x29, 0xd9, 0xfa, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x60, 0x0d, 0xc5, 0x41, 0x30, 0xb3, 0xe1, 0xc1, 0xc0, 0xa8, 0x34, 0x8b, 0x91, 0x4b, 0x16, 0x25, 0x18, 0xc2, 0x33, 0x4b, 0x32, 0x52, 0x8a, 0x12, 0xcb, 0x07, 0x43, 0x1c, 0xb5, 0x32, 0x71, 0x29, 0xe2, 0x75, 0xdc, 0xc8, 0x88, 0x24, - 0x27, 0x87, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, - 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x52, 0x43, 0x32, 0x16, - 0x94, 0x6b, 0x75, 0x73, 0x12, 0x93, 0x8a, 0xc1, 0x2c, 0xfd, 0x0a, 0x48, 0x1e, 0x07, 0x1b, 0x9d, - 0xc4, 0x06, 0xce, 0x90, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x21, 0xfc, 0xed, 0xa9, 0xfd, - 0x03, 0x00, 0x00, + 0x27, 0xc7, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, + 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x52, 0x47, 0x32, 0xd6, + 0x20, 0x3d, 0x27, 0x31, 0xa9, 0x58, 0xdf, 0x20, 0x5d, 0x37, 0x39, 0x23, 0x31, 0x33, 0x4f, 0xbf, + 0x02, 0x92, 0xc9, 0xc1, 0x66, 0x27, 0xb1, 0x81, 0x73, 0xa4, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, + 0xdc, 0x8a, 0x33, 0x31, 0xfe, 0x03, 0x00, 0x00, } func (m *CommunityPoolDepositProposal) Marshal() (dAtA []byte, err error) { diff --git a/x/earn/types/query.pb.go b/x/earn/types/query.pb.go index a470d300..f9534c12 100644 --- a/x/earn/types/query.pb.go +++ b/x/earn/types/query.pb.go @@ -544,68 +544,69 @@ func init() { func init() { proto.RegisterFile("kava/earn/v1beta1/query.proto", fileDescriptor_63f8dee2f3192a6b) } var fileDescriptor_63f8dee2f3192a6b = []byte{ - // 971 bytes of a gzipped FileDescriptorProto + // 977 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x6f, 0x1b, 0x45, 0x14, 0xf6, 0xda, 0xb1, 0x95, 0x3c, 0xd3, 0x42, 0x26, 0xa6, 0xd8, 0x2e, 0x59, 0x3b, 0x4b, 0x9b, - 0x98, 0x40, 0x76, 0x69, 0x2a, 0xc1, 0xa5, 0x20, 0x61, 0x22, 0xaa, 0x70, 0x40, 0x65, 0x13, 0x7a, - 0x40, 0x42, 0xd6, 0x38, 0x1e, 0x6d, 0x56, 0x71, 0x76, 0xb6, 0x3b, 0x63, 0x43, 0x40, 0x5c, 0xfa, + 0x98, 0x40, 0x76, 0xd3, 0x54, 0x82, 0x4b, 0x41, 0xc2, 0x14, 0xaa, 0x70, 0x40, 0x65, 0x13, 0x7a, + 0x40, 0x42, 0xd6, 0xd8, 0x1e, 0xad, 0x57, 0x71, 0x76, 0xb6, 0x3b, 0x63, 0x43, 0x40, 0x5c, 0xfa, 0x0f, 0x80, 0xc4, 0x81, 0x03, 0x77, 0x0e, 0x3d, 0xf7, 0x8f, 0xc8, 0xb1, 0x2a, 0x17, 0xc4, 0xa1, - 0xa5, 0x09, 0x67, 0xce, 0x1c, 0xd1, 0xcc, 0xbc, 0xf5, 0x8f, 0xd8, 0x4e, 0x22, 0xd4, 0x53, 0xb2, - 0xef, 0xc7, 0xf7, 0x7d, 0x6f, 0xe6, 0xcd, 0x7b, 0x86, 0xe5, 0x03, 0xda, 0xa7, 0x1e, 0xa3, 0x49, - 0xe4, 0xf5, 0x6f, 0xb5, 0x99, 0xa4, 0xb7, 0xbc, 0x07, 0x3d, 0x96, 0x1c, 0xb9, 0x71, 0xc2, 0x25, - 0x27, 0x8b, 0xca, 0xed, 0x2a, 0xb7, 0x8b, 0xee, 0xea, 0xfa, 0x1e, 0x17, 0x87, 0x5c, 0x78, 0x6d, - 0x2a, 0x98, 0x89, 0x1d, 0x64, 0xc6, 0x34, 0x08, 0x23, 0x2a, 0x43, 0x1e, 0x99, 0xf4, 0xaa, 0x3d, - 0x1a, 0x9b, 0x46, 0xed, 0xf1, 0x30, 0xf5, 0x57, 0x8c, 0xbf, 0xa5, 0xbf, 0x3c, 0xf3, 0x81, 0xae, - 0x52, 0xc0, 0x03, 0x6e, 0xec, 0xea, 0x3f, 0xb4, 0xbe, 0x19, 0x70, 0x1e, 0x74, 0x99, 0x47, 0xe3, - 0xd0, 0xa3, 0x51, 0xc4, 0xa5, 0x66, 0x4b, 0x73, 0xec, 0xc9, 0x62, 0x62, 0x9a, 0xd0, 0xc3, 0xd4, - 0x5f, 0x9f, 0xf4, 0x0b, 0x99, 0x50, 0xc9, 0x02, 0xac, 0xb7, 0x3a, 0xe5, 0x38, 0xfa, 0xb4, 0xd7, - 0x95, 0xc6, 0xed, 0x94, 0x80, 0x7c, 0xa1, 0x2a, 0xbe, 0xa7, 0x51, 0x7d, 0xf6, 0xa0, 0xc7, 0x84, - 0x74, 0x3e, 0x87, 0xa5, 0x31, 0xab, 0x88, 0x79, 0x24, 0x18, 0xf9, 0x00, 0x0a, 0x86, 0xbd, 0x6c, - 0xd5, 0xad, 0x46, 0x71, 0xb3, 0xe2, 0x4e, 0x1c, 0xa6, 0x6b, 0x52, 0x9a, 0x73, 0xc7, 0xcf, 0x6a, - 0x19, 0x1f, 0xc3, 0x07, 0x2c, 0xf7, 0x15, 0xf3, 0x80, 0xe5, 0x4b, 0x64, 0x49, 0xad, 0xc8, 0xf2, - 0x11, 0x14, 0xb4, 0x42, 0xc5, 0x92, 0x6b, 0x14, 0x37, 0xeb, 0x53, 0x58, 0x74, 0x4a, 0x9a, 0x91, - 0x92, 0x99, 0x2c, 0xe7, 0x6d, 0x58, 0x1c, 0xc2, 0x22, 0x17, 0x29, 0x41, 0xbe, 0xc3, 0x22, 0x7e, - 0xa8, 0x95, 0x2f, 0xf8, 0xe6, 0xc3, 0xf1, 0x47, 0x75, 0x0d, 0x04, 0xdc, 0x81, 0xbc, 0x86, 0xc2, - 0x2a, 0x2f, 0xcb, 0x6f, 0x92, 0x9c, 0x7f, 0xb2, 0x70, 0x65, 0x1c, 0x6f, 0x2a, 0x37, 0xf1, 0x01, - 0xf0, 0xaa, 0x42, 0x26, 0xca, 0xd9, 0x7a, 0xae, 0x71, 0x75, 0xb3, 0x36, 0x85, 0x6a, 0x07, 0xef, - 0x73, 0xf7, 0x28, 0x66, 0xcd, 0xc5, 0x47, 0xcf, 0x6b, 0x57, 0x46, 0x2d, 0xc2, 0x1f, 0x41, 0x21, - 0x0d, 0x78, 0x2d, 0x54, 0xbd, 0x17, 0xf6, 0xa9, 0x64, 0x2d, 0x53, 0x44, 0xae, 0x6e, 0x35, 0xe6, - 0xfd, 0xab, 0xa1, 0xb8, 0x67, 0xcc, 0x5a, 0x1b, 0xb9, 0x0b, 0x84, 0x76, 0xbb, 0xfc, 0x1b, 0xd6, - 0x69, 0x75, 0x58, 0xcc, 0x45, 0x28, 0x79, 0x22, 0xca, 0x73, 0xf5, 0x5c, 0x63, 0xa1, 0x59, 0x7e, - 0xfa, 0x78, 0xa3, 0x84, 0xad, 0xfb, 0x71, 0xa7, 0x93, 0x30, 0x21, 0x76, 0x64, 0x12, 0x46, 0x81, - 0xbf, 0x88, 0x39, 0x5b, 0x83, 0x14, 0xb2, 0x02, 0xaf, 0x48, 0x2e, 0x69, 0xb7, 0x25, 0xf6, 0x69, - 0xc2, 0x44, 0x39, 0xaf, 0x6b, 0x2c, 0x6a, 0xdb, 0x8e, 0x36, 0x91, 0xaf, 0xc1, 0x7c, 0xb6, 0xfa, - 0xb4, 0xdb, 0x63, 0xe5, 0x82, 0x8a, 0x68, 0xde, 0x51, 0x67, 0xf6, 0xe7, 0xb3, 0xda, 0x6a, 0x10, - 0xca, 0xfd, 0x5e, 0xdb, 0xdd, 0xe3, 0x87, 0xf8, 0x5c, 0xf0, 0xcf, 0x86, 0xe8, 0x1c, 0x78, 0x52, - 0x95, 0xe8, 0x6e, 0x47, 0xf2, 0xe9, 0xe3, 0x0d, 0x40, 0x49, 0xdb, 0x91, 0xf4, 0x41, 0x03, 0xde, - 0x57, 0x78, 0xce, 0x0b, 0x0b, 0x4a, 0xfa, 0x16, 0x51, 0x55, 0xda, 0x5f, 0xe4, 0x7d, 0x58, 0x18, - 0xd4, 0x66, 0xce, 0xfe, 0x9c, 0xd2, 0x86, 0xa1, 0xc3, 0xfb, 0xca, 0x8e, 0xde, 0xd7, 0x6d, 0xb8, - 0xa6, 0xf5, 0xb7, 0xc2, 0xa8, 0x25, 0x24, 0x3d, 0x60, 0x9d, 0x96, 0xe4, 0x07, 0x2c, 0x12, 0x78, - 0xc2, 0x4b, 0xda, 0xbb, 0x1d, 0xed, 0x68, 0xdf, 0xae, 0x76, 0x91, 0x4f, 0x01, 0x86, 0x23, 0xa4, - 0x3c, 0xa7, 0xfb, 0x69, 0xd5, 0x45, 0x01, 0x6a, 0x86, 0xb8, 0x66, 0x36, 0x0d, 0x5f, 0x4f, 0xc0, - 0x50, 0xbe, 0x3f, 0x92, 0xe9, 0xfc, 0x66, 0xc1, 0xeb, 0x67, 0x6a, 0xc4, 0xe6, 0xda, 0x82, 0x79, - 0x54, 0x9e, 0xbe, 0x17, 0x67, 0x4a, 0x13, 0x61, 0xda, 0x99, 0x8e, 0x1d, 0x64, 0x92, 0xbb, 0x63, - 0x3a, 0xb3, 0x5a, 0xe7, 0xda, 0x85, 0x3a, 0x0d, 0xd8, 0x98, 0xd0, 0x7f, 0x2d, 0x78, 0xf5, 0x0c, - 0xd9, 0xff, 0xbe, 0x87, 0xcf, 0xa0, 0x80, 0x4d, 0x95, 0xd5, 0x85, 0x2d, 0xcf, 0x7a, 0x88, 0xba, - 0xcf, 0x9a, 0x4b, 0xaa, 0xa6, 0x47, 0xcf, 0x6b, 0xc5, 0xa1, 0x4d, 0xf8, 0x88, 0x40, 0xa8, 0x7a, - 0xd3, 0xaa, 0xfb, 0x72, 0x1a, 0xaa, 0x32, 0x56, 0x5b, 0x0a, 0xf6, 0x09, 0x0f, 0xa3, 0xe6, 0x7b, - 0x08, 0xd3, 0xb8, 0x44, 0x63, 0xaa, 0x04, 0xe1, 0x1b, 0x64, 0xa7, 0x02, 0x6f, 0xe8, 0x2b, 0xda, - 0xd5, 0xad, 0xdf, 0x8b, 0xe3, 0xee, 0x51, 0x3a, 0xe9, 0x7e, 0xb1, 0xa0, 0x3c, 0xe9, 0xc3, 0xe3, - 0xb9, 0x06, 0x85, 0x7d, 0x16, 0x06, 0xfb, 0x66, 0xde, 0xe4, 0x7c, 0xfc, 0x22, 0x7b, 0x50, 0x48, - 0x98, 0x50, 0x4f, 0x38, 0xfb, 0xf2, 0x35, 0x23, 0xf4, 0xe6, 0xaf, 0x79, 0xc8, 0x6b, 0x65, 0xe4, - 0x3b, 0x28, 0x98, 0xd9, 0x4d, 0x6e, 0x4e, 0x39, 0xe7, 0xc9, 0x25, 0x51, 0x5d, 0xbd, 0x28, 0xcc, - 0xd4, 0xe7, 0xac, 0x3c, 0xfc, 0xfd, 0xef, 0x9f, 0xb3, 0xd7, 0x49, 0xc5, 0x9b, 0xb5, 0xcc, 0x14, - 0xb7, 0x59, 0x02, 0xb3, 0xb9, 0xc7, 0x56, 0xc7, 0x6c, 0xee, 0xf1, 0x5d, 0x72, 0x2e, 0xb7, 0x59, - 0x17, 0xe4, 0xa1, 0x05, 0x79, 0x33, 0x13, 0x6f, 0x9c, 0x0b, 0x9a, 0x52, 0xdf, 0xbc, 0x20, 0x0a, - 0x99, 0xdf, 0xd5, 0xcc, 0xab, 0xe4, 0xc6, 0x4c, 0x66, 0xef, 0x7b, 0x3d, 0x58, 0x3e, 0x5c, 0x5f, - 0xff, 0x41, 0x89, 0x98, 0x4f, 0x9f, 0x36, 0x59, 0x9b, 0xc5, 0x70, 0x66, 0xc0, 0x55, 0x1b, 0x17, - 0x07, 0xa2, 0x9a, 0xb7, 0xb4, 0x9a, 0x65, 0x72, 0x7d, 0x8a, 0x9a, 0xc1, 0x10, 0xf8, 0xd1, 0x82, - 0xe2, 0x48, 0x83, 0x92, 0xf5, 0x59, 0xf0, 0x93, 0x1d, 0x5e, 0x7d, 0xe7, 0x52, 0xb1, 0xa8, 0x66, - 0x4d, 0xab, 0x59, 0x21, 0xb5, 0x29, 0x6a, 0x70, 0x99, 0xe8, 0x84, 0xe6, 0xd6, 0xf1, 0x0b, 0x3b, - 0x73, 0x7c, 0x62, 0x5b, 0x4f, 0x4e, 0x6c, 0xeb, 0xaf, 0x13, 0xdb, 0xfa, 0xe9, 0xd4, 0xce, 0x3c, - 0x39, 0xb5, 0x33, 0x7f, 0x9c, 0xda, 0x99, 0xaf, 0x46, 0x57, 0x87, 0x02, 0xda, 0xe8, 0xd2, 0xb6, - 0x30, 0x90, 0xdf, 0x1a, 0x50, 0xdd, 0xf1, 0xed, 0x82, 0xfe, 0xa9, 0x73, 0xfb, 0xbf, 0x00, 0x00, - 0x00, 0xff, 0xff, 0xb7, 0x20, 0xeb, 0xea, 0x1a, 0x0a, 0x00, 0x00, + 0x25, 0x09, 0x67, 0xce, 0x1c, 0xd1, 0xfc, 0x58, 0x7b, 0x1d, 0xaf, 0xe3, 0x08, 0xf5, 0x64, 0xcf, + 0xfb, 0xf1, 0x7d, 0xdf, 0x9b, 0x79, 0xf3, 0x66, 0x61, 0xf5, 0x00, 0x0f, 0xb1, 0x43, 0x70, 0x14, + 0x38, 0xc3, 0x5b, 0x6d, 0xc2, 0xf1, 0x2d, 0xe7, 0xe1, 0x80, 0x44, 0x47, 0x76, 0x18, 0x51, 0x4e, + 0xd1, 0xb2, 0x70, 0xdb, 0xc2, 0x6d, 0x6b, 0x77, 0x75, 0xb3, 0x43, 0xd9, 0x21, 0x65, 0x4e, 0x1b, + 0x33, 0xa2, 0x62, 0x47, 0x99, 0x21, 0xf6, 0xfc, 0x00, 0x73, 0x9f, 0x06, 0x2a, 0xbd, 0x6a, 0x26, + 0x63, 0xe3, 0xa8, 0x0e, 0xf5, 0x63, 0x7f, 0x45, 0xf9, 0x5b, 0x72, 0xe5, 0xa8, 0x85, 0x76, 0x95, + 0x3c, 0xea, 0x51, 0x65, 0x17, 0xff, 0xb4, 0xf5, 0x4d, 0x8f, 0x52, 0xaf, 0x4f, 0x1c, 0x1c, 0xfa, + 0x0e, 0x0e, 0x02, 0xca, 0x25, 0x5b, 0x9c, 0x63, 0x4e, 0x17, 0x13, 0xe2, 0x08, 0x1f, 0xc6, 0xfe, + 0xfa, 0xb4, 0x9f, 0xf1, 0x08, 0x73, 0xe2, 0xe9, 0x7a, 0xab, 0x29, 0xdb, 0x31, 0xc4, 0x83, 0x3e, + 0x57, 0x6e, 0xab, 0x04, 0xe8, 0x0b, 0x51, 0xf1, 0x7d, 0x89, 0xea, 0x92, 0x87, 0x03, 0xc2, 0xb8, + 0xf5, 0x39, 0xac, 0x4c, 0x58, 0x59, 0x48, 0x03, 0x46, 0xd0, 0xfb, 0x50, 0x50, 0xec, 0x65, 0xa3, + 0x6e, 0x34, 0x8a, 0x3b, 0x15, 0x7b, 0x6a, 0x33, 0x6d, 0x95, 0xd2, 0x5c, 0x38, 0x7e, 0x5e, 0xcb, + 0xb8, 0x3a, 0x7c, 0xc4, 0xf2, 0x40, 0x30, 0x8f, 0x58, 0xbe, 0xd4, 0x2c, 0xb1, 0x55, 0xb3, 0x7c, + 0x08, 0x05, 0xa9, 0x50, 0xb0, 0xe4, 0x1a, 0xc5, 0x9d, 0x7a, 0x0a, 0x8b, 0x4c, 0x89, 0x33, 0x62, + 0x32, 0x95, 0x65, 0xbd, 0x0d, 0xcb, 0x63, 0x58, 0xcd, 0x85, 0x4a, 0x90, 0xef, 0x92, 0x80, 0x1e, + 0x4a, 0xe5, 0x4b, 0xae, 0x5a, 0x58, 0x6e, 0x52, 0xd7, 0x48, 0xc0, 0x1d, 0xc8, 0x4b, 0x28, 0x5d, + 0xe5, 0x65, 0xf9, 0x55, 0x92, 0xf5, 0x4f, 0x16, 0xae, 0x4c, 0xe2, 0xa5, 0x72, 0x23, 0x17, 0x40, + 0x1f, 0x95, 0x4f, 0x58, 0x39, 0x5b, 0xcf, 0x35, 0xae, 0xee, 0xd4, 0x52, 0xa8, 0xf6, 0xf4, 0x79, + 0xee, 0x1f, 0x85, 0xa4, 0xb9, 0xfc, 0xf8, 0x45, 0xed, 0x4a, 0xd2, 0xc2, 0xdc, 0x04, 0x0a, 0x6a, + 0xc0, 0x6b, 0xbe, 0xe8, 0x3d, 0x7f, 0x88, 0x39, 0x69, 0xa9, 0x22, 0x72, 0x75, 0xa3, 0xb1, 0xe8, + 0x5e, 0xf5, 0xd9, 0x7d, 0x65, 0x96, 0xda, 0xd0, 0x3d, 0x40, 0xb8, 0xdf, 0xa7, 0xdf, 0x90, 0x6e, + 0xab, 0x4b, 0x42, 0xca, 0x7c, 0x4e, 0x23, 0x56, 0x5e, 0xa8, 0xe7, 0x1a, 0x4b, 0xcd, 0xf2, 0xb3, + 0x27, 0x5b, 0x25, 0xdd, 0xba, 0x1f, 0x75, 0xbb, 0x11, 0x61, 0x6c, 0x8f, 0x47, 0x7e, 0xe0, 0xb9, + 0xcb, 0x3a, 0xe7, 0xee, 0x28, 0x05, 0xad, 0xc1, 0x2b, 0x9c, 0x72, 0xdc, 0x6f, 0xb1, 0x1e, 0x8e, + 0x08, 0x2b, 0xe7, 0x65, 0x8d, 0x45, 0x69, 0xdb, 0x93, 0x26, 0xf4, 0x35, 0xa8, 0x65, 0x6b, 0x88, + 0xfb, 0x03, 0x52, 0x2e, 0x88, 0x88, 0xe6, 0x1d, 0xb1, 0x67, 0x7f, 0x3e, 0xaf, 0xad, 0x7b, 0x3e, + 0xef, 0x0d, 0xda, 0x76, 0x87, 0x1e, 0xea, 0xeb, 0xa2, 0x7f, 0xb6, 0x58, 0xf7, 0xc0, 0xe1, 0xa2, + 0x44, 0x7b, 0x37, 0xe0, 0xcf, 0x9e, 0x6c, 0x81, 0x96, 0xb4, 0x1b, 0x70, 0x17, 0x24, 0xe0, 0x03, + 0x81, 0x67, 0x9d, 0x18, 0x50, 0x92, 0xa7, 0xa8, 0x55, 0xc5, 0xfd, 0x85, 0xde, 0x83, 0xa5, 0x51, + 0x6d, 0x6a, 0xef, 0x2f, 0x28, 0x6d, 0x1c, 0x3a, 0x3e, 0xaf, 0x6c, 0xf2, 0xbc, 0x6e, 0xc3, 0x35, + 0xa9, 0xbf, 0xe5, 0x07, 0x2d, 0xc6, 0xf1, 0x01, 0xe9, 0xb6, 0x38, 0x3d, 0x20, 0x01, 0xd3, 0x3b, + 0xbc, 0x22, 0xbd, 0xbb, 0xc1, 0x9e, 0xf4, 0xed, 0x4b, 0x17, 0xfa, 0x14, 0x60, 0x3c, 0x42, 0xca, + 0x0b, 0xb2, 0x9f, 0xd6, 0x6d, 0x2d, 0x40, 0xcc, 0x10, 0x5b, 0xcd, 0xa6, 0xf1, 0xed, 0xf1, 0x88, + 0x96, 0xef, 0x26, 0x32, 0xad, 0xdf, 0x0c, 0x78, 0xfd, 0x5c, 0x8d, 0xba, 0xb9, 0xee, 0xc2, 0xa2, + 0x56, 0x1e, 0xdf, 0x17, 0x2b, 0xa5, 0x89, 0x74, 0xda, 0xb9, 0x8e, 0x1d, 0x65, 0xa2, 0x7b, 0x13, + 0x3a, 0xb3, 0x52, 0xe7, 0xc6, 0x5c, 0x9d, 0x0a, 0x6c, 0x42, 0xe8, 0xbf, 0x06, 0xbc, 0x7a, 0x8e, + 0xec, 0x7f, 0x9f, 0xc3, 0x67, 0x50, 0xd0, 0x4d, 0x95, 0x95, 0x85, 0xad, 0xce, 0xba, 0x88, 0xb2, + 0xcf, 0x9a, 0x2b, 0xa2, 0xa6, 0xc7, 0x2f, 0x6a, 0xc5, 0xb1, 0x8d, 0xb9, 0x1a, 0x01, 0x61, 0x71, + 0xa7, 0x45, 0xf7, 0xe5, 0x24, 0x54, 0x65, 0xa2, 0xb6, 0x18, 0xec, 0x63, 0xea, 0x07, 0xcd, 0x6d, + 0x0d, 0xd3, 0xb8, 0x44, 0x63, 0x8a, 0x04, 0xe6, 0x2a, 0x64, 0xab, 0x02, 0x6f, 0xc8, 0x23, 0xda, + 0x97, 0xad, 0x3f, 0x08, 0xc3, 0xfe, 0x51, 0x3c, 0xe9, 0x7e, 0x31, 0xa0, 0x3c, 0xed, 0xd3, 0xdb, + 0x73, 0x0d, 0x0a, 0x3d, 0xe2, 0x7b, 0x3d, 0x35, 0x6f, 0x72, 0xae, 0x5e, 0xa1, 0x0e, 0x14, 0x22, + 0xc2, 0xc4, 0x15, 0xce, 0xbe, 0x7c, 0xcd, 0x1a, 0x7a, 0xe7, 0xd7, 0x3c, 0xe4, 0xa5, 0x32, 0xf4, + 0x1d, 0x14, 0xd4, 0xec, 0x46, 0x37, 0x53, 0xf6, 0x79, 0xfa, 0x91, 0xa8, 0xae, 0xcf, 0x0b, 0x53, + 0xf5, 0x59, 0x6b, 0x8f, 0x7e, 0xff, 0xfb, 0xe7, 0xec, 0x75, 0x54, 0x71, 0x66, 0x3d, 0x66, 0x82, + 0x5b, 0x3d, 0x02, 0xb3, 0xb9, 0x27, 0x9e, 0x8e, 0xd9, 0xdc, 0x93, 0x6f, 0xc9, 0x85, 0xdc, 0xea, + 0xb9, 0x40, 0x8f, 0x0c, 0xc8, 0xab, 0x99, 0x78, 0xe3, 0x42, 0xd0, 0x98, 0xfa, 0xe6, 0x9c, 0x28, + 0xcd, 0xfc, 0xae, 0x64, 0x5e, 0x47, 0x37, 0x66, 0x32, 0x3b, 0xdf, 0xcb, 0xc1, 0xf2, 0xc1, 0xe6, + 0xe6, 0x0f, 0x42, 0xc4, 0x62, 0x7c, 0xb5, 0xd1, 0xc6, 0x2c, 0x86, 0x73, 0x03, 0xae, 0xda, 0x98, + 0x1f, 0xa8, 0xd5, 0xbc, 0x25, 0xd5, 0xac, 0xa2, 0xeb, 0x29, 0x6a, 0x46, 0x43, 0xe0, 0x47, 0x03, + 0x8a, 0x89, 0x06, 0x45, 0x9b, 0xb3, 0xe0, 0xa7, 0x3b, 0xbc, 0xfa, 0xce, 0xa5, 0x62, 0xb5, 0x9a, + 0x0d, 0xa9, 0x66, 0x0d, 0xd5, 0x52, 0xd4, 0xe8, 0xc7, 0x44, 0x26, 0x34, 0x3f, 0x39, 0x3e, 0x31, + 0x33, 0xc7, 0xa7, 0xa6, 0xf1, 0xf4, 0xd4, 0x34, 0xfe, 0x3a, 0x35, 0x8d, 0x9f, 0xce, 0xcc, 0xcc, + 0xd3, 0x33, 0x33, 0xf3, 0xc7, 0x99, 0x99, 0xf9, 0x6a, 0x23, 0xd1, 0xed, 0xdb, 0x5e, 0x1f, 0xb7, + 0x99, 0xb3, 0xed, 0x6d, 0x75, 0x7a, 0xd8, 0x0f, 0x9c, 0x6f, 0x15, 0xaa, 0x6c, 0xf9, 0x76, 0x41, + 0x7e, 0xeb, 0xdc, 0xfe, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x0f, 0x4d, 0xf0, 0x32, 0x1b, 0x0a, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/earn/types/strategy.pb.go b/x/earn/types/strategy.pb.go index a20f602c..53fecfe6 100644 --- a/x/earn/types/strategy.pb.go +++ b/x/earn/types/strategy.pb.go @@ -62,7 +62,7 @@ func init() { func init() { proto.RegisterFile("kava/earn/v1beta1/strategy.proto", fileDescriptor_257c4968dd48fa09) } var fileDescriptor_257c4968dd48fa09 = []byte{ - // 220 bytes of a gzipped FileDescriptorProto + // 226 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xc8, 0x4e, 0x2c, 0x4b, 0xd4, 0x4f, 0x4d, 0x2c, 0xca, 0xd3, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x2f, 0x2e, 0x29, 0x4a, 0x2c, 0x49, 0x4d, 0xaf, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x04, 0xa9, @@ -72,9 +72,10 @@ var fileDescriptor_257c4968dd48fa09 = []byte{ 0xa1, 0x7e, 0xc1, 0x01, 0xae, 0xce, 0x9e, 0x6e, 0x9e, 0xae, 0x2e, 0x02, 0x0c, 0x42, 0x62, 0x5c, 0x42, 0xa8, 0xd2, 0x1e, 0x8e, 0x41, 0x2e, 0x02, 0x8c, 0x42, 0x92, 0x5c, 0xa2, 0xa8, 0xe2, 0xc1, 0x8e, 0x61, 0x9e, 0x7e, 0xee, 0xc1, 0x02, 0x4c, 0x52, 0x2c, 0x1d, 0x8b, 0xe5, 0x18, 0x9c, 0x1c, - 0x4e, 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, 0x2d, 0x3d, 0xb3, 0x24, 0xa3, - 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0xe4, 0x6a, 0xdd, 0x9c, 0xc4, 0xa4, 0x62, 0x30, 0x4b, - 0xbf, 0x02, 0xe2, 0xc7, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0x83, 0x8d, 0x01, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x81, 0x9e, 0x23, 0x1c, 0xfd, 0x00, 0x00, 0x00, + 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, 0x3d, 0x3d, 0xb3, 0x24, 0xa3, + 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0xdf, 0x20, 0x3d, 0x27, 0x31, 0xa9, 0x58, 0xdf, 0x20, 0x5d, + 0x37, 0x39, 0x23, 0x31, 0x33, 0x4f, 0xbf, 0x02, 0xe2, 0xc9, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, + 0x36, 0xb0, 0x8b, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x56, 0xe7, 0x50, 0xe7, 0xfe, 0x00, + 0x00, 0x00, } diff --git a/x/earn/types/tx.pb.go b/x/earn/types/tx.pb.go index 44555c8d..766fd200 100644 --- a/x/earn/types/tx.pb.go +++ b/x/earn/types/tx.pb.go @@ -218,35 +218,35 @@ func init() { func init() { proto.RegisterFile("kava/earn/v1beta1/tx.proto", fileDescriptor_2e9dcf48a3fa0009) } var fileDescriptor_2e9dcf48a3fa0009 = []byte{ - // 442 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x53, 0x41, 0x6b, 0x13, 0x41, - 0x14, 0xde, 0xb1, 0x21, 0xb6, 0x13, 0x10, 0x1c, 0x7b, 0x48, 0x17, 0x3a, 0x09, 0x01, 0x4b, 0x0e, - 0x76, 0x96, 0x46, 0x50, 0xb0, 0x17, 0x8d, 0x5e, 0x83, 0xb8, 0x11, 0x05, 0x2f, 0x32, 0x9b, 0x1d, - 0x27, 0x8b, 0xdd, 0x9d, 0x65, 0xde, 0x24, 0x36, 0xff, 0xc0, 0xa3, 0x3f, 0xc1, 0xb3, 0x67, 0xc1, - 0xab, 0xc7, 0x1e, 0x8b, 0x27, 0x4f, 0x22, 0xc9, 0x1f, 0x91, 0xdd, 0x99, 0xdd, 0x08, 0x09, 0xf5, - 0x22, 0xf4, 0xf6, 0x66, 0xbe, 0xef, 0x7b, 0xfb, 0xbd, 0x6f, 0xe7, 0x61, 0xff, 0x3d, 0x9f, 0xf3, - 0x40, 0x70, 0x9d, 0x05, 0xf3, 0x93, 0x48, 0x18, 0x7e, 0x12, 0x98, 0x73, 0x96, 0x6b, 0x65, 0x14, - 0xb9, 0x5d, 0x60, 0xac, 0xc0, 0x98, 0xc3, 0x7c, 0x3a, 0x51, 0x90, 0x2a, 0x08, 0x22, 0x0e, 0xa2, - 0x16, 0x4c, 0x54, 0x92, 0x59, 0x89, 0x7f, 0x60, 0xf1, 0xb7, 0xe5, 0x29, 0xb0, 0x07, 0x07, 0xed, - 0x4b, 0x25, 0x95, 0xbd, 0x2f, 0x2a, 0x77, 0xdb, 0xdd, 0xfc, 0x3e, 0x18, 0xcd, 0x8d, 0x90, 0x0b, - 0xc7, 0x38, 0xdc, 0x64, 0xcc, 0xf9, 0xec, 0xcc, 0x58, 0xb8, 0xf7, 0x1d, 0x61, 0x3c, 0x02, 0xf9, - 0x4c, 0xe4, 0x0a, 0x12, 0x43, 0x1e, 0xe0, 0xbd, 0xd8, 0x96, 0x4a, 0xb7, 0x51, 0x17, 0xf5, 0xf7, - 0x86, 0xed, 0x1f, 0x5f, 0x8f, 0xf7, 0x9d, 0x95, 0x27, 0x71, 0xac, 0x05, 0xc0, 0xd8, 0xe8, 0x24, - 0x93, 0xe1, 0x9a, 0x4a, 0x1e, 0xe2, 0x26, 0x4f, 0xd5, 0x2c, 0x33, 0xed, 0x1b, 0x5d, 0xd4, 0x6f, - 0x0d, 0x0e, 0x98, 0x53, 0x14, 0x93, 0x56, 0xe3, 0xb3, 0xa7, 0x2a, 0xc9, 0x86, 0x8d, 0x8b, 0x5f, - 0x1d, 0x2f, 0x74, 0x74, 0x72, 0x8a, 0x77, 0x2b, 0xc3, 0xed, 0x9d, 0x2e, 0xea, 0xdf, 0x1a, 0x74, - 0xd8, 0x46, 0x6e, 0x6c, 0xec, 0x28, 0x2f, 0x17, 0xb9, 0x08, 0x6b, 0xc1, 0xa3, 0xc6, 0xc7, 0xcf, - 0x1d, 0xaf, 0xf7, 0x02, 0x93, 0xf5, 0x04, 0xa1, 0x80, 0x5c, 0x65, 0x20, 0xc8, 0x29, 0x6e, 0xc2, - 0x94, 0x6b, 0x01, 0xe5, 0x18, 0xad, 0xc1, 0xe1, 0x96, 0xb6, 0xaf, 0x8a, 0x20, 0xc6, 0x05, 0xab, - 0x72, 0x65, 0x25, 0xbd, 0x6f, 0x08, 0xb7, 0x46, 0x20, 0x5f, 0x27, 0x66, 0x1a, 0x6b, 0xfe, 0x81, - 0xdc, 0xc3, 0x8d, 0x77, 0x5a, 0xa5, 0xff, 0x4c, 0xa4, 0x64, 0x5d, 0x6b, 0x18, 0x21, 0xbe, 0xf3, - 0x97, 0xf1, 0xff, 0x92, 0xc6, 0xe0, 0x0b, 0xc2, 0x3b, 0x23, 0x90, 0xe4, 0x39, 0xbe, 0x59, 0xbd, - 0x93, 0x6d, 0xfa, 0xf5, 0x4f, 0xf0, 0xef, 0x5e, 0x09, 0xd7, 0xae, 0x42, 0xbc, 0x5b, 0x47, 0x4c, - 0xb7, 0x4b, 0x2a, 0xdc, 0x3f, 0xba, 0x1a, 0xaf, 0x7a, 0x0e, 0x1f, 0x5f, 0x2c, 0x29, 0xba, 0x5c, - 0x52, 0xf4, 0x7b, 0x49, 0xd1, 0xa7, 0x15, 0xf5, 0x2e, 0x57, 0xd4, 0xfb, 0xb9, 0xa2, 0xde, 0x9b, - 0x23, 0x99, 0x98, 0xe9, 0x2c, 0x62, 0x13, 0x95, 0x06, 0x45, 0xaf, 0xe3, 0x33, 0x1e, 0x41, 0x59, - 0x05, 0xe7, 0x76, 0x41, 0xcc, 0x22, 0x17, 0x10, 0x35, 0xcb, 0xcd, 0xb8, 0xff, 0x27, 0x00, 0x00, - 0xff, 0xff, 0x9c, 0x47, 0x8e, 0xc7, 0xdc, 0x03, 0x00, 0x00, + // 447 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x93, 0x41, 0x8b, 0x13, 0x31, + 0x1c, 0xc5, 0x27, 0x6e, 0xa9, 0xbb, 0x29, 0x08, 0xc6, 0x3d, 0x74, 0x07, 0x36, 0x2d, 0x05, 0xb5, + 0x07, 0x37, 0xd9, 0xad, 0xa0, 0xe0, 0x9e, 0xb6, 0x7a, 0x2d, 0xe2, 0x54, 0x14, 0xbc, 0x48, 0xa6, + 0x8d, 0xe9, 0xe0, 0x76, 0x32, 0xe4, 0x9f, 0xd6, 0xed, 0x37, 0xf0, 0xe8, 0x47, 0xf0, 0xec, 0x59, + 0xf0, 0xea, 0x71, 0x8f, 0x8b, 0x27, 0x4f, 0x22, 0xed, 0x17, 0x91, 0x69, 0x32, 0x53, 0xa1, 0xa5, + 0x5e, 0x84, 0xbd, 0x25, 0xf9, 0xbd, 0x97, 0xbe, 0xff, 0xeb, 0x04, 0x87, 0xef, 0xc5, 0x54, 0x70, + 0x29, 0x4c, 0xca, 0xa7, 0x27, 0xb1, 0xb4, 0xe2, 0x84, 0xdb, 0x0b, 0x96, 0x19, 0x6d, 0x35, 0xb9, + 0x9d, 0x33, 0x96, 0x33, 0xe6, 0x59, 0x48, 0x07, 0x1a, 0xc6, 0x1a, 0x78, 0x2c, 0x40, 0x96, 0x86, + 0x81, 0x4e, 0x52, 0x67, 0x09, 0x0f, 0x1c, 0x7f, 0xbb, 0xdc, 0x71, 0xb7, 0xf1, 0x68, 0x5f, 0x69, + 0xa5, 0xdd, 0x79, 0xbe, 0xf2, 0xa7, 0xcd, 0xf5, 0xdf, 0x07, 0x6b, 0x84, 0x95, 0x6a, 0xe6, 0x15, + 0x87, 0xeb, 0x8a, 0xa9, 0x98, 0x9c, 0x5b, 0x87, 0x5b, 0xdf, 0x11, 0xc6, 0x3d, 0x50, 0xcf, 0x64, + 0xa6, 0x21, 0xb1, 0xe4, 0x11, 0xde, 0x1b, 0xba, 0xa5, 0x36, 0x75, 0xd4, 0x44, 0xed, 0xbd, 0x6e, + 0xfd, 0xc7, 0xd7, 0xa3, 0x7d, 0x1f, 0xe5, 0x6c, 0x38, 0x34, 0x12, 0xa0, 0x6f, 0x4d, 0x92, 0xaa, + 0x68, 0x25, 0x25, 0x8f, 0x71, 0x55, 0x8c, 0xf5, 0x24, 0xb5, 0xf5, 0x1b, 0x4d, 0xd4, 0xae, 0x75, + 0x0e, 0x98, 0x77, 0xe4, 0x93, 0x16, 0xe3, 0xb3, 0xa7, 0x3a, 0x49, 0xbb, 0x95, 0xcb, 0x5f, 0x8d, + 0x20, 0xf2, 0x72, 0x72, 0x8a, 0x77, 0x8b, 0xc0, 0xf5, 0x9d, 0x26, 0x6a, 0xdf, 0xea, 0x34, 0xd8, + 0x5a, 0x6f, 0xac, 0xef, 0x25, 0x2f, 0x67, 0x99, 0x8c, 0x4a, 0xc3, 0x93, 0xca, 0xc7, 0xcf, 0x8d, + 0xa0, 0xf5, 0x02, 0x93, 0xd5, 0x04, 0x91, 0x84, 0x4c, 0xa7, 0x20, 0xc9, 0x29, 0xae, 0xc2, 0x48, + 0x18, 0x09, 0xcb, 0x31, 0x6a, 0x9d, 0xc3, 0x0d, 0xd7, 0xbe, 0xca, 0x8b, 0xe8, 0xe7, 0xaa, 0x22, + 0x95, 0xb3, 0xb4, 0xbe, 0x21, 0x5c, 0xeb, 0x81, 0x7a, 0x9d, 0xd8, 0xd1, 0xd0, 0x88, 0x0f, 0xe4, + 0x01, 0xae, 0xbc, 0x33, 0x7a, 0xfc, 0xcf, 0x46, 0x96, 0xaa, 0x6b, 0x2d, 0x23, 0xc2, 0x77, 0xfe, + 0x0a, 0xfe, 0x5f, 0xda, 0xe8, 0x7c, 0x41, 0x78, 0xa7, 0x07, 0x8a, 0x3c, 0xc7, 0x37, 0x8b, 0xef, + 0x64, 0x93, 0x7f, 0xf5, 0x27, 0x84, 0x77, 0xb7, 0xe2, 0x32, 0x55, 0x84, 0x77, 0xcb, 0x8a, 0xe9, + 0x66, 0x4b, 0xc1, 0xc3, 0x7b, 0xdb, 0x79, 0x71, 0x67, 0xf7, 0xec, 0x72, 0x4e, 0xd1, 0xd5, 0x9c, + 0xa2, 0xdf, 0x73, 0x8a, 0x3e, 0x2d, 0x68, 0x70, 0xb5, 0xa0, 0xc1, 0xcf, 0x05, 0x0d, 0xde, 0xdc, + 0x57, 0x89, 0x1d, 0x4d, 0x62, 0x36, 0xd0, 0x63, 0x7e, 0xac, 0xce, 0x45, 0x0c, 0xfc, 0x58, 0x1d, + 0x0d, 0x46, 0x22, 0x49, 0xf9, 0x85, 0x7b, 0x21, 0x76, 0x96, 0x49, 0x88, 0xab, 0xcb, 0xa7, 0xf1, + 0xf0, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56, 0x26, 0x8d, 0x84, 0xdd, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/earn/types/vault.pb.go b/x/earn/types/vault.pb.go index 55b37c2e..83ffcdb0 100644 --- a/x/earn/types/vault.pb.go +++ b/x/earn/types/vault.pb.go @@ -259,38 +259,38 @@ func init() { func init() { proto.RegisterFile("kava/earn/v1beta1/vault.proto", fileDescriptor_884eb89509fbdc04) } var fileDescriptor_884eb89509fbdc04 = []byte{ - // 487 bytes of a gzipped FileDescriptorProto + // 492 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0x3f, 0x6f, 0xd3, 0x40, - 0x14, 0xb7, 0x93, 0x10, 0xd1, 0x4b, 0xa8, 0x1a, 0xb7, 0x83, 0xa9, 0x54, 0xdb, 0xca, 0x80, 0xbc, - 0xd8, 0x56, 0xcb, 0x86, 0x18, 0x88, 0x15, 0x21, 0xc4, 0x84, 0xae, 0x85, 0x81, 0x25, 0xba, 0xd8, - 0x47, 0x6a, 0xd5, 0xc9, 0x45, 0x7e, 0x17, 0x97, 0x2c, 0x7c, 0x06, 0x46, 0x24, 0x16, 0xe6, 0xce, - 0xfd, 0x0c, 0xa8, 0x63, 0xd5, 0x09, 0x31, 0xa4, 0x28, 0xf9, 0x16, 0x4c, 0xe8, 0xfe, 0xa8, 0x8e, - 0x14, 0x10, 0x0c, 0x4c, 0xb9, 0xfb, 0xbd, 0xf7, 0x7e, 0x7f, 0x5e, 0x7c, 0xe8, 0xe0, 0x8c, 0x94, - 0x24, 0xa2, 0xa4, 0x98, 0x44, 0xe5, 0xe1, 0x90, 0x72, 0x72, 0x18, 0x95, 0x64, 0x96, 0xf3, 0x70, - 0x5a, 0x30, 0xce, 0xac, 0x8e, 0x28, 0x87, 0xa2, 0x1c, 0xea, 0xf2, 0xfe, 0xc3, 0x84, 0xc1, 0x98, - 0xc1, 0x40, 0x36, 0x44, 0xea, 0xa2, 0xba, 0xf7, 0xf7, 0x46, 0x6c, 0xc4, 0x14, 0x2e, 0x4e, 0x1a, - 0xf5, 0x36, 0x25, 0x80, 0x17, 0x84, 0xd3, 0xd1, 0x5c, 0x75, 0x74, 0x3f, 0xd7, 0x50, 0xbb, 0x97, - 0xe7, 0xec, 0x9c, 0xa6, 0x6f, 0x84, 0xb8, 0xb5, 0x87, 0xee, 0xa5, 0x74, 0xc2, 0xc6, 0xb6, 0xe9, - 0x99, 0xfe, 0x16, 0x56, 0x17, 0x0b, 0x23, 0xa4, 0x07, 0x33, 0x0a, 0x76, 0xcd, 0xab, 0xfb, 0xdb, - 0x47, 0x6e, 0xb8, 0xe1, 0x30, 0x3c, 0xd6, 0xec, 0x27, 0xf3, 0x29, 0x8d, 0x3b, 0x17, 0xb7, 0xee, - 0x83, 0x75, 0x04, 0xf0, 0x1a, 0x8b, 0xe5, 0xa3, 0x9d, 0x4c, 0x64, 0xc9, 0x4a, 0xc2, 0xe9, 0x40, - 0x46, 0xb7, 0xeb, 0x9e, 0xe9, 0xdf, 0xc7, 0xdb, 0x19, 0xbc, 0x52, 0xb0, 0xf2, 0x74, 0x8e, 0x2c, - 0xa2, 0x3c, 0x0e, 0x52, 0x3a, 0x65, 0x90, 0x71, 0x56, 0x80, 0xdd, 0xf0, 0xea, 0x7e, 0x3b, 0x7e, - 0xf1, 0x73, 0xe1, 0x06, 0xa3, 0x8c, 0x9f, 0xce, 0x86, 0x61, 0xc2, 0xc6, 0x7a, 0x2b, 0xfa, 0x27, - 0x80, 0xf4, 0x2c, 0xe2, 0x42, 0x39, 0xec, 0x25, 0x49, 0x2f, 0x4d, 0x0b, 0x0a, 0x70, 0x73, 0x19, - 0xec, 0xea, 0xdd, 0x69, 0x24, 0x9e, 0x73, 0x0a, 0xb8, 0xa3, 0x35, 0xfa, 0x77, 0x12, 0xdd, 0xd7, - 0xa8, 0x25, 0x1d, 0x60, 0x9a, 0xb0, 0x22, 0xb5, 0x9e, 0xa3, 0x36, 0x67, 0x9c, 0xe4, 0x03, 0x38, - 0x25, 0x05, 0x05, 0xb9, 0xa2, 0xd6, 0xd1, 0xc1, 0x6f, 0xf6, 0x20, 0xa7, 0x8e, 0x45, 0x57, 0xdc, - 0xb8, 0x5a, 0xb8, 0x06, 0x6e, 0xc9, 0x41, 0x89, 0x40, 0xf7, 0xab, 0x89, 0x76, 0xaa, 0x0e, 0x4d, - 0xfe, 0x0e, 0x6d, 0xdd, 0x85, 0x93, 0xcc, 0xff, 0x33, 0x5b, 0x45, 0x6d, 0xbd, 0x44, 0x4d, 0x6d, - 0x5f, 0xfc, 0x8d, 0x7f, 0xb5, 0xbf, 0x2b, 0xec, 0x5f, 0xdc, 0xba, 0xad, 0x0a, 0x03, 0xac, 0x19, - 0xba, 0x1f, 0x10, 0xaa, 0xe0, 0x3f, 0x7c, 0x3a, 0x27, 0xa8, 0x49, 0xc6, 0x6c, 0x36, 0xe1, 0x76, - 0x4d, 0xc0, 0xf1, 0x53, 0x41, 0xf8, 0x7d, 0xe1, 0x3e, 0xfa, 0x87, 0x60, 0x7d, 0x9a, 0xdc, 0x5c, - 0x06, 0x48, 0x27, 0xea, 0xd3, 0x04, 0x6b, 0xae, 0x27, 0x8d, 0x4f, 0x5f, 0x5c, 0x23, 0x7e, 0x76, - 0xb5, 0x74, 0xcc, 0xeb, 0xa5, 0x63, 0xfe, 0x58, 0x3a, 0xe6, 0xc7, 0x95, 0x63, 0x5c, 0xaf, 0x1c, - 0xe3, 0xdb, 0xca, 0x31, 0xde, 0xae, 0xb3, 0x8b, 0x7c, 0x41, 0x4e, 0x86, 0x20, 0x4f, 0xd1, 0x7b, - 0xf5, 0x20, 0xa4, 0xc2, 0xb0, 0x29, 0x9f, 0xc1, 0xe3, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa0, - 0xa9, 0xba, 0x64, 0x8d, 0x03, 0x00, 0x00, + 0x14, 0xb7, 0x93, 0x10, 0xd1, 0x4b, 0xa8, 0x1a, 0xb7, 0x83, 0xa9, 0x54, 0xdb, 0xca, 0x00, 0x5e, + 0x6c, 0xb7, 0x65, 0x43, 0x2c, 0xb1, 0x22, 0x84, 0x98, 0xd0, 0xb5, 0x30, 0xb0, 0x44, 0x17, 0xfb, + 0x70, 0xac, 0x3a, 0xb9, 0xc8, 0xef, 0x92, 0x92, 0x85, 0xcf, 0xc0, 0x88, 0xc4, 0xc2, 0xdc, 0xb9, + 0x9f, 0x01, 0x75, 0xac, 0x3a, 0x21, 0x86, 0x14, 0x25, 0xdf, 0x82, 0x09, 0xdd, 0x1f, 0x35, 0x91, + 0x02, 0x82, 0x81, 0xc9, 0xbe, 0xdf, 0x7b, 0xef, 0xf7, 0xe7, 0xd9, 0x87, 0x0e, 0xce, 0xc8, 0x94, + 0x44, 0x94, 0x94, 0xa3, 0x68, 0x7a, 0xd4, 0xa7, 0x9c, 0x1c, 0x45, 0x53, 0x32, 0x29, 0x78, 0x38, + 0x2e, 0x19, 0x67, 0x56, 0x4b, 0x94, 0x43, 0x51, 0x0e, 0x75, 0x79, 0xff, 0x61, 0xc2, 0x60, 0xc8, + 0xa0, 0x27, 0x1b, 0x22, 0x75, 0x50, 0xdd, 0xfb, 0x7b, 0x19, 0xcb, 0x98, 0xc2, 0xc5, 0x9b, 0x46, + 0xbd, 0x4d, 0x09, 0xe0, 0x25, 0xe1, 0x34, 0x9b, 0xa9, 0x8e, 0xf6, 0xe7, 0x0a, 0x6a, 0x76, 0x8a, + 0x82, 0x9d, 0xd3, 0xf4, 0x8d, 0x10, 0xb7, 0xf6, 0xd0, 0xbd, 0x94, 0x8e, 0xd8, 0xd0, 0x36, 0x3d, + 0xd3, 0xdf, 0xc2, 0xea, 0x60, 0x61, 0x84, 0xf4, 0x60, 0x4e, 0xc1, 0xae, 0x78, 0x55, 0x7f, 0xfb, + 0xd8, 0x0d, 0x37, 0x1c, 0x86, 0x27, 0x9a, 0xfd, 0x74, 0x36, 0xa6, 0x71, 0xeb, 0xe2, 0xd6, 0x7d, + 0xb0, 0x8e, 0x00, 0x5e, 0x63, 0xb1, 0x7c, 0xb4, 0x93, 0x8b, 0x2c, 0xf9, 0x94, 0x70, 0xda, 0x93, + 0xd1, 0xed, 0xaa, 0x67, 0xfa, 0xf7, 0xf1, 0x76, 0x0e, 0xaf, 0x14, 0xac, 0x3c, 0x9d, 0x23, 0x8b, + 0x28, 0x8f, 0xbd, 0x94, 0x8e, 0x19, 0xe4, 0x9c, 0x95, 0x60, 0xd7, 0xbc, 0xaa, 0xdf, 0x8c, 0x5f, + 0xfc, 0x9c, 0xbb, 0x41, 0x96, 0xf3, 0xc1, 0xa4, 0x1f, 0x26, 0x6c, 0xa8, 0xb7, 0xa2, 0x1f, 0x01, + 0xa4, 0x67, 0x11, 0x17, 0xca, 0x61, 0x27, 0x49, 0x3a, 0x69, 0x5a, 0x52, 0x80, 0x9b, 0xcb, 0x60, + 0x57, 0xef, 0x4e, 0x23, 0xf1, 0x8c, 0x53, 0xc0, 0x2d, 0xad, 0xd1, 0xbd, 0x93, 0x68, 0xbf, 0x46, + 0x0d, 0xe9, 0x00, 0xd3, 0x84, 0x95, 0xa9, 0xf5, 0x1c, 0x35, 0x39, 0xe3, 0xa4, 0xe8, 0xc1, 0x80, + 0x94, 0x14, 0xe4, 0x8a, 0x1a, 0xc7, 0x07, 0xbf, 0xd9, 0x83, 0x9c, 0x3a, 0x11, 0x5d, 0x71, 0xed, + 0x6a, 0xee, 0x1a, 0xb8, 0x21, 0x07, 0x25, 0x02, 0xed, 0xaf, 0x26, 0xda, 0x59, 0x75, 0x68, 0xf2, + 0x77, 0x68, 0xeb, 0x2e, 0x9c, 0x64, 0xfe, 0x9f, 0xd9, 0x56, 0xd4, 0xd6, 0x4b, 0x54, 0xd7, 0xf6, + 0xc5, 0x67, 0xfc, 0xab, 0xfd, 0x5d, 0x61, 0xff, 0xe2, 0xd6, 0x6d, 0xac, 0x30, 0xc0, 0x9a, 0xa1, + 0xfd, 0x01, 0xa1, 0x15, 0xfc, 0x87, 0x5f, 0xe7, 0x14, 0xd5, 0xc9, 0x90, 0x4d, 0x46, 0xdc, 0xae, + 0x08, 0x38, 0x7e, 0x26, 0x08, 0xbf, 0xcf, 0xdd, 0x47, 0xff, 0x10, 0xac, 0x4b, 0x93, 0x9b, 0xcb, + 0x00, 0xe9, 0x44, 0x5d, 0x9a, 0x60, 0xcd, 0xf5, 0xb4, 0xf6, 0xe9, 0x8b, 0x6b, 0xc4, 0x9d, 0xab, + 0x85, 0x63, 0x5e, 0x2f, 0x1c, 0xf3, 0xc7, 0xc2, 0x31, 0x3f, 0x2e, 0x1d, 0xe3, 0x7a, 0xe9, 0x18, + 0xdf, 0x96, 0x8e, 0xf1, 0xf6, 0xf1, 0x1a, 0xfb, 0x61, 0x56, 0x90, 0x3e, 0x44, 0x87, 0x59, 0x90, + 0x0c, 0x48, 0x3e, 0x8a, 0xde, 0xab, 0x1b, 0x21, 0x25, 0xfa, 0x75, 0x79, 0x0f, 0x9e, 0xfc, 0x0a, + 0x00, 0x00, 0xff, 0xff, 0x3f, 0x6e, 0x41, 0xab, 0x8e, 0x03, 0x00, 0x00, } func (m *AllowedVault) Marshal() (dAtA []byte, err error) { diff --git a/x/evmutil/types/conversion_pair.pb.go b/x/evmutil/types/conversion_pair.pb.go index 637dd783..275f374b 100644 --- a/x/evmutil/types/conversion_pair.pb.go +++ b/x/evmutil/types/conversion_pair.pb.go @@ -124,30 +124,30 @@ func init() { } var fileDescriptor_e1396d08199817d0 = []byte{ - // 356 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x3c, 0x91, 0xcf, 0x4a, 0xeb, 0x40, - 0x18, 0xc5, 0x33, 0xf7, 0xf6, 0x96, 0xde, 0xb1, 0x4a, 0x19, 0x8a, 0x84, 0x0a, 0xd3, 0xd8, 0x55, - 0x15, 0x4c, 0xda, 0xba, 0x73, 0xd7, 0xc6, 0x82, 0x50, 0x10, 0x09, 0xae, 0xdc, 0x84, 0x49, 0x32, - 0xd4, 0xd0, 0x24, 0x5f, 0xc9, 0xa4, 0xb1, 0x05, 0x1f, 0xc0, 0x95, 0xf8, 0x08, 0x2e, 0x7d, 0x14, - 0x97, 0x5d, 0xba, 0x2a, 0x35, 0x7d, 0x0b, 0x57, 0x92, 0x49, 0xe8, 0xee, 0x3b, 0xe7, 0x3b, 0xe7, - 0xc7, 0xfc, 0xc1, 0xe7, 0x33, 0x96, 0x32, 0x83, 0xa7, 0xe1, 0x22, 0xf1, 0x03, 0x23, 0xed, 0x3b, - 0x3c, 0x61, 0x7d, 0xc3, 0x85, 0x28, 0xe5, 0xb1, 0xf0, 0x21, 0xb2, 0xe7, 0xcc, 0x8f, 0xf5, 0x79, - 0x0c, 0x09, 0x90, 0x66, 0x9e, 0xd5, 0xcb, 0xac, 0x5e, 0x66, 0x5b, 0xcd, 0x29, 0x4c, 0x41, 0x06, - 0x8c, 0x7c, 0x2a, 0xb2, 0x9d, 0x67, 0x7c, 0x64, 0xee, 0x21, 0x77, 0xcc, 0x8f, 0xc9, 0x2d, 0x26, - 0x79, 0xdf, 0xe6, 0xb1, 0x3b, 0xe8, 0xd9, 0xcc, 0xf3, 0x62, 0x2e, 0x84, 0x8a, 0x34, 0xd4, 0xad, - 0x8f, 0xb4, 0x6c, 0xd3, 0x6e, 0x4c, 0x58, 0xca, 0xc6, 0x96, 0x39, 0xe8, 0x0d, 0x8b, 0xdd, 0xcf, - 0xa6, 0x5d, 0xbb, 0xe1, 0xcb, 0xd1, 0x2a, 0xe1, 0xc2, 0x6a, 0xe4, 0xdd, 0x71, 0x5e, 0x2d, 0xb7, - 0xa4, 0x89, 0xff, 0x79, 0x3c, 0x82, 0x50, 0xfd, 0xa3, 0xa1, 0xee, 0x7f, 0xab, 0x10, 0x57, 0x95, - 0x97, 0xf7, 0xb6, 0xd2, 0x79, 0x45, 0xf8, 0x64, 0x18, 0x04, 0xf0, 0xc4, 0x3d, 0x13, 0x44, 0x08, - 0xc2, 0x04, 0x3f, 0x92, 0xec, 0x7b, 0x98, 0xf1, 0x88, 0x9c, 0xe2, 0xba, 0x2b, 0x7d, 0xbb, 0x40, - 0x20, 0x89, 0x38, 0x28, 0xbc, 0xeb, 0xdc, 0x22, 0x04, 0x57, 0x22, 0x16, 0xf2, 0x92, 0x2e, 0x67, - 0x72, 0x8c, 0xab, 0x62, 0x15, 0x3a, 0x10, 0xa8, 0x7f, 0xa5, 0x5b, 0x2a, 0xd2, 0xc2, 0x35, 0x8f, - 0xbb, 0x7e, 0xc8, 0x02, 0xa1, 0x56, 0x34, 0xd4, 0x3d, 0xb4, 0xf6, 0xba, 0x38, 0xd0, 0x68, 0xb2, - 0xfd, 0xa6, 0xe8, 0x23, 0xa3, 0xe8, 0x33, 0xa3, 0x68, 0x9d, 0x51, 0xb4, 0xcd, 0x28, 0x7a, 0xdb, - 0x51, 0x65, 0xbd, 0xa3, 0xca, 0xd7, 0x8e, 0x2a, 0x0f, 0x67, 0x53, 0x3f, 0x79, 0x5c, 0x38, 0xba, - 0x0b, 0xa1, 0x91, 0xdf, 0xf5, 0x22, 0x60, 0x8e, 0x90, 0x93, 0xb1, 0xdc, 0xff, 0x4f, 0xb2, 0x9a, - 0x73, 0xe1, 0x54, 0xe5, 0x13, 0x5f, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0x95, 0x40, 0xc5, 0x63, - 0xbc, 0x01, 0x00, 0x00, + // 361 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x3c, 0x91, 0xc1, 0x4a, 0xeb, 0x40, + 0x18, 0x85, 0x33, 0xf7, 0xf6, 0x96, 0xde, 0xb9, 0xbd, 0x52, 0x86, 0x22, 0xa1, 0xc2, 0x34, 0x76, + 0x55, 0x0a, 0x26, 0x69, 0xdd, 0xb9, 0x6b, 0x63, 0x41, 0x50, 0x44, 0x82, 0x2b, 0x37, 0x61, 0x92, + 0x0c, 0xe9, 0xd0, 0x24, 0x53, 0x32, 0x69, 0x6c, 0xc1, 0x07, 0x70, 0x25, 0x3e, 0x82, 0x4b, 0x1f, + 0xc5, 0x65, 0x97, 0xae, 0x4a, 0x4d, 0xdf, 0xc2, 0x95, 0x64, 0x12, 0xba, 0xfb, 0xcf, 0xf9, 0xcf, + 0xf9, 0x18, 0xe6, 0x87, 0x83, 0x39, 0xc9, 0x88, 0x41, 0xb3, 0x68, 0x99, 0xb2, 0xd0, 0xc8, 0x86, + 0x2e, 0x4d, 0xc9, 0xd0, 0xf0, 0x78, 0x9c, 0xd1, 0x44, 0x30, 0x1e, 0x3b, 0x0b, 0xc2, 0x12, 0x7d, + 0x91, 0xf0, 0x94, 0xa3, 0x76, 0x91, 0xd5, 0xab, 0xac, 0x5e, 0x65, 0x3b, 0xed, 0x80, 0x07, 0x5c, + 0x06, 0x8c, 0x62, 0x2a, 0xb3, 0xbd, 0x27, 0x78, 0x64, 0x1d, 0x20, 0x77, 0x84, 0x25, 0xe8, 0x16, + 0xa2, 0xa2, 0xef, 0xd0, 0xc4, 0x1b, 0x99, 0x0e, 0xf1, 0xfd, 0x84, 0x0a, 0xa1, 0x02, 0x0d, 0xf4, + 0x9b, 0x13, 0x2d, 0xdf, 0x76, 0x5b, 0xd7, 0x24, 0x23, 0x53, 0xdb, 0x1a, 0x99, 0xe3, 0x72, 0xf7, + 0xbd, 0xed, 0x36, 0xae, 0xe8, 0x6a, 0xb2, 0x4e, 0xa9, 0xb0, 0x5b, 0x45, 0x77, 0x5a, 0x54, 0xab, + 0x2d, 0x6a, 0xc3, 0x3f, 0x3e, 0x8d, 0x79, 0xa4, 0xfe, 0xd2, 0x40, 0xff, 0xaf, 0x5d, 0x8a, 0x8b, + 0xda, 0xf3, 0x5b, 0x57, 0xe9, 0xbd, 0x00, 0x78, 0x32, 0x0e, 0x43, 0xfe, 0x48, 0x7d, 0x8b, 0x8b, + 0x88, 0x0b, 0x8b, 0xb3, 0x58, 0xb2, 0xef, 0xf9, 0x9c, 0xc6, 0xe8, 0x14, 0x36, 0x3d, 0xe9, 0x3b, + 0x25, 0x02, 0x48, 0xc4, 0xbf, 0xd2, 0xbb, 0x2c, 0x2c, 0x84, 0x60, 0x2d, 0x26, 0x11, 0xad, 0xe8, + 0x72, 0x46, 0xc7, 0xb0, 0x2e, 0xd6, 0x91, 0xcb, 0x43, 0xf5, 0xb7, 0x74, 0x2b, 0x85, 0x3a, 0xb0, + 0xe1, 0x53, 0x8f, 0x45, 0x24, 0x14, 0x6a, 0x4d, 0x03, 0xfd, 0xff, 0xf6, 0x41, 0x97, 0x0f, 0x9a, + 0xdc, 0xec, 0xbe, 0x30, 0x78, 0xcf, 0x31, 0xf8, 0xc8, 0x31, 0xd8, 0xe4, 0x18, 0xec, 0x72, 0x0c, + 0x5e, 0xf7, 0x58, 0xd9, 0xec, 0xb1, 0xf2, 0xb9, 0xc7, 0xca, 0xc3, 0x20, 0x60, 0xe9, 0x6c, 0xe9, + 0xea, 0x1e, 0x8f, 0x0c, 0x33, 0x08, 0x89, 0x2b, 0x0c, 0x33, 0x38, 0xf3, 0x66, 0x84, 0xc5, 0xc6, + 0xea, 0x70, 0xa0, 0x74, 0xbd, 0xa0, 0xc2, 0xad, 0xcb, 0x3f, 0x3e, 0xff, 0x09, 0x00, 0x00, 0xff, + 0xff, 0xd9, 0x75, 0x8b, 0x8e, 0xbd, 0x01, 0x00, 0x00, } func (this *ConversionPair) VerboseEqual(that interface{}) error { diff --git a/x/evmutil/types/genesis.pb.go b/x/evmutil/types/genesis.pb.go index 93aa0b97..601a2767 100644 --- a/x/evmutil/types/genesis.pb.go +++ b/x/evmutil/types/genesis.pb.go @@ -174,38 +174,38 @@ func init() { } var fileDescriptor_d916ab97b8e628c2 = []byte{ - // 489 bytes of a gzipped FileDescriptorProto + // 493 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0x41, 0x6b, 0x13, 0x41, - 0x14, 0xde, 0xa9, 0x21, 0xd1, 0x69, 0x41, 0xd8, 0x56, 0x8d, 0xa5, 0xce, 0x96, 0x50, 0x24, 0x0a, - 0xbb, 0x6b, 0xe2, 0xad, 0x08, 0xd2, 0x8d, 0xa2, 0xc5, 0x4b, 0x59, 0xc5, 0x83, 0x97, 0xf0, 0x76, - 0x77, 0x88, 0x4b, 0x76, 0x67, 0xc2, 0xce, 0x24, 0xb5, 0xff, 0x40, 0xf0, 0xa0, 0xfe, 0x03, 0x8f, - 0xe2, 0xb9, 0x3f, 0xa2, 0xe0, 0xa5, 0xf4, 0x24, 0x1e, 0x62, 0x4d, 0xfe, 0x85, 0x27, 0xd9, 0x99, - 0x49, 0xa8, 0x21, 0x8a, 0xa7, 0x9d, 0x7d, 0xf3, 0x7d, 0xef, 0xfb, 0xe6, 0x7b, 0x0f, 0x37, 0xfa, - 0x30, 0x02, 0x9f, 0x8e, 0xf2, 0xa1, 0x4c, 0x33, 0x7f, 0xd4, 0x8a, 0xa8, 0x84, 0x96, 0xdf, 0xa3, - 0x8c, 0x8a, 0x54, 0x78, 0x83, 0x82, 0x4b, 0x6e, 0x6f, 0x94, 0x18, 0xcf, 0x60, 0x3c, 0x83, 0xd9, - 0xbc, 0x19, 0x73, 0x91, 0x73, 0xd1, 0x55, 0x18, 0x5f, 0xff, 0x68, 0xc2, 0xe6, 0x46, 0x8f, 0xf7, - 0xb8, 0xae, 0x97, 0x27, 0x53, 0xbd, 0xbb, 0x54, 0x2a, 0xe6, 0x6c, 0x44, 0x0b, 0x91, 0x72, 0xd6, - 0x1d, 0x40, 0x5a, 0x68, 0x6c, 0xe3, 0x23, 0xc2, 0x6b, 0x4f, 0xb4, 0x89, 0xe7, 0x12, 0x24, 0xb5, - 0x1f, 0xe2, 0xcb, 0x10, 0xc7, 0x7c, 0xc8, 0xa4, 0xa8, 0xa3, 0xed, 0x4b, 0xcd, 0xd5, 0xf6, 0x2d, - 0x6f, 0x99, 0x2d, 0x6f, 0x4f, 0xa3, 0x82, 0xca, 0xc9, 0xd8, 0xb1, 0xc2, 0x39, 0xc9, 0xde, 0xc5, - 0xd5, 0x01, 0x14, 0x90, 0x8b, 0xfa, 0xca, 0x36, 0x6a, 0xae, 0xb6, 0xb7, 0x96, 0xd3, 0x0f, 0x14, - 0xc6, 0xb0, 0x0d, 0x63, 0xb7, 0xf2, 0xf6, 0x93, 0x63, 0x35, 0xbe, 0x22, 0x5c, 0x33, 0xdd, 0xed, - 0x08, 0xd7, 0x20, 0x49, 0x0a, 0x2a, 0x4a, 0x37, 0xa8, 0xb9, 0x16, 0x3c, 0xfd, 0x35, 0x76, 0xdc, - 0x5e, 0x2a, 0x5f, 0x0f, 0x23, 0x2f, 0xe6, 0xb9, 0xc9, 0xc3, 0x7c, 0x5c, 0x91, 0xf4, 0x7d, 0x79, - 0x34, 0xa0, 0xa2, 0xb4, 0xb7, 0xa7, 0x89, 0x67, 0xc7, 0xee, 0xba, 0x49, 0xcd, 0x54, 0x82, 0x23, - 0x49, 0x45, 0x38, 0x6b, 0x6c, 0xbf, 0xc4, 0xb5, 0x08, 0x32, 0x60, 0x31, 0x55, 0x96, 0xaf, 0x04, - 0x0f, 0x4a, 0x53, 0xdf, 0xc7, 0xce, 0xed, 0xff, 0xd0, 0xd9, 0x67, 0xf2, 0xec, 0xd8, 0xc5, 0x46, - 0x60, 0x9f, 0xc9, 0x70, 0xd6, 0xcc, 0xbc, 0xe6, 0xfd, 0x0a, 0xae, 0xea, 0xc7, 0xda, 0x87, 0xb8, - 0x4e, 0x19, 0x44, 0x19, 0x4d, 0xba, 0x0b, 0xd3, 0x10, 0xf5, 0x8a, 0xca, 0x7a, 0x67, 0x79, 0x58, - 0x9d, 0x39, 0xfa, 0x00, 0xd2, 0x22, 0xb8, 0x51, 0xfa, 0xfb, 0xf2, 0xc3, 0xb9, 0xfa, 0x67, 0x5d, - 0x84, 0xd7, 0x4d, 0xfb, 0x85, 0xba, 0xfd, 0x0e, 0xe1, 0x6b, 0x90, 0x65, 0xfc, 0x50, 0x29, 0xab, - 0x6d, 0x4a, 0x28, 0xe3, 0xf9, 0x6c, 0xc4, 0xad, 0xbf, 0x8c, 0x58, 0x53, 0x3a, 0x8a, 0xd1, 0xe1, - 0x29, 0x7b, 0x1c, 0x76, 0xda, 0xf7, 0x5e, 0xf0, 0x3e, 0x65, 0xc1, 0x8e, 0xf1, 0xb0, 0xf5, 0x0f, - 0x90, 0x08, 0xd7, 0xe1, 0xe2, 0xed, 0x23, 0xa5, 0x19, 0x3c, 0x3b, 0xff, 0x49, 0xd0, 0xe7, 0x09, - 0x41, 0x27, 0x13, 0x82, 0x4e, 0x27, 0x04, 0x9d, 0x4f, 0x08, 0xfa, 0x30, 0x25, 0xd6, 0xe9, 0x94, - 0x58, 0xdf, 0xa6, 0xc4, 0x7a, 0x75, 0xe7, 0x42, 0xf0, 0xa5, 0x33, 0x37, 0x83, 0x48, 0xa8, 0x93, - 0xff, 0x66, 0xbe, 0xd8, 0x2a, 0xff, 0xa8, 0xaa, 0xf6, 0xf8, 0xfe, 0xef, 0x00, 0x00, 0x00, 0xff, - 0xff, 0xa1, 0xec, 0x74, 0x78, 0x60, 0x03, 0x00, 0x00, + 0x18, 0xdd, 0xa9, 0x21, 0xd1, 0x69, 0x41, 0xd8, 0x56, 0x8d, 0xa5, 0xee, 0x96, 0x50, 0x24, 0x14, + 0x76, 0x37, 0x89, 0xb7, 0x22, 0x48, 0x37, 0x8a, 0x16, 0x3c, 0x94, 0x55, 0x3c, 0x78, 0x09, 0xdf, + 0xee, 0x0e, 0xdb, 0x25, 0xbb, 0x33, 0x61, 0x67, 0x92, 0xda, 0x7f, 0x20, 0x78, 0x50, 0xff, 0x81, + 0x47, 0xf1, 0xdc, 0x1f, 0x51, 0xf0, 0x52, 0x7a, 0x12, 0x0f, 0xb1, 0x26, 0xff, 0xc2, 0x93, 0xec, + 0xcc, 0x24, 0xd4, 0x10, 0xc5, 0xd3, 0xee, 0xbe, 0x7d, 0xef, 0x7b, 0x6f, 0xde, 0x37, 0xb8, 0xd1, + 0x87, 0x11, 0x78, 0x64, 0x94, 0x0f, 0x45, 0x9a, 0x79, 0xa3, 0x76, 0x48, 0x04, 0xb4, 0xbd, 0x84, + 0x50, 0xc2, 0x53, 0xee, 0x0e, 0x0a, 0x26, 0x98, 0xb9, 0x51, 0x72, 0x5c, 0xcd, 0x71, 0x35, 0x67, + 0xf3, 0x6e, 0xc4, 0x78, 0xce, 0x78, 0x4f, 0x72, 0x3c, 0xf5, 0xa1, 0x04, 0x9b, 0x1b, 0x09, 0x4b, + 0x98, 0xc2, 0xcb, 0x37, 0x8d, 0xee, 0x2e, 0xb5, 0x8a, 0x18, 0x1d, 0x91, 0x82, 0xa7, 0x8c, 0xf6, + 0x06, 0x90, 0x16, 0x8a, 0xdb, 0xf8, 0x88, 0xf0, 0xda, 0x53, 0x15, 0xe2, 0x85, 0x00, 0x41, 0xcc, + 0x47, 0xf8, 0x3a, 0x44, 0x11, 0x1b, 0x52, 0xc1, 0xeb, 0x68, 0xfb, 0x5a, 0x73, 0xb5, 0x73, 0xcf, + 0x5d, 0x16, 0xcb, 0xdd, 0x57, 0x2c, 0xbf, 0x72, 0x36, 0xb6, 0x8d, 0x60, 0x2e, 0x32, 0xf7, 0x70, + 0x75, 0x00, 0x05, 0xe4, 0xbc, 0xbe, 0xb2, 0x8d, 0x9a, 0xab, 0x9d, 0xad, 0xe5, 0xf2, 0x43, 0xc9, + 0xd1, 0x6a, 0xad, 0xd8, 0xab, 0xbc, 0xfd, 0x64, 0x1b, 0x8d, 0xaf, 0x08, 0xd7, 0xf4, 0x74, 0x33, + 0xc4, 0x35, 0x88, 0xe3, 0x82, 0xf0, 0x32, 0x0d, 0x6a, 0xae, 0xf9, 0xcf, 0x7e, 0x8d, 0x6d, 0x27, + 0x49, 0xc5, 0xd1, 0x30, 0x74, 0x23, 0x96, 0xeb, 0x3e, 0xf4, 0xc3, 0xe1, 0x71, 0xdf, 0x13, 0x27, + 0x03, 0xc2, 0xcb, 0x78, 0xfb, 0x4a, 0x78, 0x71, 0xea, 0xac, 0xeb, 0xd6, 0x34, 0xe2, 0x9f, 0x08, + 0xc2, 0x83, 0xd9, 0x60, 0xf3, 0x15, 0xae, 0x85, 0x90, 0x01, 0x8d, 0x88, 0x8c, 0x7c, 0xc3, 0x7f, + 0x58, 0x86, 0xfa, 0x3e, 0xb6, 0xef, 0xff, 0x87, 0xcf, 0x01, 0x15, 0x17, 0xa7, 0x0e, 0xd6, 0x06, + 0x07, 0x54, 0x04, 0xb3, 0x61, 0xfa, 0x34, 0xef, 0x57, 0x70, 0x55, 0x1d, 0xd6, 0x3c, 0xc6, 0x75, + 0x42, 0x21, 0xcc, 0x48, 0xdc, 0x5b, 0xd8, 0x06, 0xaf, 0x57, 0x64, 0xd7, 0x3b, 0xcb, 0xcb, 0xea, + 0xce, 0xd9, 0x87, 0x90, 0x16, 0xfe, 0x9d, 0x32, 0xdf, 0x97, 0x1f, 0xf6, 0xcd, 0x3f, 0x71, 0x1e, + 0xdc, 0xd6, 0xe3, 0x17, 0x70, 0xf3, 0x1d, 0xc2, 0xb7, 0x20, 0xcb, 0xd8, 0xb1, 0x74, 0x96, 0xb7, + 0x29, 0x26, 0x94, 0xe5, 0xb3, 0x15, 0xb7, 0xff, 0xb2, 0x62, 0x25, 0xe9, 0x4a, 0x45, 0x97, 0xa5, + 0xf4, 0x49, 0xd0, 0xed, 0xb4, 0x5e, 0xb2, 0x3e, 0xa1, 0xfe, 0x8e, 0xce, 0xb0, 0xf5, 0x0f, 0x12, + 0x0f, 0xd6, 0xe1, 0xea, 0xdf, 0xc7, 0xd2, 0xd3, 0x7f, 0x7e, 0xf9, 0xd3, 0x42, 0x9f, 0x27, 0x16, + 0x3a, 0x9b, 0x58, 0xe8, 0x7c, 0x62, 0xa1, 0xcb, 0x89, 0x85, 0x3e, 0x4c, 0x2d, 0xe3, 0x7c, 0x6a, + 0x19, 0xdf, 0xa6, 0x96, 0xf1, 0x7a, 0xf7, 0x4a, 0xf1, 0xad, 0x24, 0x83, 0x90, 0x7b, 0xad, 0xc4, + 0x89, 0x8e, 0x20, 0xa5, 0xde, 0x9b, 0xf9, 0xcd, 0x96, 0x0b, 0x08, 0xab, 0xf2, 0x22, 0x3f, 0xf8, + 0x1d, 0x00, 0x00, 0xff, 0xff, 0xc0, 0x30, 0x24, 0xaf, 0x61, 0x03, 0x00, 0x00, } func (this *GenesisState) VerboseEqual(that interface{}) error { diff --git a/x/evmutil/types/query.pb.go b/x/evmutil/types/query.pb.go index 9336d95d..29402308 100644 --- a/x/evmutil/types/query.pb.go +++ b/x/evmutil/types/query.pb.go @@ -271,41 +271,42 @@ func init() { func init() { proto.RegisterFile("kava/evmutil/v1beta1/query.proto", fileDescriptor_4a8d0512331709e7) } var fileDescriptor_4a8d0512331709e7 = []byte{ - // 542 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x4f, 0x6f, 0xd3, 0x30, - 0x14, 0x8f, 0x0b, 0x14, 0xea, 0x8e, 0x8b, 0xa9, 0xd0, 0xd4, 0x55, 0xe9, 0x08, 0x88, 0x75, 0x48, - 0x38, 0x5b, 0x41, 0x1c, 0x26, 0x40, 0xa2, 0x1d, 0x20, 0x0e, 0x48, 0x2c, 0x07, 0x0e, 0x5c, 0x2a, - 0x27, 0xb1, 0x42, 0x44, 0x6a, 0xa7, 0xb1, 0x5b, 0x51, 0x71, 0x83, 0x0b, 0x47, 0x24, 0xbe, 0x40, - 0x3f, 0xce, 0x8e, 0x93, 0xb8, 0xa0, 0x1d, 0x26, 0xd4, 0x72, 0x40, 0x9c, 0xf8, 0x08, 0xa8, 0xb6, - 0xbb, 0x15, 0x91, 0xb6, 0x88, 0x9b, 0xf5, 0xfc, 0x7b, 0xfe, 0xfd, 0x79, 0x2f, 0x81, 0x9b, 0x6f, - 0xc8, 0x80, 0xb8, 0x74, 0xd0, 0xed, 0xcb, 0x38, 0x71, 0x07, 0xbb, 0x3e, 0x95, 0x64, 0xd7, 0xed, - 0xf5, 0x69, 0x36, 0xc4, 0x69, 0xc6, 0x25, 0x47, 0x95, 0x29, 0x02, 0x1b, 0x04, 0x36, 0x88, 0xea, - 0xad, 0x80, 0x8b, 0x2e, 0x17, 0xae, 0x4f, 0x04, 0xd5, 0xf0, 0xd3, 0xe6, 0x94, 0x44, 0x31, 0x23, - 0x32, 0xe6, 0x4c, 0xbf, 0x50, 0xad, 0x44, 0x3c, 0xe2, 0xea, 0xe8, 0x4e, 0x4f, 0xa6, 0x5a, 0x8b, - 0x38, 0x8f, 0x12, 0xea, 0x92, 0x34, 0x76, 0x09, 0x63, 0x5c, 0xaa, 0x16, 0x61, 0x6e, 0x9d, 0x5c, - 0x5d, 0x11, 0x65, 0x54, 0xc4, 0x06, 0xe3, 0x54, 0x20, 0x3a, 0x98, 0x32, 0xbf, 0x20, 0x19, 0xe9, - 0x0a, 0x8f, 0xf6, 0xfa, 0x54, 0x48, 0xe7, 0x00, 0x5e, 0xf9, 0xa3, 0x2a, 0x52, 0xce, 0x04, 0x45, - 0x7b, 0xb0, 0x98, 0xaa, 0xca, 0x3a, 0xd8, 0x04, 0x8d, 0x72, 0xb3, 0x86, 0xf3, 0x7c, 0x61, 0xdd, - 0xd5, 0x3a, 0x7f, 0x78, 0x52, 0xb7, 0x3c, 0xd3, 0xe1, 0x8c, 0x00, 0xdc, 0x52, 0x6f, 0xee, 0xd3, - 0x34, 0xe1, 0x43, 0x1a, 0xb6, 0x95, 0xf9, 0x36, 0x8f, 0x59, 0x9b, 0x33, 0x99, 0x91, 0x40, 0xce, - 0xe8, 0xd1, 0x75, 0x78, 0x59, 0x47, 0xd3, 0x09, 0x29, 0xe3, 0x8a, 0xee, 0x5c, 0xa3, 0xe4, 0xad, - 0xe9, 0xe2, 0xbe, 0xaa, 0xa1, 0x27, 0x10, 0x9e, 0xa5, 0xb4, 0x5e, 0x50, 0x82, 0x6e, 0x62, 0x0d, - 0xc1, 0xd3, 0x48, 0xb1, 0x9e, 0xc0, 0x99, 0xaa, 0x88, 0x1a, 0x02, 0x6f, 0xae, 0x73, 0xef, 0xd2, - 0xc7, 0x51, 0xdd, 0xfa, 0x31, 0xaa, 0x5b, 0xce, 0x2f, 0x00, 0x1b, 0xab, 0x25, 0x9a, 0x2c, 0xde, - 0x41, 0x3b, 0x34, 0xb0, 0x8e, 0x11, 0x1b, 0xf0, 0x98, 0x75, 0x82, 0x19, 0x52, 0x89, 0x2e, 0x37, - 0x77, 0xf2, 0x33, 0x5a, 0x4c, 0x61, 0x72, 0xdb, 0x08, 0x17, 0x8b, 0x40, 0x4f, 0x73, 0xbc, 0x6f, - 0xad, 0xf4, 0xae, 0x95, 0xcf, 0x9b, 0x77, 0x7a, 0xb0, 0xba, 0x58, 0x09, 0xba, 0x06, 0xd7, 0xe6, - 0xe7, 0xa0, 0xa6, 0x5e, 0xf2, 0xca, 0x73, 0x63, 0x40, 0x3b, 0xf0, 0x22, 0x09, 0xc3, 0x8c, 0x0a, - 0xa1, 0x64, 0x94, 0x5a, 0x57, 0x8f, 0x4f, 0xea, 0xe8, 0x19, 0x93, 0x34, 0x63, 0x24, 0x79, 0xfc, - 0xf2, 0xf9, 0x23, 0x7d, 0xeb, 0xcd, 0x60, 0xcd, 0x9f, 0x05, 0x78, 0x41, 0xa5, 0x8c, 0x3e, 0x00, - 0x58, 0xd4, 0xbb, 0x82, 0x1a, 0xf9, 0x29, 0xfd, 0xbd, 0x9a, 0xd5, 0xed, 0x7f, 0x40, 0x6a, 0xa3, - 0xce, 0x8d, 0xf7, 0x5f, 0xbe, 0x7f, 0x2e, 0xd8, 0xa8, 0xe6, 0xe6, 0x7e, 0x08, 0x7a, 0x31, 0xd1, - 0x31, 0x80, 0x1b, 0x4b, 0x06, 0x8e, 0x1e, 0x2c, 0x21, 0x5c, 0xbd, 0xcb, 0xd5, 0x87, 0xff, 0xdb, - 0x6e, 0x4c, 0xdc, 0x57, 0x26, 0xee, 0xa1, 0xbb, 0xf9, 0x26, 0x96, 0xef, 0x60, 0xab, 0x7d, 0x38, - 0xb6, 0xc1, 0xd1, 0xd8, 0x06, 0xdf, 0xc6, 0x36, 0xf8, 0x34, 0xb1, 0xad, 0xa3, 0x89, 0x6d, 0x7d, - 0x9d, 0xd8, 0xd6, 0xab, 0xed, 0x28, 0x96, 0xaf, 0xfb, 0x3e, 0x0e, 0x78, 0x57, 0xbd, 0x7c, 0x3b, - 0x21, 0xbe, 0xd0, 0x1c, 0x6f, 0x4f, 0x59, 0xe4, 0x30, 0xa5, 0xc2, 0x2f, 0xaa, 0x5f, 0xc5, 0x9d, - 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1f, 0xfa, 0x86, 0x41, 0xe8, 0x04, 0x00, 0x00, + // 549 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x4f, 0x6b, 0x13, 0x4d, + 0x18, 0xdf, 0xcd, 0xfb, 0x1a, 0xcd, 0xa4, 0x5e, 0xc6, 0x20, 0x25, 0x0d, 0x9b, 0xba, 0x8a, 0x8d, + 0x05, 0x77, 0xd2, 0x28, 0x1e, 0x8a, 0x0a, 0x26, 0x51, 0xf1, 0x20, 0xd8, 0x3d, 0x78, 0xf0, 0x12, + 0x26, 0xbb, 0xc3, 0x74, 0x71, 0x33, 0xb3, 0xd9, 0x99, 0x04, 0x83, 0x37, 0xbd, 0x78, 0x14, 0xfc, + 0x02, 0xf9, 0x38, 0x3d, 0x16, 0xbc, 0x48, 0x0f, 0x45, 0x12, 0x0f, 0xe2, 0xc9, 0x8f, 0x20, 0x99, + 0x99, 0xb4, 0x11, 0x37, 0x89, 0x78, 0x1b, 0x9e, 0xf9, 0x3d, 0xf3, 0xfb, 0xf3, 0x3c, 0xbb, 0x60, + 0xfb, 0x35, 0x1e, 0x62, 0x44, 0x86, 0xbd, 0x81, 0x8c, 0x62, 0x34, 0xdc, 0xeb, 0x12, 0x89, 0xf7, + 0x50, 0x7f, 0x40, 0xd2, 0x91, 0x97, 0xa4, 0x5c, 0x72, 0x58, 0x9a, 0x21, 0x3c, 0x83, 0xf0, 0x0c, + 0xa2, 0xbc, 0x1b, 0x70, 0xd1, 0xe3, 0x02, 0x75, 0xb1, 0x20, 0x1a, 0x7e, 0xd6, 0x9c, 0x60, 0x1a, + 0x31, 0x2c, 0x23, 0xce, 0xf4, 0x0b, 0xe5, 0x12, 0xe5, 0x94, 0xab, 0x23, 0x9a, 0x9d, 0x4c, 0xb5, + 0x42, 0x39, 0xa7, 0x31, 0x41, 0x38, 0x89, 0x10, 0x66, 0x8c, 0x4b, 0xd5, 0x22, 0xcc, 0xad, 0x9b, + 0xa9, 0x8b, 0x12, 0x46, 0x44, 0x64, 0x30, 0x6e, 0x09, 0xc0, 0x83, 0x19, 0xf3, 0x0b, 0x9c, 0xe2, + 0x9e, 0xf0, 0x49, 0x7f, 0x40, 0x84, 0x74, 0x0f, 0xc0, 0x95, 0xdf, 0xaa, 0x22, 0xe1, 0x4c, 0x10, + 0xb8, 0x0f, 0xf2, 0x89, 0xaa, 0x6c, 0xda, 0xdb, 0x76, 0xad, 0xd8, 0xa8, 0x78, 0x59, 0xbe, 0x3c, + 0xdd, 0xd5, 0xfc, 0xff, 0xe8, 0xb4, 0x6a, 0xf9, 0xa6, 0xc3, 0x1d, 0xdb, 0x60, 0x47, 0xbd, 0xd9, + 0x26, 0x49, 0xcc, 0x47, 0x24, 0x6c, 0x29, 0xf3, 0x2d, 0x1e, 0xb1, 0x16, 0x67, 0x32, 0xc5, 0x81, + 0x9c, 0xd3, 0xc3, 0xeb, 0xe0, 0xb2, 0x8e, 0xa6, 0x13, 0x12, 0xc6, 0x15, 0xdd, 0x7f, 0xb5, 0x82, + 0xbf, 0xa1, 0x8b, 0x6d, 0x55, 0x83, 0x4f, 0x00, 0x38, 0x4f, 0x69, 0x33, 0xa7, 0x04, 0xdd, 0xf4, + 0x34, 0xc4, 0x9b, 0x45, 0xea, 0xe9, 0x09, 0x9c, 0xab, 0xa2, 0xc4, 0x10, 0xf8, 0x0b, 0x9d, 0xfb, + 0x97, 0x3e, 0x8c, 0xab, 0xd6, 0xf7, 0x71, 0xd5, 0x72, 0x7f, 0xda, 0xa0, 0xb6, 0x5e, 0xa2, 0xc9, + 0xe2, 0x2d, 0x70, 0x42, 0x03, 0xeb, 0x18, 0xb1, 0x01, 0x8f, 0x58, 0x27, 0x98, 0x23, 0x95, 0xe8, + 0x62, 0xa3, 0x9e, 0x9d, 0xd1, 0x72, 0x0a, 0x93, 0xdb, 0x56, 0xb8, 0x5c, 0x04, 0x7c, 0x9a, 0xe1, + 0x7d, 0x67, 0xad, 0x77, 0xad, 0x7c, 0xd1, 0xbc, 0xdb, 0x07, 0xe5, 0xe5, 0x4a, 0xe0, 0x35, 0xb0, + 0xb1, 0x38, 0x07, 0x35, 0xf5, 0x82, 0x5f, 0x5c, 0x18, 0x03, 0xac, 0x83, 0x8b, 0x38, 0x0c, 0x53, + 0x22, 0x84, 0x92, 0x51, 0x68, 0x5e, 0x3d, 0x39, 0xad, 0xc2, 0x67, 0x4c, 0x92, 0x94, 0xe1, 0xf8, + 0xf1, 0xcb, 0xe7, 0x8f, 0xf4, 0xad, 0x3f, 0x87, 0x35, 0x7e, 0xe4, 0xc0, 0x05, 0x95, 0x32, 0x7c, + 0x6f, 0x83, 0xbc, 0xde, 0x15, 0x58, 0xcb, 0x4e, 0xe9, 0xcf, 0xd5, 0x2c, 0xdf, 0xfa, 0x0b, 0xa4, + 0x36, 0xea, 0xde, 0x78, 0xf7, 0xf9, 0xdb, 0xa7, 0x9c, 0x03, 0x2b, 0x28, 0xf3, 0x43, 0xd0, 0x8b, + 0x09, 0x4f, 0x6c, 0xb0, 0xb5, 0x62, 0xe0, 0xf0, 0xc1, 0x0a, 0xc2, 0xf5, 0xbb, 0x5c, 0x7e, 0xf8, + 0xaf, 0xed, 0xc6, 0xc4, 0x7d, 0x65, 0xe2, 0x1e, 0xbc, 0x9b, 0x6d, 0x62, 0xf5, 0x0e, 0x36, 0xdb, + 0x47, 0x13, 0xc7, 0x3e, 0x9e, 0x38, 0xf6, 0xd7, 0x89, 0x63, 0x7f, 0x9c, 0x3a, 0xd6, 0xf1, 0xd4, + 0xb1, 0xbe, 0x4c, 0x1d, 0xeb, 0xd5, 0x2e, 0x8d, 0xe4, 0xe1, 0xa0, 0xeb, 0x05, 0xbc, 0x87, 0xea, + 0x34, 0xc6, 0x5d, 0x81, 0xea, 0xf4, 0x76, 0x70, 0x88, 0x23, 0x86, 0xde, 0x9c, 0xd1, 0xc8, 0x51, + 0x42, 0x44, 0x37, 0xaf, 0xfe, 0x15, 0x77, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0x5f, 0xdc, 0x5e, + 0x99, 0xe9, 0x04, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/evmutil/types/tx.pb.go b/x/evmutil/types/tx.pb.go index d4aa63b4..44f558b1 100644 --- a/x/evmutil/types/tx.pb.go +++ b/x/evmutil/types/tx.pb.go @@ -452,42 +452,43 @@ func init() { func init() { proto.RegisterFile("kava/evmutil/v1beta1/tx.proto", fileDescriptor_6e82783c6c58f89c) } var fileDescriptor_6e82783c6c58f89c = []byte{ - // 559 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x55, 0x41, 0x6b, 0xd4, 0x4c, - 0x18, 0xde, 0x69, 0x4b, 0xf9, 0x76, 0xbe, 0x4b, 0x19, 0x56, 0x48, 0xa3, 0xcd, 0x96, 0x95, 0x6a, - 0x45, 0x36, 0xe9, 0xee, 0x8a, 0x20, 0x7a, 0x71, 0x97, 0x0a, 0xa5, 0xf4, 0x12, 0xf7, 0xe4, 0x65, - 0x99, 0x64, 0x87, 0x18, 0xda, 0x64, 0x96, 0xcc, 0x6c, 0xa8, 0x3f, 0x40, 0x10, 0x11, 0xd1, 0x3f, - 0xe0, 0xd9, 0x1f, 0xd0, 0x1f, 0xd1, 0x63, 0xe9, 0x49, 0x3c, 0x2c, 0x35, 0xfb, 0x47, 0x64, 0x92, - 0x49, 0x3a, 0xd6, 0x98, 0xb5, 0x22, 0x78, 0xda, 0xcc, 0xbc, 0xcf, 0xf3, 0xbe, 0xcf, 0xf3, 0xbe, - 0x33, 0xb3, 0x70, 0xe3, 0x10, 0xc7, 0xd8, 0x22, 0x71, 0x30, 0xe5, 0xfe, 0x91, 0x15, 0x77, 0x1c, - 0xc2, 0x71, 0xc7, 0xe2, 0xc7, 0xe6, 0x24, 0xa2, 0x9c, 0xa2, 0x86, 0x08, 0x9b, 0x32, 0x6c, 0xca, - 0xb0, 0x6e, 0xb8, 0x94, 0x05, 0x94, 0x59, 0x0e, 0x66, 0xa4, 0xe0, 0xb8, 0xd4, 0x0f, 0x33, 0x96, - 0xbe, 0x9e, 0xc5, 0x47, 0xe9, 0xca, 0xca, 0x16, 0x32, 0xd4, 0xf0, 0xa8, 0x47, 0xb3, 0x7d, 0xf1, - 0x95, 0xed, 0xb6, 0x3e, 0x01, 0x78, 0xe3, 0x80, 0x79, 0x03, 0x1a, 0xc6, 0x24, 0xe2, 0x03, 0xea, - 0x87, 0x43, 0xba, 0x6b, 0x0f, 0xba, 0x3b, 0xe8, 0x21, 0xac, 0xfb, 0xa1, 0xcf, 0x7d, 0xcc, 0x69, - 0xa4, 0x81, 0x4d, 0xb0, 0x5d, 0xef, 0x6b, 0xe7, 0x27, 0xed, 0x86, 0x4c, 0xfa, 0x74, 0x3c, 0x8e, - 0x08, 0x63, 0xcf, 0x79, 0xe4, 0x87, 0x9e, 0x7d, 0x09, 0x45, 0x3a, 0xfc, 0x2f, 0x22, 0x2e, 0xf1, - 0x63, 0x12, 0x69, 0x4b, 0x82, 0x66, 0x17, 0x6b, 0xd4, 0x81, 0xab, 0x38, 0xa0, 0xd3, 0x90, 0x6b, - 0xcb, 0x9b, 0x60, 0xfb, 0xff, 0xee, 0xba, 0x29, 0xb3, 0x09, 0x3f, 0xb9, 0x49, 0x53, 0xa8, 0xb0, - 0x25, 0xb0, 0xd5, 0x84, 0x1b, 0xa5, 0xfa, 0x6c, 0xc2, 0x26, 0x34, 0x64, 0xa4, 0xf5, 0x7a, 0x49, - 0x75, 0x90, 0xc6, 0x86, 0x54, 0x00, 0xd1, 0xad, 0x9f, 0x1c, 0xa8, 0x3a, 0x1f, 0x5c, 0xd5, 0x59, - 0x61, 0xef, 0xd2, 0x41, 0x1f, 0x22, 0x31, 0x98, 0x11, 0x89, 0xdc, 0xee, 0xce, 0x08, 0x67, 0xa8, - 0xd4, 0x4d, 0xbd, 0xdf, 0x48, 0x66, 0xcd, 0xb5, 0x7d, 0x1c, 0xe3, 0x54, 0x84, 0xcc, 0x60, 0xaf, - 0x09, 0xfc, 0xae, 0x80, 0xcb, 0x1d, 0x34, 0x2c, 0xba, 0xb0, 0x92, 0xf2, 0x9e, 0x9c, 0xce, 0x9a, - 0xb5, 0xaf, 0xb3, 0xe6, 0x1d, 0xcf, 0xe7, 0x2f, 0xa7, 0x8e, 0xe9, 0xd2, 0x40, 0x8e, 0x4e, 0xfe, - 0xb4, 0xd9, 0xf8, 0xd0, 0xe2, 0xaf, 0x26, 0x84, 0x99, 0x7b, 0x21, 0x3f, 0x3f, 0x69, 0x43, 0xa9, - 0x72, 0x2f, 0xe4, 0xe5, 0x8d, 0x52, 0xda, 0x50, 0x34, 0xea, 0x2d, 0x80, 0x37, 0xd5, 0x56, 0x8a, - 0x0c, 0xea, 0xc0, 0xab, 0xdb, 0xf5, 0x97, 0xc7, 0xba, 0x05, 0x6f, 0x57, 0x68, 0x29, 0x34, 0xbf, - 0x03, 0x3f, 0x8e, 0x3f, 0xc7, 0x3d, 0x8b, 0x68, 0xf0, 0x0f, 0x54, 0xdf, 0x85, 0x5b, 0x95, 0x6a, - 0x72, 0xdd, 0xdd, 0x8f, 0x2b, 0x70, 0xf9, 0x80, 0x79, 0x28, 0x86, 0xa8, 0xe4, 0x6a, 0xdd, 0x37, - 0xcb, 0x2e, 0xb7, 0x59, 0x7a, 0xce, 0xf5, 0xde, 0x35, 0xc0, 0x79, 0x7d, 0xa5, 0xae, 0x7a, 0x21, - 0x16, 0xd6, 0x55, 0xc0, 0x8b, 0xeb, 0x96, 0x9c, 0x31, 0xf4, 0x06, 0x40, 0xed, 0x97, 0x07, 0xac, - 0xb3, 0xd8, 0xc9, 0x15, 0x8a, 0xfe, 0xe8, 0xda, 0x94, 0x42, 0xca, 0x7b, 0x00, 0xf5, 0x8a, 0x73, - 0xd3, 0xfb, 0xfd, 0xcc, 0x05, 0x49, 0x7f, 0xfc, 0x07, 0xa4, 0x5c, 0x50, 0x7f, 0xff, 0xe2, 0x9b, - 0x01, 0x3e, 0x27, 0x06, 0x38, 0x4d, 0x0c, 0x70, 0x96, 0x18, 0xe0, 0x22, 0x31, 0xc0, 0x87, 0xb9, - 0x51, 0x3b, 0x9b, 0x1b, 0xb5, 0x2f, 0x73, 0xa3, 0xf6, 0xe2, 0x9e, 0xf2, 0x00, 0x88, 0x42, 0xed, - 0x23, 0xec, 0xb0, 0xf4, 0xcb, 0x3a, 0x2e, 0xfe, 0x29, 0xd2, 0x77, 0xc0, 0x59, 0x4d, 0x9f, 0xef, - 0xde, 0xf7, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa2, 0x5a, 0x1f, 0x90, 0x46, 0x06, 0x00, 0x00, + // 562 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x55, 0xcf, 0x6a, 0x13, 0x41, + 0x18, 0xcf, 0xb4, 0xa5, 0x98, 0xf1, 0x52, 0x86, 0x08, 0xe9, 0x6a, 0x37, 0x25, 0x52, 0x2d, 0x4a, + 0x76, 0xf3, 0x47, 0x04, 0xd1, 0x8b, 0x09, 0x15, 0x8a, 0xf6, 0xb2, 0xe6, 0xe4, 0x25, 0x4c, 0x36, + 0xc3, 0x76, 0x68, 0x33, 0x13, 0x76, 0x26, 0x4b, 0x7d, 0x00, 0x41, 0x44, 0x44, 0x5f, 0xc0, 0xb3, + 0x0f, 0xd0, 0x87, 0xe8, 0xb1, 0xf4, 0x24, 0x1e, 0x42, 0xdd, 0xbc, 0x88, 0xcc, 0xee, 0xec, 0x76, + 0xad, 0xeb, 0xc6, 0x8a, 0xe0, 0x29, 0x99, 0xf9, 0x7e, 0xbf, 0x6f, 0x7e, 0xbf, 0xef, 0xfb, 0x66, + 0x16, 0x6e, 0x1c, 0xe0, 0x00, 0xdb, 0x24, 0x18, 0x4f, 0x25, 0x3d, 0xb4, 0x83, 0xd6, 0x90, 0x48, + 0xdc, 0xb2, 0xe5, 0x91, 0x35, 0xf1, 0xb9, 0xe4, 0xa8, 0xa2, 0xc2, 0x96, 0x0e, 0x5b, 0x3a, 0x6c, + 0x98, 0x2e, 0x17, 0x63, 0x2e, 0xec, 0x21, 0x16, 0x24, 0xe5, 0xb8, 0x9c, 0xb2, 0x98, 0x65, 0xac, + 0xc7, 0xf1, 0x41, 0xb4, 0xb2, 0xe3, 0x85, 0x0e, 0x55, 0x3c, 0xee, 0xf1, 0x78, 0x5f, 0xfd, 0x8b, + 0x77, 0xeb, 0x9f, 0x01, 0xbc, 0xb1, 0x27, 0xbc, 0x1e, 0x67, 0x01, 0xf1, 0x65, 0x8f, 0x53, 0xd6, + 0xe7, 0x3b, 0x4e, 0xaf, 0xdd, 0x44, 0x0f, 0x61, 0x99, 0x32, 0x2a, 0x29, 0x96, 0xdc, 0xaf, 0x82, + 0x4d, 0xb0, 0x5d, 0xee, 0x56, 0xcf, 0x8e, 0x1b, 0x15, 0x9d, 0xf4, 0xe9, 0x68, 0xe4, 0x13, 0x21, + 0x5e, 0x4a, 0x9f, 0x32, 0xcf, 0xb9, 0x80, 0x22, 0x03, 0x5e, 0xf3, 0x89, 0x4b, 0x68, 0x40, 0xfc, + 0xea, 0x92, 0xa2, 0x39, 0xe9, 0x1a, 0xb5, 0xe0, 0x2a, 0x1e, 0xf3, 0x29, 0x93, 0xd5, 0xe5, 0x4d, + 0xb0, 0x7d, 0xbd, 0xbd, 0x6e, 0xe9, 0x6c, 0xca, 0x4f, 0x62, 0xd2, 0x52, 0x2a, 0x1c, 0x0d, 0xac, + 0xd7, 0xe0, 0x46, 0xae, 0x3e, 0x87, 0x88, 0x09, 0x67, 0x82, 0xd4, 0xdf, 0x2c, 0x65, 0x1d, 0x44, + 0xb1, 0x3e, 0x57, 0x40, 0x74, 0xeb, 0x17, 0x07, 0x59, 0x9d, 0x0f, 0x2e, 0xeb, 0x2c, 0xb0, 0x77, + 0xe1, 0xa0, 0x0b, 0x91, 0x6a, 0xcc, 0x80, 0xf8, 0x6e, 0xbb, 0x39, 0xc0, 0x31, 0x2a, 0x72, 0x53, + 0xee, 0x56, 0xc2, 0x59, 0x6d, 0xed, 0x39, 0x0e, 0x70, 0x24, 0x42, 0x67, 0x70, 0xd6, 0x14, 0x7e, + 0x47, 0xc1, 0xf5, 0x0e, 0xea, 0xa7, 0x55, 0x58, 0x89, 0x78, 0x4f, 0x4e, 0x66, 0xb5, 0xd2, 0xb7, + 0x59, 0xed, 0x8e, 0x47, 0xe5, 0xfe, 0x74, 0x68, 0xb9, 0x7c, 0xac, 0x5b, 0xa7, 0x7f, 0x1a, 0x62, + 0x74, 0x60, 0xcb, 0xd7, 0x13, 0x22, 0xac, 0x5d, 0x26, 0xcf, 0x8e, 0x1b, 0x50, 0xab, 0xdc, 0x65, + 0x32, 0xbf, 0x50, 0x99, 0x32, 0xa4, 0x85, 0x7a, 0x07, 0xe0, 0xcd, 0x6c, 0x29, 0x55, 0x86, 0x6c, + 0xc3, 0x8b, 0xcb, 0xf5, 0x8f, 0xdb, 0xba, 0x05, 0x6f, 0x17, 0x68, 0x49, 0x35, 0xbf, 0x07, 0x3f, + 0xb7, 0x3f, 0xc1, 0x3d, 0xf3, 0xf9, 0xf8, 0x3f, 0xa8, 0xbe, 0x0b, 0xb7, 0x0a, 0xd5, 0x24, 0xba, + 0xdb, 0x9f, 0x56, 0xe0, 0xf2, 0x9e, 0xf0, 0x50, 0x00, 0x51, 0xce, 0xd5, 0xba, 0x6f, 0xe5, 0x5d, + 0x6e, 0x2b, 0x77, 0xce, 0x8d, 0xce, 0x15, 0xc0, 0xc9, 0xf9, 0x99, 0x73, 0xb3, 0x17, 0x62, 0xe1, + 0xb9, 0x19, 0xf0, 0xe2, 0x73, 0x73, 0x66, 0x0c, 0xbd, 0x05, 0xb0, 0xfa, 0xdb, 0x01, 0x6b, 0x2d, + 0x76, 0x72, 0x89, 0x62, 0x3c, 0xba, 0x32, 0x25, 0x95, 0xf2, 0x01, 0x40, 0xa3, 0x60, 0x6e, 0x3a, + 0x7f, 0x9e, 0x39, 0x25, 0x19, 0x8f, 0xff, 0x82, 0x94, 0x08, 0xea, 0xbe, 0x38, 0xff, 0x6e, 0x82, + 0x2f, 0xa1, 0x09, 0x4e, 0x42, 0x13, 0x9c, 0x86, 0x26, 0x38, 0x0f, 0x4d, 0xf0, 0x71, 0x6e, 0x96, + 0x4e, 0xe7, 0x66, 0xe9, 0xeb, 0xdc, 0x2c, 0xbd, 0xba, 0x97, 0x79, 0x00, 0x9a, 0xde, 0x21, 0x1e, + 0x0a, 0xbb, 0xe9, 0x35, 0xdc, 0x7d, 0x4c, 0x99, 0x7d, 0x94, 0x7e, 0x2a, 0xa2, 0x87, 0x60, 0xb8, + 0x1a, 0xbd, 0xdf, 0x9d, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x0a, 0xc5, 0x36, 0x47, 0x06, + 0x00, 0x00, } func (this *MsgConvertCoinToERC20) VerboseEqual(that interface{}) error { diff --git a/x/hard/types/genesis.pb.go b/x/hard/types/genesis.pb.go index 45dcb84d..50e0cdf2 100644 --- a/x/hard/types/genesis.pb.go +++ b/x/hard/types/genesis.pb.go @@ -186,44 +186,45 @@ func init() { func init() { proto.RegisterFile("kava/hard/v1beta1/genesis.proto", fileDescriptor_20a1f6c2cf728e74) } var fileDescriptor_20a1f6c2cf728e74 = []byte{ - // 590 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x94, 0xcd, 0x6e, 0xd3, 0x40, - 0x10, 0xc7, 0xe3, 0xa6, 0x6d, 0xc2, 0x16, 0x5a, 0xb0, 0x2a, 0x70, 0x02, 0xb2, 0xa3, 0x1e, 0x20, - 0x42, 0x8a, 0x4d, 0xcb, 0x81, 0x0b, 0x07, 0x30, 0x11, 0x1f, 0x37, 0xe4, 0xe6, 0xc4, 0xc5, 0x5a, - 0x3b, 0x5b, 0xd7, 0xaa, 0x9d, 0xb5, 0x76, 0xd6, 0x81, 0xbc, 0x03, 0x42, 0x7d, 0x0e, 0xce, 0x3c, - 0x01, 0xa7, 0x1e, 0x2b, 0x4e, 0x88, 0x43, 0x8b, 0x92, 0x17, 0x41, 0xfb, 0x91, 0xa4, 0x28, 0x89, - 0xc4, 0x81, 0x9e, 0xe2, 0xdd, 0xfd, 0xcf, 0xff, 0x37, 0x3b, 0x3b, 0x13, 0xe4, 0x9c, 0xe0, 0x21, - 0xf6, 0x8e, 0x31, 0xeb, 0x7b, 0xc3, 0xfd, 0x88, 0x70, 0xbc, 0xef, 0x25, 0x64, 0x40, 0x20, 0x05, - 0xb7, 0x60, 0x94, 0x53, 0xf3, 0x8e, 0x10, 0xb8, 0x42, 0xe0, 0x6a, 0x41, 0xd3, 0x8e, 0x29, 0xe4, - 0x14, 0xbc, 0x08, 0x03, 0x99, 0x45, 0xc5, 0x34, 0x1d, 0xa8, 0x90, 0x66, 0x43, 0x9d, 0x87, 0x72, - 0xe5, 0xa9, 0x85, 0x3e, 0xda, 0x4d, 0x68, 0x42, 0xd5, 0xbe, 0xf8, 0xd2, 0xbb, 0x4e, 0x42, 0x69, - 0x92, 0x11, 0x4f, 0xae, 0xa2, 0xf2, 0xc8, 0xe3, 0x69, 0x4e, 0x80, 0xe3, 0xbc, 0xd0, 0x82, 0x07, - 0x8b, 0x59, 0xca, 0x8c, 0xe4, 0xe9, 0xde, 0xf7, 0x0d, 0x74, 0xf3, 0x8d, 0x4a, 0xfa, 0x90, 0x63, - 0x4e, 0xcc, 0x67, 0x68, 0xb3, 0xc0, 0x0c, 0xe7, 0x60, 0x19, 0x2d, 0xa3, 0xbd, 0x75, 0xd0, 0x70, - 0x17, 0x2e, 0xe1, 0xbe, 0x97, 0x02, 0x7f, 0xfd, 0xec, 0xc2, 0xa9, 0x04, 0x5a, 0x6e, 0x7e, 0x36, - 0xd0, 0xfd, 0x82, 0x91, 0x61, 0x4a, 0x4b, 0x08, 0x71, 0x1c, 0x97, 0x79, 0x99, 0x61, 0x9e, 0xd2, - 0x41, 0x28, 0x33, 0xb2, 0xd6, 0x5a, 0xd5, 0xf6, 0xd6, 0xc1, 0xe3, 0x25, 0x76, 0x9a, 0xff, 0xf2, - 0x4a, 0x4c, 0x2f, 0xcd, 0x89, 0xdf, 0x12, 0xfe, 0x5f, 0x2f, 0x1d, 0x6b, 0x85, 0x00, 0x82, 0xc6, - 0x14, 0xb8, 0x70, 0x64, 0xbe, 0x45, 0xf5, 0x3e, 0x29, 0x28, 0xa4, 0x1c, 0xac, 0xaa, 0x44, 0x37, - 0x97, 0xa0, 0xbb, 0x4a, 0xe2, 0xdf, 0xd6, 0xa8, 0xba, 0xde, 0x80, 0x60, 0x16, 0x6d, 0x76, 0x51, - 0x2d, 0xa2, 0x8c, 0xd1, 0x8f, 0x60, 0xad, 0x4b, 0xa3, 0x65, 0x25, 0xf1, 0xa5, 0xc2, 0xdf, 0xd1, - 0x3e, 0x35, 0xb5, 0x86, 0x60, 0x1a, 0x6a, 0x32, 0xb4, 0xcd, 0x29, 0xc7, 0x59, 0x08, 0x65, 0x51, - 0x64, 0x29, 0xe9, 0x5b, 0x1b, 0xda, 0x4c, 0x3f, 0xb2, 0xe8, 0x88, 0x99, 0xdd, 0x2b, 0x9a, 0x0e, - 0xfc, 0x27, 0xda, 0xac, 0x9d, 0xa4, 0xfc, 0xb8, 0x8c, 0xdc, 0x98, 0xe6, 0xba, 0x23, 0xf4, 0x4f, - 0x07, 0xfa, 0x27, 0x1e, 0x1f, 0x15, 0x04, 0x64, 0x00, 0x04, 0xb7, 0x24, 0xe2, 0x50, 0x13, 0xe6, - 0x4c, 0x95, 0x04, 0xe9, 0x5b, 0x9b, 0xd7, 0xc5, 0xf4, 0x35, 0x61, 0xce, 0x64, 0x04, 0x08, 0x1b, - 0x12, 0xb0, 0x6a, 0xd7, 0xc5, 0x0c, 0x34, 0x61, 0xef, 0x4b, 0x15, 0xdd, 0x5b, 0xd1, 0x23, 0xe6, - 0x23, 0xb4, 0x13, 0xd3, 0x2c, 0xc3, 0x9c, 0x30, 0x9c, 0x85, 0xc2, 0x44, 0x36, 0xf6, 0x8d, 0x60, - 0x7b, 0xbe, 0xdd, 0x1b, 0x15, 0xc4, 0x8c, 0x50, 0x73, 0x75, 0xfb, 0x5a, 0x6b, 0x72, 0x18, 0x9a, - 0xae, 0x9a, 0x36, 0x77, 0x3a, 0x6d, 0x6e, 0x6f, 0x3a, 0x6d, 0x7e, 0x5d, 0xdc, 0xe2, 0xf4, 0xd2, - 0x31, 0x02, 0x6b, 0x55, 0x57, 0x9a, 0x0c, 0xdd, 0x95, 0xcf, 0x3f, 0x0a, 0xd3, 0x01, 0x27, 0x8c, - 0x00, 0x0f, 0x8f, 0x70, 0xcc, 0x29, 0xb3, 0xaa, 0x22, 0x27, 0xff, 0xb9, 0xf0, 0xf8, 0x75, 0xe1, - 0x3c, 0xfc, 0x87, 0x4a, 0x74, 0x49, 0xfc, 0xe3, 0x5b, 0x07, 0xe9, 0xaa, 0x76, 0x49, 0x1c, 0xec, - 0x2a, 0xef, 0x77, 0xda, 0xfa, 0xb5, 0x74, 0x16, 0x4c, 0xf5, 0xfc, 0x0b, 0xcc, 0xf5, 0xff, 0xc1, - 0x54, 0xde, 0x7f, 0x33, 0xfd, 0x17, 0x67, 0x63, 0xdb, 0x38, 0x1f, 0xdb, 0xc6, 0xef, 0xb1, 0x6d, - 0x9c, 0x4e, 0xec, 0xca, 0xf9, 0xc4, 0xae, 0xfc, 0x9c, 0xd8, 0x95, 0x0f, 0x57, 0x29, 0x62, 0x8a, - 0x3a, 0x19, 0x8e, 0x40, 0x7e, 0x79, 0x9f, 0xd4, 0x9f, 0x94, 0x24, 0x45, 0x9b, 0xb2, 0xc2, 0x4f, - 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x16, 0xde, 0x3f, 0x0d, 0x64, 0x05, 0x00, 0x00, + // 595 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x94, 0x4d, 0x6f, 0xd3, 0x30, + 0x18, 0xc7, 0x9b, 0x75, 0x2f, 0xc5, 0x83, 0x0d, 0xa2, 0x09, 0xdc, 0x82, 0x92, 0x6a, 0x07, 0x56, + 0x21, 0x35, 0xe9, 0xc6, 0x81, 0x0b, 0x97, 0x85, 0x8a, 0x97, 0x1b, 0xca, 0x7a, 0xe2, 0x12, 0x39, + 0xa9, 0x97, 0x5a, 0x4b, 0xe2, 0xc8, 0x76, 0x0a, 0xfd, 0x0e, 0x08, 0xed, 0x73, 0x70, 0xe6, 0x13, + 0x70, 0xda, 0x71, 0xe2, 0x84, 0x38, 0x6c, 0xa8, 0xfd, 0x22, 0x28, 0xb6, 0xdb, 0x0e, 0xb5, 0x95, + 0x38, 0xb0, 0x53, 0x6b, 0xfb, 0xff, 0xfc, 0x7f, 0x8f, 0x1f, 0x3f, 0x4f, 0x80, 0x7d, 0x86, 0x86, + 0xc8, 0x1d, 0x20, 0xd6, 0x77, 0x87, 0x87, 0x21, 0x16, 0xe8, 0xd0, 0x8d, 0x71, 0x86, 0x39, 0xe1, + 0x4e, 0xce, 0xa8, 0xa0, 0xe6, 0x83, 0x52, 0xe0, 0x94, 0x02, 0x47, 0x0b, 0x1a, 0x56, 0x44, 0x79, + 0x4a, 0xb9, 0x1b, 0x22, 0x8e, 0x67, 0x51, 0x11, 0x25, 0x99, 0x0a, 0x69, 0xd4, 0xd5, 0x79, 0x20, + 0x57, 0xae, 0x5a, 0xe8, 0xa3, 0xbd, 0x98, 0xc6, 0x54, 0xed, 0x97, 0xff, 0xf4, 0xae, 0x1d, 0x53, + 0x1a, 0x27, 0xd8, 0x95, 0xab, 0xb0, 0x38, 0x75, 0x05, 0x49, 0x31, 0x17, 0x28, 0xcd, 0xb5, 0xe0, + 0xc9, 0x62, 0x96, 0x32, 0x23, 0x79, 0xba, 0xff, 0x7d, 0x03, 0xdc, 0x7d, 0xa3, 0x92, 0x3e, 0x11, + 0x48, 0x60, 0xf3, 0x05, 0xd8, 0xcc, 0x11, 0x43, 0x29, 0x87, 0x46, 0xd3, 0x68, 0x6d, 0x1f, 0xd5, + 0x9d, 0x85, 0x4b, 0x38, 0xef, 0xa5, 0xc0, 0x5b, 0xbf, 0xb8, 0xb2, 0x2b, 0xbe, 0x96, 0x9b, 0x9f, + 0x0d, 0xf0, 0x38, 0x67, 0x78, 0x48, 0x68, 0xc1, 0x03, 0x14, 0x45, 0x45, 0x5a, 0x24, 0x48, 0x10, + 0x9a, 0x05, 0x32, 0x23, 0xb8, 0xd6, 0xac, 0xb6, 0xb6, 0x8f, 0x9e, 0x2d, 0xb1, 0xd3, 0xfc, 0xe3, + 0x1b, 0x31, 0x3d, 0x92, 0x62, 0xaf, 0x59, 0xfa, 0x7f, 0xbd, 0xb6, 0xe1, 0x0a, 0x01, 0xf7, 0xeb, + 0x53, 0xe0, 0xc2, 0x91, 0xf9, 0x16, 0xd4, 0xfa, 0x38, 0xa7, 0x9c, 0x08, 0x0e, 0xab, 0x12, 0xdd, + 0x58, 0x82, 0xee, 0x2a, 0x89, 0x77, 0x5f, 0xa3, 0x6a, 0x7a, 0x83, 0xfb, 0xb3, 0x68, 0xb3, 0x0b, + 0xb6, 0x42, 0xca, 0x18, 0xfd, 0xc8, 0xe1, 0xba, 0x34, 0x5a, 0x56, 0x12, 0x4f, 0x2a, 0xbc, 0x5d, + 0xed, 0xb3, 0xa5, 0xd6, 0xdc, 0x9f, 0x86, 0x9a, 0x0c, 0xec, 0x08, 0x2a, 0x50, 0x12, 0xf0, 0x22, + 0xcf, 0x13, 0x82, 0xfb, 0x70, 0x43, 0x9b, 0xe9, 0x47, 0x2e, 0x3b, 0x62, 0x66, 0xf7, 0x8a, 0x92, + 0xcc, 0xeb, 0x68, 0xb3, 0x56, 0x4c, 0xc4, 0xa0, 0x08, 0x9d, 0x88, 0xa6, 0xba, 0x23, 0xf4, 0x4f, + 0x9b, 0xf7, 0xcf, 0x5c, 0x31, 0xca, 0x31, 0x97, 0x01, 0xdc, 0xbf, 0x27, 0x11, 0x27, 0x9a, 0x30, + 0x67, 0xaa, 0x24, 0x70, 0x1f, 0x6e, 0xde, 0x16, 0xd3, 0xd3, 0x84, 0x39, 0x93, 0x61, 0x8e, 0xd9, + 0x10, 0x73, 0xb8, 0x75, 0x5b, 0x4c, 0x5f, 0x13, 0xf6, 0xbf, 0x54, 0xc1, 0xa3, 0x15, 0x3d, 0x62, + 0x1e, 0x80, 0xdd, 0x88, 0x26, 0x09, 0x12, 0x98, 0xa1, 0x24, 0x28, 0x4d, 0x64, 0x63, 0xdf, 0xf1, + 0x77, 0xe6, 0xdb, 0xbd, 0x51, 0x8e, 0xcd, 0x10, 0x34, 0x56, 0xb7, 0x2f, 0x5c, 0x93, 0xc3, 0xd0, + 0x70, 0xd4, 0xb4, 0x39, 0xd3, 0x69, 0x73, 0x7a, 0xd3, 0x69, 0xf3, 0x6a, 0xe5, 0x2d, 0xce, 0xaf, + 0x6d, 0xc3, 0x87, 0xab, 0xba, 0xd2, 0x64, 0xe0, 0xa1, 0x7c, 0xfe, 0x51, 0x40, 0x32, 0x81, 0x19, + 0xe6, 0x22, 0x38, 0x45, 0x91, 0xa0, 0x0c, 0x56, 0xcb, 0x9c, 0xbc, 0x97, 0xa5, 0xc7, 0xaf, 0x2b, + 0xfb, 0xe9, 0x3f, 0x54, 0xa2, 0x8b, 0xa3, 0x1f, 0xdf, 0xda, 0x40, 0x57, 0xb5, 0x8b, 0x23, 0x7f, + 0x4f, 0x79, 0xbf, 0xd3, 0xd6, 0xaf, 0xa5, 0x73, 0xc9, 0x54, 0xcf, 0xbf, 0xc0, 0x5c, 0xff, 0x1f, + 0x4c, 0xe5, 0xfd, 0x37, 0xd3, 0x3b, 0xbe, 0x18, 0x5b, 0xc6, 0xe5, 0xd8, 0x32, 0x7e, 0x8f, 0x2d, + 0xe3, 0x7c, 0x62, 0x55, 0x2e, 0x27, 0x56, 0xe5, 0xe7, 0xc4, 0xaa, 0x7c, 0x38, 0xb8, 0x41, 0xe9, + 0xc4, 0x09, 0x0a, 0xb9, 0xdb, 0x89, 0xdb, 0xd1, 0x00, 0x91, 0xcc, 0xfd, 0xa4, 0xbe, 0x52, 0x12, + 0x15, 0x6e, 0xca, 0x12, 0x3f, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x65, 0x16, 0xde, 0x65, + 0x05, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/hard/types/hard.pb.go b/x/hard/types/hard.pb.go index e7de080b..e94d02c3 100644 --- a/x/hard/types/hard.pb.go +++ b/x/hard/types/hard.pb.go @@ -401,64 +401,65 @@ func init() { func init() { proto.RegisterFile("kava/hard/v1beta1/hard.proto", fileDescriptor_23a5de800263a2ff) } var fileDescriptor_23a5de800263a2ff = []byte{ - // 911 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xbd, 0x8f, 0x1b, 0x45, - 0x14, 0xf7, 0x9e, 0x3f, 0x92, 0x8c, 0xed, 0x23, 0xde, 0xdc, 0xa1, 0x4d, 0x04, 0xeb, 0xc8, 0x42, - 0x70, 0x8d, 0x6d, 0x02, 0x82, 0x8a, 0xe6, 0x16, 0x0b, 0x38, 0x81, 0x25, 0x6b, 0x8f, 0x20, 0x25, - 0x42, 0x5a, 0xc6, 0xbb, 0x2f, 0x77, 0x83, 0x3d, 0x3b, 0xab, 0x99, 0xb1, 0x63, 0x77, 0xb4, 0x34, - 0x88, 0x3f, 0x82, 0x8a, 0x0e, 0xe9, 0xfe, 0x88, 0x2b, 0xa3, 0x54, 0x88, 0xc2, 0x80, 0xaf, 0xa3, - 0xa6, 0xa2, 0x42, 0xf3, 0xe1, 0x8f, 0x5c, 0x1c, 0x29, 0xa7, 0x58, 0x88, 0x6a, 0x77, 0xe6, 0xbd, - 0xf9, 0xbd, 0xdf, 0xfb, 0xcd, 0x9b, 0x99, 0x87, 0xde, 0x18, 0xe0, 0x31, 0x6e, 0x9f, 0x62, 0x9e, - 0xb4, 0xc7, 0xf7, 0xfa, 0x20, 0xf1, 0x3d, 0x3d, 0x68, 0x65, 0x9c, 0x49, 0xe6, 0xd6, 0x94, 0xb5, - 0xa5, 0x27, 0xac, 0xf5, 0x8e, 0x1f, 0x33, 0x41, 0x99, 0x68, 0xf7, 0xb1, 0x80, 0xe5, 0x92, 0x98, - 0x91, 0xd4, 0x2c, 0xb9, 0x73, 0xdb, 0xd8, 0x23, 0x3d, 0x6a, 0x9b, 0x81, 0x35, 0xed, 0x9d, 0xb0, - 0x13, 0x66, 0xe6, 0xd5, 0x9f, 0x99, 0x6d, 0xfc, 0xed, 0xa0, 0x52, 0x0f, 0x73, 0x4c, 0x85, 0xfb, - 0x00, 0x55, 0x29, 0x4b, 0x61, 0x1a, 0x51, 0xcc, 0x07, 0x20, 0x85, 0xe7, 0xdc, 0xcd, 0x1f, 0x94, - 0xdf, 0xf3, 0x5b, 0xcf, 0xd1, 0x68, 0x75, 0x95, 0x5f, 0x57, 0xbb, 0x05, 0x7b, 0xe7, 0xb3, 0x7a, - 0xee, 0xe7, 0xdf, 0xeb, 0x95, 0xb5, 0x49, 0x11, 0x56, 0xe8, 0xda, 0xc8, 0xfd, 0xc1, 0x41, 0x1e, - 0x25, 0x29, 0xa1, 0x23, 0x1a, 0xf5, 0x19, 0xe7, 0xec, 0x71, 0x34, 0x12, 0x49, 0x34, 0xc6, 0xc3, - 0x11, 0x78, 0x3b, 0x77, 0x9d, 0x83, 0x1b, 0xc1, 0x7d, 0x05, 0xf3, 0xdb, 0xac, 0xfe, 0xf6, 0x09, - 0x91, 0xa7, 0xa3, 0x7e, 0x2b, 0x66, 0xd4, 0xf2, 0xb7, 0x9f, 0xa6, 0x48, 0x06, 0x6d, 0x39, 0xcd, - 0x40, 0xb4, 0x3a, 0x10, 0xcf, 0x67, 0xf5, 0xfd, 0xae, 0x41, 0x0c, 0x34, 0xe0, 0xfd, 0xe3, 0xce, - 0x57, 0x0a, 0xee, 0xe9, 0x59, 0x13, 0xd9, 0xbc, 0x3b, 0x10, 0x87, 0xfb, 0xf4, 0x19, 0x27, 0x91, - 0x68, 0xa7, 0xc6, 0x79, 0x01, 0x95, 0xd7, 0xf8, 0xba, 0x7b, 0xa8, 0x98, 0x40, 0xca, 0xa8, 0xe7, - 0x28, 0x32, 0xa1, 0x19, 0xb8, 0x9f, 0xa2, 0x8a, 0x65, 0x3b, 0x24, 0x94, 0x48, 0xcd, 0x74, 0xb3, - 0x20, 0x06, 0xfe, 0x0b, 0xe5, 0x15, 0x14, 0x54, 0x26, 0x61, 0xb9, 0xbf, 0x9a, 0x72, 0x3f, 0x44, - 0xbb, 0x22, 0x63, 0xd2, 0x2a, 0x1b, 0x91, 0xc4, 0xcb, 0xeb, 0xa4, 0x6f, 0xce, 0x67, 0xf5, 0xca, - 0x71, 0xc6, 0xa4, 0xa1, 0x71, 0xd4, 0x09, 0x2b, 0x62, 0x35, 0x4a, 0x5c, 0x82, 0x6a, 0x31, 0x4b, - 0xc7, 0xc0, 0x05, 0x61, 0x69, 0xf4, 0x08, 0xc7, 0x92, 0x71, 0xaf, 0xa0, 0x97, 0x7e, 0x74, 0x05, - 0xbd, 0x8e, 0x52, 0xb9, 0x26, 0xcb, 0x51, 0x2a, 0xc3, 0x9b, 0x2b, 0xd8, 0x4f, 0x34, 0xaa, 0xfb, - 0x10, 0xdd, 0x22, 0xa9, 0x04, 0x0e, 0x42, 0x46, 0x1c, 0x4b, 0x88, 0x28, 0x4b, 0x60, 0xe8, 0x15, - 0x75, 0xca, 0x6f, 0x6d, 0x48, 0xf9, 0xc8, 0x7a, 0x87, 0x58, 0x42, 0x57, 0xf9, 0xda, 0xc4, 0x6b, - 0xe4, 0xb2, 0xc1, 0x8d, 0xd1, 0x2e, 0x07, 0x01, 0x7c, 0x0c, 0x8b, 0x1c, 0x4a, 0x57, 0xce, 0xa1, - 0x03, 0xf1, 0xa5, 0xad, 0xad, 0x5a, 0x4c, 0x9b, 0xc0, 0x18, 0x79, 0x03, 0x80, 0x0c, 0x78, 0xc4, - 0xe1, 0x31, 0xe6, 0x49, 0x94, 0x01, 0x8f, 0x21, 0x95, 0xf8, 0x04, 0xbc, 0x6b, 0x5b, 0x08, 0xf7, - 0xba, 0x41, 0x0f, 0x35, 0x78, 0x6f, 0x89, 0xdd, 0xf8, 0x7e, 0x07, 0x95, 0xd7, 0xb6, 0xdf, 0xfd, - 0x00, 0x55, 0x4f, 0xb1, 0x88, 0x28, 0x9e, 0xd8, 0xaa, 0x51, 0x25, 0x75, 0x3d, 0xa8, 0xfd, 0x35, - 0xab, 0x3f, 0x6b, 0x08, 0xcb, 0xa7, 0x58, 0x74, 0xf1, 0xc4, 0x2c, 0xc3, 0xa8, 0x4a, 0xf1, 0x44, - 0x9f, 0x90, 0x55, 0xb1, 0xbd, 0x2a, 0xe7, 0x8a, 0x85, 0x34, 0x21, 0xbe, 0x41, 0xd5, 0x21, 0xc3, - 0x69, 0x24, 0x99, 0x3d, 0x79, 0xf9, 0x2d, 0x84, 0x28, 0x2b, 0xc8, 0x2f, 0x99, 0x39, 0x56, 0x3f, - 0xe5, 0x51, 0xed, 0xb9, 0xba, 0x70, 0x19, 0xaa, 0xaa, 0xfb, 0xca, 0x94, 0x15, 0xce, 0xa6, 0xe6, - 0x90, 0x05, 0x9f, 0x5f, 0xf9, 0xc4, 0x97, 0x03, 0x2c, 0x40, 0xe1, 0x1e, 0xf6, 0x1e, 0x5c, 0xa6, - 0xd1, 0x5f, 0x98, 0xb2, 0xa9, 0x0b, 0xe8, 0x35, 0x1d, 0x90, 0x8e, 0x86, 0x92, 0x64, 0x43, 0x02, - 0x7c, 0x2b, 0x6a, 0xee, 0x2a, 0xd0, 0xee, 0x12, 0xd3, 0xed, 0xa1, 0xc2, 0x80, 0xa4, 0x83, 0xad, - 0xc8, 0xa8, 0x91, 0x14, 0xf1, 0x6f, 0x47, 0x34, 0x5b, 0x27, 0x5e, 0xd8, 0x06, 0x71, 0x05, 0xba, - 0x22, 0xde, 0x38, 0xdb, 0x41, 0xd7, 0x3a, 0x90, 0x31, 0x41, 0xa4, 0xfb, 0x08, 0xdd, 0x48, 0xcc, - 0x2f, 0xe3, 0x76, 0x63, 0x3e, 0xfb, 0x67, 0x56, 0x6f, 0xbe, 0x44, 0xa0, 0xc3, 0x38, 0x3e, 0x4c, - 0x12, 0x0e, 0x42, 0x3c, 0x3d, 0x6b, 0xde, 0xb2, 0xf1, 0xec, 0x4c, 0x30, 0x95, 0x20, 0xc2, 0x15, - 0xb4, 0x1b, 0xa3, 0x12, 0xa6, 0x6c, 0x94, 0xaa, 0xc2, 0x56, 0xcf, 0xca, 0xed, 0x96, 0x5d, 0xa0, - 0x44, 0x5d, 0x5e, 0x2a, 0x1f, 0x33, 0x92, 0x06, 0xef, 0xda, 0x17, 0xe5, 0xe0, 0x25, 0x38, 0xa8, - 0x05, 0x22, 0xb4, 0xd0, 0xee, 0xd7, 0xa8, 0x48, 0xd2, 0x04, 0x26, 0x5e, 0x5e, 0xc7, 0x78, 0x67, - 0xc3, 0xb5, 0x75, 0x3c, 0xca, 0xb2, 0xe1, 0x74, 0x51, 0xa4, 0xe6, 0xee, 0x08, 0xde, 0xb4, 0x11, - 0xf7, 0x37, 0x59, 0x45, 0x68, 0x40, 0x1b, 0xbf, 0xec, 0xa0, 0x92, 0x39, 0xe9, 0x6e, 0x82, 0xae, - 0x9b, 0xfb, 0x1d, 0xb6, 0x2f, 0xda, 0x12, 0xf9, 0x7f, 0xa3, 0x99, 0x49, 0xfa, 0x45, 0x9a, 0x6d, - 0xb2, 0x2e, 0x35, 0xfb, 0xce, 0x41, 0x7b, 0x9b, 0x44, 0x7d, 0xc1, 0x8b, 0x1b, 0xa2, 0xe2, 0x7a, - 0x53, 0xf0, 0x6a, 0x65, 0x6f, 0xa0, 0x34, 0x85, 0x4d, 0x1c, 0xff, 0x43, 0x0a, 0x0c, 0x21, 0x2d, - 0x7a, 0x4f, 0xf7, 0x75, 0x18, 0x15, 0x55, 0xcb, 0xb6, 0x68, 0xb0, 0xb6, 0xba, 0xab, 0x06, 0x39, - 0xe8, 0x9c, 0xff, 0xe9, 0xe7, 0xce, 0xe7, 0xbe, 0xf3, 0x64, 0xee, 0x3b, 0x7f, 0xcc, 0x7d, 0xe7, - 0xc7, 0x0b, 0x3f, 0xf7, 0xe4, 0xc2, 0xcf, 0xfd, 0x7a, 0xe1, 0xe7, 0x1e, 0xae, 0xe7, 0xa2, 0x76, - 0xbb, 0x39, 0xc4, 0x7d, 0xa1, 0xff, 0xda, 0x13, 0xd3, 0x8d, 0x6a, 0xc8, 0x7e, 0x49, 0xf7, 0x88, - 0xef, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x40, 0xda, 0xa7, 0xd8, 0xa7, 0x0a, 0x00, 0x00, + // 918 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x96, 0xcf, 0x8f, 0x1b, 0x35, + 0x14, 0xc7, 0x33, 0x9b, 0x1f, 0x6d, 0x9d, 0x64, 0x69, 0xdc, 0x5d, 0x34, 0xad, 0x60, 0x52, 0x45, + 0x88, 0xee, 0x25, 0xc9, 0x16, 0x04, 0x27, 0x2e, 0x3b, 0x84, 0x1f, 0x2b, 0x88, 0x14, 0xcd, 0x52, + 0xa4, 0x56, 0x48, 0x83, 0x33, 0xe3, 0x26, 0x26, 0xf1, 0x78, 0x64, 0x3b, 0x69, 0x72, 0xe3, 0xca, + 0x05, 0xf1, 0x47, 0x70, 0xe2, 0x86, 0xb4, 0x7f, 0xc4, 0x1e, 0xab, 0x9e, 0x10, 0x87, 0x00, 0xd9, + 0x1b, 0x67, 0x4e, 0x9c, 0x90, 0x7f, 0xe4, 0x47, 0xb7, 0xa9, 0xd4, 0xd5, 0x46, 0xa8, 0xa7, 0xc4, + 0x7e, 0xcf, 0x9f, 0xf7, 0x7d, 0xcf, 0xcf, 0x1e, 0x83, 0xb7, 0x06, 0x68, 0x8c, 0x9a, 0x7d, 0xc4, + 0xe3, 0xe6, 0xf8, 0x7e, 0x17, 0x4b, 0x74, 0x5f, 0x0f, 0x1a, 0x29, 0x67, 0x92, 0xc1, 0x8a, 0xb2, + 0x36, 0xf4, 0x84, 0xb5, 0xde, 0xf1, 0x22, 0x26, 0x28, 0x13, 0xcd, 0x2e, 0x12, 0x78, 0xb9, 0x24, + 0x62, 0x24, 0x31, 0x4b, 0xee, 0xdc, 0x36, 0xf6, 0x50, 0x8f, 0x9a, 0x66, 0x60, 0x4d, 0x7b, 0x3d, + 0xd6, 0x63, 0x66, 0x5e, 0xfd, 0x33, 0xb3, 0xb5, 0x7f, 0x1c, 0x50, 0xe8, 0x20, 0x8e, 0xa8, 0x80, + 0x0f, 0x41, 0x99, 0xb2, 0x04, 0x4f, 0x43, 0x8a, 0xf8, 0x00, 0x4b, 0xe1, 0x3a, 0x77, 0xb3, 0x07, + 0xc5, 0xf7, 0xbc, 0xc6, 0x0b, 0x32, 0x1a, 0x6d, 0xe5, 0xd7, 0xd6, 0x6e, 0xfe, 0xde, 0xd9, 0xac, + 0x9a, 0xf9, 0xe5, 0x8f, 0x6a, 0x69, 0x6d, 0x52, 0x04, 0x25, 0xba, 0x36, 0x82, 0x3f, 0x3a, 0xc0, + 0xa5, 0x24, 0x21, 0x74, 0x44, 0xc3, 0x2e, 0xe3, 0x9c, 0x3d, 0x09, 0x47, 0x22, 0x0e, 0xc7, 0x68, + 0x38, 0xc2, 0xee, 0xce, 0x5d, 0xe7, 0xe0, 0x86, 0xff, 0x40, 0x61, 0x7e, 0x9f, 0x55, 0xdf, 0xed, + 0x11, 0xd9, 0x1f, 0x75, 0x1b, 0x11, 0xa3, 0x56, 0xbf, 0xfd, 0xa9, 0x8b, 0x78, 0xd0, 0x94, 0xd3, + 0x14, 0x8b, 0x46, 0x0b, 0x47, 0xf3, 0x59, 0x75, 0xbf, 0x6d, 0x88, 0xbe, 0x06, 0x3e, 0x38, 0x69, + 0x7d, 0xad, 0x70, 0xcf, 0x4e, 0xeb, 0xc0, 0xe6, 0xdd, 0xc2, 0x51, 0xb0, 0x4f, 0x9f, 0x73, 0x12, + 0xb1, 0x76, 0xaa, 0x9d, 0xe5, 0x40, 0x71, 0x4d, 0x2f, 0xdc, 0x03, 0xf9, 0x18, 0x27, 0x8c, 0xba, + 0x8e, 0x12, 0x13, 0x98, 0x01, 0xfc, 0x0c, 0x94, 0xac, 0xda, 0x21, 0xa1, 0x44, 0x6a, 0xa5, 0x9b, + 0x0b, 0x62, 0xf0, 0x5f, 0x2a, 0x2f, 0x3f, 0xa7, 0x32, 0x09, 0x8a, 0xdd, 0xd5, 0x14, 0xfc, 0x10, + 0xec, 0x8a, 0x94, 0x49, 0x5b, 0xd9, 0x90, 0xc4, 0x6e, 0x56, 0x27, 0x7d, 0x73, 0x3e, 0xab, 0x96, + 0x4e, 0x52, 0x26, 0x8d, 0x8c, 0xe3, 0x56, 0x50, 0x12, 0xab, 0x51, 0x0c, 0x09, 0xa8, 0x44, 0x2c, + 0x19, 0x63, 0x2e, 0x08, 0x4b, 0xc2, 0xc7, 0x28, 0x92, 0x8c, 0xbb, 0x39, 0xbd, 0xf4, 0xa3, 0x4b, + 0xd4, 0xeb, 0x38, 0x91, 0x6b, 0x65, 0x39, 0x4e, 0x64, 0x70, 0x73, 0x85, 0xfd, 0x54, 0x53, 0xe1, + 0x23, 0x70, 0x8b, 0x24, 0x12, 0x73, 0x2c, 0x64, 0xc8, 0x91, 0xc4, 0x21, 0x65, 0x31, 0x1e, 0xba, + 0x79, 0x9d, 0xf2, 0x3b, 0x1b, 0x52, 0x3e, 0xb6, 0xde, 0x01, 0x92, 0xb8, 0xad, 0x7c, 0x6d, 0xe2, + 0x15, 0x72, 0xd1, 0x00, 0x23, 0xb0, 0xcb, 0xb1, 0xc0, 0x7c, 0x8c, 0x17, 0x39, 0x14, 0x2e, 0x9d, + 0x43, 0x0b, 0x47, 0x17, 0xb6, 0xb6, 0x6c, 0x99, 0x36, 0x81, 0x31, 0x70, 0x07, 0x18, 0xa7, 0x98, + 0x87, 0x1c, 0x3f, 0x41, 0x3c, 0x0e, 0x53, 0xcc, 0x23, 0x9c, 0x48, 0xd4, 0xc3, 0xee, 0xb5, 0x2d, + 0x84, 0x7b, 0xd3, 0xd0, 0x03, 0x0d, 0xef, 0x2c, 0xd9, 0xb5, 0x1f, 0x76, 0x40, 0x71, 0x6d, 0xfb, + 0xe1, 0x07, 0xa0, 0xdc, 0x47, 0x22, 0xa4, 0x68, 0x62, 0xbb, 0x46, 0xb5, 0xd4, 0x75, 0xbf, 0xf2, + 0xf7, 0xac, 0xfa, 0xbc, 0x21, 0x28, 0xf6, 0x91, 0x68, 0xa3, 0x89, 0x59, 0x86, 0x40, 0x99, 0xa2, + 0x89, 0x3e, 0x21, 0xab, 0x66, 0xbb, 0xaa, 0xe6, 0x92, 0x45, 0x9a, 0x10, 0xdf, 0x82, 0xf2, 0x90, + 0xa1, 0x24, 0x94, 0xcc, 0x9e, 0xbc, 0xec, 0x16, 0x42, 0x14, 0x15, 0xf2, 0x2b, 0x66, 0x8e, 0xd5, + 0xcf, 0x59, 0x50, 0x79, 0xa1, 0x2f, 0x20, 0x03, 0x65, 0x75, 0x5f, 0x99, 0xb6, 0x42, 0xe9, 0xd4, + 0x1c, 0x32, 0xff, 0x8b, 0x4b, 0x9f, 0xf8, 0xa2, 0x8f, 0x04, 0x56, 0xdc, 0xa3, 0xce, 0xc3, 0x8b, + 0x32, 0xba, 0x0b, 0x53, 0x3a, 0x85, 0x18, 0xbc, 0xa1, 0x03, 0xd2, 0xd1, 0x50, 0x92, 0x74, 0x48, + 0x30, 0xdf, 0x4a, 0x35, 0x77, 0x15, 0xb4, 0xbd, 0x64, 0xc2, 0x0e, 0xc8, 0x0d, 0x48, 0x32, 0xd8, + 0x4a, 0x19, 0x35, 0x49, 0x09, 0xff, 0x6e, 0x44, 0xd3, 0x75, 0xe1, 0xb9, 0x6d, 0x08, 0x57, 0xd0, + 0x95, 0xf0, 0xda, 0xe9, 0x0e, 0xb8, 0xd6, 0xc2, 0x29, 0x13, 0x44, 0xc2, 0xc7, 0xe0, 0x46, 0x6c, + 0xfe, 0x32, 0x6e, 0x37, 0xe6, 0xf3, 0x7f, 0x67, 0xd5, 0xfa, 0x2b, 0x04, 0x3a, 0x8a, 0xa2, 0xa3, + 0x38, 0xe6, 0x58, 0x88, 0x67, 0xa7, 0xf5, 0x5b, 0x36, 0x9e, 0x9d, 0xf1, 0xa7, 0x12, 0x8b, 0x60, + 0x85, 0x86, 0x11, 0x28, 0x20, 0xca, 0x46, 0x89, 0x6a, 0x6c, 0xf5, 0x59, 0xb9, 0xdd, 0xb0, 0x0b, + 0x54, 0x51, 0x97, 0x97, 0xca, 0xc7, 0x8c, 0x24, 0xfe, 0xa1, 0xfd, 0xa2, 0x1c, 0xbc, 0x82, 0x06, + 0xb5, 0x40, 0x04, 0x16, 0x0d, 0xbf, 0x01, 0x79, 0x92, 0xc4, 0x78, 0xe2, 0x66, 0x75, 0x8c, 0x7b, + 0x1b, 0xae, 0xad, 0x93, 0x51, 0x9a, 0x0e, 0xa7, 0x8b, 0x26, 0x35, 0x77, 0x87, 0xff, 0xb6, 0x8d, + 0xb8, 0xbf, 0xc9, 0x2a, 0x02, 0x03, 0xad, 0xfd, 0xba, 0x03, 0x0a, 0xe6, 0xa4, 0xc3, 0x18, 0x5c, + 0x37, 0xf7, 0x3b, 0xde, 0x7e, 0xd1, 0x96, 0xe4, 0xd7, 0xa6, 0x66, 0x26, 0xe9, 0x97, 0xd5, 0x6c, + 0x93, 0x75, 0x59, 0xb3, 0xef, 0x1d, 0xb0, 0xb7, 0xa9, 0xa8, 0x2f, 0xf9, 0xe2, 0x06, 0x20, 0xbf, + 0xfe, 0x28, 0xb8, 0x5a, 0xdb, 0x1b, 0x94, 0x96, 0xb0, 0x49, 0xe3, 0xff, 0x28, 0x81, 0x01, 0xa0, + 0x8b, 0xde, 0xd1, 0xef, 0x3a, 0x04, 0xf2, 0xea, 0xc9, 0xb6, 0x78, 0x60, 0x6d, 0x75, 0x57, 0x0d, + 0xd9, 0xff, 0xe4, 0xec, 0x2f, 0x2f, 0x73, 0x36, 0xf7, 0x9c, 0xa7, 0x73, 0xcf, 0xf9, 0x73, 0xee, + 0x39, 0x3f, 0x9d, 0x7b, 0x99, 0xa7, 0xe7, 0x5e, 0xe6, 0xb7, 0x73, 0x2f, 0xf3, 0xe8, 0xde, 0x1a, + 0xee, 0xb0, 0x37, 0x44, 0x5d, 0xd1, 0x3c, 0xec, 0xd5, 0xa3, 0x3e, 0x22, 0x49, 0x73, 0x62, 0x9e, + 0xa3, 0x9a, 0xd9, 0x2d, 0xe8, 0x47, 0xe2, 0xfb, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xa4, 0xfe, + 0x27, 0x46, 0xa8, 0x0a, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { diff --git a/x/hard/types/query.pb.go b/x/hard/types/query.pb.go index 35d2b877..74cfbded 100644 --- a/x/hard/types/query.pb.go +++ b/x/hard/types/query.pb.go @@ -1494,90 +1494,90 @@ func init() { func init() { proto.RegisterFile("kava/hard/v1beta1/query.proto", fileDescriptor_1eedf429c9bff7da) } var fileDescriptor_1eedf429c9bff7da = []byte{ - // 1318 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0xcd, 0x6f, 0x1b, 0x45, - 0x14, 0xcf, 0x3a, 0x24, 0x4d, 0x5f, 0x9b, 0x0f, 0x06, 0xd3, 0xda, 0x4e, 0xe2, 0x26, 0x9b, 0xe6, - 0x83, 0x34, 0xf6, 0x26, 0x69, 0x05, 0x57, 0x6a, 0xaa, 0x22, 0x90, 0x82, 0x60, 0x5b, 0x24, 0x84, - 0x84, 0xa2, 0xb5, 0x77, 0x70, 0x56, 0x71, 0x76, 0xdc, 0x9d, 0x75, 0xda, 0x20, 0xc4, 0xa1, 0x12, - 0xf7, 0x42, 0x0e, 0x08, 0x81, 0xc4, 0xa1, 0x9c, 0x80, 0x23, 0x5c, 0x90, 0xb8, 0x70, 0xaa, 0x38, - 0x55, 0x70, 0xe1, 0x04, 0x28, 0xe1, 0x0f, 0x41, 0x3b, 0xf3, 0x66, 0xed, 0x5d, 0xef, 0xae, 0x83, - 0x44, 0x51, 0x7a, 0x4a, 0x66, 0xe6, 0x7d, 0xfc, 0xde, 0x6f, 0xde, 0xbc, 0x7d, 0xcf, 0x30, 0xbb, - 0x6b, 0xed, 0x5b, 0xc6, 0x8e, 0xe5, 0xd9, 0xc6, 0xfe, 0x46, 0x9d, 0xfa, 0xd6, 0x86, 0x71, 0xa7, - 0x43, 0xbd, 0x83, 0x6a, 0xdb, 0x63, 0x3e, 0x23, 0xcf, 0x06, 0xc7, 0xd5, 0xe0, 0xb8, 0x8a, 0xc7, - 0xa5, 0x72, 0x83, 0xf1, 0x3d, 0xc6, 0x0d, 0xab, 0xe3, 0xef, 0x84, 0x3a, 0xc1, 0x42, 0xaa, 0x94, - 0x56, 0xf1, 0xbc, 0x6e, 0x71, 0x2a, 0x6d, 0x85, 0x52, 0x6d, 0xab, 0xe9, 0xb8, 0x96, 0xef, 0x30, - 0x17, 0x65, 0xcb, 0xbd, 0xb2, 0x4a, 0xaa, 0xc1, 0x1c, 0x75, 0x5e, 0x94, 0xe7, 0xdb, 0x62, 0x65, - 0xc8, 0x05, 0x1e, 0xe5, 0x9b, 0xac, 0xc9, 0xe4, 0x7e, 0xf0, 0x1f, 0xee, 0xce, 0x34, 0x19, 0x6b, - 0xb6, 0xa8, 0x61, 0xb5, 0x1d, 0xc3, 0x72, 0x5d, 0xe6, 0x0b, 0x6f, 0x4a, 0x67, 0xa6, 0x3f, 0x58, - 0x11, 0x9a, 0x38, 0xd5, 0xf3, 0x40, 0xde, 0x0a, 0xe0, 0xbe, 0x69, 0x79, 0xd6, 0x1e, 0x37, 0xe9, - 0x9d, 0x0e, 0xe5, 0xbe, 0xfe, 0x06, 0x3c, 0x17, 0xd9, 0xe5, 0x6d, 0xe6, 0x72, 0x4a, 0x5e, 0x82, - 0xd1, 0xb6, 0xd8, 0x29, 0x68, 0x73, 0xda, 0xca, 0xb9, 0xcd, 0x62, 0xb5, 0x8f, 0xa9, 0xaa, 0x54, - 0xa9, 0x3d, 0xf3, 0xe8, 0x8f, 0x4b, 0x43, 0x26, 0x8a, 0xeb, 0x17, 0x20, 0x2f, 0xec, 0x5d, 0x6f, - 0x34, 0x58, 0xc7, 0xf5, 0x43, 0x3f, 0xef, 0xc1, 0xf3, 0xb1, 0x7d, 0xf4, 0x74, 0x03, 0xc6, 0x2c, - 0xdc, 0x2b, 0x68, 0x73, 0xc3, 0x2b, 0xe7, 0x36, 0xf5, 0x2a, 0x32, 0x21, 0x58, 0x57, 0xde, 0xb6, - 0x98, 0xdd, 0x69, 0x51, 0x54, 0x47, 0xa7, 0xa1, 0xa6, 0xfe, 0xb5, 0x86, 0x7e, 0x6f, 0xd0, 0x36, - 0xe3, 0x4e, 0xe8, 0x97, 0xe4, 0x61, 0xc4, 0xa6, 0x2e, 0xdb, 0x13, 0x71, 0x9c, 0x35, 0xe5, 0x82, - 0x54, 0x61, 0x84, 0xdd, 0x75, 0xa9, 0x57, 0xc8, 0x05, 0xbb, 0xb5, 0xc2, 0xaf, 0xdf, 0x57, 0xf2, - 0xe8, 0xf4, 0xba, 0x6d, 0x7b, 0x94, 0xf3, 0x5b, 0xbe, 0xe7, 0xb8, 0x4d, 0x53, 0x8a, 0x91, 0x9b, - 0x00, 0xdd, 0xcb, 0x2d, 0x0c, 0x0b, 0x4a, 0x96, 0x14, 0xcc, 0xe0, 0x76, 0xab, 0x32, 0xab, 0xba, - 0xd4, 0x34, 0x29, 0x22, 0x30, 0x7b, 0x34, 0xf5, 0x1f, 0x35, 0xa4, 0xa1, 0x0b, 0x13, 0x69, 0x78, - 0x07, 0xc6, 0x6c, 0xdc, 0x0b, 0x69, 0xe8, 0xa7, 0x1c, 0xd5, 0x94, 0x56, 0xad, 0x10, 0xd0, 0xf0, - 0xcd, 0x9f, 0x97, 0xa6, 0x62, 0x07, 0xdc, 0x0c, 0xad, 0x91, 0x57, 0x23, 0xd8, 0x73, 0x02, 0xfb, - 0xf2, 0x40, 0xec, 0xd2, 0x4e, 0x04, 0xfc, 0x77, 0x1a, 0xcc, 0x08, 0xf0, 0x6f, 0xbb, 0xfc, 0xc0, - 0x6d, 0x50, 0xfb, 0x74, 0x73, 0xfd, 0xb3, 0x06, 0xb3, 0x29, 0x70, 0x9f, 0x1e, 0xce, 0x37, 0xa1, - 0x24, 0x62, 0xb8, 0xcd, 0x7c, 0xab, 0x85, 0x0e, 0xa9, 0x9d, 0x49, 0xb8, 0xfe, 0x89, 0x06, 0xd3, - 0x89, 0x4a, 0x18, 0xb6, 0x07, 0x13, 0xbc, 0xd3, 0x6e, 0xb7, 0x1c, 0x6a, 0x6f, 0x07, 0xc5, 0x88, - 0x17, 0x72, 0x22, 0xf8, 0x62, 0x04, 0xa0, 0x82, 0xf6, 0x0a, 0x73, 0xdc, 0xda, 0x3a, 0xc6, 0xbc, - 0xd2, 0x74, 0xfc, 0x9d, 0x4e, 0xbd, 0xda, 0x60, 0x7b, 0x58, 0xae, 0xf0, 0x4f, 0x85, 0xdb, 0xbb, - 0x86, 0x7f, 0xd0, 0xa6, 0x5c, 0x28, 0x70, 0x73, 0x5c, 0xb9, 0x10, 0x4b, 0xfd, 0xa1, 0x86, 0x75, - 0xa6, 0xc6, 0x3c, 0x8f, 0xdd, 0x3d, 0xa5, 0x29, 0xf3, 0x83, 0xaa, 0x22, 0x21, 0x4a, 0xa4, 0xec, - 0x36, 0x9c, 0xa9, 0xcb, 0x2d, 0x4c, 0x94, 0xf9, 0x84, 0x44, 0x91, 0x4a, 0x61, 0x9e, 0x5c, 0x44, - 0xce, 0x26, 0xa3, 0xfb, 0xdc, 0x54, 0xa6, 0xfe, 0xbb, 0x2c, 0xf9, 0x56, 0xdd, 0xb8, 0x4a, 0xf5, - 0x53, 0xcd, 0xf2, 0x4f, 0xf1, 0x3a, 0xf2, 0x94, 0xb1, 0xbd, 0x01, 0xc5, 0xee, 0xf3, 0x92, 0xee, - 0x06, 0x3d, 0xc9, 0x07, 0x5a, 0xef, 0x3b, 0xee, 0xea, 0x74, 0x5f, 0x64, 0x1d, 0xf7, 0x9e, 0xe0, - 0x8b, 0x54, 0x2e, 0xe4, 0x8b, 0x5c, 0x87, 0x82, 0x40, 0xf4, 0x9a, 0xeb, 0x53, 0x2f, 0xb8, 0x22, - 0xcb, 0xa7, 0x03, 0x83, 0x28, 0x26, 0xa8, 0x60, 0x0c, 0x1c, 0x26, 0x1c, 0xdc, 0xdf, 0xf6, 0x2c, - 0x9f, 0xaa, 0xbb, 0x5b, 0x4d, 0xb8, 0xbb, 0x2d, 0xe6, 0xd2, 0x83, 0x2d, 0xcb, 0xdb, 0xa5, 0x7e, - 0xaf, 0xad, 0xda, 0x1c, 0x06, 0x55, 0x48, 0x11, 0xe0, 0xe6, 0xb8, 0xd3, 0xbb, 0xd4, 0xd7, 0xf0, - 0xbd, 0x9a, 0x94, 0x53, 0x6f, 0x9f, 0x66, 0x27, 0xbc, 0xfe, 0x21, 0x7e, 0x7c, 0xbb, 0xd2, 0x88, - 0xbd, 0x01, 0xa3, 0xd6, 0x5e, 0xd0, 0x48, 0x3c, 0x09, 0xde, 0xd1, 0xb4, 0x7e, 0x15, 0xdf, 0xa8, - 0x0a, 0xe8, 0xa6, 0xd5, 0xf0, 0x99, 0x37, 0x00, 0xf2, 0xc7, 0xea, 0xad, 0xf4, 0x69, 0x21, 0x74, - 0x0a, 0x53, 0x21, 0xed, 0xef, 0xcb, 0xb3, 0x8c, 0x47, 0x13, 0xb5, 0xd2, 0x7d, 0x34, 0x71, 0xeb, - 0x93, 0x4e, 0x74, 0x43, 0xff, 0x32, 0x07, 0x93, 0xb1, 0xef, 0x1d, 0x79, 0x11, 0xce, 0xe2, 0x07, - 0x8f, 0x79, 0x12, 0x75, 0x46, 0x0d, 0xe9, 0x8a, 0xfe, 0x2f, 0x6c, 0x93, 0x16, 0x8c, 0x38, 0xae, - 0x4d, 0xef, 0x15, 0x86, 0x85, 0x0f, 0x23, 0x81, 0x8c, 0x5b, 0xc1, 0x17, 0x2a, 0x46, 0x6c, 0x58, - 0x4f, 0x16, 0xd1, 0xf3, 0x6c, 0x96, 0x14, 0x37, 0xa5, 0x13, 0xfd, 0x75, 0x98, 0xc9, 0x92, 0x4b, - 0x29, 0xc0, 0x79, 0x18, 0xd9, 0xb7, 0x5a, 0x1d, 0x2a, 0x0b, 0xb0, 0x29, 0x17, 0xfa, 0xe7, 0x39, - 0x98, 0x88, 0x16, 0x31, 0x72, 0x0d, 0xc6, 0xf0, 0xf1, 0x0e, 0x26, 0x3a, 0x94, 0x3c, 0x35, 0x3c, - 0xcb, 0x60, 0x06, 0xf1, 0x9c, 0x25, 0xd5, 0xcb, 0x73, 0x96, 0xdc, 0xbf, 0xe2, 0xf9, 0x50, 0x83, - 0x8b, 0x29, 0x75, 0x26, 0xc5, 0xce, 0x3a, 0xe4, 0x45, 0x57, 0x73, 0xb0, 0x1d, 0xa9, 0x74, 0x68, - 0x96, 0xf0, 0x48, 0x06, 0x08, 0x3b, 0xeb, 0x90, 0x97, 0xd7, 0x11, 0xd3, 0x18, 0x96, 0x1a, 0xf5, - 0x48, 0x2c, 0x81, 0x86, 0xfe, 0xa9, 0x06, 0x13, 0xd1, 0xe0, 0x52, 0xc0, 0x5c, 0x83, 0x0b, 0x71, - 0xd3, 0xf2, 0xfd, 0x23, 0x9c, 0x7c, 0x3d, 0x81, 0xa8, 0x40, 0x2b, 0x1e, 0x02, 0x6a, 0x49, 0x48, - 0x79, 0x9e, 0x90, 0xc6, 0x9b, 0xbf, 0x9c, 0x87, 0x11, 0x51, 0x85, 0xc8, 0x07, 0x30, 0x2a, 0xc7, - 0x3e, 0xb2, 0x98, 0x70, 0xd3, 0xfd, 0xf3, 0x65, 0x69, 0x69, 0x90, 0x98, 0xbc, 0x39, 0x7d, 0xfe, - 0xfe, 0x6f, 0x7f, 0x1f, 0xe6, 0xa6, 0x49, 0xd1, 0xe8, 0x1f, 0x62, 0xe5, 0x68, 0x49, 0xee, 0x6b, - 0x30, 0xa6, 0xc6, 0x47, 0xb2, 0x9c, 0x66, 0x37, 0x36, 0x78, 0x96, 0x56, 0x06, 0x0b, 0x22, 0x84, - 0x05, 0x01, 0x61, 0x96, 0x4c, 0x27, 0x40, 0x50, 0x83, 0xa6, 0x00, 0xa1, 0x06, 0x89, 0x74, 0x10, - 0xb1, 0xc9, 0x28, 0x1d, 0x44, 0x7c, 0x26, 0xc9, 0x04, 0x11, 0x8e, 0x17, 0x0f, 0x35, 0x98, 0x8a, - 0x4f, 0x35, 0xc4, 0x48, 0xf3, 0x91, 0x32, 0xae, 0x95, 0xd6, 0x4f, 0xae, 0x80, 0xe0, 0xd6, 0x04, - 0xb8, 0x25, 0x72, 0x39, 0x01, 0x5c, 0x07, 0x95, 0x2a, 0x21, 0xca, 0x2f, 0x34, 0x98, 0x88, 0x8e, - 0x20, 0xa4, 0x92, 0xe6, 0x32, 0x71, 0xbe, 0x29, 0x55, 0x4f, 0x2a, 0x8e, 0xf8, 0x56, 0x05, 0xbe, - 0xcb, 0x44, 0x4f, 0xc0, 0xe7, 0x07, 0x2a, 0x0a, 0x1c, 0xb5, 0xc9, 0x47, 0x70, 0x06, 0xfb, 0x4e, - 0x92, 0x9a, 0xa3, 0xd1, 0x36, 0xba, 0xb4, 0x3c, 0x50, 0x0e, 0x71, 0xe8, 0x02, 0xc7, 0x0c, 0x29, - 0x25, 0xe0, 0x50, 0xed, 0xe8, 0x57, 0x1a, 0x4c, 0xc6, 0x1a, 0x60, 0x52, 0x1d, 0x74, 0x23, 0x31, - 0x40, 0xc6, 0x89, 0xe5, 0x11, 0xd8, 0x15, 0x01, 0x6c, 0x91, 0x2c, 0x64, 0x5d, 0xa0, 0x42, 0xf8, - 0x99, 0x06, 0xe3, 0x91, 0x7e, 0x95, 0xac, 0x65, 0xde, 0x47, 0xac, 0x15, 0x2e, 0x55, 0x4e, 0x28, - 0x8d, 0xd8, 0x5e, 0x10, 0xd8, 0x16, 0xc8, 0x7c, 0xea, 0xe5, 0xa9, 0x06, 0x96, 0x1c, 0x6a, 0x70, - 0x3e, 0x52, 0x67, 0xaf, 0xa4, 0xb9, 0x4a, 0xe8, 0x6e, 0x4b, 0x6b, 0x27, 0x13, 0x46, 0x58, 0x2b, - 0x02, 0x96, 0x4e, 0xe6, 0x12, 0x60, 0xa9, 0x1a, 0x5a, 0x09, 0x8a, 0xba, 0x28, 0x0d, 0xaa, 0xb5, - 0x4c, 0x2f, 0x0d, 0xb1, 0x56, 0x35, 0xbd, 0x34, 0xc4, 0xbb, 0xd4, 0xcc, 0xd2, 0xe0, 0x29, 0xbf, - 0x41, 0x5a, 0xc5, 0xba, 0xb9, 0xf4, 0xb4, 0x4a, 0x6e, 0x45, 0xd3, 0xd3, 0x2a, 0xa5, 0x09, 0xcd, - 0x4c, 0xab, 0x90, 0x23, 0xec, 0x4e, 0x6b, 0x2f, 0x3f, 0x3a, 0x2a, 0x6b, 0x8f, 0x8f, 0xca, 0xda, - 0x5f, 0x47, 0x65, 0xed, 0xc1, 0x71, 0x79, 0xe8, 0xf1, 0x71, 0x79, 0xe8, 0xf7, 0xe3, 0xf2, 0xd0, - 0xbb, 0x4b, 0x3d, 0xdd, 0x47, 0x60, 0xa8, 0xd2, 0xb2, 0xea, 0x5c, 0x9a, 0xbc, 0x27, 0x8d, 0x8a, - 0x0e, 0xa4, 0x3e, 0x2a, 0x7e, 0xd0, 0xbc, 0xfa, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x50, 0x6b, - 0x16, 0xfb, 0xdd, 0x15, 0x00, 0x00, + // 1324 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0xcf, 0x6f, 0x1b, 0xc5, + 0x17, 0xcf, 0x3a, 0xdf, 0xa4, 0xe9, 0x6b, 0x9b, 0xf4, 0x3b, 0x98, 0xd6, 0x76, 0x12, 0x37, 0xd9, + 0x34, 0x3f, 0x48, 0x63, 0xaf, 0x93, 0x56, 0x70, 0x8e, 0xa9, 0x8a, 0x40, 0x0a, 0x82, 0x6d, 0x91, + 0x10, 0x12, 0x8a, 0xd6, 0xde, 0xc1, 0x59, 0xc5, 0xd9, 0x71, 0x77, 0xd6, 0x69, 0x83, 0x10, 0x87, + 0x4a, 0xdc, 0x0b, 0x39, 0x20, 0x04, 0x12, 0x87, 0x72, 0x02, 0x8e, 0x70, 0x41, 0xe2, 0xc2, 0xa9, + 0xe2, 0x54, 0xc1, 0x85, 0x13, 0xa0, 0x84, 0x3f, 0x04, 0xed, 0xcc, 0x9b, 0xb5, 0x77, 0xbd, 0xbb, + 0x0e, 0x12, 0x45, 0xe9, 0x29, 0x99, 0x99, 0xf7, 0xe3, 0xf3, 0x3e, 0xf3, 0xe6, 0xed, 0x7b, 0x86, + 0xd9, 0x5d, 0x6b, 0xdf, 0x32, 0x76, 0x2c, 0xcf, 0x36, 0xf6, 0xd7, 0x1b, 0xd4, 0xb7, 0xd6, 0x8d, + 0xbb, 0x5d, 0xea, 0x1d, 0x54, 0x3b, 0x1e, 0xf3, 0x19, 0xf9, 0x7f, 0x70, 0x5c, 0x0d, 0x8e, 0xab, + 0x78, 0x5c, 0x2a, 0x37, 0x19, 0xdf, 0x63, 0xdc, 0xb0, 0xba, 0xfe, 0x4e, 0xa8, 0x13, 0x2c, 0xa4, + 0x4a, 0x69, 0x15, 0xcf, 0x1b, 0x16, 0xa7, 0xd2, 0x56, 0x28, 0xd5, 0xb1, 0x5a, 0x8e, 0x6b, 0xf9, + 0x0e, 0x73, 0x51, 0xb6, 0xdc, 0x2f, 0xab, 0xa4, 0x9a, 0xcc, 0x51, 0xe7, 0x45, 0x79, 0xbe, 0x2d, + 0x56, 0x86, 0x5c, 0xe0, 0x51, 0xbe, 0xc5, 0x5a, 0x4c, 0xee, 0x07, 0xff, 0xe1, 0xee, 0x4c, 0x8b, + 0xb1, 0x56, 0x9b, 0x1a, 0x56, 0xc7, 0x31, 0x2c, 0xd7, 0x65, 0xbe, 0xf0, 0xa6, 0x74, 0x66, 0x06, + 0x83, 0x15, 0xa1, 0x89, 0x53, 0x3d, 0x0f, 0xe4, 0xcd, 0x00, 0xee, 0x1b, 0x96, 0x67, 0xed, 0x71, + 0x93, 0xde, 0xed, 0x52, 0xee, 0xeb, 0xaf, 0xc3, 0x73, 0x91, 0x5d, 0xde, 0x61, 0x2e, 0xa7, 0xe4, + 0x25, 0x18, 0xef, 0x88, 0x9d, 0x82, 0x36, 0xa7, 0xad, 0x9c, 0xdb, 0x28, 0x56, 0x07, 0x98, 0xaa, + 0x4a, 0x95, 0xfa, 0xff, 0x1e, 0xff, 0x7e, 0x65, 0xc4, 0x44, 0x71, 0xfd, 0x12, 0xe4, 0x85, 0xbd, + 0xcd, 0x66, 0x93, 0x75, 0x5d, 0x3f, 0xf4, 0xf3, 0x2e, 0x3c, 0x1f, 0xdb, 0x47, 0x4f, 0x37, 0x61, + 0xc2, 0xc2, 0xbd, 0x82, 0x36, 0x37, 0xba, 0x72, 0x6e, 0x43, 0xaf, 0x22, 0x13, 0x82, 0x75, 0xe5, + 0x6d, 0x8b, 0xd9, 0xdd, 0x36, 0x45, 0x75, 0x74, 0x1a, 0x6a, 0xea, 0x5f, 0x69, 0xe8, 0xf7, 0x26, + 0xed, 0x30, 0xee, 0x84, 0x7e, 0x49, 0x1e, 0xc6, 0x6c, 0xea, 0xb2, 0x3d, 0x11, 0xc7, 0x59, 0x53, + 0x2e, 0x48, 0x15, 0xc6, 0xd8, 0x3d, 0x97, 0x7a, 0x85, 0x5c, 0xb0, 0x5b, 0x2f, 0xfc, 0xf2, 0x5d, + 0x25, 0x8f, 0x4e, 0x37, 0x6d, 0xdb, 0xa3, 0x9c, 0xdf, 0xf6, 0x3d, 0xc7, 0x6d, 0x99, 0x52, 0x8c, + 0xdc, 0x02, 0xe8, 0x5d, 0x6e, 0x61, 0x54, 0x50, 0xb2, 0xa4, 0x60, 0x06, 0xb7, 0x5b, 0x95, 0x59, + 0xd5, 0xa3, 0xa6, 0x45, 0x11, 0x81, 0xd9, 0xa7, 0xa9, 0xff, 0xa0, 0x21, 0x0d, 0x3d, 0x98, 0x48, + 0xc3, 0xdb, 0x30, 0x61, 0xe3, 0x5e, 0x48, 0xc3, 0x20, 0xe5, 0xa8, 0xa6, 0xb4, 0xea, 0x85, 0x80, + 0x86, 0xaf, 0xff, 0xb8, 0x72, 0x31, 0x76, 0xc0, 0xcd, 0xd0, 0x1a, 0x79, 0x25, 0x82, 0x3d, 0x27, + 0xb0, 0x2f, 0x0f, 0xc5, 0x2e, 0xed, 0x44, 0xc0, 0x7f, 0xab, 0xc1, 0x8c, 0x00, 0xff, 0x96, 0xcb, + 0x0f, 0xdc, 0x26, 0xb5, 0x4f, 0x37, 0xd7, 0x3f, 0x69, 0x30, 0x9b, 0x02, 0xf7, 0xd9, 0xe1, 0x7c, + 0x03, 0x4a, 0x22, 0x86, 0x3b, 0xcc, 0xb7, 0xda, 0xe8, 0x90, 0xda, 0x99, 0x84, 0xeb, 0x1f, 0x6b, + 0x30, 0x9d, 0xa8, 0x84, 0x61, 0x7b, 0x30, 0xc9, 0xbb, 0x9d, 0x4e, 0xdb, 0xa1, 0xf6, 0x76, 0x50, + 0x8c, 0x78, 0x21, 0x27, 0x82, 0x2f, 0x46, 0x00, 0x2a, 0x68, 0x2f, 0x33, 0xc7, 0xad, 0xd7, 0x30, + 0xe6, 0x95, 0x96, 0xe3, 0xef, 0x74, 0x1b, 0xd5, 0x26, 0xdb, 0xc3, 0x72, 0x85, 0x7f, 0x2a, 0xdc, + 0xde, 0x35, 0xfc, 0x83, 0x0e, 0xe5, 0x42, 0x81, 0x9b, 0x17, 0x94, 0x0b, 0xb1, 0xd4, 0x1f, 0x69, + 0x58, 0x67, 0xea, 0xcc, 0xf3, 0xd8, 0xbd, 0x53, 0x9a, 0x32, 0xdf, 0xab, 0x2a, 0x12, 0xa2, 0x44, + 0xca, 0xee, 0xc0, 0x99, 0x86, 0xdc, 0xc2, 0x44, 0x99, 0x4f, 0x48, 0x14, 0xa9, 0x14, 0xe6, 0xc9, + 0x65, 0xe4, 0x6c, 0x2a, 0xba, 0xcf, 0x4d, 0x65, 0xea, 0xdf, 0xcb, 0x92, 0x6f, 0xd4, 0x8d, 0xab, + 0x54, 0x3f, 0xd5, 0x2c, 0xff, 0x18, 0xaf, 0x23, 0xcf, 0x18, 0xdb, 0xeb, 0x50, 0xec, 0x3d, 0x2f, + 0xe9, 0x6e, 0xd8, 0x93, 0x7c, 0xa8, 0xf5, 0xbf, 0xe3, 0x9e, 0x4e, 0xef, 0x45, 0x36, 0x70, 0xef, + 0x29, 0xbe, 0x48, 0xe5, 0x42, 0xbe, 0xc8, 0x1a, 0x14, 0x04, 0xa2, 0x57, 0x5d, 0x9f, 0x7a, 0xc1, + 0x15, 0x59, 0x3e, 0x1d, 0x1a, 0x44, 0x31, 0x41, 0x05, 0x63, 0xe0, 0x30, 0xe9, 0xe0, 0xfe, 0xb6, + 0x67, 0xf9, 0x54, 0xdd, 0xdd, 0x6a, 0xc2, 0xdd, 0x6d, 0x31, 0x97, 0x1e, 0x6c, 0x59, 0xde, 0x2e, + 0xf5, 0xfb, 0x6d, 0xd5, 0xe7, 0x30, 0xa8, 0x42, 0x8a, 0x00, 0x37, 0x2f, 0x38, 0xfd, 0x4b, 0x7d, + 0x0d, 0xdf, 0xab, 0x49, 0x39, 0xf5, 0xf6, 0x69, 0x76, 0xc2, 0xeb, 0x1f, 0xe0, 0xc7, 0xb7, 0x27, + 0x8d, 0xd8, 0x9b, 0x30, 0x6e, 0xed, 0x05, 0x8d, 0xc4, 0xd3, 0xe0, 0x1d, 0x4d, 0xeb, 0xd7, 0xf1, + 0x8d, 0xaa, 0x80, 0x6e, 0x59, 0x4d, 0x9f, 0x79, 0x43, 0x20, 0x7f, 0xa4, 0xde, 0xca, 0x80, 0x16, + 0x42, 0xa7, 0x70, 0x31, 0xa4, 0xfd, 0x3d, 0x79, 0x96, 0xf1, 0x68, 0xa2, 0x56, 0x7a, 0x8f, 0x26, + 0x6e, 0x7d, 0xca, 0x89, 0x6e, 0xe8, 0x5f, 0xe4, 0x60, 0x2a, 0xf6, 0xbd, 0x23, 0x2f, 0xc2, 0x59, + 0xfc, 0xe0, 0x31, 0x4f, 0xa2, 0xce, 0xa8, 0x21, 0x3d, 0xd1, 0xff, 0x84, 0x6d, 0xd2, 0x86, 0x31, + 0xc7, 0xb5, 0xe9, 0xfd, 0xc2, 0xa8, 0xf0, 0x61, 0x24, 0x90, 0x71, 0x3b, 0xf8, 0x42, 0xc5, 0x88, + 0x0d, 0xeb, 0xc9, 0x22, 0x7a, 0x9e, 0xcd, 0x92, 0xe2, 0xa6, 0x74, 0xa2, 0xbf, 0x06, 0x33, 0x59, + 0x72, 0x29, 0x05, 0x38, 0x0f, 0x63, 0xfb, 0x56, 0xbb, 0x4b, 0x65, 0x01, 0x36, 0xe5, 0x42, 0xff, + 0x2c, 0x07, 0x93, 0xd1, 0x22, 0x46, 0x6e, 0xc0, 0x04, 0x3e, 0xde, 0xe1, 0x44, 0x87, 0x92, 0xa7, + 0x86, 0x67, 0x19, 0xcc, 0x30, 0x9e, 0xb3, 0xa4, 0xfa, 0x79, 0xce, 0x92, 0xfb, 0x47, 0x3c, 0x1f, + 0x6a, 0x70, 0x39, 0xa5, 0xce, 0xa4, 0xd8, 0xa9, 0x41, 0x5e, 0x74, 0x35, 0x07, 0xdb, 0x91, 0x4a, + 0x87, 0x66, 0x09, 0x8f, 0x64, 0x80, 0xb0, 0x53, 0x83, 0xbc, 0xbc, 0x8e, 0x98, 0xc6, 0xa8, 0xd4, + 0x68, 0x44, 0x62, 0x09, 0x34, 0xf4, 0x4f, 0x34, 0x98, 0x8c, 0x06, 0x97, 0x02, 0xe6, 0x06, 0x5c, + 0x8a, 0x9b, 0x96, 0xef, 0x1f, 0xe1, 0xe4, 0x1b, 0x09, 0x44, 0x05, 0x5a, 0xf1, 0x10, 0x50, 0x4b, + 0x42, 0xca, 0xf3, 0x84, 0x34, 0xde, 0xf8, 0xf9, 0x3c, 0x8c, 0x89, 0x2a, 0x44, 0xde, 0x87, 0x71, + 0x39, 0xf6, 0x91, 0xc5, 0x84, 0x9b, 0x1e, 0x9c, 0x2f, 0x4b, 0x4b, 0xc3, 0xc4, 0xe4, 0xcd, 0xe9, + 0xf3, 0x0f, 0x7e, 0xfd, 0xeb, 0x30, 0x37, 0x4d, 0x8a, 0xc6, 0xe0, 0x10, 0x2b, 0x47, 0x4b, 0xf2, + 0x40, 0x83, 0x09, 0x35, 0x3e, 0x92, 0xe5, 0x34, 0xbb, 0xb1, 0xc1, 0xb3, 0xb4, 0x32, 0x5c, 0x10, + 0x21, 0x2c, 0x08, 0x08, 0xb3, 0x64, 0x3a, 0x01, 0x82, 0x1a, 0x34, 0x05, 0x08, 0x35, 0x48, 0xa4, + 0x83, 0x88, 0x4d, 0x46, 0xe9, 0x20, 0xe2, 0x33, 0x49, 0x26, 0x88, 0x70, 0xbc, 0x78, 0xa4, 0xc1, + 0xc5, 0xf8, 0x54, 0x43, 0x8c, 0x34, 0x1f, 0x29, 0xe3, 0x5a, 0xa9, 0x76, 0x72, 0x05, 0x04, 0xb7, + 0x26, 0xc0, 0x2d, 0x91, 0xab, 0x09, 0xe0, 0xba, 0xa8, 0x54, 0x09, 0x51, 0x7e, 0xae, 0xc1, 0x64, + 0x74, 0x04, 0x21, 0x95, 0x34, 0x97, 0x89, 0xf3, 0x4d, 0xa9, 0x7a, 0x52, 0x71, 0xc4, 0xb7, 0x2a, + 0xf0, 0x5d, 0x25, 0x7a, 0x02, 0x3e, 0x3f, 0x50, 0x51, 0xe0, 0xa8, 0x4d, 0x3e, 0x84, 0x33, 0xd8, + 0x77, 0x92, 0xd4, 0x1c, 0x8d, 0xb6, 0xd1, 0xa5, 0xe5, 0xa1, 0x72, 0x88, 0x43, 0x17, 0x38, 0x66, + 0x48, 0x29, 0x01, 0x87, 0x6a, 0x47, 0xbf, 0xd4, 0x60, 0x2a, 0xd6, 0x00, 0x93, 0xea, 0xb0, 0x1b, + 0x89, 0x01, 0x32, 0x4e, 0x2c, 0x8f, 0xc0, 0xae, 0x09, 0x60, 0x8b, 0x64, 0x21, 0xeb, 0x02, 0x15, + 0xc2, 0x4f, 0x35, 0xb8, 0x10, 0xe9, 0x57, 0xc9, 0x5a, 0xe6, 0x7d, 0xc4, 0x5a, 0xe1, 0x52, 0xe5, + 0x84, 0xd2, 0x88, 0xed, 0x05, 0x81, 0x6d, 0x81, 0xcc, 0xa7, 0x5e, 0x9e, 0x6a, 0x60, 0xc9, 0xa1, + 0x06, 0xe7, 0x23, 0x75, 0xf6, 0x5a, 0x9a, 0xab, 0x84, 0xee, 0xb6, 0xb4, 0x76, 0x32, 0x61, 0x84, + 0xb5, 0x22, 0x60, 0xe9, 0x64, 0x2e, 0x01, 0x96, 0xaa, 0xa1, 0x95, 0xa0, 0xa8, 0x8b, 0xd2, 0xa0, + 0x5a, 0xcb, 0xf4, 0xd2, 0x10, 0x6b, 0x55, 0xd3, 0x4b, 0x43, 0xbc, 0x4b, 0xcd, 0x2c, 0x0d, 0x9e, + 0xf2, 0x1b, 0xa4, 0x55, 0xac, 0x9b, 0x4b, 0x4f, 0xab, 0xe4, 0x56, 0x34, 0x3d, 0xad, 0x52, 0x9a, + 0xd0, 0xcc, 0xb4, 0x0a, 0x39, 0xc2, 0xee, 0xb4, 0xbe, 0xf9, 0xf8, 0xa8, 0xac, 0x3d, 0x39, 0x2a, + 0x6b, 0x7f, 0x1e, 0x95, 0xb5, 0x87, 0xc7, 0xe5, 0x91, 0x27, 0xc7, 0xe5, 0x91, 0xdf, 0x8e, 0xcb, + 0x23, 0xef, 0x2c, 0xf7, 0x75, 0x1f, 0xb5, 0x56, 0xdb, 0x6a, 0x70, 0xa3, 0xd6, 0xaa, 0x34, 0x77, + 0x2c, 0xc7, 0x35, 0xee, 0x4b, 0xab, 0xa2, 0x05, 0x69, 0x8c, 0x8b, 0x5f, 0x34, 0xaf, 0xff, 0x1d, + 0x00, 0x00, 0xff, 0xff, 0x0f, 0xa8, 0x5f, 0x41, 0xde, 0x15, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/hard/types/tx.pb.go b/x/hard/types/tx.pb.go index e14cb5d5..4d7a417f 100644 --- a/x/hard/types/tx.pb.go +++ b/x/hard/types/tx.pb.go @@ -505,41 +505,41 @@ func init() { func init() { proto.RegisterFile("kava/hard/v1beta1/tx.proto", fileDescriptor_72cf8eb667c23b8a) } var fileDescriptor_72cf8eb667c23b8a = []byte{ - // 533 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x55, 0x4f, 0x8f, 0xd2, 0x4e, - 0x18, 0xa6, 0x90, 0xe5, 0x07, 0xef, 0xfe, 0x0e, 0xee, 0x2c, 0x1a, 0xb6, 0x6a, 0xd9, 0xa0, 0xae, - 0x5c, 0x68, 0x77, 0x57, 0xe3, 0x59, 0xd1, 0x8b, 0xc9, 0x36, 0x26, 0x18, 0x63, 0xe2, 0xc5, 0x4c, - 0xe9, 0x64, 0x68, 0x90, 0x4e, 0xed, 0x3b, 0xc0, 0xee, 0xb7, 0xf0, 0xec, 0x07, 0x30, 0x71, 0xcf, - 0x7e, 0x88, 0x3d, 0xae, 0x9e, 0x3c, 0xa9, 0x81, 0x2f, 0x62, 0xda, 0x69, 0x07, 0x8c, 0x04, 0xb8, - 0x68, 0x3c, 0x31, 0xed, 0xf3, 0x87, 0xe7, 0xc9, 0xbc, 0x33, 0x05, 0x73, 0x40, 0xc7, 0xd4, 0xe9, - 0xd3, 0xd8, 0x77, 0xc6, 0x47, 0x1e, 0x93, 0xf4, 0xc8, 0x91, 0xa7, 0x76, 0x14, 0x0b, 0x29, 0xc8, - 0x4e, 0x82, 0xd9, 0x09, 0x66, 0x67, 0x98, 0x69, 0xf5, 0x04, 0x0e, 0x05, 0x3a, 0x1e, 0x45, 0xa6, - 0x05, 0x3d, 0x11, 0x84, 0x4a, 0x62, 0xee, 0x29, 0xfc, 0x75, 0xfa, 0xe4, 0xa8, 0x87, 0x0c, 0xaa, - 0x71, 0xc1, 0x85, 0x7a, 0x9f, 0xac, 0xd4, 0xdb, 0xe6, 0x47, 0x03, 0xc0, 0x45, 0xfe, 0x84, 0x45, - 0x02, 0x03, 0x49, 0x1e, 0x40, 0xd5, 0x57, 0x4b, 0x11, 0xd7, 0x8d, 0x7d, 0xa3, 0x55, 0xed, 0xd4, - 0xbf, 0x7c, 0x6a, 0xd7, 0x32, 0xa7, 0x47, 0xbe, 0x1f, 0x33, 0xc4, 0xe7, 0x32, 0x0e, 0x42, 0xde, - 0x9d, 0x53, 0x49, 0x0f, 0xca, 0x74, 0x28, 0x46, 0xa1, 0xac, 0x17, 0xf7, 0x4b, 0xad, 0xed, 0xe3, - 0x3d, 0x3b, 0x53, 0x24, 0x41, 0xf3, 0xf4, 0xf6, 0x63, 0x11, 0x84, 0x9d, 0xc3, 0x8b, 0x6f, 0x8d, - 0xc2, 0xf9, 0xf7, 0x46, 0x8b, 0x07, 0xb2, 0x3f, 0xf2, 0xec, 0x9e, 0x18, 0x66, 0x41, 0xb3, 0x9f, - 0x36, 0xfa, 0x03, 0x47, 0x9e, 0x45, 0x0c, 0x53, 0x01, 0x76, 0x33, 0xeb, 0x66, 0x0d, 0xc8, 0x3c, - 0x6a, 0x97, 0x61, 0x24, 0x42, 0x64, 0xcd, 0x73, 0x03, 0xb6, 0x5d, 0xe4, 0x2f, 0x03, 0xd9, 0xf7, - 0x63, 0x3a, 0xf9, 0xb7, 0x2b, 0x5c, 0x85, 0xdd, 0x85, 0xac, 0xba, 0xc3, 0x07, 0x03, 0xaa, 0x2e, - 0xf2, 0x8e, 0x88, 0x63, 0x31, 0x21, 0xf7, 0xa1, 0xe2, 0xa5, 0x2b, 0xb6, 0xbe, 0x80, 0x66, 0xfe, - 0x9d, 0xfc, 0xbb, 0xb0, 0xa3, 0x73, 0xea, 0xf4, 0x9f, 0x0d, 0xa8, 0xb8, 0xc8, 0xbb, 0x2c, 0xa2, - 0x67, 0xe4, 0x10, 0xca, 0xc8, 0x42, 0x7f, 0x83, 0xe8, 0x19, 0x8f, 0xd8, 0xb0, 0x25, 0x26, 0x21, - 0x8b, 0xeb, 0xc5, 0x35, 0x02, 0x45, 0x5b, 0x28, 0x5a, 0xfa, 0x73, 0x45, 0x09, 0x5c, 0xc9, 0x2b, - 0xe9, 0x9e, 0x63, 0xf8, 0xdf, 0x45, 0x7e, 0x12, 0xbc, 0x1d, 0x05, 0x3e, 0x95, 0x2c, 0xa9, 0x3a, - 0x60, 0x2c, 0xda, 0xa4, 0xaa, 0xe2, 0xfd, 0xb2, 0xb3, 0xc5, 0x4d, 0x77, 0xb6, 0x79, 0x0d, 0x6a, - 0x8b, 0xff, 0x9b, 0xe7, 0x39, 0x7e, 0x5f, 0x82, 0x92, 0x8b, 0x9c, 0x3c, 0x83, 0xff, 0xf2, 0xf3, - 0x7b, 0xd3, 0xfe, 0xed, 0xce, 0xb0, 0xe7, 0x67, 0xc6, 0xbc, 0xb3, 0x12, 0xce, 0x8d, 0x49, 0x17, - 0x2a, 0xfa, 0x38, 0x59, 0xcb, 0x25, 0x39, 0x6e, 0x1e, 0xac, 0xc6, 0xb5, 0xe7, 0x09, 0x94, 0xb3, - 0xf1, 0xbe, 0xb1, 0x5c, 0xa1, 0x50, 0xf3, 0xf6, 0x2a, 0x54, 0xbb, 0x3d, 0x85, 0x2d, 0x35, 0x6e, - 0xd7, 0x97, 0xd3, 0x53, 0xd0, 0xbc, 0xb5, 0x02, 0xd4, 0x56, 0x2f, 0xa0, 0x3a, 0xdf, 0xd2, 0xc6, - 0x72, 0x85, 0x26, 0x98, 0x77, 0xd7, 0x10, 0x72, 0xdb, 0xce, 0xc3, 0x8b, 0xa9, 0x65, 0x5c, 0x4e, - 0x2d, 0xe3, 0xc7, 0xd4, 0x32, 0xde, 0xcd, 0xac, 0xc2, 0xe5, 0xcc, 0x2a, 0x7c, 0x9d, 0x59, 0x85, - 0x57, 0x07, 0x0b, 0xc3, 0x98, 0x98, 0xb5, 0xdf, 0x50, 0x0f, 0xd3, 0x95, 0x73, 0xaa, 0xbe, 0x04, - 0xe9, 0x40, 0x7a, 0xe5, 0xf4, 0x86, 0xbe, 0xf7, 0x33, 0x00, 0x00, 0xff, 0xff, 0x91, 0x63, 0x35, - 0x65, 0x23, 0x06, 0x00, 0x00, + // 536 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x55, 0x4d, 0x8f, 0xd2, 0x40, + 0x18, 0xa6, 0x90, 0x45, 0x78, 0xd7, 0x83, 0x3b, 0x8b, 0x86, 0xad, 0x5a, 0x36, 0xf8, 0xb1, 0x5c, + 0x68, 0xd9, 0xd5, 0x78, 0x5f, 0xf4, 0x62, 0xb2, 0x8d, 0x09, 0xc6, 0x98, 0x78, 0x31, 0x53, 0x3a, + 0x19, 0x1a, 0xa4, 0x53, 0xfb, 0x0e, 0xb0, 0xfb, 0x2f, 0x3c, 0xfb, 0x03, 0x4c, 0xdc, 0xb3, 0x3f, + 0x62, 0x8f, 0xab, 0x27, 0x4f, 0x6a, 0xe0, 0x8f, 0x18, 0x3a, 0xed, 0x80, 0x91, 0x00, 0x17, 0xcd, + 0x9e, 0x98, 0xf6, 0xf9, 0xe0, 0x79, 0x32, 0xef, 0x4c, 0xc1, 0xec, 0xd3, 0x11, 0x75, 0x7a, 0x34, + 0xf6, 0x9d, 0xd1, 0xa1, 0xc7, 0x24, 0x3d, 0x74, 0xe4, 0xa9, 0x1d, 0xc5, 0x42, 0x0a, 0xb2, 0x33, + 0xc3, 0xec, 0x19, 0x66, 0xa7, 0x98, 0x69, 0x75, 0x05, 0x0e, 0x04, 0x3a, 0x1e, 0x45, 0xa6, 0x05, + 0x5d, 0x11, 0x84, 0x4a, 0x62, 0xee, 0x29, 0xfc, 0x6d, 0xf2, 0xe4, 0xa8, 0x87, 0x14, 0xaa, 0x70, + 0xc1, 0x85, 0x7a, 0x3f, 0x5b, 0xa9, 0xb7, 0xf5, 0xcf, 0x06, 0x80, 0x8b, 0xfc, 0x19, 0x8b, 0x04, + 0x06, 0x92, 0x3c, 0x81, 0xb2, 0xaf, 0x96, 0x22, 0xae, 0x1a, 0xfb, 0x46, 0xa3, 0xdc, 0xae, 0x7e, + 0xfb, 0xd2, 0xac, 0xa4, 0x4e, 0xc7, 0xbe, 0x1f, 0x33, 0xc4, 0x97, 0x32, 0x0e, 0x42, 0xde, 0x99, + 0x53, 0x49, 0x17, 0x8a, 0x74, 0x20, 0x86, 0xa1, 0xac, 0xe6, 0xf7, 0x0b, 0x8d, 0xed, 0xa3, 0x3d, + 0x3b, 0x55, 0xcc, 0x82, 0x66, 0xe9, 0xed, 0xa7, 0x22, 0x08, 0xdb, 0xad, 0x8b, 0x1f, 0xb5, 0xdc, + 0xf9, 0xcf, 0x5a, 0x83, 0x07, 0xb2, 0x37, 0xf4, 0xec, 0xae, 0x18, 0xa4, 0x41, 0xd3, 0x9f, 0x26, + 0xfa, 0x7d, 0x47, 0x9e, 0x45, 0x0c, 0x13, 0x01, 0x76, 0x52, 0xeb, 0x7a, 0x05, 0xc8, 0x3c, 0x6a, + 0x87, 0x61, 0x24, 0x42, 0x64, 0xf5, 0x73, 0x03, 0xb6, 0x5d, 0xe4, 0xaf, 0x03, 0xd9, 0xf3, 0x63, + 0x3a, 0xbe, 0xda, 0x15, 0x6e, 0xc2, 0xee, 0x42, 0x56, 0xdd, 0xe1, 0x93, 0x01, 0x65, 0x17, 0x79, + 0x5b, 0xc4, 0xb1, 0x18, 0x93, 0xc7, 0x50, 0xf2, 0x92, 0x15, 0x5b, 0x5f, 0x40, 0x33, 0xff, 0x4f, + 0xfe, 0x5d, 0xd8, 0xd1, 0x39, 0x75, 0xfa, 0xaf, 0x06, 0x94, 0x5c, 0xe4, 0x1d, 0x16, 0xd1, 0x33, + 0xd2, 0x82, 0x22, 0xb2, 0xd0, 0xdf, 0x20, 0x7a, 0xca, 0x23, 0x36, 0x6c, 0x89, 0x71, 0xc8, 0xe2, + 0x6a, 0x7e, 0x8d, 0x40, 0xd1, 0x16, 0x8a, 0x16, 0xfe, 0x5d, 0x51, 0x02, 0x37, 0xb2, 0x4a, 0xba, + 0xe7, 0x08, 0xae, 0xbb, 0xc8, 0x4f, 0x82, 0xf7, 0xc3, 0xc0, 0xa7, 0x92, 0xcd, 0xaa, 0xf6, 0x19, + 0x8b, 0x36, 0xa9, 0xaa, 0x78, 0x7f, 0xec, 0x6c, 0x7e, 0xd3, 0x9d, 0xad, 0xdf, 0x82, 0xca, 0xe2, + 0xff, 0x66, 0x79, 0x8e, 0x3e, 0x16, 0xa0, 0xe0, 0x22, 0x27, 0x2f, 0xe0, 0x5a, 0x76, 0x7e, 0xef, + 0xda, 0x7f, 0xdd, 0x19, 0xf6, 0xfc, 0xcc, 0x98, 0x0f, 0x56, 0xc2, 0x99, 0x31, 0xe9, 0x40, 0x49, + 0x1f, 0x27, 0x6b, 0xb9, 0x24, 0xc3, 0xcd, 0x87, 0xab, 0x71, 0xed, 0x79, 0x02, 0xc5, 0x74, 0xbc, + 0xef, 0x2c, 0x57, 0x28, 0xd4, 0xbc, 0xbf, 0x0a, 0xd5, 0x6e, 0xcf, 0x61, 0x4b, 0x8d, 0xdb, 0xed, + 0xe5, 0xf4, 0x04, 0x34, 0xef, 0xad, 0x00, 0xb5, 0xd5, 0x2b, 0x28, 0xcf, 0xb7, 0xb4, 0xb6, 0x5c, + 0xa1, 0x09, 0xe6, 0xc1, 0x1a, 0x42, 0x66, 0xdb, 0x3e, 0xbe, 0x98, 0x58, 0xc6, 0xe5, 0xc4, 0x32, + 0x7e, 0x4d, 0x2c, 0xe3, 0xc3, 0xd4, 0xca, 0x5d, 0x4e, 0xad, 0xdc, 0xf7, 0xa9, 0x95, 0x7b, 0x73, + 0xb0, 0x30, 0x8c, 0x2d, 0xfe, 0x8e, 0x7a, 0xe8, 0xb4, 0x78, 0xb3, 0xdb, 0xa3, 0x41, 0xe8, 0x9c, + 0xaa, 0x4f, 0x41, 0x32, 0x91, 0x5e, 0x31, 0xb9, 0xa2, 0x1f, 0xfd, 0x0e, 0x00, 0x00, 0xff, 0xff, + 0x21, 0x79, 0xa2, 0xad, 0x24, 0x06, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/incentive/types/apy.pb.go b/x/incentive/types/apy.pb.go index ecf4ca3b..97304b7e 100644 --- a/x/incentive/types/apy.pb.go +++ b/x/incentive/types/apy.pb.go @@ -79,7 +79,7 @@ func init() { func init() { proto.RegisterFile("kava/incentive/v1beta1/apy.proto", fileDescriptor_b2c1ad571f25cae9) } var fileDescriptor_b2c1ad571f25cae9 = []byte{ - // 248 bytes of a gzipped FileDescriptorProto + // 254 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xc8, 0x4e, 0x2c, 0x4b, 0xd4, 0xcf, 0xcc, 0x4b, 0x4e, 0xcd, 0x2b, 0xc9, 0x2c, 0x4b, 0xd5, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x2c, 0xa8, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x03, 0xa9, @@ -91,11 +91,11 @@ var fileDescriptor_b2c1ad571f25cae9 = []byte{ 0x29, 0xc1, 0x04, 0x92, 0x74, 0xb2, 0x39, 0x71, 0x4f, 0x9e, 0xe1, 0xd6, 0x3d, 0x79, 0xb5, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0xa8, 0x9d, 0x50, 0x4a, 0xb7, 0x38, 0x25, 0x5b, 0x1f, 0x64, 0x5a, 0xb1, 0x9e, 0x4b, 0x6a, 0xf2, 0xa5, 0x2d, 0xba, 0x5c, 0x50, 0x27, 0xb9, - 0xa4, 0x26, 0x07, 0x81, 0x0c, 0x72, 0x72, 0x3d, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, + 0xa4, 0x26, 0x07, 0x81, 0x0c, 0x72, 0x72, 0x3b, 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, 0x6d, 0x24, 0x43, 0x41, 0xbe, 0xd5, 0xcd, 0x49, 0x4c, 0x2a, 0x06, 0xb3, 0xf4, 0x2b, - 0x90, 0xc2, 0x06, 0x6c, 0x7a, 0x12, 0x1b, 0xd8, 0x37, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, - 0x95, 0x59, 0xa8, 0x77, 0x3a, 0x01, 0x00, 0x00, + 0x86, 0x28, 0x1d, 0x24, 0x43, 0x0d, 0xd2, 0x73, 0x12, 0x93, 0x8a, 0xf5, 0x0d, 0xd2, 0x75, 0x93, + 0x33, 0x12, 0x33, 0xf3, 0xf4, 0x2b, 0x90, 0x02, 0x07, 0x6c, 0x7c, 0x12, 0x1b, 0xd8, 0x3b, 0xc6, + 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6c, 0x70, 0x97, 0xf8, 0x3b, 0x01, 0x00, 0x00, } func (m *Apy) Marshal() (dAtA []byte, err error) { diff --git a/x/incentive/types/claims.pb.go b/x/incentive/types/claims.pb.go index 8f098c55..220bf48b 100644 --- a/x/incentive/types/claims.pb.go +++ b/x/incentive/types/claims.pb.go @@ -513,51 +513,51 @@ func init() { } var fileDescriptor_5f7515029623a895 = []byte{ - // 691 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x56, 0x4f, 0x4f, 0x13, 0x4d, - 0x18, 0xef, 0xc0, 0x0b, 0x79, 0x3b, 0x94, 0xbe, 0x64, 0x81, 0x57, 0xe8, 0x61, 0x8b, 0x25, 0xc1, - 0x26, 0xa6, 0xbb, 0x82, 0x07, 0x13, 0x6f, 0x2c, 0x68, 0xc0, 0x48, 0x24, 0x5b, 0x4d, 0x8c, 0x07, - 0x9b, 0xd9, 0xdd, 0xb1, 0x4e, 0xd8, 0xee, 0xd4, 0x99, 0x6d, 0x4b, 0x3f, 0x83, 0x17, 0xfd, 0x02, - 0x7e, 0x00, 0x2f, 0x5e, 0xf8, 0x10, 0xc4, 0x78, 0x20, 0xc6, 0xc4, 0x3f, 0x87, 0x8a, 0x70, 0xf5, - 0x13, 0x78, 0x32, 0xf3, 0x07, 0x58, 0xa0, 0x25, 0xc4, 0x14, 0x0f, 0x9c, 0x76, 0xe7, 0x99, 0x67, - 0x9e, 0xdf, 0x9f, 0x79, 0x76, 0x76, 0xe0, 0xec, 0x06, 0x6a, 0x22, 0x9b, 0x44, 0x3e, 0x8e, 0x62, - 0xd2, 0xc4, 0x76, 0x73, 0xde, 0xc3, 0x31, 0x9a, 0xb7, 0xfd, 0x10, 0x91, 0x1a, 0xb7, 0xea, 0x8c, - 0xc6, 0xd4, 0xf8, 0x5f, 0x24, 0x59, 0x87, 0x49, 0x96, 0x4e, 0xca, 0x99, 0x3e, 0xe5, 0x35, 0xca, - 0x6d, 0x0f, 0xf1, 0xc4, 0x4a, 0x4a, 0x22, 0xb5, 0x2e, 0x37, 0xad, 0xe6, 0x2b, 0x72, 0x64, 0xab, - 0x81, 0x9e, 0x9a, 0xa8, 0xd2, 0x2a, 0x55, 0x71, 0xf1, 0xa6, 0xa2, 0x85, 0x77, 0x00, 0xa6, 0x1d, - 0xc4, 0xf1, 0x92, 0x40, 0x37, 0x9e, 0xc2, 0x21, 0xda, 0x8a, 0x30, 0x9b, 0x02, 0x33, 0xa0, 0x98, - 0x71, 0x56, 0x7e, 0x75, 0xf2, 0xa5, 0x2a, 0x89, 0x9f, 0x37, 0x3c, 0xcb, 0xa7, 0x35, 0x5d, 0x4f, - 0x3f, 0x4a, 0x3c, 0xd8, 0xb0, 0xe3, 0x76, 0x1d, 0x73, 0x6b, 0xd1, 0xf7, 0x17, 0x83, 0x80, 0x61, - 0xce, 0x3f, 0x6e, 0x95, 0xc6, 0x35, 0xaa, 0x8e, 0x38, 0xed, 0x18, 0x73, 0x57, 0x95, 0x35, 0x6e, - 0xc1, 0x61, 0x86, 0x5b, 0x88, 0x05, 0x53, 0x03, 0x33, 0xa0, 0x38, 0xb2, 0x30, 0x6d, 0xe9, 0x64, - 0xa1, 0xe7, 0x40, 0xa4, 0xb5, 0x44, 0x49, 0xe4, 0xfc, 0xb3, 0xdd, 0xc9, 0xa7, 0x5c, 0x9d, 0x7e, - 0x3b, 0xfd, 0x7e, 0xab, 0x34, 0x24, 0x39, 0x16, 0x76, 0x01, 0xcc, 0x0a, 0xc6, 0x6b, 0x8d, 0x30, - 0x26, 0x7f, 0x87, 0xb6, 0x9f, 0xa0, 0x3d, 0x78, 0x36, 0xed, 0x1b, 0x82, 0xf6, 0xdb, 0xef, 0xf9, - 0xe2, 0x39, 0xf0, 0xc5, 0x02, 0xde, 0x4d, 0xe2, 0x4b, 0x00, 0x47, 0x5c, 0x19, 0x5d, 0x8d, 0x02, - 0xbc, 0x69, 0x5c, 0x83, 0xff, 0xf9, 0x34, 0x0c, 0x51, 0x8c, 0x19, 0x0a, 0x2b, 0x62, 0xb1, 0x54, - 0x9a, 0x76, 0xb3, 0x47, 0xe1, 0x87, 0xed, 0x3a, 0x36, 0xca, 0x70, 0x54, 0x55, 0xab, 0x3c, 0x43, - 0x7e, 0x4c, 0x99, 0xb4, 0x39, 0xe3, 0x58, 0x82, 0xd4, 0xb7, 0x4e, 0x7e, 0xee, 0x1c, 0xa4, 0x96, - 0xb1, 0xef, 0x66, 0x54, 0x91, 0xbb, 0xb2, 0x46, 0xa1, 0x05, 0x8d, 0x04, 0x19, 0xcc, 0xd7, 0x65, - 0x87, 0x22, 0x98, 0xd5, 0x50, 0x44, 0x85, 0xa7, 0x80, 0xf4, 0x66, 0xd6, 0xea, 0xde, 0xba, 0x56, - 0xa2, 0x86, 0x33, 0xa9, 0x5d, 0x1a, 0x3d, 0x56, 0xd8, 0xd5, 0xe4, 0xf5, 0xb0, 0xf0, 0x06, 0xc0, - 0x31, 0xb9, 0xcb, 0x7f, 0xe4, 0xc5, 0x69, 0x82, 0x03, 0xfd, 0x26, 0xf8, 0x1a, 0xc0, 0x2b, 0x27, - 0x09, 0x1e, 0xf8, 0xd3, 0x84, 0x13, 0x35, 0x31, 0x55, 0xe9, 0xea, 0x52, 0xb1, 0x17, 0x89, 0x93, - 0xe5, 0x9c, 0x9c, 0x66, 0x62, 0x9c, 0x06, 0x72, 0x8d, 0xda, 0xa9, 0x58, 0xe1, 0x03, 0x80, 0x63, - 0x8f, 0xca, 0xcb, 0x8f, 0xd7, 0x48, 0x14, 0x93, 0xa8, 0xaa, 0x3e, 0x90, 0x7b, 0x10, 0x8a, 0x56, - 0xad, 0xc8, 0x33, 0x46, 0xfa, 0x35, 0xb2, 0x70, 0xb5, 0x17, 0x85, 0xc3, 0xe3, 0xc0, 0xf9, 0x57, - 0x60, 0xef, 0x74, 0xf2, 0xc0, 0x4d, 0x7b, 0x87, 0x67, 0xc4, 0xc5, 0xfb, 0x9a, 0xfc, 0x14, 0x7e, - 0x0e, 0xc0, 0xdc, 0x0a, 0x62, 0xc1, 0x7d, 0xf2, 0xa2, 0x41, 0x02, 0x12, 0xb7, 0xd7, 0x19, 0x6d, - 0x92, 0x00, 0x33, 0x45, 0xe6, 0x41, 0x17, 0x61, 0x73, 0x67, 0x09, 0x3b, 0x3a, 0x35, 0xba, 0xab, - 0xdb, 0x84, 0x93, 0xbc, 0x51, 0xaf, 0x87, 0xed, 0x4a, 0x57, 0x91, 0xfd, 0xd9, 0xb7, 0x71, 0x05, - 0x71, 0x2c, 0x28, 0x90, 0x3d, 0xca, 0x18, 0x6d, 0x9d, 0x44, 0x1e, 0xec, 0x27, 0xb2, 0x82, 0x70, - 0x7b, 0xd9, 0xfd, 0x15, 0xc0, 0xec, 0x32, 0x0e, 0x71, 0x15, 0xc5, 0xf4, 0xa2, 0x2c, 0xde, 0xe8, - 0xd1, 0x40, 0xfd, 0x51, 0xd8, 0xbb, 0x95, 0x3e, 0x01, 0x98, 0x2e, 0xb7, 0x50, 0xfd, 0x92, 0xc9, - 0xfa, 0x0c, 0x60, 0xa6, 0x8c, 0x9a, 0x24, 0xaa, 0xf2, 0x4b, 0xb8, 0x61, 0x77, 0x10, 0x8b, 0x2e, - 0x97, 0x2c, 0x67, 0x75, 0xfb, 0x87, 0x99, 0xda, 0xde, 0x33, 0xc1, 0xce, 0x9e, 0x09, 0x76, 0xf7, - 0x4c, 0xf0, 0x6a, 0xdf, 0x4c, 0xed, 0xec, 0x9b, 0xa9, 0x2f, 0xfb, 0x66, 0xea, 0xc9, 0xf5, 0xc4, - 0x3f, 0x5a, 0xf0, 0x28, 0x85, 0xc8, 0xe3, 0xf2, 0xcd, 0xde, 0x4c, 0xdc, 0x1a, 0xe5, 0xcf, 0xda, - 0x1b, 0x96, 0x97, 0xb8, 0x9b, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x88, 0xd7, 0x8a, 0x4f, 0x54, - 0x0a, 0x00, 0x00, + // 693 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x56, 0xcf, 0x4e, 0x13, 0x41, + 0x18, 0xef, 0x80, 0x10, 0x3b, 0x94, 0x4a, 0x16, 0x50, 0xe8, 0x61, 0x8b, 0x25, 0xc1, 0x1e, 0xec, + 0x2e, 0xe0, 0xc1, 0xc4, 0x1b, 0x0b, 0x1a, 0x24, 0x12, 0xc9, 0x56, 0x13, 0xe3, 0xc1, 0x66, 0x76, + 0x77, 0x5c, 0x26, 0x6c, 0x77, 0xea, 0xce, 0xb6, 0xa5, 0xcf, 0xe0, 0x45, 0x5f, 0xc0, 0x07, 0xf0, + 0xe2, 0x85, 0x87, 0x20, 0xc6, 0x03, 0x31, 0x26, 0xfe, 0x39, 0x54, 0x84, 0xab, 0x4f, 0xe0, 0xc9, + 0xcc, 0x1f, 0x60, 0x81, 0x96, 0x10, 0x53, 0x3c, 0x70, 0x6a, 0xe7, 0x9b, 0x6f, 0xbe, 0xdf, 0x9f, + 0xf9, 0xf6, 0xdb, 0x85, 0xd3, 0x1b, 0xa8, 0x81, 0x4c, 0x12, 0xba, 0x38, 0x8c, 0x49, 0x03, 0x9b, + 0x8d, 0x39, 0x07, 0xc7, 0x68, 0xce, 0x74, 0x03, 0x44, 0xaa, 0xcc, 0xa8, 0x45, 0x34, 0xa6, 0xda, + 0x75, 0x9e, 0x64, 0x1c, 0x26, 0x19, 0x2a, 0x29, 0xa7, 0xbb, 0x94, 0x55, 0x29, 0x33, 0x1d, 0xc4, + 0x12, 0x27, 0x29, 0x09, 0xe5, 0xb9, 0xdc, 0xa4, 0xdc, 0xaf, 0x88, 0x95, 0x29, 0x17, 0x6a, 0x6b, + 0xcc, 0xa7, 0x3e, 0x95, 0x71, 0xfe, 0x4f, 0x46, 0x0b, 0x1f, 0x00, 0x4c, 0x5b, 0x88, 0xe1, 0x45, + 0x8e, 0xae, 0xbd, 0x80, 0x03, 0xb4, 0x19, 0xe2, 0x68, 0x02, 0x4c, 0x81, 0x62, 0xc6, 0x5a, 0xfe, + 0xd3, 0xce, 0x97, 0x7c, 0x12, 0xaf, 0xd7, 0x1d, 0xc3, 0xa5, 0x55, 0x55, 0x4f, 0xfd, 0x94, 0x98, + 0xb7, 0x61, 0xc6, 0xad, 0x1a, 0x66, 0xc6, 0x82, 0xeb, 0x2e, 0x78, 0x5e, 0x84, 0x19, 0xfb, 0xbc, + 0x55, 0x1a, 0x55, 0xa8, 0x2a, 0x62, 0xb5, 0x62, 0xcc, 0x6c, 0x59, 0x56, 0xbb, 0x0b, 0x07, 0x23, + 0xdc, 0x44, 0x91, 0x37, 0xd1, 0x37, 0x05, 0x8a, 0x43, 0xf3, 0x93, 0x86, 0x4a, 0xe6, 0x7a, 0x0e, + 0x44, 0x1a, 0x8b, 0x94, 0x84, 0xd6, 0x95, 0xed, 0x76, 0x3e, 0x65, 0xab, 0xf4, 0x7b, 0xe9, 0x8f, + 0x5b, 0xa5, 0x01, 0xc1, 0xb1, 0xb0, 0x0b, 0x60, 0x96, 0x33, 0x5e, 0xad, 0x07, 0x31, 0xf9, 0x3f, + 0xb4, 0xdd, 0x04, 0xed, 0xfe, 0xb3, 0x69, 0xcf, 0x72, 0xda, 0xef, 0x7f, 0xe6, 0x8b, 0xe7, 0xc0, + 0xe7, 0x07, 0x58, 0x27, 0x89, 0xaf, 0x01, 0x1c, 0xb2, 0x45, 0xf4, 0x61, 0xe8, 0xe1, 0x4d, 0xed, + 0x16, 0xbc, 0xe6, 0xd2, 0x20, 0x40, 0x31, 0x8e, 0x50, 0x50, 0xe1, 0x87, 0x85, 0xd2, 0xb4, 0x9d, + 0x3d, 0x0a, 0x3f, 0x69, 0xd5, 0xb0, 0x56, 0x86, 0xc3, 0xb2, 0x5a, 0xe5, 0x25, 0x72, 0x63, 0x1a, + 0x09, 0x9b, 0x33, 0x96, 0xc1, 0x49, 0xfd, 0x68, 0xe7, 0x67, 0xce, 0x41, 0x6a, 0x09, 0xbb, 0x76, + 0x46, 0x16, 0x79, 0x20, 0x6a, 0x14, 0x9a, 0x50, 0x4b, 0x90, 0xc1, 0x6c, 0x4d, 0x74, 0x28, 0x82, + 0x59, 0x05, 0x45, 0x64, 0x78, 0x02, 0x08, 0x6f, 0xa6, 0x8d, 0xce, 0xad, 0x6b, 0x24, 0x6a, 0x58, + 0xe3, 0xca, 0xa5, 0xe1, 0x63, 0x85, 0x6d, 0x45, 0x5e, 0x2d, 0x0b, 0xef, 0x00, 0x1c, 0x11, 0xb7, + 0xfc, 0x4f, 0x5e, 0x9c, 0x26, 0xd8, 0xd7, 0x6b, 0x82, 0x6f, 0x01, 0xbc, 0x71, 0x92, 0xe0, 0x81, + 0x3f, 0x0d, 0x38, 0x56, 0xe5, 0x5b, 0x95, 0x8e, 0x2e, 0x15, 0xbb, 0x91, 0x38, 0x59, 0xce, 0xca, + 0x29, 0x26, 0xda, 0x69, 0x20, 0x5b, 0xab, 0x9e, 0x8a, 0x15, 0x3e, 0x01, 0x38, 0xf2, 0xb4, 0xbc, + 0xf4, 0x6c, 0x95, 0x84, 0x31, 0x09, 0x7d, 0xf9, 0x80, 0xac, 0x40, 0xc8, 0x5b, 0xb5, 0x22, 0x66, + 0x8c, 0xf0, 0x6b, 0x68, 0xfe, 0x66, 0x37, 0x0a, 0x87, 0xe3, 0xc0, 0xba, 0xca, 0xb1, 0x77, 0xda, + 0x79, 0x60, 0xa7, 0x9d, 0xc3, 0x19, 0x71, 0xf1, 0xbe, 0x26, 0x1f, 0x85, 0xdf, 0x7d, 0x30, 0xb7, + 0x8c, 0x22, 0xef, 0x11, 0x79, 0x55, 0x27, 0x1e, 0x89, 0x5b, 0x6b, 0x11, 0x6d, 0x10, 0x0f, 0x47, + 0x92, 0xcc, 0xe3, 0x0e, 0xc2, 0x66, 0xce, 0x12, 0x76, 0x34, 0x35, 0x3a, 0xab, 0xdb, 0x84, 0xe3, + 0xac, 0x5e, 0xab, 0x05, 0xad, 0x4a, 0x47, 0x91, 0xbd, 0xb9, 0xb7, 0x51, 0x09, 0x71, 0x2c, 0xc8, + 0x91, 0x1d, 0x1a, 0x45, 0xb4, 0x79, 0x12, 0xb9, 0xbf, 0x97, 0xc8, 0x12, 0xc2, 0xee, 0x66, 0xf7, + 0x77, 0x00, 0xb3, 0x4b, 0x38, 0xc0, 0x3e, 0x8a, 0xe9, 0x45, 0x59, 0xbc, 0xd1, 0xa5, 0x81, 0x7a, + 0xa3, 0xb0, 0x7b, 0x2b, 0x7d, 0x01, 0x30, 0x5d, 0x6e, 0xa2, 0xda, 0x25, 0x93, 0xf5, 0x15, 0xc0, + 0x4c, 0x19, 0x35, 0x48, 0xe8, 0xb3, 0x4b, 0x78, 0x61, 0xf7, 0x51, 0x14, 0x5e, 0x2e, 0x59, 0xd6, + 0xca, 0xf6, 0x2f, 0x3d, 0xb5, 0xbd, 0xa7, 0x83, 0x9d, 0x3d, 0x1d, 0xec, 0xee, 0xe9, 0xe0, 0xcd, + 0xbe, 0x9e, 0xda, 0xd9, 0xd7, 0x53, 0xdf, 0xf6, 0xf5, 0xd4, 0xf3, 0xdb, 0x89, 0x77, 0xf4, 0xac, + 0x1f, 0x20, 0x87, 0x99, 0xb3, 0x7e, 0xc9, 0x5d, 0x47, 0x24, 0x34, 0x37, 0x13, 0x9f, 0x8d, 0xe2, + 0x6d, 0xed, 0x0c, 0x8a, 0xaf, 0xb8, 0x3b, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xca, 0xda, 0x22, + 0x4d, 0x55, 0x0a, 0x00, 0x00, } func (m *BaseClaim) Marshal() (dAtA []byte, err error) { diff --git a/x/incentive/types/genesis.pb.go b/x/incentive/types/genesis.pb.go index e4cadfa4..67e22dec 100644 --- a/x/incentive/types/genesis.pb.go +++ b/x/incentive/types/genesis.pb.go @@ -167,57 +167,57 @@ func init() { } var fileDescriptor_8b76737885d05afd = []byte{ - // 785 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xcf, 0x4f, 0xdb, 0x48, - 0x14, 0xc7, 0x63, 0x60, 0x59, 0x98, 0x00, 0x21, 0xb3, 0x01, 0xb2, 0x41, 0x72, 0x58, 0x40, 0xbb, - 0xd1, 0x56, 0xb5, 0x45, 0x7a, 0xed, 0xa5, 0x2e, 0x55, 0x8b, 0x54, 0x24, 0xe4, 0x50, 0x54, 0x55, - 0x95, 0xa2, 0x71, 0x3c, 0x98, 0x69, 0xfd, 0xab, 0x1e, 0x3b, 0x21, 0xb7, 0x1e, 0x7b, 0xe4, 0x0f, - 0xa8, 0xd4, 0x7b, 0xff, 0x8f, 0x4a, 0x1c, 0x39, 0xf6, 0x04, 0x6d, 0xf8, 0x47, 0xaa, 0x19, 0x8f, - 0x83, 0x9d, 0x60, 0xaa, 0xa6, 0xb7, 0xc9, 0x9b, 0x37, 0xdf, 0xcf, 0xf7, 0xcd, 0x7b, 0x13, 0x83, - 0xed, 0xb7, 0xa8, 0x8b, 0x54, 0xe2, 0x76, 0xb0, 0x1b, 0x92, 0x2e, 0x56, 0xbb, 0x3b, 0x06, 0x0e, - 0xd1, 0x8e, 0x6a, 0x61, 0x17, 0x53, 0x42, 0x15, 0x3f, 0xf0, 0x42, 0x0f, 0xae, 0xb2, 0x2c, 0x65, - 0x98, 0xa5, 0x88, 0xac, 0x5a, 0xc5, 0xf2, 0x2c, 0x8f, 0xa7, 0xa8, 0x6c, 0x15, 0x67, 0xd7, 0xea, - 0x96, 0xe7, 0x59, 0x36, 0x56, 0xf9, 0x2f, 0x23, 0x3a, 0x56, 0x43, 0xe2, 0x60, 0x1a, 0x22, 0xc7, - 0x17, 0x09, 0x5b, 0x39, 0xd0, 0x8e, 0x8d, 0x88, 0x43, 0x7f, 0x92, 0xe4, 0xa3, 0x00, 0x25, 0x49, - 0x9b, 0x9f, 0x24, 0xb0, 0xfc, 0xa8, 0xd3, 0x89, 0x9c, 0xc8, 0x46, 0x21, 0xf1, 0xdc, 0x43, 0xe2, - 0x60, 0xf8, 0x1f, 0x28, 0x75, 0x3c, 0xdb, 0x46, 0x21, 0x0e, 0x90, 0xdd, 0x0e, 0xfb, 0x3e, 0xae, - 0x4a, 0x1b, 0x52, 0x63, 0x5e, 0x5f, 0xba, 0x09, 0x1f, 0xf6, 0x7d, 0x0c, 0x0d, 0x50, 0xf3, 0x03, - 0xdc, 0x25, 0x5e, 0x44, 0xdb, 0x28, 0xa5, 0xd2, 0x66, 0x86, 0xab, 0x53, 0x1b, 0x52, 0xa3, 0xd8, - 0xac, 0x29, 0x71, 0x35, 0x4a, 0x52, 0x8d, 0x72, 0x98, 0x54, 0xa3, 0xcd, 0x9d, 0x5f, 0xd6, 0x0b, - 0x67, 0x57, 0x75, 0x49, 0xaf, 0x26, 0x3a, 0xa3, 0x66, 0x36, 0xdf, 0x4f, 0x01, 0xf8, 0x34, 0xbe, - 0x4c, 0x1d, 0xf7, 0x50, 0x60, 0xb6, 0x42, 0x14, 0x62, 0x18, 0x00, 0x38, 0x46, 0xa4, 0x55, 0x69, - 0x63, 0xba, 0x51, 0x6c, 0x36, 0x94, 0xdb, 0xaf, 0x5b, 0x19, 0x15, 0xd7, 0xfe, 0x66, 0x06, 0x3e, - 0x5f, 0xd5, 0xcb, 0xa3, 0x3b, 0x54, 0x2f, 0xa3, 0xd1, 0x10, 0xec, 0x82, 0x8a, 0x13, 0xd9, 0x21, - 0x69, 0x07, 0xdc, 0x48, 0x9b, 0xb8, 0x26, 0x3e, 0xc5, 0xb4, 0x3a, 0x75, 0x37, 0x75, 0x9f, 0x9d, - 0x89, 0xbd, 0xef, 0xb1, 0x13, 0x5a, 0x4d, 0x50, 0xe1, 0xe8, 0x0e, 0xa6, 0x3a, 0x74, 0xc6, 0x62, - 0x9b, 0x5f, 0x8a, 0x60, 0x41, 0x5c, 0x41, 0x5c, 0xfc, 0x43, 0x30, 0x1b, 0x77, 0x91, 0xf7, 0xa5, - 0xd8, 0x94, 0xf3, 0xd0, 0x07, 0x3c, 0x4b, 0x9b, 0x61, 0x40, 0x5d, 0x9c, 0x81, 0x1e, 0x28, 0x47, - 0xd4, 0x3c, 0x4d, 0xaa, 0xa0, 0x4c, 0x52, 0x34, 0xeb, 0xff, 0x3c, 0xa1, 0xf1, 0x0e, 0x68, 0x6b, - 0x4c, 0x74, 0x70, 0x59, 0x2f, 0xbd, 0x68, 0xed, 0xbe, 0x4c, 0x6d, 0xe8, 0x25, 0xa6, 0x9e, 0xee, - 0x15, 0x01, 0xd5, 0x13, 0x4e, 0x8a, 0x7c, 0xdf, 0xee, 0x67, 0xb9, 0xd3, 0xbf, 0xcc, 0x8d, 0x8b, - 0x59, 0x61, 0x8a, 0x2d, 0x2e, 0x78, 0x1b, 0xca, 0xf0, 0x82, 0xc0, 0xeb, 0x65, 0x51, 0x33, 0xbf, - 0x83, 0xd2, 0xb8, 0x60, 0x1a, 0x75, 0x0c, 0x56, 0x4d, 0x6c, 0x63, 0x0b, 0x85, 0x5e, 0x90, 0x05, - 0xfd, 0x31, 0x21, 0xa8, 0x32, 0xd4, 0x4b, 0x73, 0x5e, 0x83, 0x32, 0xed, 0x21, 0x3f, 0x8b, 0x98, - 0x9d, 0x10, 0x51, 0x62, 0x52, 0x69, 0xf5, 0x0f, 0x12, 0xf8, 0x8b, 0x4f, 0x83, 0x43, 0xdc, 0x90, - 0xb8, 0x56, 0x3b, 0xfe, 0x0f, 0xa9, 0xfe, 0x79, 0xf7, 0x4c, 0xb3, 0x9e, 0xef, 0xc7, 0x27, 0x1e, - 0xb3, 0x03, 0x9a, 0x22, 0xa6, 0xa1, 0x3c, 0xba, 0x43, 0xd9, 0xf3, 0x1a, 0x0b, 0xea, 0x7c, 0x04, - 0x33, 0x21, 0xf8, 0x51, 0x02, 0x32, 0x6f, 0x9e, 0x4d, 0xde, 0x45, 0xc4, 0x24, 0x61, 0xbf, 0xed, - 0x07, 0x5e, 0x97, 0x98, 0x38, 0x48, 0x5c, 0xcd, 0x71, 0x57, 0xcd, 0x3c, 0x57, 0xcf, 0x50, 0x60, - 0x3e, 0x4f, 0x0e, 0x1f, 0x88, 0xb3, 0xb1, 0xbf, 0x2d, 0xf1, 0xe6, 0xd6, 0xf3, 0x73, 0xa8, 0xbe, - 0x7e, 0x92, 0xbf, 0x09, 0xdf, 0x80, 0xe5, 0x9b, 0x7e, 0x0b, 0x3f, 0xf3, 0xdc, 0xcf, 0xbf, 0x79, - 0x7e, 0x76, 0x93, 0xfc, 0xd8, 0xc3, 0x9a, 0xf0, 0x50, 0xca, 0xc6, 0xa9, 0x5e, 0x32, 0xb3, 0x01, - 0x78, 0x04, 0x8a, 0xbc, 0xe7, 0x02, 0x03, 0x38, 0xe6, 0x9f, 0x3c, 0x4c, 0xab, 0x87, 0xfc, 0x98, - 0x00, 0x05, 0x01, 0x0c, 0x43, 0x54, 0x07, 0x74, 0xb8, 0x86, 0x06, 0xa8, 0x50, 0xd4, 0x25, 0xae, - 0x45, 0xb3, 0xe3, 0x54, 0x9c, 0x70, 0x9c, 0xa0, 0x50, 0x4b, 0x4f, 0x94, 0x01, 0x96, 0x12, 0x86, - 0xb0, 0xbf, 0xc0, 0xed, 0x6f, 0xe7, 0xda, 0x8f, 0xb3, 0xe3, 0x0a, 0x56, 0x44, 0x05, 0x8b, 0xe9, - 0x28, 0xd5, 0x17, 0x69, 0xfa, 0x27, 0x7b, 0x13, 0x18, 0x05, 0x6e, 0xb6, 0x88, 0xc5, 0x49, 0xdf, - 0x04, 0x93, 0x4a, 0x57, 0x70, 0x04, 0x8a, 0x5c, 0x5d, 0xd8, 0x5f, 0xba, 0xfb, 0xf6, 0x9f, 0xa0, - 0xc0, 0x1d, 0xb9, 0xfd, 0x61, 0x88, 0xea, 0x00, 0x0f, 0xd7, 0xda, 0xde, 0xf9, 0x77, 0xb9, 0x70, - 0x3e, 0x90, 0xa5, 0x8b, 0x81, 0x2c, 0x7d, 0x1b, 0xc8, 0xd2, 0xd9, 0xb5, 0x5c, 0xb8, 0xb8, 0x96, - 0x0b, 0x5f, 0xaf, 0xe5, 0xc2, 0xab, 0x7b, 0x16, 0x09, 0x4f, 0x22, 0x43, 0xe9, 0x78, 0x8e, 0xca, - 0x50, 0xf7, 0x6d, 0x64, 0x50, 0xbe, 0x52, 0x4f, 0x53, 0x9f, 0x71, 0xf6, 0x39, 0xa6, 0xc6, 0x2c, - 0xff, 0x9a, 0x3e, 0xf8, 0x11, 0x00, 0x00, 0xff, 0xff, 0xbc, 0xa8, 0x1c, 0xb0, 0x7f, 0x08, 0x00, - 0x00, + // 791 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xcf, 0x4f, 0xdb, 0x48, + 0x14, 0x8e, 0x81, 0x65, 0x61, 0x02, 0x84, 0xcc, 0x06, 0xc8, 0x06, 0xc9, 0x61, 0x01, 0xed, 0x46, + 0xab, 0x5d, 0x1b, 0xb2, 0xd7, 0xbd, 0xac, 0x97, 0xd5, 0xb6, 0x55, 0x91, 0x90, 0x43, 0x51, 0x55, + 0x55, 0x8a, 0xc6, 0xf1, 0xe0, 0x4c, 0xeb, 0x5f, 0xf5, 0xd8, 0x09, 0xb9, 0xf5, 0xd8, 0x23, 0x7f, + 0x40, 0xa5, 0xde, 0xfb, 0x7f, 0x54, 0xe2, 0xc8, 0xb1, 0x27, 0x68, 0xc3, 0x3f, 0x52, 0xcd, 0x78, + 0x1c, 0xec, 0x04, 0x53, 0x35, 0xbd, 0x8d, 0xdf, 0x7c, 0xef, 0xfb, 0xbe, 0x37, 0xef, 0x8d, 0x07, + 0xec, 0xbe, 0x44, 0x3d, 0xa4, 0x12, 0xb7, 0x83, 0xdd, 0x90, 0xf4, 0xb0, 0xda, 0xdb, 0x37, 0x70, + 0x88, 0xf6, 0x55, 0x0b, 0xbb, 0x98, 0x12, 0xaa, 0xf8, 0x81, 0x17, 0x7a, 0x70, 0x9d, 0xa1, 0x94, + 0x11, 0x4a, 0x11, 0xa8, 0x5a, 0xc5, 0xf2, 0x2c, 0x8f, 0x43, 0x54, 0xb6, 0x8a, 0xd1, 0xb5, 0xba, + 0xe5, 0x79, 0x96, 0x8d, 0x55, 0xfe, 0x65, 0x44, 0xa7, 0x6a, 0x48, 0x1c, 0x4c, 0x43, 0xe4, 0xf8, + 0x02, 0xb0, 0x93, 0x23, 0xda, 0xb1, 0x11, 0x71, 0xe8, 0x57, 0x40, 0x3e, 0x0a, 0x50, 0x02, 0xda, + 0x7e, 0x27, 0x81, 0xd5, 0x7f, 0x3a, 0x9d, 0xc8, 0x89, 0x6c, 0x14, 0x12, 0xcf, 0x3d, 0x26, 0x0e, + 0x86, 0xbf, 0x81, 0x52, 0xc7, 0xb3, 0x6d, 0x14, 0xe2, 0x00, 0xd9, 0xed, 0x70, 0xe0, 0xe3, 0xaa, + 0xb4, 0x25, 0x35, 0x16, 0xf5, 0x95, 0xdb, 0xf0, 0xf1, 0xc0, 0xc7, 0xd0, 0x00, 0x35, 0x3f, 0xc0, + 0x3d, 0xe2, 0x45, 0xb4, 0x8d, 0x52, 0x2c, 0x6d, 0x66, 0xb8, 0x3a, 0xb3, 0x25, 0x35, 0x8a, 0xcd, + 0x9a, 0x12, 0x57, 0xa3, 0x24, 0xd5, 0x28, 0xc7, 0x49, 0x35, 0xda, 0xc2, 0xc5, 0x55, 0xbd, 0x70, + 0x7e, 0x5d, 0x97, 0xf4, 0x6a, 0xc2, 0x33, 0x6e, 0x66, 0xfb, 0xf5, 0x0c, 0x80, 0xff, 0xc7, 0x87, + 0xa9, 0xe3, 0x3e, 0x0a, 0xcc, 0x56, 0x88, 0x42, 0x0c, 0x03, 0x00, 0x27, 0x14, 0x69, 0x55, 0xda, + 0x9a, 0x6d, 0x14, 0x9b, 0x0d, 0xe5, 0xee, 0xe3, 0x56, 0xc6, 0xc9, 0xb5, 0x9f, 0x99, 0x81, 0xf7, + 0xd7, 0xf5, 0xf2, 0xf8, 0x0e, 0xd5, 0xcb, 0x68, 0x3c, 0x04, 0x7b, 0xa0, 0xe2, 0x44, 0x76, 0x48, + 0xda, 0x01, 0x37, 0xd2, 0x26, 0xae, 0x89, 0xcf, 0x30, 0xad, 0xce, 0xdc, 0xaf, 0x7a, 0xc8, 0x72, + 0x62, 0xef, 0x0f, 0x59, 0x86, 0x56, 0x13, 0xaa, 0x70, 0x7c, 0x07, 0x53, 0x1d, 0x3a, 0x13, 0xb1, + 0xed, 0x0f, 0x45, 0xb0, 0x24, 0x8e, 0x20, 0x2e, 0xfe, 0x6f, 0x30, 0x1f, 0x77, 0x91, 0xf7, 0xa5, + 0xd8, 0x94, 0xf3, 0xa4, 0x8f, 0x38, 0x4a, 0x9b, 0x63, 0x82, 0xba, 0xc8, 0x81, 0x1e, 0x28, 0x47, + 0xd4, 0x3c, 0x4b, 0xaa, 0xa0, 0x8c, 0x52, 0x34, 0xeb, 0xf7, 0x3c, 0xa2, 0xc9, 0x0e, 0x68, 0x1b, + 0x8c, 0x74, 0x78, 0x55, 0x2f, 0x3d, 0x69, 0x1d, 0x3c, 0x4d, 0x6d, 0xe8, 0x25, 0xc6, 0x9e, 0xee, + 0x15, 0x01, 0xd5, 0x2e, 0x57, 0x8a, 0x7c, 0xdf, 0x1e, 0x64, 0x75, 0x67, 0xbf, 0x59, 0x37, 0x2e, + 0x66, 0x8d, 0x31, 0xb6, 0x38, 0xe1, 0x5d, 0x52, 0x86, 0x17, 0x04, 0x5e, 0x3f, 0x2b, 0x35, 0xf7, + 0x3d, 0x52, 0x1a, 0x27, 0x4c, 0x4b, 0x9d, 0x82, 0x75, 0x13, 0xdb, 0xd8, 0x42, 0xa1, 0x17, 0x64, + 0x85, 0x7e, 0x98, 0x52, 0xa8, 0x32, 0xe2, 0x4b, 0xeb, 0x3c, 0x07, 0x65, 0xda, 0x47, 0x7e, 0x56, + 0x62, 0x7e, 0x4a, 0x89, 0x12, 0xa3, 0x4a, 0xb3, 0xbf, 0x91, 0xc0, 0x4f, 0x7c, 0x1a, 0x1c, 0xe2, + 0x86, 0xc4, 0xb5, 0xda, 0xf1, 0x3f, 0xa4, 0xfa, 0xe3, 0xfd, 0x33, 0xcd, 0x7a, 0x7e, 0x18, 0x67, + 0xfc, 0xcb, 0x12, 0x34, 0x45, 0x4c, 0x43, 0x79, 0x7c, 0x87, 0xb2, 0xeb, 0x35, 0x11, 0xd4, 0xf9, + 0x08, 0x66, 0x42, 0xf0, 0xad, 0x04, 0x64, 0xde, 0x3c, 0x9b, 0xbc, 0x8a, 0x88, 0x49, 0xc2, 0x41, + 0xdb, 0x0f, 0xbc, 0x1e, 0x31, 0x71, 0x90, 0xb8, 0x5a, 0xe0, 0xae, 0x9a, 0x79, 0xae, 0x1e, 0xa0, + 0xc0, 0x7c, 0x9c, 0x24, 0x1f, 0x89, 0xdc, 0xd8, 0xdf, 0x8e, 0xb8, 0x73, 0x9b, 0xf9, 0x18, 0xaa, + 0x6f, 0x76, 0xf3, 0x37, 0xe1, 0x0b, 0xb0, 0x7a, 0xdb, 0x6f, 0xe1, 0x67, 0x91, 0xfb, 0xf9, 0x35, + 0xcf, 0xcf, 0x41, 0x82, 0x8f, 0x3d, 0x6c, 0x08, 0x0f, 0xa5, 0x6c, 0x9c, 0xea, 0x25, 0x33, 0x1b, + 0x80, 0x27, 0xa0, 0xc8, 0x7b, 0x2e, 0x64, 0x00, 0x97, 0xf9, 0x25, 0x4f, 0xa6, 0xd5, 0x47, 0x7e, + 0xac, 0x00, 0x85, 0x02, 0x18, 0x85, 0xa8, 0x0e, 0xe8, 0x68, 0x0d, 0x0d, 0x50, 0xa1, 0xa8, 0x47, + 0x5c, 0x8b, 0x66, 0xc7, 0xa9, 0x38, 0xe5, 0x38, 0x41, 0xc1, 0x96, 0x9e, 0x28, 0x03, 0xac, 0x24, + 0x1a, 0xc2, 0xfe, 0x12, 0xb7, 0xbf, 0x9b, 0x6b, 0x3f, 0x46, 0xc7, 0x15, 0xac, 0x89, 0x0a, 0x96, + 0xd3, 0x51, 0xaa, 0x2f, 0xd3, 0xf4, 0x27, 0xbb, 0x13, 0x18, 0x05, 0x6e, 0xb6, 0x88, 0xe5, 0x69, + 0xef, 0x04, 0xa3, 0x4a, 0x57, 0x70, 0x02, 0x8a, 0x9c, 0x5d, 0xd8, 0x5f, 0xb9, 0xff, 0xf4, 0xff, + 0x43, 0x81, 0x3b, 0x76, 0xfa, 0xa3, 0x10, 0xd5, 0x01, 0x1e, 0xad, 0xb5, 0x47, 0x17, 0x9f, 0xe5, + 0xc2, 0xc5, 0x50, 0x96, 0x2e, 0x87, 0xb2, 0xf4, 0x69, 0x28, 0x4b, 0xe7, 0x37, 0x72, 0xe1, 0xf2, + 0x46, 0x2e, 0x7c, 0xbc, 0x91, 0x0b, 0xcf, 0xfe, 0xb0, 0x48, 0xd8, 0x8d, 0x0c, 0xa5, 0xe3, 0x39, + 0xea, 0x9e, 0x65, 0x23, 0x83, 0xaa, 0x7b, 0xd6, 0x9f, 0x9d, 0x2e, 0x22, 0xae, 0x7a, 0x96, 0x7a, + 0xc7, 0xd9, 0x7b, 0x4c, 0x8d, 0x79, 0xfe, 0x9c, 0xfe, 0xf5, 0x25, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xb8, 0x69, 0x6c, 0x80, 0x08, 0x00, 0x00, } func (m *AccumulationTime) Marshal() (dAtA []byte, err error) { diff --git a/x/incentive/types/params.pb.go b/x/incentive/types/params.pb.go index 9656459b..08b5c414 100644 --- a/x/incentive/types/params.pb.go +++ b/x/incentive/types/params.pb.go @@ -251,56 +251,56 @@ func init() { } var fileDescriptor_bb8833f5d745eac9 = []byte{ - // 774 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x96, 0xcf, 0x6e, 0xd3, 0x4a, - 0x14, 0xc6, 0xe3, 0xfc, 0xbb, 0xc9, 0xb4, 0xbd, 0xb7, 0x9d, 0x46, 0xb9, 0xbe, 0xb9, 0xc8, 0xa9, - 0x52, 0x04, 0x41, 0x55, 0x6d, 0x0a, 0x12, 0x0b, 0x76, 0x98, 0x82, 0x84, 0x44, 0xa5, 0xca, 0x2d, - 0x12, 0xb0, 0x89, 0x26, 0xf6, 0xd4, 0xb5, 0x6a, 0x7b, 0xac, 0x99, 0x49, 0xda, 0x88, 0x05, 0x12, - 0x0b, 0x76, 0x48, 0x15, 0x0b, 0x1e, 0xa2, 0xaf, 0xc1, 0xa6, 0xcb, 0x8a, 0x15, 0x62, 0xd1, 0x42, - 0xfa, 0x22, 0x68, 0xc6, 0x6e, 0xe3, 0xa4, 0x69, 0xa1, 0x52, 0x36, 0xac, 0x32, 0x3e, 0x73, 0xce, - 0xf9, 0x7d, 0xfe, 0xc6, 0x67, 0x14, 0xb0, 0xb8, 0x83, 0xba, 0xc8, 0xf0, 0x42, 0x1b, 0x87, 0xdc, - 0xeb, 0x62, 0xa3, 0xbb, 0xd2, 0xc6, 0x1c, 0xad, 0x18, 0x11, 0xa2, 0x28, 0x60, 0x7a, 0x44, 0x09, - 0x27, 0xb0, 0x2a, 0x92, 0xf4, 0xf3, 0x24, 0x3d, 0x49, 0xaa, 0x69, 0x36, 0x61, 0x01, 0x61, 0x46, - 0x1b, 0xb1, 0x41, 0xa5, 0x4d, 0xbc, 0x30, 0xae, 0xab, 0x55, 0x5c, 0xe2, 0x12, 0xb9, 0x34, 0xc4, - 0x2a, 0x89, 0xd6, 0x5d, 0x42, 0x5c, 0x1f, 0x1b, 0xf2, 0xa9, 0xdd, 0xd9, 0x32, 0xb8, 0x17, 0x60, - 0xc6, 0x51, 0x10, 0xc5, 0x09, 0x8d, 0x8f, 0x59, 0x30, 0x6d, 0xe1, 0x5d, 0x44, 0x9d, 0x75, 0x4c, - 0x3d, 0xe2, 0xc0, 0x2a, 0x28, 0x22, 0x5b, 0x90, 0x55, 0x65, 0x41, 0x69, 0x96, 0xac, 0xe4, 0x09, - 0xde, 0x06, 0xff, 0xd8, 0xc4, 0xf7, 0x11, 0xc7, 0x14, 0xf9, 0x2d, 0xde, 0x8b, 0xb0, 0x9a, 0x5d, - 0x50, 0x9a, 0x65, 0xeb, 0xef, 0x41, 0x78, 0xb3, 0x17, 0x61, 0xf8, 0x10, 0x14, 0x18, 0x47, 0x94, - 0xab, 0xb9, 0x05, 0xa5, 0x39, 0x75, 0xaf, 0xa6, 0xc7, 0x12, 0xf4, 0x33, 0x09, 0xfa, 0xe6, 0x99, - 0x04, 0xb3, 0x74, 0x78, 0x5c, 0xcf, 0xec, 0x9f, 0xd4, 0x15, 0x2b, 0x2e, 0x81, 0x0f, 0x40, 0x0e, - 0x87, 0x8e, 0x9a, 0xbf, 0x46, 0xa5, 0x28, 0x80, 0x6b, 0x00, 0x52, 0xf9, 0x12, 0xac, 0x15, 0x61, - 0xda, 0x62, 0xd8, 0x26, 0xa1, 0xa3, 0x16, 0x64, 0x9b, 0xff, 0xf4, 0xd8, 0x39, 0x5d, 0x38, 0x77, - 0x66, 0xa7, 0xfe, 0x98, 0x78, 0xa1, 0x99, 0x17, 0x5d, 0xac, 0xd9, 0xa4, 0x74, 0x1d, 0xd3, 0x0d, - 0x59, 0xd8, 0xf8, 0x9c, 0x05, 0x73, 0x6b, 0x1d, 0x9f, 0x7b, 0x7f, 0xbe, 0x33, 0xbd, 0x4b, 0x9c, - 0xc9, 0x5d, 0xed, 0xcc, 0x5d, 0xd1, 0xe5, 0xe0, 0xa4, 0xde, 0x74, 0x3d, 0xbe, 0xdd, 0x69, 0xeb, - 0x36, 0x09, 0x8c, 0xe4, 0x03, 0x8c, 0x7f, 0x96, 0x99, 0xb3, 0x63, 0x88, 0x77, 0x65, 0xb2, 0x80, - 0x8d, 0x71, 0xf1, 0x83, 0x02, 0x80, 0x74, 0x31, 0xf2, 0x3d, 0x4c, 0x21, 0x04, 0xf9, 0x10, 0x05, - 0xb1, 0x79, 0x65, 0x4b, 0xae, 0xe1, 0x22, 0x98, 0x09, 0x48, 0xc8, 0xb7, 0x59, 0xcb, 0x27, 0xf6, - 0x4e, 0x27, 0x92, 0xc6, 0xe5, 0xac, 0xe9, 0x38, 0xf8, 0x5c, 0xc6, 0xe0, 0x53, 0x50, 0xdc, 0x42, - 0x36, 0x27, 0x54, 0xfa, 0x36, 0x6d, 0xea, 0x42, 0xdb, 0xb7, 0xe3, 0xfa, 0xad, 0xdf, 0xd0, 0xb6, - 0x8a, 0x6d, 0x2b, 0xa9, 0x6e, 0xbc, 0x57, 0xc0, 0xfc, 0x40, 0x8f, 0x10, 0xba, 0x8a, 0x43, 0x12, - 0xc0, 0x0a, 0x28, 0x38, 0x62, 0x91, 0x28, 0x8b, 0x1f, 0xe0, 0x2b, 0x30, 0x15, 0x0c, 0x92, 0xd5, - 0xac, 0x74, 0xac, 0xa1, 0x8f, 0x9f, 0x4e, 0x7d, 0xd0, 0xd7, 0x9c, 0x4f, 0xac, 0x9b, 0x4a, 0xb1, - 0xac, 0x74, 0xaf, 0xc6, 0x97, 0x12, 0x28, 0xae, 0xcb, 0x99, 0x87, 0x9f, 0x14, 0xf0, 0x7f, 0x87, - 0x39, 0x7b, 0xad, 0xc0, 0x0b, 0xb9, 0x17, 0xba, 0xad, 0xd8, 0x45, 0x71, 0x56, 0x1e, 0x71, 0x98, - 0xaa, 0x48, 0xec, 0xcd, 0xcb, 0xb0, 0xe9, 0xef, 0xd3, 0x5c, 0x11, 0xe0, 0xfe, 0x71, 0x5d, 0x7d, - 0xb1, 0xb1, 0xfa, 0x72, 0x2d, 0xee, 0x97, 0x4e, 0x60, 0x07, 0x27, 0xf5, 0x99, 0xa1, 0x80, 0xa5, - 0x0a, 0xf6, 0xb8, 0x54, 0xf8, 0x4e, 0x01, 0xb5, 0x6d, 0xa1, 0x84, 0x75, 0xa2, 0xc8, 0xef, 0x8d, - 0xea, 0x8a, 0xed, 0xb8, 0x73, 0xa5, 0x1d, 0x43, 0xe2, 0x6a, 0x89, 0x2b, 0xf0, 0xc2, 0x16, 0xb3, - 0xfe, 0x15, 0xa0, 0x0d, 0xc9, 0xb9, 0x44, 0x44, 0x9b, 0x50, 0x4a, 0x76, 0x47, 0x45, 0xe4, 0x26, - 0x2e, 0xc2, 0x94, 0x9c, 0x61, 0x11, 0x6f, 0x81, 0xea, 0x60, 0x1f, 0xbb, 0x88, 0x13, 0x3a, 0xaa, - 0x20, 0x3f, 0x49, 0x05, 0xd5, 0x73, 0xcc, 0xb0, 0x80, 0x0e, 0x98, 0x67, 0xbb, 0x28, 0x1a, 0x65, - 0x17, 0x26, 0xc9, 0x9e, 0x13, 0x84, 0x61, 0x6c, 0x17, 0xcc, 0xd9, 0x3e, 0xf2, 0x82, 0x56, 0x7a, - 0x0c, 0x8a, 0x12, 0xba, 0xf4, 0xeb, 0x31, 0x38, 0x1f, 0x2f, 0xf3, 0x46, 0x82, 0xad, 0x8c, 0xd9, - 0x64, 0xd6, 0xac, 0x64, 0xa4, 0xb6, 0xe0, 0x23, 0x50, 0x8e, 0xb9, 0xe2, 0xbe, 0xfb, 0xeb, 0x1a, - 0xf7, 0x5d, 0x49, 0x96, 0x3d, 0x09, 0x1d, 0xf8, 0x06, 0x54, 0x19, 0xea, 0x7a, 0xa1, 0xcb, 0x46, - 0x4d, 0x2b, 0x4d, 0xd2, 0xb4, 0x4a, 0x02, 0xb9, 0x70, 0x5c, 0x18, 0xd1, 0x70, 0x94, 0x5c, 0x9e, - 0xe8, 0x71, 0x09, 0xc2, 0x50, 0xc8, 0x7c, 0x76, 0xf8, 0x43, 0xcb, 0x1c, 0xf6, 0x35, 0xe5, 0xa8, - 0xaf, 0x29, 0xdf, 0xfb, 0x9a, 0xb2, 0x7f, 0xaa, 0x65, 0x8e, 0x4e, 0xb5, 0xcc, 0xd7, 0x53, 0x2d, - 0xf3, 0x7a, 0x29, 0x75, 0x57, 0x0a, 0x05, 0xcb, 0x3e, 0x6a, 0x33, 0xb9, 0x32, 0xf6, 0x52, 0xff, - 0x48, 0xe4, 0xa5, 0xd9, 0x2e, 0x4a, 0x9b, 0xef, 0xff, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xca, 0x77, - 0xf8, 0x09, 0xb0, 0x08, 0x00, 0x00, + // 781 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x96, 0xcf, 0x4f, 0xdb, 0x48, + 0x14, 0xc7, 0xe3, 0xfc, 0xda, 0x64, 0x80, 0x5d, 0x18, 0xa2, 0xac, 0x37, 0xbb, 0x72, 0x50, 0x58, + 0xed, 0x66, 0xb5, 0xc5, 0x86, 0x56, 0xea, 0xa1, 0xb7, 0xba, 0xb4, 0x87, 0xaa, 0x48, 0xc8, 0x50, + 0xa9, 0xed, 0x25, 0x9a, 0xd8, 0x83, 0x63, 0x61, 0x7b, 0xac, 0x99, 0x49, 0x20, 0xea, 0xa1, 0x52, + 0x0f, 0xbd, 0x55, 0x42, 0x3d, 0xf4, 0x8f, 0xe0, 0xdf, 0xe8, 0x85, 0x23, 0xea, 0xa9, 0xea, 0x01, + 0xda, 0xf0, 0x8f, 0x54, 0x33, 0x36, 0xc4, 0x09, 0x81, 0x16, 0x29, 0x97, 0x9e, 0x32, 0x7e, 0xf3, + 0xde, 0xfb, 0x7c, 0xfd, 0x1d, 0xbf, 0x51, 0xc0, 0xf2, 0x2e, 0xea, 0x21, 0xc3, 0x0b, 0x6d, 0x1c, + 0x72, 0xaf, 0x87, 0x8d, 0xde, 0x5a, 0x1b, 0x73, 0xb4, 0x66, 0x44, 0x88, 0xa2, 0x80, 0xe9, 0x11, + 0x25, 0x9c, 0xc0, 0xaa, 0x48, 0xd2, 0x2f, 0x92, 0xf4, 0x24, 0xa9, 0xa6, 0xd9, 0x84, 0x05, 0x84, + 0x19, 0x6d, 0xc4, 0x86, 0x95, 0x36, 0xf1, 0xc2, 0xb8, 0xae, 0x56, 0x71, 0x89, 0x4b, 0xe4, 0xd2, + 0x10, 0xab, 0x24, 0x5a, 0x77, 0x09, 0x71, 0x7d, 0x6c, 0xc8, 0xa7, 0x76, 0x77, 0xc7, 0xe0, 0x5e, + 0x80, 0x19, 0x47, 0x41, 0x14, 0x27, 0x34, 0xde, 0x65, 0xc1, 0xac, 0x85, 0xf7, 0x10, 0x75, 0x36, + 0x31, 0xf5, 0x88, 0x03, 0xab, 0xa0, 0x88, 0x6c, 0x41, 0x56, 0x95, 0x25, 0xa5, 0x59, 0xb2, 0x92, + 0x27, 0xf8, 0x2f, 0xf8, 0xcd, 0x26, 0xbe, 0x8f, 0x38, 0xa6, 0xc8, 0x6f, 0xf1, 0x7e, 0x84, 0xd5, + 0xec, 0x92, 0xd2, 0x2c, 0x5b, 0xbf, 0x0e, 0xc3, 0xdb, 0xfd, 0x08, 0xc3, 0x7b, 0xa0, 0xc0, 0x38, + 0xa2, 0x5c, 0xcd, 0x2d, 0x29, 0xcd, 0x99, 0xdb, 0x35, 0x3d, 0x96, 0xa0, 0x9f, 0x4b, 0xd0, 0xb7, + 0xcf, 0x25, 0x98, 0xa5, 0xa3, 0x93, 0x7a, 0xe6, 0xe0, 0xb4, 0xae, 0x58, 0x71, 0x09, 0xbc, 0x0b, + 0x72, 0x38, 0x74, 0xd4, 0xfc, 0x0d, 0x2a, 0x45, 0x01, 0xdc, 0x00, 0x90, 0xca, 0x97, 0x60, 0xad, + 0x08, 0xd3, 0x16, 0xc3, 0x36, 0x09, 0x1d, 0xb5, 0x20, 0xdb, 0xfc, 0xa1, 0xc7, 0xce, 0xe9, 0xc2, + 0xb9, 0x73, 0x3b, 0xf5, 0x07, 0xc4, 0x0b, 0xcd, 0xbc, 0xe8, 0x62, 0xcd, 0x27, 0xa5, 0x9b, 0x98, + 0x6e, 0xc9, 0xc2, 0xc6, 0x87, 0x2c, 0x58, 0xd8, 0xe8, 0xfa, 0xdc, 0xfb, 0xf9, 0x9d, 0xe9, 0x5f, + 0xe1, 0x4c, 0xee, 0x7a, 0x67, 0x56, 0x45, 0x97, 0xc3, 0xd3, 0x7a, 0xd3, 0xf5, 0x78, 0xa7, 0xdb, + 0xd6, 0x6d, 0x12, 0x18, 0xc9, 0x07, 0x18, 0xff, 0xac, 0x30, 0x67, 0xd7, 0x10, 0xef, 0xca, 0x64, + 0x01, 0x9b, 0xe0, 0xe2, 0x5b, 0x05, 0x00, 0xe9, 0x62, 0xe4, 0x7b, 0x98, 0x42, 0x08, 0xf2, 0x21, + 0x0a, 0x62, 0xf3, 0xca, 0x96, 0x5c, 0xc3, 0x65, 0x30, 0x17, 0x90, 0x90, 0x77, 0x58, 0xcb, 0x27, + 0xf6, 0x6e, 0x37, 0x92, 0xc6, 0xe5, 0xac, 0xd9, 0x38, 0xf8, 0x44, 0xc6, 0xe0, 0x23, 0x50, 0xdc, + 0x41, 0x36, 0x27, 0x54, 0xfa, 0x36, 0x6b, 0xea, 0x42, 0xdb, 0xe7, 0x93, 0xfa, 0x3f, 0x3f, 0xa0, + 0x6d, 0x1d, 0xdb, 0x56, 0x52, 0xdd, 0x78, 0xa3, 0x80, 0xc5, 0xa1, 0x1e, 0x21, 0x74, 0x1d, 0x87, + 0x24, 0x80, 0x15, 0x50, 0x70, 0xc4, 0x22, 0x51, 0x16, 0x3f, 0xc0, 0xe7, 0x60, 0x26, 0x18, 0x26, + 0xab, 0x59, 0xe9, 0x58, 0x43, 0x9f, 0x3c, 0x9d, 0xfa, 0xb0, 0xaf, 0xb9, 0x98, 0x58, 0x37, 0x93, + 0x62, 0x59, 0xe9, 0x5e, 0x8d, 0x8f, 0x25, 0x50, 0xdc, 0x94, 0x33, 0x0f, 0xdf, 0x2b, 0xe0, 0xcf, + 0x2e, 0x73, 0xf6, 0x5b, 0x81, 0x17, 0x72, 0x2f, 0x74, 0x5b, 0xb1, 0x8b, 0xe2, 0xac, 0x3c, 0xe2, + 0x30, 0x55, 0x91, 0xd8, 0xbf, 0xaf, 0xc2, 0xa6, 0xbf, 0x4f, 0x73, 0x4d, 0x80, 0x07, 0x27, 0x75, + 0xf5, 0xe9, 0xd6, 0xfa, 0xb3, 0x8d, 0xb8, 0x5f, 0x3a, 0x81, 0x1d, 0x9e, 0xd6, 0xe7, 0x46, 0x02, + 0x96, 0x2a, 0xd8, 0x93, 0x52, 0xe1, 0x6b, 0x05, 0xd4, 0x3a, 0x42, 0x09, 0xeb, 0x46, 0x91, 0xdf, + 0x1f, 0xd7, 0x15, 0xdb, 0xf1, 0xdf, 0xb5, 0x76, 0x8c, 0x88, 0xab, 0x25, 0xae, 0xc0, 0x4b, 0x5b, + 0xcc, 0xfa, 0x5d, 0x80, 0xb6, 0x24, 0xe7, 0x0a, 0x11, 0x6d, 0x42, 0x29, 0xd9, 0x1b, 0x17, 0x91, + 0x9b, 0xba, 0x08, 0x53, 0x72, 0x46, 0x45, 0xbc, 0x02, 0xaa, 0x83, 0x7d, 0xec, 0x22, 0x4e, 0xe8, + 0xb8, 0x82, 0xfc, 0x34, 0x15, 0x54, 0x2f, 0x30, 0xa3, 0x02, 0xba, 0x60, 0x91, 0xed, 0xa1, 0x68, + 0x9c, 0x5d, 0x98, 0x26, 0x7b, 0x41, 0x10, 0x46, 0xb1, 0x3d, 0xb0, 0x60, 0xfb, 0xc8, 0x0b, 0x5a, + 0xe9, 0x31, 0x28, 0x4a, 0xe8, 0xff, 0xdf, 0x1f, 0x83, 0x8b, 0xf1, 0x32, 0xff, 0x4a, 0xb0, 0x95, + 0x09, 0x9b, 0xcc, 0x9a, 0x97, 0x8c, 0xd4, 0x16, 0xbc, 0x0f, 0xca, 0x31, 0x57, 0xdc, 0x77, 0xbf, + 0xdc, 0xe0, 0xbe, 0x2b, 0xc9, 0xb2, 0x87, 0xa1, 0x03, 0x5f, 0x82, 0x2a, 0x43, 0x3d, 0x2f, 0x74, + 0xd9, 0xb8, 0x69, 0xa5, 0x69, 0x9a, 0x56, 0x49, 0x20, 0x97, 0x8e, 0x0b, 0x23, 0x1a, 0x8e, 0x93, + 0xcb, 0x53, 0x3d, 0x2e, 0x41, 0x18, 0x09, 0x99, 0x8f, 0x8f, 0xbe, 0x6a, 0x99, 0xa3, 0x81, 0xa6, + 0x1c, 0x0f, 0x34, 0xe5, 0xcb, 0x40, 0x53, 0x0e, 0xce, 0xb4, 0xcc, 0xf1, 0x99, 0x96, 0xf9, 0x74, + 0xa6, 0x65, 0x5e, 0xdc, 0x4a, 0xdd, 0x95, 0xab, 0xae, 0x8f, 0xda, 0xcc, 0x58, 0x75, 0x57, 0xec, + 0x0e, 0xf2, 0x42, 0x63, 0x3f, 0xf5, 0x97, 0x44, 0xde, 0x9a, 0xed, 0xa2, 0xf4, 0xf9, 0xce, 0xb7, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x88, 0xb6, 0xd5, 0xb1, 0x08, 0x00, 0x00, } func (m *RewardPeriod) Marshal() (dAtA []byte, err error) { diff --git a/x/incentive/types/query.pb.go b/x/incentive/types/query.pb.go index d639bf69..dc0cb0ca 100644 --- a/x/incentive/types/query.pb.go +++ b/x/incentive/types/query.pb.go @@ -490,64 +490,64 @@ func init() { } var fileDescriptor_a78d71d0cbe5e95a = []byte{ - // 904 bytes of a gzipped FileDescriptorProto + // 911 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xcf, 0x6f, 0xe3, 0x44, 0x14, 0xc7, 0xeb, 0xe6, 0x47, 0xe1, 0x55, 0xdd, 0x6e, 0xa7, 0xa1, 0x1b, 0x1c, 0x70, 0xb2, 0x29, - 0xea, 0x46, 0x2c, 0xc4, 0x6a, 0x10, 0x37, 0x2e, 0x2d, 0xbb, 0x88, 0x95, 0x58, 0x69, 0x71, 0x01, - 0x21, 0x2e, 0xd5, 0x24, 0x1e, 0x5c, 0x43, 0x3a, 0xe3, 0xce, 0xd8, 0x49, 0xbd, 0x12, 0x48, 0x70, - 0x01, 0x0e, 0x48, 0x48, 0x5c, 0x39, 0x73, 0xd8, 0xbf, 0x82, 0xe3, 0x4a, 0x5c, 0x56, 0xe2, 0xc2, - 0x69, 0x17, 0xb5, 0xfc, 0x21, 0xc8, 0x33, 0x63, 0x37, 0xf6, 0xd6, 0xd9, 0x22, 0xe5, 0xe6, 0xbc, - 0xf9, 0xbe, 0xf7, 0xfd, 0x3c, 0xeb, 0xbd, 0x8c, 0xa1, 0xfb, 0x35, 0x9e, 0x60, 0xdb, 0xa7, 0x23, - 0x42, 0x43, 0x7f, 0x42, 0xec, 0xc9, 0xee, 0x90, 0x84, 0x78, 0xd7, 0x3e, 0x89, 0x08, 0x8f, 0xfb, - 0x01, 0x67, 0x21, 0x43, 0x5b, 0x89, 0xa6, 0x9f, 0x69, 0xfa, 0x5a, 0x63, 0x36, 0x3c, 0xe6, 0x31, - 0x29, 0xb1, 0x93, 0x27, 0xa5, 0x36, 0x5f, 0xf3, 0x18, 0xf3, 0xc6, 0xc4, 0xc6, 0x81, 0x6f, 0x63, - 0x4a, 0x59, 0x88, 0x43, 0x9f, 0x51, 0xa1, 0x4f, 0x3b, 0x25, 0x7e, 0x38, 0xd0, 0x6e, 0xe6, 0x76, - 0x89, 0x62, 0x34, 0xc6, 0xfe, 0xb1, 0x78, 0x81, 0x28, 0xc0, 0x1c, 0xa7, 0xa2, 0x6e, 0x03, 0xd0, - 0xc7, 0x49, 0x1b, 0x0f, 0x64, 0xd0, 0x21, 0x27, 0x11, 0x11, 0x61, 0xf7, 0x00, 0x36, 0x73, 0x51, - 0x11, 0x30, 0x2a, 0x08, 0x7a, 0x0f, 0xea, 0x2a, 0xb9, 0x69, 0x74, 0x8c, 0xde, 0xea, 0xc0, 0xea, - 0x5f, 0xde, 0x75, 0x5f, 0xe5, 0xed, 0x57, 0x1f, 0x3f, 0x6d, 0x2f, 0x39, 0x3a, 0xa7, 0x1b, 0xea, - 0xa2, 0x0e, 0x99, 0x62, 0xee, 0xa6, 0x5e, 0xa8, 0x01, 0x35, 0x36, 0xa5, 0x84, 0xcb, 0x9a, 0x2f, - 0x3b, 0xea, 0x07, 0x6a, 0xc3, 0x2a, 0x97, 0xba, 0xc3, 0x30, 0x0e, 0x48, 0x73, 0x59, 0x9e, 0x81, - 0x0a, 0x7d, 0x12, 0x07, 0x04, 0xed, 0xc0, 0xb5, 0x88, 0x8a, 0x98, 0x8e, 0x8e, 0x38, 0xa3, 0xfe, - 0x43, 0xe2, 0x36, 0x2b, 0x1d, 0xa3, 0xf7, 0x92, 0x53, 0x88, 0x76, 0xff, 0xa8, 0x41, 0x23, 0x6f, - 0xab, 0x9b, 0xf9, 0xd1, 0x80, 0xcd, 0x48, 0xb8, 0xa7, 0x87, 0xc7, 0x3e, 0x0d, 0x7d, 0xea, 0x1d, - 0xaa, 0x97, 0xd7, 0x34, 0x3a, 0x95, 0xde, 0xea, 0xa0, 0x57, 0xd6, 0xda, 0xa7, 0x07, 0x77, 0x3e, - 0xbf, 0xaf, 0x32, 0xde, 0x4f, 0x12, 0xf6, 0xfb, 0x49, 0x93, 0x67, 0x4f, 0xdb, 0x1b, 0xc5, 0x13, - 0xf1, 0xe8, 0xd9, 0x25, 0x41, 0x67, 0x23, 0x31, 0xcd, 0x85, 0xd0, 0x6f, 0x06, 0x58, 0x47, 0x49, - 0xaf, 0x63, 0xff, 0x24, 0xf2, 0x5d, 0x3f, 0x8c, 0x0f, 0x03, 0xce, 0x26, 0xbe, 0x4b, 0x78, 0x4a, - 0xb5, 0x2c, 0xa9, 0x06, 0x65, 0x54, 0x1f, 0x62, 0xee, 0x7e, 0x94, 0x26, 0x3f, 0xd0, 0xb9, 0x8a, - 0x6f, 0x3b, 0xe1, 0x7b, 0xf4, 0xac, 0xdd, 0x2a, 0xd7, 0x08, 0xa7, 0x75, 0x54, 0x7e, 0x88, 0xbe, - 0x82, 0xeb, 0x2e, 0x19, 0x13, 0x0f, 0x87, 0x2c, 0xe3, 0xa9, 0x48, 0x9e, 0x9d, 0x32, 0x9e, 0x3b, - 0xa9, 0x5e, 0x31, 0xdc, 0xd0, 0x0c, 0xeb, 0xf9, 0xb8, 0x70, 0xd6, 0xdd, 0x7c, 0x00, 0x7d, 0x06, - 0xab, 0x62, 0x8a, 0x83, 0xd4, 0xa6, 0x2a, 0x6d, 0x6e, 0x96, 0xd9, 0x1c, 0x4c, 0x71, 0xa0, 0x1c, - 0x90, 0x76, 0x80, 0x2c, 0x24, 0x1c, 0x10, 0xd9, 0x33, 0x1a, 0xc2, 0x35, 0x81, 0x27, 0x3e, 0xf5, - 0x44, 0x5a, 0xba, 0x26, 0x4b, 0xbf, 0x51, 0x5a, 0x5a, 0xa9, 0x55, 0xf5, 0x57, 0x74, 0xf5, 0xb5, - 0xd9, 0xa8, 0x70, 0xd6, 0xc4, 0xec, 0xcf, 0x84, 0x9d, 0x60, 0x4e, 0x53, 0x83, 0xfa, 0x7c, 0xf6, - 0xbb, 0x98, 0xd3, 0x02, 0x7b, 0x16, 0x12, 0x0e, 0x90, 0xec, 0xb9, 0xdb, 0x82, 0x57, 0x67, 0x26, - 0xf8, 0x03, 0x3c, 0x0a, 0x19, 0xcf, 0x56, 0xf5, 0x87, 0x15, 0x30, 0x2f, 0x3b, 0xd5, 0x53, 0x1e, - 0x43, 0x2b, 0x37, 0xe4, 0x7a, 0xa9, 0xbe, 0x54, 0x32, 0x3d, 0xec, 0xdb, 0x65, 0x8c, 0xaa, 0xe6, - 0x3d, 0xea, 0x92, 0xd3, 0x8b, 0x77, 0x30, 0x13, 0x24, 0xc2, 0x69, 0xce, 0x8c, 0x73, 0x0e, 0x01, - 0x7d, 0x67, 0x80, 0x29, 0xa7, 0x5a, 0x44, 0x41, 0x30, 0x8e, 0x8b, 0xd6, 0xcb, 0xf3, 0xf7, 0xec, - 0x7e, 0x34, 0x0e, 0xfd, 0x59, 0x7f, 0x53, 0xfb, 0xa3, 0xe2, 0x09, 0x11, 0xce, 0x8d, 0xc4, 0xe7, - 0x40, 0xda, 0x94, 0x30, 0x0c, 0x19, 0xe7, 0x6c, 0x5a, 0x64, 0xa8, 0x2c, 0x9a, 0x61, 0x5f, 0xda, - 0xe4, 0x19, 0xbe, 0x85, 0xe6, 0xc5, 0xfa, 0x14, 0x00, 0xaa, 0x0b, 0x04, 0xd8, 0xca, 0x5c, 0xf2, - 0xfe, 0x21, 0x6c, 0xca, 0x95, 0x2a, 0x58, 0xd7, 0x16, 0x68, 0xbd, 0x91, 0x18, 0xe4, 0x5d, 0x1f, - 0xc2, 0x56, 0xba, 0x70, 0x05, 0xe3, 0xfa, 0x02, 0x8d, 0x1b, 0xda, 0xe3, 0xb9, 0x8e, 0xe5, 0x22, - 0x16, 0x8c, 0x57, 0x16, 0xd9, 0x71, 0x62, 0x90, 0x73, 0xed, 0x6e, 0xc0, 0xba, 0x5c, 0xc4, 0xbd, - 0x20, 0x4e, 0x97, 0xf3, 0x1e, 0x5c, 0xbf, 0x08, 0xe9, 0x8d, 0x7c, 0x17, 0xaa, 0x49, 0xae, 0x5e, - 0xbd, 0x56, 0x19, 0xcd, 0x5e, 0x10, 0xeb, 0xfb, 0x53, 0xca, 0x07, 0x7f, 0x56, 0xa1, 0x26, 0x6b, - 0xa1, 0x9f, 0x0c, 0xa8, 0xab, 0x0b, 0x16, 0xbd, 0x59, 0x96, 0xfd, 0xfc, 0x9d, 0x6e, 0xde, 0xbe, - 0x92, 0x56, 0x41, 0x76, 0x77, 0xbe, 0xff, 0xeb, 0xdf, 0x5f, 0x97, 0x3b, 0xc8, 0xb2, 0xe7, 0x7e, - 0x44, 0xa0, 0x9f, 0x0d, 0x58, 0xd1, 0x17, 0x2b, 0x9a, 0x6f, 0x90, 0xbf, 0xf5, 0xcd, 0xb7, 0xae, - 0x26, 0xd6, 0x38, 0xb7, 0x24, 0xce, 0x4d, 0xd4, 0x2e, 0xc3, 0xe1, 0x9a, 0xe1, 0x77, 0x03, 0xd6, - 0xf2, 0xb3, 0xb0, 0x7b, 0x05, 0xa3, 0xfc, 0x5f, 0xaa, 0x39, 0xf8, 0x3f, 0x29, 0x9a, 0xb0, 0x2f, - 0x09, 0x7b, 0x68, 0x67, 0x3e, 0x61, 0x3a, 0x8b, 0xe8, 0x1b, 0xa8, 0xec, 0x05, 0x31, 0xba, 0x35, - 0xd7, 0xea, 0x62, 0x92, 0xcc, 0xde, 0x8b, 0x85, 0x9a, 0x64, 0x5b, 0x92, 0xbc, 0x8e, 0x5a, 0x76, - 0xf9, 0x67, 0xe4, 0xfe, 0xdd, 0xc7, 0x67, 0x96, 0xf1, 0xe4, 0xcc, 0x32, 0xfe, 0x39, 0xb3, 0x8c, - 0x5f, 0xce, 0xad, 0xa5, 0x27, 0xe7, 0xd6, 0xd2, 0xdf, 0xe7, 0xd6, 0xd2, 0x17, 0xb7, 0x3d, 0x3f, - 0x3c, 0x8a, 0x86, 0xfd, 0x11, 0x3b, 0x96, 0x05, 0xde, 0x1e, 0xe3, 0xa1, 0x50, 0xa5, 0x4e, 0x67, - 0x8a, 0x25, 0x5f, 0x65, 0x62, 0x58, 0x97, 0x1f, 0x91, 0xef, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, - 0x8e, 0xce, 0x8c, 0x23, 0x22, 0x0b, 0x00, 0x00, + 0xea, 0x46, 0xb0, 0xc4, 0xdb, 0x20, 0x6e, 0x5c, 0x5a, 0x96, 0x15, 0x2b, 0xb1, 0xd2, 0xe2, 0x02, + 0x42, 0x5c, 0xaa, 0x49, 0x3c, 0x38, 0x86, 0x74, 0xc6, 0x9d, 0x71, 0x92, 0x7a, 0x25, 0x90, 0xe0, + 0x02, 0x1c, 0x90, 0x90, 0xb8, 0x72, 0xe6, 0xb0, 0x7f, 0x05, 0xc7, 0x95, 0xb8, 0xac, 0xc4, 0x85, + 0xd3, 0x2e, 0x6a, 0xf9, 0x43, 0x90, 0x67, 0xc6, 0x6e, 0xec, 0xad, 0xd3, 0x22, 0xe5, 0xe6, 0xbc, + 0xf9, 0xbe, 0xf7, 0xfd, 0x3c, 0xeb, 0xbd, 0x8c, 0xa1, 0xfd, 0x35, 0x9e, 0x60, 0xdb, 0xa7, 0x03, + 0x42, 0x43, 0x7f, 0x42, 0xec, 0xc9, 0x6e, 0x9f, 0x84, 0x78, 0xd7, 0x3e, 0x1e, 0x13, 0x1e, 0x75, + 0x03, 0xce, 0x42, 0x86, 0xb6, 0x62, 0x4d, 0x37, 0xd5, 0x74, 0xb5, 0xc6, 0xac, 0x79, 0xcc, 0x63, + 0x52, 0x62, 0xc7, 0x4f, 0x4a, 0x6d, 0xbe, 0xe6, 0x31, 0xe6, 0x8d, 0x88, 0x8d, 0x03, 0xdf, 0xc6, + 0x94, 0xb2, 0x10, 0x87, 0x3e, 0xa3, 0x42, 0x9f, 0xb6, 0x0a, 0xfc, 0x70, 0xa0, 0xdd, 0xcc, 0xed, + 0x02, 0xc5, 0x60, 0x84, 0xfd, 0x23, 0x71, 0x89, 0x28, 0xc0, 0x1c, 0x27, 0xa2, 0x76, 0x0d, 0xd0, + 0xc7, 0x71, 0x1b, 0x0f, 0x65, 0xd0, 0x21, 0xc7, 0x63, 0x22, 0xc2, 0xf6, 0x01, 0x6c, 0x66, 0xa2, + 0x22, 0x60, 0x54, 0x10, 0xf4, 0x1e, 0x54, 0x55, 0x72, 0xdd, 0x68, 0x19, 0x9d, 0xd5, 0x9e, 0xd5, + 0xbd, 0xb8, 0xeb, 0xae, 0xca, 0xdb, 0x2f, 0x3f, 0x79, 0xd6, 0x5c, 0x72, 0x74, 0x4e, 0x3b, 0xd4, + 0x45, 0x1d, 0x32, 0xc5, 0xdc, 0x4d, 0xbc, 0x50, 0x0d, 0x2a, 0x6c, 0x4a, 0x09, 0x97, 0x35, 0x5f, + 0x76, 0xd4, 0x0f, 0xd4, 0x84, 0x55, 0x2e, 0x75, 0x87, 0x61, 0x14, 0x90, 0xfa, 0xb2, 0x3c, 0x03, + 0x15, 0xfa, 0x24, 0x0a, 0x08, 0xda, 0x81, 0x6b, 0x63, 0x2a, 0x22, 0x3a, 0x18, 0x72, 0x46, 0xfd, + 0x47, 0xc4, 0xad, 0x97, 0x5a, 0x46, 0xe7, 0x25, 0x27, 0x17, 0x6d, 0xff, 0x51, 0x81, 0x5a, 0xd6, + 0x56, 0x37, 0xf3, 0xa3, 0x01, 0x9b, 0x63, 0xe1, 0x9e, 0x1c, 0x1e, 0xf9, 0x34, 0xf4, 0xa9, 0x77, + 0xa8, 0x5e, 0x5e, 0xdd, 0x68, 0x95, 0x3a, 0xab, 0xbd, 0x4e, 0x51, 0x6b, 0x9f, 0x1e, 0xdc, 0xfd, + 0xfc, 0x81, 0xca, 0x78, 0x3f, 0x4e, 0xd8, 0xef, 0xc6, 0x4d, 0x9e, 0x3e, 0x6b, 0x6e, 0xe4, 0x4f, + 0xc4, 0xe3, 0xe7, 0x17, 0x04, 0x9d, 0x8d, 0xd8, 0x34, 0x13, 0x42, 0xbf, 0x19, 0x60, 0x0d, 0xe3, + 0x5e, 0x47, 0xfe, 0xf1, 0xd8, 0x77, 0xfd, 0x30, 0x3a, 0x0c, 0x38, 0x9b, 0xf8, 0x2e, 0xe1, 0x09, + 0xd5, 0xb2, 0xa4, 0xea, 0x15, 0x51, 0x7d, 0x88, 0xb9, 0xfb, 0x51, 0x92, 0xfc, 0x50, 0xe7, 0x2a, + 0xbe, 0xed, 0x98, 0xef, 0xf1, 0xf3, 0x66, 0xa3, 0x58, 0x23, 0x9c, 0xc6, 0xb0, 0xf8, 0x10, 0x7d, + 0x05, 0xd7, 0x5d, 0x32, 0x22, 0x1e, 0x0e, 0x59, 0xca, 0x53, 0x92, 0x3c, 0x3b, 0x45, 0x3c, 0x77, + 0x13, 0xbd, 0x62, 0xb8, 0xa1, 0x19, 0xd6, 0xb3, 0x71, 0xe1, 0xac, 0xbb, 0xd9, 0x00, 0xfa, 0x0c, + 0x56, 0xc5, 0x14, 0x07, 0x89, 0x4d, 0x59, 0xda, 0xdc, 0x2c, 0xb2, 0x39, 0x98, 0xe2, 0x40, 0x39, + 0x20, 0xed, 0x00, 0x69, 0x48, 0x38, 0x20, 0xd2, 0x67, 0xd4, 0x87, 0x6b, 0x02, 0x4f, 0x7c, 0xea, + 0x89, 0xa4, 0x74, 0x45, 0x96, 0x7e, 0xa3, 0xb0, 0xb4, 0x52, 0xab, 0xea, 0xaf, 0xe8, 0xea, 0x6b, + 0xb3, 0x51, 0xe1, 0xac, 0x89, 0xd9, 0x9f, 0x31, 0x3b, 0xc1, 0x9c, 0x26, 0x06, 0xd5, 0xf9, 0xec, + 0x1f, 0x60, 0x4e, 0x73, 0xec, 0x69, 0x48, 0x38, 0x40, 0xd2, 0xe7, 0x76, 0x03, 0x5e, 0x9d, 0x99, + 0xe0, 0x7b, 0x78, 0x10, 0x32, 0x9e, 0xae, 0xea, 0x0f, 0x2b, 0x60, 0x5e, 0x74, 0xaa, 0xa7, 0x3c, + 0x82, 0x46, 0x66, 0xc8, 0xf5, 0x52, 0x7d, 0xa9, 0x64, 0x7a, 0xd8, 0xb7, 0x8b, 0x18, 0x55, 0xcd, + 0xfb, 0xd4, 0x25, 0x27, 0xe7, 0xef, 0x60, 0x26, 0x48, 0x84, 0x53, 0x9f, 0x19, 0xe7, 0x0c, 0x02, + 0xfa, 0xce, 0x00, 0x53, 0x4e, 0xb5, 0x18, 0x07, 0xc1, 0x28, 0xca, 0x5b, 0x2f, 0xcf, 0xdf, 0xb3, + 0x07, 0xe3, 0x51, 0xe8, 0xcf, 0xfa, 0x9b, 0xda, 0x1f, 0xe5, 0x4f, 0x88, 0x70, 0x6e, 0xc4, 0x3e, + 0x07, 0xd2, 0xa6, 0x80, 0xa1, 0xcf, 0x38, 0x67, 0xd3, 0x3c, 0x43, 0x69, 0xd1, 0x0c, 0xfb, 0xd2, + 0x26, 0xcb, 0xf0, 0x2d, 0xd4, 0xcf, 0xd7, 0x27, 0x07, 0x50, 0x5e, 0x20, 0xc0, 0x56, 0xea, 0x92, + 0xf5, 0x0f, 0x61, 0x53, 0xae, 0x54, 0xce, 0xba, 0xb2, 0x40, 0xeb, 0x8d, 0xd8, 0x20, 0xeb, 0xfa, + 0x08, 0xb6, 0x92, 0x85, 0xcb, 0x19, 0x57, 0x17, 0x68, 0x5c, 0xd3, 0x1e, 0x2f, 0x74, 0x2c, 0x17, + 0x31, 0x67, 0xbc, 0xb2, 0xc8, 0x8e, 0x63, 0x83, 0x8c, 0x6b, 0x7b, 0x03, 0xd6, 0xe5, 0x22, 0xee, + 0x05, 0x51, 0xb2, 0x9c, 0xf7, 0xe1, 0xfa, 0x79, 0x48, 0x6f, 0xe4, 0xbb, 0x50, 0x8e, 0x73, 0xf5, + 0xea, 0x35, 0x8a, 0x68, 0xf6, 0x82, 0x48, 0xdf, 0x9f, 0x52, 0xde, 0xfb, 0xb3, 0x0c, 0x15, 0x59, + 0x0b, 0xfd, 0x64, 0x40, 0x55, 0x5d, 0xb0, 0xe8, 0xcd, 0xa2, 0xec, 0x17, 0xef, 0x74, 0xf3, 0xad, + 0x2b, 0x69, 0x15, 0x64, 0x7b, 0xe7, 0xfb, 0xbf, 0xfe, 0xfd, 0x75, 0xb9, 0x85, 0x2c, 0x7b, 0xee, + 0x47, 0x04, 0xfa, 0xd9, 0x80, 0x15, 0x7d, 0xb1, 0xa2, 0xf9, 0x06, 0xd9, 0x5b, 0xdf, 0xbc, 0x7d, + 0x35, 0xb1, 0xc6, 0xb9, 0x25, 0x71, 0x6e, 0xa2, 0x66, 0x11, 0x0e, 0xd7, 0x0c, 0xbf, 0x1b, 0xb0, + 0x96, 0x9d, 0x85, 0xdd, 0x2b, 0x18, 0x65, 0xff, 0x52, 0xcd, 0xde, 0xff, 0x49, 0xd1, 0x84, 0x5d, + 0x49, 0xd8, 0x41, 0x3b, 0xf3, 0x09, 0x93, 0x59, 0x44, 0xdf, 0x40, 0x69, 0x2f, 0x88, 0xd0, 0xad, + 0xb9, 0x56, 0xe7, 0x93, 0x64, 0x76, 0x2e, 0x17, 0x6a, 0x92, 0x6d, 0x49, 0xf2, 0x3a, 0x6a, 0xd8, + 0xc5, 0x9f, 0x91, 0xfb, 0xf7, 0x9e, 0x9c, 0x5a, 0xc6, 0xd3, 0x53, 0xcb, 0xf8, 0xe7, 0xd4, 0x32, + 0x7e, 0x39, 0xb3, 0x96, 0x9e, 0x9e, 0x59, 0x4b, 0x7f, 0x9f, 0x59, 0x4b, 0x5f, 0xdc, 0xf6, 0xfc, + 0x70, 0x38, 0xee, 0x77, 0x07, 0xec, 0xc8, 0xbe, 0xe3, 0x8d, 0x70, 0x5f, 0xd8, 0x77, 0xbc, 0xb7, + 0x07, 0x43, 0xec, 0x53, 0xfb, 0x64, 0xa6, 0x5a, 0xfc, 0x59, 0x26, 0xfa, 0x55, 0xf9, 0x15, 0xf9, + 0xce, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x17, 0x9d, 0xa6, 0x72, 0x23, 0x0b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/incentive/types/tx.pb.go b/x/incentive/types/tx.pb.go index 30dd8bec..70a98731 100644 --- a/x/incentive/types/tx.pb.go +++ b/x/incentive/types/tx.pb.go @@ -543,40 +543,41 @@ func init() { func init() { proto.RegisterFile("kava/incentive/v1beta1/tx.proto", fileDescriptor_b1cec058e3ff75d5) } var fileDescriptor_b1cec058e3ff75d5 = []byte{ - // 525 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x95, 0x31, 0x6f, 0xd3, 0x40, - 0x14, 0xc7, 0x7d, 0xad, 0x5a, 0xd1, 0x87, 0x20, 0xd2, 0x29, 0x84, 0x60, 0x81, 0xdd, 0x84, 0x81, - 0x0a, 0x54, 0x5b, 0x09, 0x42, 0x08, 0xc6, 0xd2, 0x4a, 0x2c, 0x61, 0x48, 0x8a, 0x84, 0x90, 0x50, - 0x74, 0x49, 0x0e, 0x73, 0xc2, 0xbe, 0x33, 0xbe, 0x6b, 0x5a, 0x98, 0x98, 0x10, 0x23, 0x0b, 0x12, - 0x62, 0xea, 0xcc, 0x27, 0xe9, 0xd8, 0x91, 0x09, 0x50, 0x22, 0x21, 0x3e, 0x06, 0x8a, 0x93, 0xd8, - 0x56, 0x6d, 0x63, 0xd2, 0x29, 0x9b, 0xed, 0xf7, 0x7f, 0xef, 0xfd, 0xfe, 0x4f, 0x7e, 0x77, 0x60, - 0xbe, 0x26, 0x43, 0x62, 0x33, 0xde, 0xa7, 0x5c, 0xb1, 0x21, 0xb5, 0x87, 0x8d, 0x1e, 0x55, 0xa4, - 0x61, 0xab, 0x23, 0xcb, 0x0f, 0x84, 0x12, 0xb8, 0x32, 0x11, 0x58, 0x91, 0xc0, 0x9a, 0x09, 0xf4, - 0xb2, 0x23, 0x1c, 0x11, 0x4a, 0xec, 0xc9, 0xd3, 0x54, 0x5d, 0xdf, 0x87, 0x8d, 0x0e, 0x75, 0x69, - 0x5f, 0x31, 0xc1, 0x71, 0x19, 0xd6, 0x06, 0x94, 0x0b, 0xaf, 0x8a, 0x36, 0xd1, 0xd6, 0x46, 0x7b, - 0xfa, 0x82, 0x6f, 0x41, 0xc9, 0x3b, 0x70, 0x15, 0xf3, 0x5d, 0x46, 0x83, 0x2e, 0x27, 0x1e, 0xad, - 0xae, 0x84, 0xf1, 0xcb, 0xf1, 0xe7, 0x27, 0xc4, 0xa3, 0x0f, 0x2f, 0x7c, 0x3c, 0x36, 0xb5, 0x3f, - 0xc7, 0xa6, 0x56, 0x7f, 0x09, 0xd7, 0x5a, 0xd2, 0x79, 0xe4, 0x12, 0xe6, 0x3d, 0xed, 0xec, 0x3e, - 0x6b, 0x31, 0xae, 0x18, 0x77, 0xda, 0xf4, 0x90, 0x04, 0x03, 0x5c, 0x81, 0x75, 0x49, 0xf9, 0x80, - 0x06, 0xb3, 0x36, 0xb3, 0xb7, 0xf3, 0xf4, 0xb9, 0x09, 0xb5, 0xdc, 0x3e, 0x6d, 0x2a, 0x7d, 0xc1, - 0x25, 0xad, 0x7f, 0x46, 0x80, 0xe7, 0xaa, 0xc7, 0x61, 0xe0, 0x9f, 0x18, 0x2f, 0xa0, 0x14, 0xfa, - 0x96, 0x5d, 0x25, 0xba, 0xfd, 0x49, 0x52, 0x75, 0x65, 0x73, 0x75, 0xeb, 0x62, 0xb3, 0x66, 0x65, - 0x4f, 0xd6, 0x8a, 0x06, 0xb8, 0x83, 0x4f, 0x7e, 0x98, 0xda, 0xb7, 0x9f, 0x26, 0x44, 0x9f, 0x64, - 0xfb, 0xd2, 0xb4, 0xda, 0xbe, 0x08, 0x01, 0x12, 0xf0, 0xd7, 0x41, 0x4f, 0x63, 0x45, 0xd4, 0x5f, - 0x11, 0x5c, 0x9d, 0x87, 0x77, 0xa9, 0x4b, 0x1d, 0xa2, 0x44, 0xb0, 0x2c, 0xe8, 0x35, 0x30, 0x73, - 0xd8, 0x32, 0xa7, 0xde, 0x39, 0x24, 0xfe, 0x12, 0x4e, 0x3d, 0xc6, 0x8a, 0xa8, 0xbf, 0x20, 0xb8, - 0x12, 0x85, 0xc9, 0x90, 0x71, 0x47, 0x2e, 0x0b, 0xb8, 0x09, 0x37, 0x32, 0xc9, 0x32, 0x27, 0xbe, - 0x47, 0x02, 0xbe, 0x84, 0x13, 0x8f, 0xb1, 0xe6, 0xd4, 0xcd, 0xdf, 0x6b, 0xb0, 0xda, 0x92, 0x0e, - 0xfe, 0x80, 0xa0, 0x92, 0x73, 0x60, 0x34, 0xf2, 0x80, 0x72, 0x77, 0x5f, 0x7f, 0xb0, 0x70, 0xca, - 0x1c, 0x08, 0xbf, 0x81, 0xd2, 0xd9, 0xa3, 0xe2, 0x76, 0x51, 0xb5, 0x58, 0xab, 0x37, 0xff, 0x5f, - 0x1b, 0xb5, 0x7c, 0x8f, 0xa0, 0x9c, 0xb9, 0xe8, 0x76, 0x51, 0xb1, 0x33, 0x09, 0xfa, 0xfd, 0x05, - 0x13, 0x52, 0xae, 0x13, 0xab, 0x5a, 0xe8, 0x3a, 0xd6, 0x16, 0xbb, 0x4e, 0xef, 0x1a, 0x7e, 0x07, - 0x38, 0x63, 0xcf, 0xb6, 0x0b, 0x2b, 0x25, 0xe5, 0xfa, 0xbd, 0x85, 0xe4, 0x29, 0xbb, 0x89, 0x3d, - 0x29, 0xb4, 0x1b, 0x6b, 0x8b, 0xed, 0xa6, 0x7f, 0xf4, 0x9d, 0xbd, 0x93, 0x91, 0x81, 0x4e, 0x47, - 0x06, 0xfa, 0x35, 0x32, 0xd0, 0xa7, 0xb1, 0xa1, 0x9d, 0x8e, 0x0d, 0xed, 0xfb, 0xd8, 0xd0, 0x9e, - 0xdf, 0x71, 0x98, 0x7a, 0x75, 0xd0, 0xb3, 0xfa, 0xc2, 0xb3, 0x27, 0x75, 0xb7, 0x5d, 0xd2, 0x93, - 0xe1, 0x93, 0x7d, 0x94, 0xb8, 0xe9, 0xd5, 0x5b, 0x9f, 0xca, 0xde, 0x7a, 0x78, 0x6f, 0xdf, 0xfd, - 0x1b, 0x00, 0x00, 0xff, 0xff, 0x28, 0x8b, 0x70, 0xee, 0x08, 0x08, 0x00, 0x00, + // 530 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x95, 0x41, 0x6b, 0x13, 0x41, + 0x14, 0xc7, 0x77, 0x5a, 0x5a, 0xec, 0x13, 0x2d, 0x0c, 0x31, 0xc6, 0x45, 0x77, 0x9b, 0x78, 0xb0, + 0x88, 0xdd, 0x6d, 0x22, 0x22, 0x7a, 0xac, 0x55, 0xbc, 0xc4, 0x43, 0x52, 0x41, 0x04, 0x09, 0x93, + 0x64, 0x9c, 0x0e, 0xee, 0xce, 0xc4, 0x9d, 0x69, 0x5a, 0x3d, 0x79, 0x12, 0x8f, 0x5e, 0x04, 0xf1, + 0xd4, 0xb3, 0x9f, 0xa4, 0xc7, 0x1e, 0x3d, 0xa9, 0x24, 0x20, 0x7e, 0x0c, 0xc9, 0x26, 0xd9, 0x0d, + 0xdd, 0x5d, 0xd7, 0x78, 0xca, 0x2d, 0x3b, 0xef, 0xff, 0xde, 0xfb, 0xfd, 0x1f, 0x79, 0x33, 0x60, + 0xbf, 0x22, 0x7d, 0xe2, 0x72, 0xd1, 0xa1, 0x42, 0xf3, 0x3e, 0x75, 0xfb, 0xd5, 0x36, 0xd5, 0xa4, + 0xea, 0xea, 0x23, 0xa7, 0x17, 0x48, 0x2d, 0x71, 0x71, 0x24, 0x70, 0x22, 0x81, 0x33, 0x11, 0x98, + 0x05, 0x26, 0x99, 0x0c, 0x25, 0xee, 0xe8, 0xd7, 0x58, 0x5d, 0xd9, 0x83, 0xb5, 0x26, 0xf5, 0x68, + 0x47, 0x73, 0x29, 0x70, 0x01, 0x56, 0xba, 0x54, 0x48, 0xbf, 0x84, 0x36, 0xd0, 0xe6, 0x5a, 0x63, + 0xfc, 0x81, 0x6f, 0xc0, 0xba, 0x7f, 0xe0, 0x69, 0xde, 0xf3, 0x38, 0x0d, 0x5a, 0x82, 0xf8, 0xb4, + 0xb4, 0x14, 0xc6, 0x2f, 0xc6, 0xc7, 0x4f, 0x88, 0x4f, 0xef, 0x9f, 0xfb, 0x70, 0x6c, 0x1b, 0xbf, + 0x8f, 0x6d, 0xa3, 0xf2, 0x12, 0xae, 0xd4, 0x15, 0x7b, 0xe0, 0x11, 0xee, 0x3f, 0x6d, 0xee, 0x3e, + 0xab, 0x73, 0xa1, 0xb9, 0x60, 0x0d, 0x7a, 0x48, 0x82, 0x2e, 0x2e, 0xc2, 0xaa, 0xa2, 0xa2, 0x4b, + 0x83, 0x49, 0x9b, 0xc9, 0xd7, 0xff, 0xf4, 0xb9, 0x0e, 0xe5, 0xcc, 0x3e, 0x0d, 0xaa, 0x7a, 0x52, + 0x28, 0x5a, 0xf9, 0x84, 0x00, 0x4f, 0x55, 0x8f, 0xc3, 0xc0, 0x5f, 0x31, 0x5e, 0xc0, 0x7a, 0xe8, + 0x5b, 0xb5, 0xb4, 0x6c, 0x75, 0x46, 0x49, 0xa5, 0xa5, 0x8d, 0xe5, 0xcd, 0xf3, 0xb5, 0xb2, 0x93, + 0x3e, 0x59, 0x27, 0x1a, 0xe0, 0x0e, 0x3e, 0xf9, 0x6e, 0x1b, 0x5f, 0x7f, 0xd8, 0x10, 0x1d, 0xa9, + 0xc6, 0x85, 0x71, 0xb5, 0x3d, 0x19, 0x02, 0xcc, 0xc0, 0x5f, 0x05, 0x33, 0x89, 0x15, 0x51, 0x7f, + 0x41, 0x70, 0x79, 0x1a, 0xde, 0xa5, 0x1e, 0x65, 0x44, 0xcb, 0x60, 0x51, 0xd0, 0xcb, 0x60, 0x67, + 0xb0, 0xa5, 0x4e, 0xbd, 0x79, 0x48, 0x7a, 0x0b, 0x38, 0xf5, 0x18, 0x2b, 0xa2, 0xfe, 0x8c, 0xe0, + 0x52, 0x14, 0x26, 0x7d, 0x2e, 0x98, 0x5a, 0x14, 0x70, 0x1b, 0xae, 0xa5, 0x92, 0xa5, 0x4e, 0xfc, + 0x21, 0x09, 0xc4, 0x02, 0x4e, 0x3c, 0xc6, 0x9a, 0x52, 0xd7, 0x7e, 0xad, 0xc0, 0x72, 0x5d, 0x31, + 0xfc, 0x1e, 0x41, 0x31, 0xe3, 0xc2, 0xa8, 0x66, 0x01, 0x65, 0xee, 0xbe, 0x79, 0x6f, 0xee, 0x94, + 0x29, 0x10, 0x7e, 0x0d, 0xeb, 0x67, 0xaf, 0x8a, 0x9b, 0x79, 0xd5, 0x62, 0xad, 0x59, 0xfb, 0x77, + 0x6d, 0xd4, 0xf2, 0x1d, 0x82, 0x42, 0xea, 0xa2, 0xbb, 0x79, 0xc5, 0xce, 0x24, 0x98, 0x77, 0xe7, + 0x4c, 0x48, 0xb8, 0x9e, 0x59, 0xd5, 0x5c, 0xd7, 0xb1, 0x36, 0xdf, 0x75, 0x72, 0xd7, 0xf0, 0x5b, + 0xc0, 0x29, 0x7b, 0xb6, 0x95, 0x5b, 0x69, 0x56, 0x6e, 0xde, 0x99, 0x4b, 0x9e, 0xb0, 0x3b, 0xb3, + 0x27, 0xb9, 0x76, 0x63, 0x6d, 0xbe, 0xdd, 0xe4, 0x1f, 0x7d, 0xe7, 0xd1, 0xc9, 0xc0, 0x42, 0xa7, + 0x03, 0x0b, 0xfd, 0x1c, 0x58, 0xe8, 0xe3, 0xd0, 0x32, 0x4e, 0x87, 0x96, 0xf1, 0x6d, 0x68, 0x19, + 0xcf, 0x6f, 0x31, 0xae, 0xf7, 0x0f, 0xda, 0x4e, 0x47, 0xfa, 0xee, 0x36, 0xf3, 0x48, 0x5b, 0xb9, + 0xdb, 0x6c, 0xab, 0xb3, 0x4f, 0xb8, 0x70, 0x8f, 0x66, 0x9e, 0x7a, 0xfd, 0xa6, 0x47, 0x55, 0x7b, + 0x35, 0x7c, 0xb8, 0x6f, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x8f, 0x67, 0xde, 0x4d, 0x09, 0x08, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/issuance/types/genesis.pb.go b/x/issuance/types/genesis.pb.go index 612b89c4..d496b725 100644 --- a/x/issuance/types/genesis.pb.go +++ b/x/issuance/types/genesis.pb.go @@ -331,44 +331,45 @@ func init() { } var fileDescriptor_e567e34e5c078b96 = []byte{ - // 590 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4f, 0x6f, 0xd3, 0x4e, - 0x10, 0x8d, 0x9b, 0x26, 0x4a, 0x36, 0xfd, 0xfd, 0x80, 0x55, 0x41, 0x6e, 0x55, 0x9c, 0x28, 0x48, - 0x28, 0x02, 0xba, 0x56, 0xcb, 0xad, 0x9c, 0x1a, 0x52, 0x10, 0x88, 0x43, 0xe5, 0x1e, 0x90, 0xb8, - 0x44, 0x6b, 0x7b, 0x30, 0xab, 0xda, 0x5e, 0xcb, 0xbb, 0x2e, 0xe4, 0x5b, 0xc0, 0xad, 0x47, 0x24, - 0xbe, 0x09, 0xa7, 0x1e, 0x7b, 0x44, 0x1c, 0x02, 0x4a, 0x6e, 0x7c, 0x0a, 0xb4, 0x7f, 0x92, 0xf4, - 0x40, 0x11, 0x27, 0xef, 0xcc, 0xbe, 0x37, 0x33, 0x6f, 0xfc, 0x16, 0xdd, 0x3b, 0xa5, 0x67, 0xd4, - 0x67, 0x42, 0x54, 0x34, 0x8f, 0xc0, 0x3f, 0xdb, 0x0b, 0x41, 0xd2, 0x3d, 0x3f, 0x81, 0x1c, 0x04, - 0x13, 0xa4, 0x28, 0xb9, 0xe4, 0xf8, 0xb6, 0x02, 0x91, 0x05, 0x88, 0x58, 0xd0, 0xb6, 0x17, 0x71, - 0x91, 0x71, 0xe1, 0x87, 0x54, 0xac, 0x98, 0x11, 0x67, 0xb9, 0xa1, 0x6d, 0x6f, 0x26, 0x3c, 0xe1, - 0xfa, 0xe8, 0xab, 0x93, 0xcd, 0x7a, 0x09, 0xe7, 0x49, 0x0a, 0xbe, 0x8e, 0xc2, 0xea, 0xad, 0x1f, - 0x57, 0x25, 0x95, 0x8c, 0x5b, 0x56, 0xff, 0x93, 0x83, 0x36, 0x9e, 0x9b, 0xf6, 0x27, 0x92, 0x4a, - 0xc0, 0x4f, 0x50, 0xb3, 0xa0, 0x25, 0xcd, 0x84, 0xeb, 0xf4, 0x9c, 0x41, 0x67, 0xff, 0x2e, 0xf9, - 0xe3, 0x38, 0xe4, 0x58, 0x83, 0x86, 0xeb, 0x17, 0xd3, 0x6e, 0x2d, 0xb0, 0x14, 0x3c, 0x42, 0x2d, - 0x51, 0x15, 0x45, 0xca, 0x40, 0xb8, 0x6b, 0xbd, 0xfa, 0xa0, 0xb3, 0xdf, 0xbf, 0x86, 0x7e, 0x28, - 0x04, 0xc8, 0x13, 0x85, 0x9d, 0xd8, 0x1a, 0x4b, 0x66, 0xff, 0x25, 0x6a, 0x9a, 0xea, 0xf8, 0x00, - 0x35, 0xa9, 0x02, 0xaa, 0x61, 0x54, 0xb5, 0x9d, 0xbf, 0x55, 0x5b, 0xcc, 0x62, 0x18, 0x07, 0xeb, - 0xe7, 0x9f, 0xbb, 0xb5, 0xfe, 0xdc, 0x41, 0x0d, 0x7d, 0x8b, 0x37, 0x51, 0x83, 0xbf, 0xcf, 0xa1, - 0xd4, 0xba, 0xda, 0x81, 0x09, 0x54, 0x36, 0x86, 0x9c, 0x67, 0xee, 0x9a, 0xc9, 0xea, 0x00, 0x3f, - 0x44, 0xb7, 0xc2, 0x94, 0x47, 0xa7, 0x10, 0x8f, 0x69, 0x1c, 0x97, 0x20, 0x04, 0x08, 0xb7, 0xde, - 0xab, 0x0f, 0xda, 0xc1, 0x4d, 0x7b, 0x71, 0xb8, 0xc8, 0xe3, 0x3b, 0x6a, 0x63, 0x95, 0x80, 0xd8, - 0x5d, 0xef, 0x39, 0x83, 0x56, 0x60, 0x23, 0xbc, 0x83, 0xda, 0x1a, 0x4b, 0xc3, 0x14, 0xdc, 0x86, - 0xbe, 0x5a, 0x25, 0xf0, 0x11, 0x42, 0x25, 0x95, 0x30, 0x4e, 0x59, 0xc6, 0xa4, 0xdb, 0xd4, 0xbb, - 0xee, 0x5d, 0x23, 0x2f, 0xa0, 0x12, 0x5e, 0x29, 0x9c, 0x95, 0xd8, 0x2e, 0x17, 0x09, 0xab, 0xf2, - 0xab, 0x83, 0xda, 0x4b, 0x90, 0x1a, 0x88, 0x46, 0x92, 0x9d, 0x81, 0x96, 0xda, 0x0a, 0x6c, 0x84, - 0x5f, 0xa3, 0x86, 0xe9, 0xa6, 0xb4, 0x6e, 0x0c, 0x0f, 0x55, 0xad, 0xef, 0xd3, 0xee, 0xfd, 0x84, - 0xc9, 0x77, 0x55, 0x48, 0x22, 0x9e, 0xf9, 0xd6, 0x63, 0xe6, 0xb3, 0x2b, 0xe2, 0x53, 0x5f, 0x4e, - 0x0a, 0x10, 0xe4, 0x45, 0x2e, 0x7f, 0x4d, 0xbb, 0x37, 0x34, 0xfd, 0x11, 0xcf, 0x98, 0x84, 0xac, - 0x90, 0x93, 0xc0, 0xd4, 0xc3, 0x23, 0xd4, 0x91, 0x2c, 0x83, 0x71, 0x01, 0x25, 0xe3, 0xb1, 0x5b, - 0xd7, 0x62, 0xb6, 0x88, 0xb1, 0x1e, 0x59, 0x58, 0x8f, 0x8c, 0xac, 0xf5, 0x86, 0x2d, 0xd5, 0xf9, - 0xfc, 0x47, 0xd7, 0x09, 0x90, 0xe2, 0x1d, 0x6b, 0x5a, 0xff, 0x8b, 0x83, 0x3a, 0x57, 0x6c, 0x81, - 0x9f, 0xa1, 0xff, 0xa3, 0xaa, 0x2c, 0x21, 0x97, 0x63, 0x6d, 0x8d, 0x89, 0x75, 0xe4, 0x16, 0x31, - 0xe3, 0x11, 0xf5, 0x12, 0x96, 0x3b, 0x7a, 0xca, 0x59, 0x6e, 0xd7, 0xf3, 0x9f, 0xa5, 0x2d, 0xeb, - 0x6c, 0xe8, 0xe9, 0x20, 0xa5, 0x85, 0xfa, 0x4b, 0x6b, 0xff, 0x3e, 0x9e, 0x96, 0x75, 0x64, 0x78, - 0x66, 0xd5, 0xc3, 0xd1, 0xc5, 0xcc, 0x73, 0x2e, 0x67, 0x9e, 0xf3, 0x73, 0xe6, 0x39, 0x1f, 0xe7, - 0x5e, 0xed, 0x72, 0xee, 0xd5, 0xbe, 0xcd, 0xbd, 0xda, 0x9b, 0x07, 0x57, 0xf6, 0xa8, 0xfe, 0xe3, - 0x6e, 0x4a, 0x43, 0xa1, 0x4f, 0xfe, 0x87, 0xd5, 0x9b, 0xd7, 0xfb, 0x0c, 0x9b, 0xba, 0xeb, 0xe3, - 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3f, 0xa6, 0xf1, 0xda, 0x11, 0x04, 0x00, 0x00, + // 593 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4d, 0x6f, 0xd3, 0x40, + 0x10, 0x8d, 0x9b, 0x26, 0x4a, 0x36, 0xe5, 0x6b, 0x55, 0x90, 0x5b, 0x15, 0x27, 0x0a, 0x12, 0x8a, + 0x54, 0xba, 0x6e, 0xcb, 0xad, 0x9c, 0x1a, 0x5a, 0x10, 0x88, 0x43, 0xe5, 0x1e, 0x90, 0xb8, 0x44, + 0x6b, 0x7b, 0x70, 0x57, 0xb5, 0xbd, 0x96, 0x77, 0x5d, 0xc8, 0xbf, 0x80, 0x5b, 0x8f, 0x48, 0xfc, + 0x13, 0x4e, 0x3d, 0xf6, 0x88, 0x38, 0x14, 0x94, 0xdc, 0xf8, 0x15, 0x68, 0x3f, 0x92, 0xf4, 0x40, + 0x11, 0x27, 0xef, 0xcc, 0xbe, 0x37, 0x33, 0x6f, 0xfc, 0x16, 0x3d, 0x3a, 0xa5, 0x67, 0xd4, 0x67, + 0x42, 0x54, 0x34, 0x8f, 0xc0, 0x3f, 0xdb, 0x09, 0x41, 0xd2, 0x1d, 0x3f, 0x81, 0x1c, 0x04, 0x13, + 0xa4, 0x28, 0xb9, 0xe4, 0xf8, 0xbe, 0x02, 0x91, 0x19, 0x88, 0x58, 0xd0, 0xba, 0x17, 0x71, 0x91, + 0x71, 0xe1, 0x87, 0x54, 0x2c, 0x98, 0x11, 0x67, 0xb9, 0xa1, 0xad, 0xaf, 0x26, 0x3c, 0xe1, 0xfa, + 0xe8, 0xab, 0x93, 0xcd, 0x7a, 0x09, 0xe7, 0x49, 0x0a, 0xbe, 0x8e, 0xc2, 0xea, 0xbd, 0x1f, 0x57, + 0x25, 0x95, 0x8c, 0x5b, 0x56, 0xff, 0xb3, 0x83, 0x56, 0x5e, 0x9a, 0xf6, 0xc7, 0x92, 0x4a, 0xc0, + 0xcf, 0x50, 0xb3, 0xa0, 0x25, 0xcd, 0x84, 0xeb, 0xf4, 0x9c, 0x41, 0x67, 0xf7, 0x21, 0xf9, 0xeb, + 0x38, 0xe4, 0x48, 0x83, 0x86, 0xcb, 0x17, 0x57, 0xdd, 0x5a, 0x60, 0x29, 0xf8, 0x00, 0xb5, 0x44, + 0x55, 0x14, 0x29, 0x03, 0xe1, 0x2e, 0xf5, 0xea, 0x83, 0xce, 0x6e, 0xff, 0x06, 0xfa, 0xbe, 0x10, + 0x20, 0x8f, 0x15, 0x76, 0x6c, 0x6b, 0xcc, 0x99, 0xfd, 0xd7, 0xa8, 0x69, 0xaa, 0xe3, 0x3d, 0xd4, + 0xa4, 0x0a, 0xa8, 0x86, 0x51, 0xd5, 0x36, 0xfe, 0x55, 0x6d, 0x36, 0x8b, 0x61, 0xec, 0x2d, 0x9f, + 0x7f, 0xe9, 0xd6, 0xfa, 0x53, 0x07, 0x35, 0xf4, 0x2d, 0x5e, 0x45, 0x0d, 0xfe, 0x21, 0x87, 0x52, + 0xeb, 0x6a, 0x07, 0x26, 0x50, 0xd9, 0x18, 0x72, 0x9e, 0xb9, 0x4b, 0x26, 0xab, 0x03, 0xbc, 0x89, + 0xee, 0x85, 0x29, 0x8f, 0x4e, 0x21, 0x1e, 0xd1, 0x38, 0x2e, 0x41, 0x08, 0x10, 0x6e, 0xbd, 0x57, + 0x1f, 0xb4, 0x83, 0xbb, 0xf6, 0x62, 0x7f, 0x96, 0xc7, 0x0f, 0xd4, 0xc6, 0x2a, 0x01, 0xb1, 0xbb, + 0xdc, 0x73, 0x06, 0xad, 0xc0, 0x46, 0x78, 0x03, 0xb5, 0x35, 0x96, 0x86, 0x29, 0xb8, 0x0d, 0x7d, + 0xb5, 0x48, 0xe0, 0x43, 0x84, 0x4a, 0x2a, 0x61, 0x94, 0xb2, 0x8c, 0x49, 0xb7, 0xa9, 0x77, 0xdd, + 0xbb, 0x41, 0x5e, 0x40, 0x25, 0xbc, 0x51, 0x38, 0x2b, 0xb1, 0x5d, 0xce, 0x12, 0x56, 0xe5, 0x37, + 0x07, 0xb5, 0xe7, 0x20, 0x35, 0x10, 0x8d, 0x24, 0x3b, 0x03, 0x2d, 0xb5, 0x15, 0xd8, 0x08, 0xbf, + 0x45, 0x0d, 0xd3, 0x4d, 0x69, 0x5d, 0x19, 0xee, 0xab, 0x5a, 0x3f, 0xae, 0xba, 0x8f, 0x13, 0x26, + 0x4f, 0xaa, 0x90, 0x44, 0x3c, 0xf3, 0xad, 0xc7, 0xcc, 0x67, 0x4b, 0xc4, 0xa7, 0xbe, 0x1c, 0x17, + 0x20, 0xc8, 0xab, 0x5c, 0xfe, 0xbe, 0xea, 0xde, 0xd1, 0xf4, 0x27, 0x3c, 0x63, 0x12, 0xb2, 0x42, + 0x8e, 0x03, 0x53, 0x0f, 0x1f, 0xa0, 0x8e, 0x64, 0x19, 0x8c, 0x0a, 0x28, 0x19, 0x8f, 0xdd, 0xba, + 0x16, 0xb3, 0x46, 0x8c, 0xf5, 0xc8, 0xcc, 0x7a, 0xe4, 0xc0, 0x5a, 0x6f, 0xd8, 0x52, 0x9d, 0xcf, + 0x7f, 0x76, 0x9d, 0x00, 0x29, 0xde, 0x91, 0xa6, 0xf5, 0xbf, 0x3a, 0xa8, 0x73, 0xcd, 0x16, 0xf8, + 0x05, 0xba, 0x1d, 0x55, 0x65, 0x09, 0xb9, 0x1c, 0x69, 0x6b, 0x8c, 0xad, 0x23, 0xd7, 0x88, 0x19, + 0x8f, 0xa8, 0x97, 0x30, 0xdf, 0xd1, 0x73, 0xce, 0x72, 0xbb, 0x9e, 0x5b, 0x96, 0x36, 0xaf, 0xb3, + 0xa2, 0xa7, 0x83, 0x94, 0x16, 0xea, 0x2f, 0x2d, 0xfd, 0xff, 0x78, 0x5a, 0xd6, 0xa1, 0xe1, 0x99, + 0x55, 0x0f, 0x0f, 0x2f, 0x26, 0x9e, 0x73, 0x39, 0xf1, 0x9c, 0x5f, 0x13, 0xcf, 0xf9, 0x34, 0xf5, + 0x6a, 0x97, 0x53, 0xaf, 0xf6, 0x7d, 0xea, 0xd5, 0xde, 0x6d, 0x5e, 0xdb, 0xe3, 0x76, 0x92, 0xd2, + 0x50, 0xf8, 0xdb, 0xc9, 0x56, 0x74, 0x42, 0x59, 0xee, 0x7f, 0x5c, 0x3c, 0x7a, 0xbd, 0xd0, 0xb0, + 0xa9, 0xdb, 0x3e, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0xe9, 0xcd, 0x02, 0x80, 0x12, 0x04, 0x00, + 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/issuance/types/query.pb.go b/x/issuance/types/query.pb.go index 3cefbb8b..976b87f4 100644 --- a/x/issuance/types/query.pb.go +++ b/x/issuance/types/query.pb.go @@ -119,25 +119,26 @@ func init() { func init() { proto.RegisterFile("kava/issuance/v1beta1/query.proto", fileDescriptor_88f8bf3fcbf02033) } var fileDescriptor_88f8bf3fcbf02033 = []byte{ - // 288 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xcc, 0x4e, 0x2c, 0x4b, - 0xd4, 0xcf, 0x2c, 0x2e, 0x2e, 0x4d, 0xcc, 0x4b, 0x4e, 0xd5, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, - 0x34, 0xd4, 0x2f, 0x2c, 0x4d, 0x2d, 0xaa, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x05, - 0x29, 0xd1, 0x83, 0x29, 0xd1, 0x83, 0x2a, 0x91, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0xab, 0xd0, - 0x07, 0xb1, 0x20, 0x8a, 0xa5, 0x64, 0xd2, 0xf3, 0xf3, 0xd3, 0x73, 0x52, 0xf5, 0x13, 0x0b, 0x32, - 0xf5, 0x13, 0xf3, 0xf2, 0xf2, 0x4b, 0x12, 0x4b, 0x32, 0xf3, 0xf3, 0x8a, 0xa1, 0xb2, 0xca, 0xd8, - 0x6d, 0x4b, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x84, 0x2a, 0x52, 0x12, 0xe1, 0x12, 0x0a, 0x04, 0x59, - 0x1f, 0x90, 0x58, 0x94, 0x98, 0x5b, 0x1c, 0x94, 0x5a, 0x58, 0x9a, 0x5a, 0x5c, 0xa2, 0x14, 0xc4, - 0x25, 0x8c, 0x22, 0x5a, 0x5c, 0x90, 0x9f, 0x57, 0x9c, 0x2a, 0x64, 0xcd, 0xc5, 0x56, 0x00, 0x16, - 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd5, 0xc3, 0xea, 0x5a, 0x3d, 0x88, 0x36, 0x27, - 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xa0, 0x5a, 0x8c, 0x26, 0x30, 0x72, 0xb1, 0x82, 0x0d, 0x15, - 0x6a, 0x63, 0xe4, 0x62, 0x83, 0x28, 0x11, 0xd2, 0xc4, 0x61, 0x02, 0xa6, 0x9b, 0xa4, 0xb4, 0x88, - 0x51, 0x0a, 0x71, 0xa8, 0x92, 0x6a, 0xd3, 0xe5, 0x27, 0x93, 0x99, 0xe4, 0x85, 0x64, 0xf5, 0xb1, - 0x87, 0x01, 0xc4, 0x49, 0x4e, 0x2e, 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, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0x0b, 0x36, 0x42, 0x37, 0x27, - 0x31, 0xa9, 0x18, 0x62, 0x58, 0x05, 0xc2, 0xb8, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0x70, - 0x48, 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x44, 0xff, 0xd6, 0x68, 0xde, 0x01, 0x00, 0x00, + // 294 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0xbf, 0x4b, 0x03, 0x31, + 0x14, 0xc7, 0x2f, 0xa2, 0x1d, 0xe2, 0x16, 0x2b, 0x48, 0xb1, 0xa9, 0x9e, 0x08, 0xfe, 0xc0, 0xa4, + 0xad, 0xa3, 0x5b, 0xc1, 0x5d, 0x6f, 0x74, 0x7b, 0x77, 0x84, 0x34, 0xd8, 0x26, 0xd7, 0x4b, 0xae, + 0xd8, 0xd5, 0xc1, 0xb9, 0xe0, 0x3f, 0xd5, 0xb1, 0xe0, 0xe2, 0x24, 0x72, 0xe7, 0x1f, 0x22, 0xf7, + 0x43, 0x44, 0x3c, 0xc1, 0x2d, 0xbc, 0x7c, 0xde, 0xf7, 0x7d, 0xf8, 0xe2, 0xc3, 0x7b, 0x98, 0x03, + 0x57, 0xd6, 0xa6, 0xa0, 0x23, 0xc1, 0xe7, 0x83, 0x50, 0x38, 0x18, 0xf0, 0x59, 0x2a, 0x92, 0x05, + 0x8b, 0x13, 0xe3, 0x0c, 0xd9, 0x2d, 0x10, 0xf6, 0x85, 0xb0, 0x1a, 0xe9, 0xb4, 0xa5, 0x91, 0xa6, + 0x24, 0x78, 0xf1, 0xaa, 0xe0, 0xce, 0xbe, 0x34, 0x46, 0x4e, 0x04, 0x87, 0x58, 0x71, 0xd0, 0xda, + 0x38, 0x70, 0xca, 0x68, 0x5b, 0xff, 0x1e, 0x35, 0x5f, 0x93, 0x42, 0x0b, 0xab, 0x6a, 0xc8, 0x6f, + 0x63, 0x72, 0x5b, 0x9c, 0xbf, 0x81, 0x04, 0xa6, 0x36, 0x10, 0xb3, 0x54, 0x58, 0xe7, 0x07, 0x78, + 0xe7, 0xc7, 0xd4, 0xc6, 0x46, 0x5b, 0x41, 0xae, 0x70, 0x2b, 0x2e, 0x27, 0x7b, 0xe8, 0x00, 0x9d, + 0x6c, 0x0f, 0xbb, 0xac, 0xd1, 0x96, 0x55, 0x6b, 0xa3, 0xcd, 0xd5, 0x5b, 0xcf, 0x0b, 0xea, 0x95, + 0xe1, 0x12, 0xe1, 0xad, 0x32, 0x94, 0x3c, 0x21, 0xdc, 0xaa, 0x10, 0x72, 0xfa, 0x47, 0xc2, 0x6f, + 0xa7, 0xce, 0xd9, 0x7f, 0xd0, 0x4a, 0xd4, 0x3f, 0x7e, 0x7c, 0xf9, 0x78, 0xde, 0xe8, 0x91, 0x2e, + 0x6f, 0xee, 0xa0, 0x52, 0x1a, 0x5d, 0xaf, 0x32, 0x8a, 0xd6, 0x19, 0x45, 0xef, 0x19, 0x45, 0xcb, + 0x9c, 0x7a, 0xeb, 0x9c, 0x7a, 0xaf, 0x39, 0xf5, 0xee, 0xce, 0xa5, 0x72, 0xe3, 0x34, 0x64, 0x91, + 0x99, 0xf2, 0xbe, 0x9c, 0x40, 0x68, 0x79, 0x5f, 0x5e, 0x44, 0x63, 0x50, 0x9a, 0x3f, 0x7c, 0xe7, + 0xb9, 0x45, 0x2c, 0x6c, 0xd8, 0x2a, 0xab, 0xbc, 0xfc, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x04, 0x42, + 0x67, 0x47, 0xdf, 0x01, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/issuance/types/tx.pb.go b/x/issuance/types/tx.pb.go index e0416cc9..a2c68728 100644 --- a/x/issuance/types/tx.pb.go +++ b/x/issuance/types/tx.pb.go @@ -429,38 +429,39 @@ func init() { func init() { proto.RegisterFile("kava/issuance/v1beta1/tx.proto", fileDescriptor_0cb7117b12e184a2) } var fileDescriptor_0cb7117b12e184a2 = []byte{ - // 496 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x94, 0xbf, 0x6e, 0xd3, 0x50, - 0x14, 0xc6, 0x6d, 0x5a, 0xa2, 0xf4, 0x14, 0xa5, 0xc2, 0x2a, 0x25, 0x31, 0x92, 0x53, 0x45, 0x02, - 0x22, 0xa4, 0x5e, 0xd3, 0x32, 0x20, 0xb1, 0x11, 0x58, 0x18, 0x22, 0x21, 0x17, 0x16, 0x16, 0x74, - 0x6d, 0x1f, 0x8c, 0x95, 0xc4, 0x37, 0xf2, 0xb9, 0x8e, 0xca, 0x13, 0xc0, 0xc8, 0xc4, 0xdc, 0xc7, - 0xe9, 0xd8, 0x91, 0x09, 0xa1, 0x64, 0xe1, 0x31, 0x90, 0xaf, 0x9d, 0xc4, 0xce, 0x3f, 0x85, 0x81, - 0x6e, 0xf7, 0xdc, 0xf3, 0x9d, 0xf3, 0xfd, 0x64, 0x7d, 0xbe, 0x60, 0xf5, 0xf8, 0x88, 0xdb, 0x21, - 0x51, 0xc2, 0x23, 0x0f, 0xed, 0xd1, 0xa9, 0x8b, 0x92, 0x9f, 0xda, 0xf2, 0x82, 0x0d, 0x63, 0x21, - 0x85, 0x71, 0x2f, 0xed, 0xb3, 0x69, 0x9f, 0xe5, 0x7d, 0xd3, 0xf2, 0x04, 0x0d, 0x04, 0xd9, 0x2e, - 0xa7, 0xf9, 0x90, 0x27, 0xc2, 0x28, 0x1b, 0x33, 0x0f, 0x03, 0x11, 0x08, 0x75, 0xb4, 0xd3, 0x53, - 0x76, 0xdb, 0xfa, 0xaa, 0x43, 0xad, 0x4b, 0xc1, 0x1b, 0xa2, 0x04, 0xdf, 0x89, 0x1e, 0x46, 0x64, - 0x1c, 0x41, 0x85, 0x30, 0xf2, 0x31, 0xae, 0xeb, 0xc7, 0x7a, 0x7b, 0xcf, 0xc9, 0x2b, 0xe3, 0x39, - 0x54, 0xa4, 0x52, 0xd4, 0x6f, 0x1d, 0xeb, 0xed, 0xfd, 0xb3, 0x06, 0xcb, 0x1c, 0x59, 0xea, 0x38, - 0xc5, 0x60, 0xaf, 0x44, 0x18, 0x75, 0x76, 0xaf, 0x7e, 0x35, 0x35, 0x27, 0x97, 0x1b, 0x26, 0x54, - 0x63, 0xf4, 0x30, 0x1c, 0x61, 0x5c, 0xdf, 0x51, 0x2b, 0x67, 0xf5, 0x8b, 0xea, 0xb7, 0xcb, 0xa6, - 0xf6, 0xe7, 0xb2, 0xa9, 0xb5, 0xea, 0x70, 0x54, 0x06, 0x71, 0x90, 0x86, 0x22, 0x22, 0x6c, 0xf5, - 0xe1, 0xa0, 0x4b, 0x81, 0x83, 0x3e, 0xe2, 0xe0, 0x3f, 0x31, 0x16, 0x38, 0x1a, 0x70, 0x7f, 0xc1, - 0x6d, 0x06, 0x12, 0x2b, 0x90, 0x4e, 0x5f, 0x78, 0xbd, 0x97, 0xbe, 0x1f, 0x23, 0xad, 0x07, 0x39, - 0x84, 0xdb, 0x3e, 0x46, 0x62, 0xa0, 0x38, 0xf6, 0x9c, 0xac, 0x30, 0x1e, 0xc3, 0x81, 0x9b, 0x4e, - 0xa3, 0xff, 0x91, 0x67, 0x0b, 0xf2, 0x0f, 0x52, 0xcb, 0xaf, 0xf3, 0xb5, 0x4b, 0x38, 0x45, 0xcf, - 0x19, 0x8e, 0x84, 0xbb, 0x5d, 0x0a, 0xde, 0x47, 0xee, 0x8d, 0x02, 0x3d, 0x80, 0xc6, 0x92, 0xeb, - 0x0c, 0xc9, 0x53, 0x48, 0xe7, 0x28, 0xdf, 0xf2, 0x84, 0xf0, 0x5c, 0x72, 0x99, 0xfc, 0x2b, 0x52, - 0xaa, 0x56, 0x73, 0x8a, 0xa4, 0xea, 0xe4, 0xd5, 0x12, 0x41, 0xd9, 0x64, 0x4a, 0x70, 0xf6, 0x63, - 0x17, 0x76, 0xba, 0x14, 0x18, 0x1e, 0xec, 0x17, 0x43, 0xfd, 0x90, 0xad, 0xfc, 0x6b, 0x58, 0x39, - 0x72, 0xe6, 0xc9, 0x56, 0xb2, 0xa9, 0x99, 0xf1, 0x09, 0xee, 0x94, 0x62, 0xf9, 0x68, 0xfd, 0x78, - 0x51, 0x67, 0xb2, 0xed, 0x74, 0x45, 0x9f, 0x52, 0xea, 0x36, 0xf8, 0x14, 0x75, 0x9b, 0x7c, 0x56, - 0x25, 0xca, 0xe8, 0x43, 0x6d, 0x21, 0x4e, 0xed, 0xf5, 0x1b, 0xca, 0x4a, 0xf3, 0xe9, 0xb6, 0xca, - 0xa2, 0xdb, 0x42, 0x52, 0x36, 0xb8, 0x95, 0x95, 0x9b, 0xdc, 0x56, 0x07, 0xa3, 0xf3, 0xfa, 0x6a, - 0x6c, 0xe9, 0xd7, 0x63, 0x4b, 0xff, 0x3d, 0xb6, 0xf4, 0xef, 0x13, 0x4b, 0xbb, 0x9e, 0x58, 0xda, - 0xcf, 0x89, 0xa5, 0x7d, 0x78, 0x12, 0x84, 0xf2, 0x73, 0xe2, 0x32, 0x4f, 0x0c, 0xec, 0x74, 0xeb, - 0x49, 0x9f, 0xbb, 0xa4, 0x4e, 0xf6, 0xc5, 0xfc, 0x1d, 0x96, 0x5f, 0x86, 0x48, 0x6e, 0x45, 0x3d, - 0x9b, 0xcf, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0x5f, 0x6f, 0x10, 0xd6, 0xa5, 0x05, 0x00, 0x00, + // 503 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x94, 0x4f, 0x6f, 0xd3, 0x4c, + 0x10, 0xc6, 0xed, 0xb7, 0x7d, 0xa3, 0x74, 0x8b, 0x52, 0x61, 0x95, 0x92, 0x18, 0xc9, 0xa9, 0x22, + 0x01, 0x91, 0x50, 0xd7, 0x69, 0x39, 0x20, 0x71, 0x23, 0x88, 0x03, 0x87, 0x48, 0xc8, 0x85, 0x0b, + 0x17, 0xb4, 0xb6, 0x87, 0xad, 0x95, 0x64, 0x37, 0xf2, 0xac, 0xa3, 0xf2, 0x09, 0xe0, 0xc8, 0x89, + 0x73, 0x3f, 0x4e, 0x8f, 0x3d, 0x72, 0x42, 0x28, 0xb9, 0xf0, 0x31, 0x90, 0xd7, 0x4e, 0x6a, 0xe7, + 0x9f, 0xc2, 0x01, 0x6e, 0x3b, 0x3b, 0xcf, 0xcc, 0xf3, 0x93, 0xf5, 0x78, 0x89, 0xd3, 0x67, 0x63, + 0xe6, 0x46, 0x88, 0x09, 0x13, 0x01, 0xb8, 0xe3, 0x53, 0x1f, 0x14, 0x3b, 0x75, 0xd5, 0x25, 0x1d, + 0xc5, 0x52, 0x49, 0xeb, 0x5e, 0xda, 0xa7, 0xb3, 0x3e, 0xcd, 0xfb, 0xb6, 0x13, 0x48, 0x1c, 0x4a, + 0x74, 0x7d, 0x86, 0xb7, 0x43, 0x81, 0x8c, 0x44, 0x36, 0x66, 0x1f, 0x72, 0xc9, 0xa5, 0x3e, 0xba, + 0xe9, 0x29, 0xbb, 0x6d, 0x7d, 0x36, 0x49, 0xad, 0x87, 0xfc, 0x35, 0x62, 0x02, 0x6f, 0x65, 0x1f, + 0x04, 0x5a, 0x47, 0xa4, 0x82, 0x20, 0x42, 0x88, 0xeb, 0xe6, 0xb1, 0xd9, 0xde, 0xf3, 0xf2, 0xca, + 0x7a, 0x46, 0x2a, 0x4a, 0x2b, 0xea, 0xff, 0x1d, 0x9b, 0xed, 0xfd, 0xb3, 0x06, 0xcd, 0x1c, 0x69, + 0xea, 0x38, 0xc3, 0xa0, 0x2f, 0x65, 0x24, 0xba, 0xbb, 0xd7, 0x3f, 0x9a, 0x86, 0x97, 0xcb, 0x2d, + 0x9b, 0x54, 0x63, 0x08, 0x20, 0x1a, 0x43, 0x5c, 0xdf, 0xd1, 0x2b, 0xe7, 0xf5, 0xf3, 0xea, 0x97, + 0xab, 0xa6, 0xf1, 0xeb, 0xaa, 0x69, 0xb4, 0xea, 0xe4, 0xa8, 0x0c, 0xe2, 0x01, 0x8e, 0xa4, 0x40, + 0x68, 0x0d, 0xc8, 0x41, 0x0f, 0xb9, 0x07, 0x21, 0xc0, 0xf0, 0x2f, 0x31, 0x16, 0x38, 0x1a, 0xe4, + 0xfe, 0x82, 0xdb, 0x1c, 0x24, 0xd6, 0x20, 0xdd, 0x81, 0x0c, 0xfa, 0x2f, 0xc2, 0x30, 0x06, 0x5c, + 0x0f, 0x72, 0x48, 0xfe, 0x0f, 0x41, 0xc8, 0xa1, 0xe6, 0xd8, 0xf3, 0xb2, 0xc2, 0x7a, 0x4c, 0x0e, + 0xfc, 0x74, 0x1a, 0xc2, 0x0f, 0x2c, 0x5b, 0x90, 0x7f, 0x90, 0x5a, 0x7e, 0x9d, 0xaf, 0x5d, 0xc2, + 0x29, 0x7a, 0xce, 0x71, 0x14, 0xb9, 0xdb, 0x43, 0xfe, 0x4e, 0xf8, 0xff, 0x14, 0xe8, 0x01, 0x69, + 0x2c, 0xb9, 0xce, 0x91, 0x02, 0x8d, 0x74, 0x0e, 0xea, 0x0d, 0x4b, 0x10, 0xce, 0x15, 0x53, 0xc9, + 0x9f, 0x22, 0xa5, 0x6a, 0x3d, 0xa7, 0x49, 0xaa, 0x5e, 0x5e, 0x2d, 0x11, 0x94, 0x4d, 0x66, 0x04, + 0x67, 0xdf, 0x76, 0xc9, 0x4e, 0x0f, 0xb9, 0x15, 0x90, 0xfd, 0x62, 0xa8, 0x1f, 0xd2, 0x95, 0x7f, + 0x0d, 0x2d, 0x47, 0xce, 0x3e, 0xd9, 0x4a, 0x36, 0x33, 0xb3, 0x3e, 0x92, 0x3b, 0xa5, 0x58, 0x3e, + 0x5a, 0x3f, 0x5e, 0xd4, 0xd9, 0x74, 0x3b, 0x5d, 0xd1, 0xa7, 0x94, 0xba, 0x0d, 0x3e, 0x45, 0xdd, + 0x26, 0x9f, 0x55, 0x89, 0xb2, 0x06, 0xa4, 0xb6, 0x10, 0xa7, 0xf6, 0xfa, 0x0d, 0x65, 0xa5, 0xdd, + 0xd9, 0x56, 0x59, 0x74, 0x5b, 0x48, 0xca, 0x06, 0xb7, 0xb2, 0x72, 0x93, 0xdb, 0xea, 0x60, 0x74, + 0x5f, 0x5d, 0x4f, 0x1c, 0xf3, 0x66, 0xe2, 0x98, 0x3f, 0x27, 0x8e, 0xf9, 0x75, 0xea, 0x18, 0x37, + 0x53, 0xc7, 0xf8, 0x3e, 0x75, 0x8c, 0xf7, 0x4f, 0x78, 0xa4, 0x2e, 0x12, 0x9f, 0x06, 0x72, 0xe8, + 0x76, 0xf8, 0x80, 0xf9, 0xe8, 0x76, 0xf8, 0x49, 0x70, 0xc1, 0x22, 0xe1, 0x5e, 0xde, 0x3e, 0xc4, + 0xea, 0xd3, 0x08, 0xd0, 0xaf, 0xe8, 0x77, 0xf3, 0xe9, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, + 0x4d, 0xbc, 0xcd, 0xa6, 0x05, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/kavadist/types/genesis.pb.go b/x/kavadist/types/genesis.pb.go index d89ed141..f13d51d6 100644 --- a/x/kavadist/types/genesis.pb.go +++ b/x/kavadist/types/genesis.pb.go @@ -89,25 +89,25 @@ func init() { } var fileDescriptor_77f4885f7744ff13 = []byte{ - // 279 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xce, 0x4e, 0x2c, 0x4b, - 0xd4, 0x07, 0x11, 0x29, 0x99, 0xc5, 0x25, 0xfa, 0x65, 0x86, 0x49, 0xa9, 0x25, 0x89, 0x86, 0xfa, - 0xe9, 0xa9, 0x79, 0xa9, 0xc5, 0x99, 0xc5, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0xa2, 0x20, - 0x79, 0x3d, 0x98, 0x22, 0x3d, 0xa8, 0x22, 0x29, 0x91, 0xf4, 0xfc, 0xf4, 0x7c, 0xb0, 0x0a, 0x7d, - 0x10, 0x0b, 0xa2, 0x58, 0x4a, 0x3e, 0x3d, 0x3f, 0x3f, 0x3d, 0x27, 0x55, 0x1f, 0xcc, 0x4b, 0x2a, - 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x80, 0x2a, 0x50, 0xc2, 0x6e, - 0x65, 0x41, 0x62, 0x51, 0x62, 0x2e, 0xd4, 0x46, 0xa5, 0x85, 0x8c, 0x5c, 0x3c, 0xee, 0x10, 0x37, - 0x04, 0x97, 0x24, 0x96, 0xa4, 0x0a, 0x59, 0x73, 0xb1, 0x41, 0x14, 0x48, 0x30, 0x2a, 0x30, 0x6a, - 0x70, 0x1b, 0xc9, 0xea, 0x61, 0x75, 0x93, 0x5e, 0x00, 0x58, 0x91, 0x13, 0xcb, 0x89, 0x7b, 0xf2, - 0x0c, 0x41, 0x50, 0x2d, 0x42, 0x21, 0x5c, 0xc2, 0x05, 0x45, 0xa9, 0x65, 0x99, 0xf9, 0xa5, 0xc5, - 0xf1, 0x49, 0x39, 0xf9, 0xc9, 0xd9, 0xf1, 0x20, 0x37, 0x49, 0x30, 0x81, 0x4d, 0x92, 0xd2, 0x83, - 0x38, 0x58, 0x0f, 0xe6, 0x60, 0xbd, 0x10, 0x98, 0x83, 0x9d, 0x38, 0x40, 0xc6, 0x4c, 0xb8, 0x2f, - 0xcf, 0x18, 0x24, 0x08, 0x33, 0xc0, 0x09, 0xa4, 0x1f, 0xa4, 0xc2, 0xc9, 0xe5, 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, 0xb4, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, - 0xf3, 0x73, 0xc1, 0xfe, 0xd4, 0xcd, 0x49, 0x4c, 0x2a, 0x06, 0xb3, 0xf4, 0x2b, 0x10, 0x1e, 0x2f, - 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x5b, 0x6b, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x10, - 0xd1, 0xf3, 0x3d, 0x89, 0x01, 0x00, 0x00, + // 284 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x8f, 0xc1, 0x4a, 0xc3, 0x30, + 0x18, 0xc7, 0x1b, 0x91, 0x21, 0xd5, 0x8b, 0x55, 0x61, 0x14, 0x4c, 0x65, 0x5e, 0x04, 0x31, 0xd9, + 0xf4, 0xe8, 0xad, 0x20, 0x5e, 0x65, 0xee, 0xe4, 0x65, 0x24, 0x35, 0x66, 0x61, 0xed, 0x52, 0x9a, + 0xaf, 0x45, 0xdf, 0x62, 0xaf, 0xe0, 0xdb, 0xec, 0xb8, 0xa3, 0x27, 0x95, 0xf6, 0x45, 0x24, 0x69, + 0x8b, 0x97, 0x5d, 0x42, 0x42, 0x7e, 0xdf, 0xff, 0xff, 0xfb, 0xfc, 0xcb, 0x25, 0xab, 0x18, 0xb5, + 0xc7, 0xab, 0x32, 0x40, 0xab, 0x09, 0x17, 0xc0, 0x26, 0x54, 0x8a, 0x95, 0x30, 0xca, 0x90, 0xbc, + 0xd0, 0xa0, 0x83, 0x33, 0xfb, 0x4f, 0x7a, 0x88, 0x74, 0x50, 0x78, 0x2a, 0xb5, 0xd4, 0x8e, 0xa0, + 0xf6, 0xd6, 0xc2, 0x61, 0x24, 0xb5, 0x96, 0xa9, 0xa0, 0xee, 0xc5, 0xcb, 0x37, 0x0a, 0x2a, 0x13, + 0x06, 0x58, 0x96, 0x77, 0xc0, 0x68, 0x77, 0x65, 0xce, 0x0a, 0x96, 0x75, 0x8d, 0xa3, 0x4f, 0xe4, + 0x1f, 0x3d, 0xb6, 0x0e, 0xcf, 0xc0, 0x40, 0x04, 0xf7, 0xfe, 0xa0, 0x05, 0x86, 0xe8, 0x02, 0x5d, + 0x1d, 0xde, 0x9e, 0x93, 0x9d, 0x4e, 0xe4, 0xc9, 0x41, 0xf1, 0xfe, 0xe6, 0x3b, 0xf2, 0xa6, 0xdd, + 0x48, 0x30, 0xf3, 0x4f, 0xf2, 0x42, 0x54, 0x4a, 0x97, 0x66, 0xce, 0x53, 0x9d, 0x2c, 0xe7, 0xd6, + 0x69, 0xb8, 0xe7, 0x92, 0x42, 0xd2, 0x0a, 0x93, 0x5e, 0x98, 0xcc, 0x7a, 0xe1, 0xf8, 0xc0, 0xc6, + 0xac, 0x7f, 0x22, 0x34, 0x3d, 0xee, 0x03, 0x62, 0x3b, 0x6f, 0x89, 0xf8, 0x61, 0x53, 0x63, 0xb4, + 0xad, 0x31, 0xfa, 0xad, 0x31, 0x5a, 0x37, 0xd8, 0xdb, 0x36, 0xd8, 0xfb, 0x6a, 0xb0, 0xf7, 0x72, + 0x2d, 0x15, 0x2c, 0x4a, 0x4e, 0x12, 0x9d, 0xd1, 0xb1, 0x4c, 0x19, 0x37, 0x74, 0x2c, 0x6f, 0x92, + 0x05, 0x53, 0x2b, 0xfa, 0xfe, 0xbf, 0x39, 0x7c, 0xe4, 0xc2, 0xf0, 0x81, 0xeb, 0xbd, 0xfb, 0x0b, + 0x00, 0x00, 0xff, 0xff, 0x69, 0x8f, 0xb1, 0x6d, 0x8a, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/kavadist/types/params.pb.go b/x/kavadist/types/params.pb.go index 49eb8475..594f9b30 100644 --- a/x/kavadist/types/params.pb.go +++ b/x/kavadist/types/params.pb.go @@ -243,48 +243,48 @@ func init() { } var fileDescriptor_2c7a7a4b0c884a4e = []byte{ - // 649 bytes of a gzipped FileDescriptorProto + // 652 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x3f, 0x4f, 0x1b, 0x3f, 0x18, 0x8e, 0x49, 0x7e, 0x01, 0x1c, 0x7e, 0x50, 0x99, 0x3f, 0x0a, 0x48, 0xbd, 0x4b, 0xa3, 0xaa, - 0x8a, 0x5a, 0xe5, 0x4e, 0xa4, 0x52, 0x07, 0xd4, 0x0e, 0x5c, 0x19, 0x5a, 0x89, 0x4a, 0xe8, 0xca, - 0xd2, 0x2e, 0x91, 0xcf, 0xe7, 0x04, 0x0b, 0x72, 0x3e, 0xd9, 0x0e, 0x94, 0x6f, 0xc1, 0xd8, 0x91, - 0xb9, 0x33, 0x5f, 0xa1, 0x6a, 0x86, 0x0e, 0x88, 0x09, 0x75, 0x80, 0x02, 0x4b, 0x3f, 0x43, 0xa7, - 0xea, 0x6c, 0x87, 0x10, 0x04, 0x52, 0xba, 0x74, 0x49, 0xee, 0x7d, 0xfd, 0x3e, 0xcf, 0xfb, 0x3e, - 0xe7, 0xe7, 0x3d, 0x58, 0xdd, 0xc6, 0xbb, 0xd8, 0xcf, 0x7e, 0x62, 0x26, 0x95, 0xbf, 0xbb, 0x1c, - 0x51, 0x85, 0x97, 0xfd, 0x14, 0x0b, 0xdc, 0x91, 0x5e, 0x2a, 0xb8, 0xe2, 0x68, 0x3e, 0x3b, 0xf6, - 0xfa, 0x35, 0x9e, 0xad, 0x59, 0x72, 0x08, 0x97, 0x1d, 0x2e, 0xfd, 0x08, 0x4b, 0x7a, 0x0d, 0x24, - 0x9c, 0x25, 0x06, 0xb6, 0xb4, 0x68, 0xce, 0x9b, 0x3a, 0xf2, 0x4d, 0x60, 0x8f, 0xe6, 0xda, 0xbc, - 0xcd, 0x4d, 0x3e, 0x7b, 0xb2, 0x59, 0xb7, 0xcd, 0x79, 0x7b, 0x87, 0xfa, 0x3a, 0x8a, 0xba, 0x2d, - 0x5f, 0xb1, 0x0e, 0x95, 0x0a, 0x77, 0x52, 0x53, 0x50, 0xfd, 0x06, 0x60, 0x71, 0x43, 0x4f, 0x86, - 0x16, 0x60, 0x11, 0x13, 0xc5, 0x76, 0x69, 0x19, 0x54, 0x40, 0x6d, 0x22, 0xb4, 0x11, 0x7a, 0x05, - 0xc7, 0x53, 0x2a, 0x18, 0x8f, 0x65, 0x39, 0x5f, 0xc9, 0xd7, 0x4a, 0x8d, 0x87, 0xde, 0x9d, 0xd3, - 0x7b, 0x1b, 0xba, 0x2a, 0x28, 0xf4, 0xce, 0xdc, 0x5c, 0xd8, 0xc7, 0xa0, 0x16, 0x9c, 0x67, 0x49, - 0x4b, 0x60, 0xa9, 0x44, 0x97, 0xa8, 0xae, 0xa0, 0x4d, 0xf3, 0x26, 0xca, 0x85, 0x0a, 0xa8, 0x95, - 0x1a, 0xcf, 0xee, 0x21, 0x7b, 0x3b, 0x84, 0x31, 0x23, 0x5a, 0xea, 0x39, 0x76, 0xc7, 0x59, 0xf5, - 0xeb, 0x18, 0x9c, 0xbb, 0x0b, 0x84, 0x28, 0x5c, 0xb8, 0x3d, 0x80, 0x95, 0x03, 0x46, 0x91, 0x33, - 0x93, 0xf5, 0xfc, 0x72, 0xee, 0x8e, 0x9b, 0x58, 0x86, 0xb7, 0xe4, 0xd8, 0x34, 0xfa, 0x00, 0xa7, - 0x08, 0x17, 0xb4, 0x29, 0xe8, 0x1e, 0x16, 0xb1, 0x2c, 0x8f, 0x69, 0xf2, 0x47, 0xf7, 0x90, 0xbf, - 0xe6, 0x82, 0x86, 0xba, 0x32, 0x98, 0xb5, 0x0d, 0x4a, 0x83, 0x9c, 0x0c, 0x4b, 0x64, 0x10, 0x20, - 0x0a, 0x67, 0x52, 0x2c, 0x54, 0x42, 0xc5, 0x35, 0xbb, 0xb9, 0x89, 0xc7, 0xf7, 0x8d, 0x6e, 0xaa, - 0x6d, 0x83, 0x05, 0xdb, 0x60, 0x7a, 0x28, 0x2d, 0xc3, 0xe9, 0x74, 0x28, 0x5e, 0x29, 0x7c, 0x3e, - 0x74, 0x41, 0xf5, 0x3b, 0x80, 0x70, 0x30, 0x09, 0x8a, 0xe0, 0x38, 0x8e, 0x63, 0x41, 0xa5, 0xd4, - 0xb6, 0x98, 0x0a, 0xde, 0xfc, 0x3e, 0x73, 0xeb, 0x6d, 0xa6, 0xb6, 0xba, 0x91, 0x47, 0x78, 0xc7, - 0xba, 0xd0, 0xfe, 0xd5, 0x65, 0xbc, 0xed, 0xab, 0xfd, 0x94, 0x4a, 0x6f, 0x95, 0x90, 0x55, 0x03, - 0x3c, 0x39, 0xaa, 0xcf, 0x5a, 0xaf, 0xda, 0x4c, 0xb0, 0xaf, 0xa8, 0x0c, 0xfb, 0xc4, 0x68, 0x13, - 0x16, 0xf7, 0x28, 0x6b, 0x6f, 0xa9, 0xf2, 0x58, 0x05, 0xd4, 0x26, 0x83, 0x97, 0xd9, 0xc0, 0x3f, - 0xce, 0xdc, 0x27, 0x23, 0xb4, 0x59, 0xa3, 0xe4, 0xe4, 0xa8, 0x0e, 0x2d, 0xff, 0x1a, 0x25, 0xa1, - 0xe5, 0xb2, 0x72, 0x7a, 0x00, 0xfe, 0x3f, 0xa4, 0xfb, 0x9f, 0x28, 0x7a, 0x07, 0x91, 0xbd, 0xa9, - 0xcc, 0x6c, 0x4d, 0x49, 0x09, 0x4f, 0x62, 0xad, 0xae, 0xd4, 0x58, 0xf4, 0x2c, 0x34, 0xdb, 0xf2, - 0x1b, 0x86, 0x60, 0x89, 0xf5, 0xf7, 0x03, 0x0b, 0xdd, 0xa0, 0xe2, 0xbd, 0x06, 0x5a, 0x29, 0xc7, - 0xd9, 0xae, 0x6a, 0xb7, 0xa1, 0x15, 0xf8, 0x9f, 0x54, 0x58, 0x28, 0xad, 0xa0, 0xd4, 0x58, 0xf2, - 0xcc, 0x9e, 0x7b, 0xfd, 0x3d, 0xf7, 0x36, 0xfb, 0x7b, 0x1e, 0x4c, 0x64, 0x9c, 0x07, 0xe7, 0x2e, - 0x08, 0x0d, 0x04, 0xbd, 0x80, 0x79, 0x7a, 0x3d, 0xcc, 0x68, 0xc8, 0x0c, 0x80, 0xd6, 0xe1, 0x24, - 0x4b, 0x5a, 0x3b, 0x58, 0x31, 0x9e, 0x94, 0xf3, 0xfa, 0xcd, 0x79, 0x7f, 0x77, 0x51, 0xe1, 0x80, - 0x60, 0xa5, 0xf0, 0xeb, 0xd0, 0x05, 0xc1, 0x7a, 0xef, 0xc2, 0xc9, 0x9d, 0x5e, 0x38, 0xb9, 0xde, - 0xa5, 0x03, 0x8e, 0x2f, 0x1d, 0xf0, 0xf3, 0xd2, 0x01, 0x07, 0x57, 0x4e, 0xee, 0xf8, 0xca, 0xc9, - 0x9d, 0x5e, 0x39, 0xb9, 0x8f, 0x4f, 0x6f, 0x50, 0x67, 0x3e, 0xaf, 0xef, 0xe0, 0x48, 0xea, 0x27, - 0xff, 0xd3, 0xe0, 0x23, 0xab, 0x5b, 0x44, 0x45, 0x2d, 0xe2, 0xf9, 0x9f, 0x00, 0x00, 0x00, 0xff, - 0xff, 0xca, 0x25, 0xda, 0x69, 0x82, 0x05, 0x00, 0x00, + 0x8a, 0x84, 0x72, 0x07, 0xa9, 0xd4, 0x01, 0xb5, 0x03, 0x29, 0x43, 0x2b, 0x15, 0x09, 0x5d, 0x59, + 0xda, 0x25, 0xf2, 0xf9, 0x9c, 0xc3, 0x82, 0x9c, 0x4f, 0xb6, 0x03, 0xe5, 0x5b, 0x30, 0x76, 0x64, + 0xee, 0xcc, 0x57, 0xa8, 0x9a, 0xa1, 0x03, 0x62, 0x42, 0x1d, 0xa0, 0xc0, 0xd2, 0xcf, 0xd0, 0xa9, + 0x3a, 0xdb, 0x21, 0x04, 0x81, 0x44, 0x97, 0x2e, 0x49, 0xde, 0xd7, 0xef, 0xf3, 0xbc, 0xcf, 0x63, + 0xbf, 0x6f, 0x60, 0x75, 0x1b, 0xef, 0x62, 0x3f, 0xfb, 0x88, 0x98, 0x54, 0xfe, 0xee, 0x72, 0x48, + 0x15, 0x5e, 0xf6, 0x53, 0x2c, 0x70, 0x47, 0x7a, 0xa9, 0xe0, 0x8a, 0xa3, 0xd9, 0xec, 0xd8, 0xeb, + 0xd7, 0x78, 0xb6, 0x66, 0xc1, 0x21, 0x5c, 0x76, 0xb8, 0xf4, 0x43, 0x2c, 0xe9, 0x35, 0x90, 0x70, + 0x96, 0x18, 0xd8, 0xc2, 0xbc, 0x39, 0x6f, 0xe9, 0xc8, 0x37, 0x81, 0x3d, 0x9a, 0x89, 0x79, 0xcc, + 0x4d, 0x3e, 0xfb, 0x65, 0xb3, 0x6e, 0xcc, 0x79, 0xbc, 0x43, 0x7d, 0x1d, 0x85, 0xdd, 0xb6, 0xaf, + 0x58, 0x87, 0x4a, 0x85, 0x3b, 0xa9, 0x29, 0xa8, 0x7e, 0x03, 0xb0, 0xb8, 0xa1, 0x95, 0xa1, 0x39, + 0x58, 0xc4, 0x44, 0xb1, 0x5d, 0x5a, 0x06, 0x15, 0x50, 0x1b, 0x0b, 0x6c, 0x84, 0x5e, 0xc1, 0xd1, + 0x94, 0x0a, 0xc6, 0x23, 0x59, 0xce, 0x57, 0xf2, 0xb5, 0x52, 0xe3, 0xb1, 0x77, 0xa7, 0x7a, 0x6f, + 0x43, 0x57, 0x35, 0x0b, 0xbd, 0x33, 0x37, 0x17, 0xf4, 0x31, 0xa8, 0x0d, 0x67, 0x59, 0xd2, 0x16, + 0x58, 0x2a, 0xd1, 0x25, 0xaa, 0x2b, 0x68, 0xcb, 0xdc, 0x44, 0xb9, 0x50, 0x01, 0xb5, 0x52, 0x63, + 0xf1, 0x1e, 0xb2, 0xb7, 0x43, 0x18, 0x23, 0xd1, 0x52, 0xcf, 0xb0, 0x3b, 0xce, 0xaa, 0x5f, 0x47, + 0xe0, 0xcc, 0x5d, 0x20, 0x44, 0xe1, 0xdc, 0x6d, 0x01, 0xd6, 0x0e, 0x78, 0x88, 0x9d, 0xa9, 0xac, + 0xe7, 0x97, 0x73, 0x77, 0xd4, 0xc4, 0x32, 0xb8, 0x65, 0xc7, 0xa6, 0xd1, 0x07, 0x38, 0x41, 0xb8, + 0xa0, 0x2d, 0x41, 0xf7, 0xb0, 0x88, 0x64, 0x79, 0x44, 0x93, 0x3f, 0xb9, 0x87, 0xfc, 0x35, 0x17, + 0x34, 0xd0, 0x95, 0xcd, 0x69, 0xdb, 0xa0, 0x34, 0xc8, 0xc9, 0xa0, 0x44, 0x06, 0x01, 0xa2, 0x70, + 0x2a, 0xc5, 0x42, 0x25, 0x54, 0x5c, 0xb3, 0x9b, 0x97, 0x78, 0x7a, 0x9f, 0x74, 0x53, 0x6d, 0x1b, + 0xcc, 0xd9, 0x06, 0x93, 0x43, 0x69, 0x19, 0x4c, 0xa6, 0x43, 0xf1, 0x4a, 0xe1, 0xf3, 0xa1, 0x0b, + 0xaa, 0xdf, 0x01, 0x84, 0x03, 0x25, 0x28, 0x84, 0xa3, 0x38, 0x8a, 0x04, 0x95, 0x52, 0x8f, 0xc5, + 0x44, 0xf3, 0xcd, 0xef, 0x33, 0xb7, 0x1e, 0x33, 0xb5, 0xd5, 0x0d, 0x3d, 0xc2, 0x3b, 0x76, 0x0a, + 0xed, 0x57, 0x5d, 0x46, 0xdb, 0xbe, 0xda, 0x4f, 0xa9, 0xf4, 0x56, 0x09, 0x59, 0x35, 0xc0, 0x93, + 0xa3, 0xfa, 0xb4, 0x9d, 0x55, 0x9b, 0x69, 0xee, 0x2b, 0x2a, 0x83, 0x3e, 0x31, 0xda, 0x84, 0xc5, + 0x3d, 0xca, 0xe2, 0x2d, 0x55, 0x1e, 0xa9, 0x80, 0xda, 0x78, 0xf3, 0x65, 0x26, 0xf8, 0xc7, 0x99, + 0xfb, 0xec, 0x01, 0x6d, 0xd6, 0x28, 0x39, 0x39, 0xaa, 0x43, 0xcb, 0xbf, 0x46, 0x49, 0x60, 0xb9, + 0xac, 0x9d, 0x1e, 0x80, 0xff, 0x0f, 0xf9, 0xfe, 0x27, 0x8e, 0xd6, 0x21, 0xb2, 0x2f, 0x95, 0x0d, + 0x5b, 0x4b, 0x52, 0xc2, 0x93, 0x48, 0xbb, 0x2b, 0x35, 0xe6, 0x3d, 0x0b, 0xcd, 0xb6, 0xfc, 0xc6, + 0x40, 0xb0, 0xc4, 0xce, 0xf7, 0x23, 0x0b, 0xdd, 0xa0, 0xe2, 0xbd, 0x06, 0x5a, 0x2b, 0xc7, 0xd9, + 0xae, 0xea, 0x69, 0x43, 0x2b, 0xf0, 0x3f, 0xa9, 0xb0, 0x50, 0xda, 0x41, 0xa9, 0xb1, 0xe0, 0x99, + 0x3d, 0xf7, 0xfa, 0x7b, 0xee, 0x6d, 0xf6, 0xf7, 0xbc, 0x39, 0x96, 0x71, 0x1e, 0x9c, 0xbb, 0x20, + 0x30, 0x10, 0xf4, 0x02, 0xe6, 0xe9, 0xb5, 0x98, 0x87, 0x21, 0x33, 0x00, 0x7a, 0x07, 0xc7, 0x59, + 0xd2, 0xde, 0xc1, 0x8a, 0xf1, 0xa4, 0x9c, 0xd7, 0x37, 0xe7, 0xfd, 0xdd, 0x43, 0x05, 0x03, 0x82, + 0x95, 0xc2, 0xaf, 0x43, 0x17, 0x34, 0xd7, 0x7b, 0x17, 0x4e, 0xee, 0xf4, 0xc2, 0xc9, 0xf5, 0x2e, + 0x1d, 0x70, 0x7c, 0xe9, 0x80, 0x9f, 0x97, 0x0e, 0x38, 0xb8, 0x72, 0x72, 0xc7, 0x57, 0x4e, 0xee, + 0xf4, 0xca, 0xc9, 0x7d, 0x5c, 0xbc, 0x41, 0xbd, 0x14, 0xef, 0xe0, 0x50, 0xfa, 0x4b, 0x71, 0x9d, + 0x6c, 0x61, 0x96, 0xf8, 0x9f, 0x06, 0xff, 0xb2, 0xba, 0x47, 0x58, 0xd4, 0x2e, 0x9e, 0xff, 0x09, + 0x00, 0x00, 0xff, 0xff, 0x18, 0xb9, 0xf4, 0x6c, 0x83, 0x05, 0x00, 0x00, } func (this *Period) Equal(that interface{}) bool { diff --git a/x/kavadist/types/proposal.pb.go b/x/kavadist/types/proposal.pb.go index 22f201f0..3a079174 100644 --- a/x/kavadist/types/proposal.pb.go +++ b/x/kavadist/types/proposal.pb.go @@ -155,33 +155,33 @@ func init() { } var fileDescriptor_22ee2c0b398254fd = []byte{ - // 409 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x93, 0xbf, 0x0f, 0xd2, 0x40, - 0x14, 0xc7, 0x7b, 0x80, 0xa0, 0x47, 0x74, 0xa8, 0x98, 0x54, 0x86, 0x96, 0xa0, 0x03, 0x21, 0xe1, - 0x4e, 0x74, 0x73, 0x04, 0x27, 0xe3, 0x0f, 0x52, 0x06, 0x13, 0x17, 0x73, 0x6d, 0x2f, 0x78, 0xa1, - 0xed, 0xbb, 0xf4, 0xae, 0x44, 0xfe, 0x03, 0x47, 0x47, 0x27, 0xc3, 0x66, 0xe2, 0xdf, 0xe0, 0x1f, - 0xc0, 0xc8, 0xe8, 0xa4, 0x06, 0xfe, 0x11, 0xd3, 0x9f, 0x30, 0x90, 0xb8, 0x38, 0xb8, 0xb4, 0xef, - 0xae, 0xef, 0xfb, 0xb9, 0xf7, 0xde, 0xb7, 0x87, 0x1f, 0xae, 0xd9, 0x86, 0xd1, 0xec, 0x11, 0x08, - 0xa5, 0xe9, 0x66, 0xea, 0x71, 0xcd, 0xa6, 0x54, 0x26, 0x20, 0x41, 0xb1, 0x90, 0xc8, 0x04, 0x34, - 0x98, 0xf7, 0xb2, 0x04, 0x52, 0x65, 0x91, 0x32, 0xab, 0x6f, 0xfb, 0xa0, 0x22, 0x50, 0xd4, 0x63, - 0x8a, 0xd7, 0x52, 0x1f, 0x44, 0x5c, 0xc8, 0xfa, 0xbd, 0x15, 0xac, 0x20, 0x0f, 0x69, 0x16, 0x15, - 0xbb, 0xc3, 0xef, 0x08, 0x3b, 0x73, 0x88, 0xa2, 0x34, 0x16, 0x7a, 0xbb, 0x00, 0x08, 0x5f, 0xa6, - 0xa1, 0x16, 0x4b, 0xc9, 0xe3, 0x60, 0x51, 0x1e, 0x6b, 0xf6, 0xf0, 0x0d, 0x2d, 0x74, 0xc8, 0x2d, - 0x34, 0x40, 0xa3, 0x5b, 0x6e, 0xb1, 0x30, 0x07, 0xb8, 0x1b, 0x70, 0xe5, 0x27, 0x42, 0x6a, 0x01, - 0xb1, 0xd5, 0xc8, 0xbf, 0x5d, 0x6e, 0x99, 0x6f, 0xf0, 0x9d, 0x84, 0xfb, 0x42, 0x0a, 0x1e, 0xeb, - 0x77, 0xa1, 0x50, 0xda, 0x6a, 0x0e, 0x9a, 0xa3, 0xee, 0xe3, 0x31, 0xb9, 0xda, 0x01, 0x39, 0x1f, - 0xed, 0x56, 0xb2, 0x59, 0x6b, 0xff, 0xd3, 0x31, 0xdc, 0xdb, 0x35, 0xe7, 0x85, 0x50, 0xfa, 0xe9, - 0xcd, 0x8f, 0x3b, 0xc7, 0xf8, 0xbc, 0x73, 0x8c, 0xe1, 0xd7, 0x06, 0x7e, 0xf0, 0x97, 0xf2, 0x9f, - 0x2f, 0x5f, 0xbf, 0xfa, 0xef, 0x5a, 0x30, 0x39, 0xee, 0x04, 0x5c, 0x82, 0x12, 0xda, 0x6a, 0xe5, - 0xc4, 0xfb, 0xa4, 0xf0, 0x8f, 0x64, 0xfe, 0xd5, 0xbc, 0x39, 0x88, 0x78, 0xf6, 0x28, 0x03, 0x7c, - 0xfb, 0xe5, 0x8c, 0x56, 0x42, 0xbf, 0x4f, 0x3d, 0xe2, 0x43, 0x44, 0x4b, 0xb3, 0x8b, 0xd7, 0x44, - 0x05, 0x6b, 0xaa, 0xb7, 0x92, 0xab, 0x5c, 0xa0, 0xdc, 0x8a, 0x5d, 0x4f, 0x0a, 0x0d, 0xbf, 0x20, - 0x7c, 0xf7, 0x4a, 0x75, 0xa6, 0x85, 0x3b, 0x2c, 0x08, 0x12, 0xae, 0x54, 0x39, 0x9b, 0x6a, 0x69, - 0xfa, 0xb8, 0xcd, 0x22, 0x48, 0x63, 0x6d, 0x35, 0xfe, 0x7d, 0x85, 0x25, 0xfa, 0x6c, 0xe5, 0xec, - 0xd9, 0xfe, 0x68, 0xa3, 0xc3, 0xd1, 0x46, 0xbf, 0x8f, 0x36, 0xfa, 0x74, 0xb2, 0x8d, 0xc3, 0xc9, - 0x36, 0x7e, 0x9c, 0x6c, 0xe3, 0xed, 0xf8, 0x82, 0x9a, 0x4d, 0x7c, 0x12, 0x32, 0x4f, 0xe5, 0x11, - 0xfd, 0x70, 0xbe, 0x2d, 0x39, 0xdd, 0x6b, 0xe7, 0xbf, 0xf5, 0x93, 0x3f, 0x01, 0x00, 0x00, 0xff, - 0xff, 0x02, 0xb8, 0xb8, 0x96, 0x4b, 0x03, 0x00, 0x00, + // 415 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x93, 0x3d, 0x8f, 0xd3, 0x30, + 0x18, 0xc7, 0xe3, 0xde, 0x71, 0x07, 0x3e, 0xc1, 0x10, 0x0e, 0x29, 0xdc, 0x90, 0x54, 0x85, 0xa1, + 0x02, 0x9d, 0xdd, 0xc2, 0xc6, 0xd8, 0x8a, 0x05, 0xf1, 0x52, 0xa5, 0x03, 0x12, 0x0b, 0x72, 0x12, + 0x2b, 0xb5, 0x9a, 0xf8, 0xb1, 0x62, 0xa7, 0xa2, 0xdf, 0x80, 0x91, 0x91, 0x09, 0x75, 0x43, 0xe2, + 0x33, 0xf0, 0x01, 0x3a, 0x76, 0x64, 0x02, 0xd4, 0x7e, 0x11, 0x94, 0xd7, 0x76, 0xa8, 0xc4, 0xc2, + 0xc0, 0x92, 0xd8, 0xce, 0xf3, 0xff, 0x3d, 0x2f, 0xff, 0x18, 0x3f, 0x9c, 0xb3, 0x05, 0xa3, 0xc5, + 0x23, 0x12, 0xda, 0xd0, 0xc5, 0x30, 0xe0, 0x86, 0x0d, 0xa9, 0xca, 0x40, 0x81, 0x66, 0x09, 0x51, + 0x19, 0x18, 0xb0, 0xef, 0x15, 0x01, 0xa4, 0x89, 0x22, 0x75, 0xd4, 0x95, 0x1b, 0x82, 0x4e, 0x41, + 0xd3, 0x80, 0x69, 0xde, 0x4a, 0x43, 0x10, 0xb2, 0x92, 0x5d, 0x5d, 0xc6, 0x10, 0x43, 0xb9, 0xa4, + 0xc5, 0xaa, 0x3a, 0xed, 0x7d, 0x47, 0xd8, 0x1b, 0x43, 0x9a, 0xe6, 0x52, 0x98, 0xe5, 0x04, 0x20, + 0x79, 0x95, 0x27, 0x46, 0x4c, 0x15, 0x97, 0xd1, 0xa4, 0x4e, 0x6b, 0x5f, 0xe2, 0x1b, 0x46, 0x98, + 0x84, 0x3b, 0xa8, 0x8b, 0xfa, 0xb7, 0xfc, 0x6a, 0x63, 0x77, 0xf1, 0x45, 0xc4, 0x75, 0x98, 0x09, + 0x65, 0x04, 0x48, 0xa7, 0x53, 0x7e, 0x3b, 0x3c, 0xb2, 0xdf, 0xe2, 0x3b, 0x19, 0x0f, 0x85, 0x12, + 0x5c, 0x9a, 0xf7, 0x89, 0xd0, 0xc6, 0x39, 0xe9, 0x9e, 0xf4, 0x2f, 0x9e, 0x3c, 0x22, 0x47, 0x3b, + 0x20, 0xfb, 0xd4, 0x7e, 0x23, 0x1b, 0x9d, 0xae, 0x7f, 0x7a, 0x96, 0x7f, 0xbb, 0xe5, 0xbc, 0x14, + 0xda, 0x3c, 0xbb, 0xf9, 0x71, 0xe5, 0x59, 0x9f, 0x57, 0x9e, 0xd5, 0xfb, 0xda, 0xc1, 0x0f, 0xfe, + 0x52, 0xfe, 0x8b, 0xe9, 0x9b, 0xd7, 0xff, 0x5d, 0x0b, 0x36, 0xc7, 0xe7, 0x11, 0x57, 0xa0, 0x85, + 0x71, 0x4e, 0x4b, 0xe2, 0x7d, 0x52, 0xf9, 0x47, 0x0a, 0xff, 0x5a, 0xde, 0x18, 0x84, 0x1c, 0x0d, + 0x0a, 0xc0, 0xb7, 0x5f, 0x5e, 0x3f, 0x16, 0x66, 0x96, 0x07, 0x24, 0x84, 0x94, 0xd6, 0x66, 0x57, + 0xaf, 0x6b, 0x1d, 0xcd, 0xa9, 0x59, 0x2a, 0xae, 0x4b, 0x81, 0xf6, 0x1b, 0x76, 0x3b, 0x29, 0xd4, + 0xfb, 0x82, 0xf0, 0xdd, 0x23, 0xd5, 0xd9, 0x0e, 0x3e, 0x67, 0x51, 0x94, 0x71, 0xad, 0xeb, 0xd9, + 0x34, 0x5b, 0x3b, 0xc4, 0x67, 0x2c, 0x85, 0x5c, 0x1a, 0xa7, 0xf3, 0xef, 0x2b, 0xac, 0xd1, 0x7b, + 0x2b, 0x47, 0xcf, 0xd7, 0x5b, 0x17, 0x6d, 0xb6, 0x2e, 0xfa, 0xbd, 0x75, 0xd1, 0xa7, 0x9d, 0x6b, + 0x6d, 0x76, 0xae, 0xf5, 0x63, 0xe7, 0x5a, 0xef, 0x1e, 0x1f, 0x50, 0x07, 0x71, 0xc2, 0x02, 0x4d, + 0x07, 0xf1, 0x75, 0x38, 0x63, 0x42, 0xd2, 0x0f, 0xfb, 0xeb, 0x52, 0xe2, 0x83, 0xb3, 0xf2, 0xbf, + 0x7e, 0xfa, 0x27, 0x00, 0x00, 0xff, 0xff, 0x48, 0xb5, 0xa3, 0x9e, 0x4c, 0x03, 0x00, 0x00, } func (m *CommunityPoolMultiSpendProposal) Marshal() (dAtA []byte, err error) { diff --git a/x/kavadist/types/query.pb.go b/x/kavadist/types/query.pb.go index 397fc89f..62718acc 100644 --- a/x/kavadist/types/query.pb.go +++ b/x/kavadist/types/query.pb.go @@ -205,32 +205,33 @@ func init() { func init() { proto.RegisterFile("kava/kavadist/v1beta1/query.proto", fileDescriptor_08142b3a0a4f2f78) } var fileDescriptor_08142b3a0a4f2f78 = []byte{ - // 400 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0xcf, 0x6e, 0xda, 0x30, - 0x1c, 0x4e, 0xd8, 0x60, 0x92, 0xb9, 0x79, 0x20, 0x6d, 0xd1, 0x66, 0x20, 0x93, 0x26, 0x60, 0xc2, - 0x1e, 0xec, 0xb8, 0x5b, 0xb6, 0x07, 0xd8, 0x72, 0xec, 0xcd, 0x09, 0x56, 0x1a, 0x01, 0x71, 0x88, - 0x0d, 0x2a, 0xd7, 0x1e, 0x7b, 0xaa, 0xd4, 0x27, 0xe8, 0xb5, 0x4f, 0xc2, 0x11, 0xa9, 0x97, 0x9e, - 0xda, 0x0a, 0xfa, 0x20, 0x95, 0x63, 0x43, 0x8b, 0x0a, 0x88, 0x4b, 0x62, 0xfd, 0xfc, 0x7d, 0xbf, - 0xef, 0x4f, 0x02, 0x1a, 0x03, 0x3a, 0xa5, 0x44, 0x3d, 0xfa, 0xb1, 0x90, 0x64, 0xda, 0x0d, 0x98, - 0xa4, 0x5d, 0x32, 0x9e, 0xb0, 0x6c, 0x86, 0xd3, 0x8c, 0x4b, 0x0e, 0xab, 0xea, 0x16, 0xaf, 0x21, - 0xd8, 0x40, 0x1c, 0x14, 0x72, 0x31, 0xe2, 0x82, 0x04, 0x54, 0xb0, 0x0d, 0x2f, 0xe4, 0x71, 0xa2, - 0x69, 0x4e, 0x25, 0xe2, 0x11, 0xcf, 0x8f, 0x44, 0x9d, 0xcc, 0xf4, 0x4b, 0xc4, 0x79, 0x34, 0x64, - 0x84, 0xa6, 0x31, 0xa1, 0x49, 0xc2, 0x25, 0x95, 0x31, 0x4f, 0x84, 0xb9, 0x75, 0x77, 0xbb, 0x49, - 0x69, 0x46, 0x47, 0x06, 0xe3, 0x56, 0x00, 0xfc, 0xaf, 0xdc, 0xfd, 0xcb, 0x87, 0x3e, 0x1b, 0x4f, - 0x98, 0x90, 0xae, 0x0f, 0x3e, 0x6e, 0x4d, 0x45, 0xca, 0x13, 0xc1, 0xe0, 0x6f, 0x50, 0xd2, 0xe4, - 0x4f, 0x76, 0xdd, 0x6e, 0x96, 0x7b, 0x5f, 0xf1, 0xce, 0x30, 0x58, 0xd3, 0xbc, 0xf7, 0xf3, 0xfb, - 0x9a, 0xe5, 0x1b, 0x8a, 0x5b, 0x35, 0x3b, 0x3d, 0x3a, 0xa4, 0x49, 0xc8, 0xd6, 0x52, 0x33, 0x50, - 0xd9, 0x1e, 0x1b, 0x2d, 0x0a, 0x8a, 0x2a, 0xbe, 0x92, 0x7a, 0xd7, 0x2c, 0xf7, 0x3e, 0x63, 0x5d, - 0x10, 0x56, 0x05, 0x6d, 0x84, 0xfe, 0xf0, 0x38, 0xf1, 0x7e, 0x2a, 0x99, 0x9b, 0x87, 0x5a, 0x33, - 0x8a, 0xe5, 0xe9, 0x24, 0xc0, 0x21, 0x1f, 0x11, 0xd3, 0xa6, 0x7e, 0x75, 0x44, 0x7f, 0x40, 0xe4, - 0x2c, 0x65, 0x22, 0x27, 0x08, 0x5f, 0x6f, 0xee, 0x5d, 0x17, 0x40, 0x31, 0xd7, 0x86, 0x17, 0x36, - 0x28, 0x69, 0xd3, 0xb0, 0xb5, 0x27, 0xd3, 0xdb, 0x96, 0x9c, 0xf6, 0x31, 0x50, 0x1d, 0xc7, 0x6d, - 0x9d, 0xdf, 0x3e, 0x5d, 0x15, 0xbe, 0xc1, 0x06, 0x39, 0xf0, 0x51, 0x98, 0x64, 0x99, 0x50, 0x66, - 0x3e, 0x98, 0x36, 0xe0, 0x41, 0x89, 0xed, 0x26, 0x9d, 0x1f, 0x47, 0x61, 0x8d, 0x9f, 0xef, 0xb9, - 0x9f, 0x3a, 0x44, 0x7b, 0xfc, 0x04, 0x1a, 0xef, 0xfd, 0x9d, 0x2f, 0x91, 0xbd, 0x58, 0x22, 0xfb, - 0x71, 0x89, 0xec, 0xcb, 0x15, 0xb2, 0x16, 0x2b, 0x64, 0xdd, 0xad, 0x90, 0x75, 0xd2, 0x7e, 0x55, - 0xb7, 0xa2, 0x77, 0x86, 0x34, 0x10, 0x7a, 0xdb, 0xd9, 0xcb, 0xbe, 0xbc, 0xf6, 0xa0, 0x94, 0xff, - 0x6c, 0xbf, 0x9e, 0x03, 0x00, 0x00, 0xff, 0xff, 0x28, 0xdc, 0x24, 0xfa, 0x20, 0x03, 0x00, 0x00, + // 403 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0x4f, 0xcf, 0xd2, 0x30, + 0x1c, 0xde, 0x50, 0x30, 0x29, 0xb7, 0x0a, 0x89, 0x2e, 0x5a, 0x60, 0x26, 0x06, 0x24, 0xb4, 0x80, + 0x47, 0x6f, 0x33, 0xde, 0x75, 0x47, 0x6f, 0xdd, 0x68, 0xc6, 0x02, 0xb4, 0x63, 0x2d, 0x44, 0xae, + 0x1e, 0x3d, 0x99, 0xf8, 0x09, 0xbc, 0xfa, 0x49, 0x38, 0x92, 0x78, 0xf1, 0xa4, 0x06, 0xde, 0x0f, + 0xf2, 0xa6, 0x6b, 0xe1, 0x7d, 0xc9, 0x0b, 0x84, 0xcb, 0xd6, 0xfc, 0xfa, 0x3c, 0xbf, 0xe7, 0xcf, + 0x06, 0x5a, 0x13, 0xba, 0xa4, 0x44, 0x3f, 0x46, 0xa9, 0x54, 0x64, 0x39, 0x88, 0x98, 0xa2, 0x03, + 0x32, 0x5f, 0xb0, 0x7c, 0x85, 0xb3, 0x5c, 0x28, 0x01, 0xeb, 0xfa, 0x16, 0xef, 0x21, 0xd8, 0x42, + 0x3c, 0x14, 0x0b, 0x39, 0x13, 0x92, 0x44, 0x54, 0xb2, 0x03, 0x2f, 0x16, 0x29, 0x37, 0x34, 0xaf, + 0x96, 0x88, 0x44, 0x14, 0x47, 0xa2, 0x4f, 0x76, 0xfa, 0x22, 0x11, 0x22, 0x99, 0x32, 0x42, 0xb3, + 0x94, 0x50, 0xce, 0x85, 0xa2, 0x2a, 0x15, 0x5c, 0xda, 0x5b, 0xff, 0xb4, 0x9b, 0x8c, 0xe6, 0x74, + 0x66, 0x31, 0x7e, 0x0d, 0xc0, 0x4f, 0xda, 0xdd, 0xc7, 0x62, 0x18, 0xb2, 0xf9, 0x82, 0x49, 0xe5, + 0x87, 0xe0, 0xe9, 0xd1, 0x54, 0x66, 0x82, 0x4b, 0x06, 0xdf, 0x81, 0x8a, 0x21, 0x3f, 0x73, 0x9b, + 0x6e, 0xbb, 0x3a, 0x7c, 0x89, 0x4f, 0x86, 0xc1, 0x86, 0x16, 0x3c, 0x5e, 0xff, 0x6d, 0x38, 0xa1, + 0xa5, 0xf8, 0x75, 0xbb, 0x33, 0xa0, 0x53, 0xca, 0x63, 0xb6, 0x97, 0x5a, 0x81, 0xda, 0xf1, 0xd8, + 0x6a, 0x51, 0x50, 0xd6, 0xf1, 0xb5, 0xd4, 0xa3, 0x76, 0x75, 0xf8, 0x1c, 0x9b, 0x82, 0xb0, 0x2e, + 0xe8, 0x20, 0xf4, 0x5e, 0xa4, 0x3c, 0xe8, 0x6b, 0x99, 0x5f, 0xff, 0x1a, 0xed, 0x24, 0x55, 0xe3, + 0x45, 0x84, 0x63, 0x31, 0x23, 0xb6, 0x4d, 0xf3, 0xea, 0xc9, 0xd1, 0x84, 0xa8, 0x55, 0xc6, 0x64, + 0x41, 0x90, 0xa1, 0xd9, 0x3c, 0xfc, 0x59, 0x02, 0xe5, 0x42, 0x1b, 0x7e, 0x73, 0x41, 0xc5, 0x98, + 0x86, 0x9d, 0x33, 0x99, 0x1e, 0xb6, 0xe4, 0xbd, 0xb9, 0x06, 0x6a, 0xe2, 0xf8, 0x9d, 0xaf, 0xbf, + 0x6f, 0x7e, 0x94, 0x5e, 0xc1, 0x16, 0xb9, 0xf0, 0x51, 0x98, 0x62, 0xb9, 0xd4, 0x66, 0x9e, 0xd8, + 0x36, 0xe0, 0x45, 0x89, 0xe3, 0x26, 0xbd, 0xee, 0x55, 0x58, 0xeb, 0xe7, 0x75, 0xe1, 0xa7, 0x09, + 0xd1, 0x19, 0x3f, 0x91, 0xc1, 0x07, 0x1f, 0xd6, 0x5b, 0xe4, 0x6e, 0xb6, 0xc8, 0xfd, 0xbf, 0x45, + 0xee, 0xf7, 0x1d, 0x72, 0x36, 0x3b, 0xe4, 0xfc, 0xd9, 0x21, 0xe7, 0x73, 0xf7, 0x5e, 0xdd, 0xfd, + 0x64, 0x4a, 0x23, 0x49, 0xfa, 0x49, 0x2f, 0x1e, 0xd3, 0x94, 0x93, 0x2f, 0x77, 0x0b, 0x8b, 0xde, + 0xa3, 0x4a, 0xf1, 0xb7, 0xbd, 0xbd, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xfa, 0xe0, 0x74, 0x45, 0x21, + 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/liquid/types/query.pb.go b/x/liquid/types/query.pb.go index f771eb3b..6024d4fa 100644 --- a/x/liquid/types/query.pb.go +++ b/x/liquid/types/query.pb.go @@ -200,39 +200,39 @@ func init() { func init() { proto.RegisterFile("kava/liquid/v1beta1/query.proto", fileDescriptor_0d745428489be444) } var fileDescriptor_0d745428489be444 = []byte{ - // 499 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0x4f, 0x6f, 0xd3, 0x30, - 0x1c, 0x8d, 0x3b, 0x28, 0x9a, 0x77, 0x41, 0x66, 0x82, 0xac, 0x1a, 0xe9, 0x08, 0x97, 0x21, 0xd1, - 0x98, 0x16, 0x04, 0x82, 0x1b, 0x05, 0x71, 0x27, 0x43, 0x1c, 0xb8, 0x54, 0x4e, 0x62, 0xb9, 0xd6, - 0x32, 0x3b, 0x8d, 0x9d, 0x8a, 0x0a, 0x71, 0xe1, 0x13, 0x20, 0x4d, 0x88, 0xef, 0xc0, 0x19, 0xbe, - 0x43, 0x8f, 0x13, 0x1c, 0xe0, 0xc4, 0x9f, 0x96, 0x0f, 0x82, 0x62, 0xbb, 0x63, 0x62, 0xdd, 0x34, - 0x4e, 0xb1, 0xfd, 0x7b, 0xef, 0xf9, 0xf9, 0xf7, 0x7e, 0x81, 0xed, 0x5d, 0x32, 0x26, 0x38, 0xe7, - 0xa3, 0x8a, 0x67, 0x78, 0xdc, 0x4d, 0xa8, 0x26, 0x5d, 0x3c, 0xaa, 0x68, 0x39, 0x89, 0x8a, 0x52, - 0x6a, 0x89, 0x2e, 0xd5, 0x80, 0xc8, 0x02, 0x22, 0x07, 0x68, 0x05, 0xa9, 0x54, 0x7b, 0x52, 0xe1, - 0x84, 0x28, 0x7a, 0xc8, 0x4a, 0x25, 0x17, 0x96, 0xd4, 0xda, 0xb0, 0xf5, 0x81, 0xd9, 0x61, 0xbb, - 0x71, 0xa5, 0x75, 0x26, 0x99, 0xb4, 0xe7, 0xf5, 0xca, 0x9d, 0x6e, 0x32, 0x29, 0x59, 0x4e, 0x31, - 0x29, 0x38, 0x26, 0x42, 0x48, 0x4d, 0x34, 0x97, 0xc2, 0x71, 0xc2, 0xe7, 0x70, 0xf3, 0x69, 0x6d, - 0xe9, 0x31, 0xcd, 0x29, 0x23, 0x9a, 0x66, 0x7d, 0x92, 0x13, 0x91, 0xd2, 0x98, 0x8e, 0x2a, 0xaa, - 0x34, 0xba, 0x0b, 0x57, 0x33, 0x5b, 0x92, 0xa5, 0x0f, 0xb6, 0xc0, 0xf6, 0x6a, 0xdf, 0xff, 0xfc, - 0xb1, 0xb3, 0xee, 0x2e, 0x7e, 0x98, 0x65, 0x25, 0x55, 0x6a, 0x47, 0x97, 0x5c, 0xb0, 0xf8, 0x2f, - 0x34, 0xdc, 0x07, 0xf0, 0xea, 0x09, 0xc2, 0xaa, 0x90, 0x42, 0x51, 0x74, 0x0f, 0x36, 0xc7, 0x54, - 0x69, 0x9a, 0x19, 0xd9, 0xb5, 0xde, 0x46, 0xe4, 0x34, 0xeb, 0x97, 0x2f, 0xda, 0x11, 0x3d, 0x92, - 0x5c, 0xf4, 0xcf, 0x4d, 0xbf, 0xb7, 0xbd, 0xd8, 0xc1, 0xd1, 0x7d, 0x78, 0xa1, 0x5e, 0x71, 0xc1, - 0xfc, 0xc6, 0xd9, 0x98, 0x0b, 0x7c, 0xb8, 0x01, 0xaf, 0x18, 0x53, 0xcf, 0xa4, 0x26, 0xf9, 0x4e, - 0x55, 0x14, 0xf9, 0xc4, 0x3d, 0x34, 0x7c, 0x0f, 0xa0, 0x7f, 0xbc, 0xe6, 0xbc, 0x5e, 0x86, 0xcd, - 0x21, 0xe5, 0x6c, 0xa8, 0x8d, 0xd7, 0x95, 0xd8, 0xed, 0x50, 0x0a, 0x9b, 0x25, 0x55, 0x55, 0xae, - 0xfd, 0xc6, 0xd6, 0xca, 0xe9, 0x4e, 0x6e, 0xd5, 0x4e, 0x3e, 0xfc, 0x68, 0x6f, 0x33, 0xae, 0x87, - 0x55, 0x12, 0xa5, 0x72, 0xcf, 0xa5, 0xe7, 0x3e, 0x1d, 0x95, 0xed, 0x62, 0x3d, 0x29, 0xa8, 0x32, - 0x04, 0x15, 0x3b, 0xe9, 0xde, 0xd7, 0x06, 0x3c, 0x6f, 0x9c, 0xa1, 0x4f, 0x00, 0x5e, 0xfc, 0xb7, - 0x9f, 0xa8, 0x1b, 0x2d, 0x19, 0xa3, 0xe8, 0xb4, 0x50, 0x5b, 0xbd, 0xff, 0xa1, 0xd8, 0x16, 0x84, - 0x0f, 0xde, 0x7c, 0xf9, 0xbd, 0xdf, 0xb8, 0x83, 0x7a, 0x78, 0xd9, 0x58, 0x67, 0x0b, 0xda, 0x20, - 0xb1, 0x3c, 0xfc, 0xea, 0x70, 0x16, 0x5e, 0xa3, 0x77, 0x00, 0xae, 0x1d, 0x69, 0x2b, 0xba, 0x79, - 0xf2, 0xfd, 0xc7, 0x93, 0x69, 0x75, 0xce, 0x88, 0x76, 0x46, 0x6f, 0x18, 0xa3, 0xd7, 0xd1, 0xb5, - 0xa5, 0x46, 0x75, 0xcd, 0x18, 0x28, 0x43, 0xe9, 0x3f, 0x99, 0xfe, 0x0a, 0xbc, 0xe9, 0x2c, 0x00, - 0x07, 0xb3, 0x00, 0xfc, 0x9c, 0x05, 0xe0, 0xed, 0x3c, 0xf0, 0x0e, 0xe6, 0x81, 0xf7, 0x6d, 0x1e, - 0x78, 0x2f, 0x8e, 0x26, 0x55, 0x4b, 0x75, 0x72, 0x92, 0x28, 0x2b, 0xfa, 0x72, 0x21, 0x6b, 0xf2, - 0x4a, 0x9a, 0xe6, 0x5f, 0xba, 0xfd, 0x27, 0x00, 0x00, 0xff, 0xff, 0xb8, 0xc2, 0xc4, 0x35, 0xf2, - 0x03, 0x00, 0x00, + // 507 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0x4f, 0x6f, 0xd3, 0x30, + 0x18, 0xc6, 0xe3, 0x0e, 0x8a, 0xe6, 0x5d, 0x90, 0x99, 0x20, 0xad, 0x46, 0x3a, 0xc2, 0x65, 0x93, + 0x68, 0xdc, 0x16, 0x04, 0x82, 0x1b, 0x05, 0x89, 0x33, 0x19, 0xe2, 0xc0, 0xa5, 0x72, 0x12, 0xcb, + 0xb5, 0x96, 0xd9, 0x69, 0xec, 0x54, 0x54, 0x88, 0x0b, 0x9f, 0x00, 0x69, 0x42, 0x7c, 0x07, 0xce, + 0xf0, 0x1d, 0x7a, 0x9c, 0xe0, 0x00, 0x27, 0xfe, 0xb4, 0x7c, 0x10, 0x14, 0xc7, 0x1d, 0x13, 0xeb, + 0xa6, 0x72, 0x8a, 0xed, 0xf7, 0x79, 0x5e, 0xff, 0xfc, 0xbe, 0x6f, 0x60, 0x6b, 0x9f, 0x8c, 0x09, + 0x4e, 0xf9, 0xa8, 0xe0, 0x09, 0x1e, 0x77, 0x23, 0xaa, 0x49, 0x17, 0x8f, 0x0a, 0x9a, 0x4f, 0x82, + 0x2c, 0x97, 0x5a, 0xa2, 0x2b, 0xa5, 0x20, 0xa8, 0x04, 0x81, 0x15, 0x34, 0xbd, 0x58, 0xaa, 0x03, + 0xa9, 0x70, 0x44, 0x14, 0x3d, 0x76, 0xc5, 0x92, 0x8b, 0xca, 0xd4, 0x6c, 0x54, 0xf1, 0x81, 0xd9, + 0xe1, 0x6a, 0x63, 0x43, 0x9b, 0x4c, 0x32, 0x59, 0x9d, 0x97, 0x2b, 0x7b, 0xba, 0xc5, 0xa4, 0x64, + 0x29, 0xc5, 0x24, 0xe3, 0x98, 0x08, 0x21, 0x35, 0xd1, 0x5c, 0x0a, 0xeb, 0xf1, 0x9f, 0xc3, 0xad, + 0xa7, 0x25, 0xd2, 0x63, 0x9a, 0x52, 0x46, 0x34, 0x4d, 0xfa, 0x24, 0x25, 0x22, 0xa6, 0x21, 0x1d, + 0x15, 0x54, 0x69, 0x74, 0x17, 0xae, 0x27, 0x55, 0x48, 0xe6, 0x2e, 0xd8, 0x06, 0x3b, 0xeb, 0x7d, + 0xf7, 0xf3, 0xc7, 0xf6, 0xa6, 0xbd, 0xf8, 0x61, 0x92, 0xe4, 0x54, 0xa9, 0x3d, 0x9d, 0x73, 0xc1, + 0xc2, 0xbf, 0x52, 0xff, 0x10, 0xc0, 0xeb, 0x67, 0x24, 0x56, 0x99, 0x14, 0x8a, 0xa2, 0x7b, 0xb0, + 0x3e, 0xa6, 0x4a, 0xd3, 0xc4, 0xa4, 0xdd, 0xe8, 0x35, 0x02, 0x9b, 0xb3, 0x7c, 0xf9, 0xa2, 0x1c, + 0xc1, 0x23, 0xc9, 0x45, 0xff, 0xc2, 0xf4, 0x7b, 0xcb, 0x09, 0xad, 0x1c, 0xdd, 0x87, 0x97, 0xca, + 0x15, 0x17, 0xcc, 0xad, 0xad, 0xe6, 0x5c, 0xe8, 0xfd, 0x06, 0xbc, 0x66, 0xa0, 0x9e, 0x49, 0x4d, + 0xd2, 0xbd, 0x22, 0xcb, 0xd2, 0x89, 0x7d, 0xa8, 0xff, 0x1e, 0x40, 0xf7, 0x74, 0xcc, 0xb2, 0x5e, + 0x85, 0xf5, 0x21, 0xe5, 0x6c, 0xa8, 0x0d, 0xeb, 0x5a, 0x68, 0x77, 0x28, 0x86, 0xf5, 0x9c, 0xaa, + 0x22, 0xd5, 0x6e, 0x6d, 0x7b, 0xed, 0x7c, 0x92, 0x4e, 0x49, 0xf2, 0xe1, 0x47, 0x6b, 0x87, 0x71, + 0x3d, 0x2c, 0xa2, 0x20, 0x96, 0x07, 0xb6, 0x7b, 0xf6, 0xd3, 0x56, 0xc9, 0x3e, 0xd6, 0x93, 0x8c, + 0x2a, 0x63, 0x50, 0xa1, 0x4d, 0xdd, 0xfb, 0x5a, 0x83, 0x17, 0x0d, 0x19, 0xfa, 0x04, 0xe0, 0xe5, + 0x7f, 0xeb, 0x89, 0xba, 0xc1, 0x92, 0x31, 0x0a, 0xce, 0x6b, 0x6a, 0xb3, 0xf7, 0x3f, 0x96, 0xaa, + 0x04, 0xfe, 0x83, 0x37, 0x5f, 0x7e, 0x1f, 0xd6, 0xee, 0xa0, 0x1e, 0x5e, 0x36, 0xd6, 0xc9, 0xc2, + 0x36, 0x88, 0x2a, 0x1f, 0x7e, 0x75, 0x3c, 0x0b, 0xaf, 0xd1, 0x3b, 0x00, 0x37, 0x4e, 0x94, 0x15, + 0xdd, 0x3a, 0xfb, 0xfe, 0xd3, 0x9d, 0x69, 0xb6, 0x57, 0x54, 0x5b, 0xd0, 0x5d, 0x03, 0x7a, 0x13, + 0xdd, 0x58, 0x0a, 0xaa, 0x4b, 0xc7, 0x40, 0x19, 0x4b, 0xff, 0xc9, 0xf4, 0x97, 0xe7, 0x4c, 0x67, + 0x1e, 0x38, 0x9a, 0x79, 0xe0, 0xe7, 0xcc, 0x03, 0x6f, 0xe7, 0x9e, 0x73, 0x34, 0xf7, 0x9c, 0x6f, + 0x73, 0xcf, 0x79, 0xb1, 0x7b, 0xa2, 0x53, 0x1d, 0x96, 0x92, 0x48, 0xe1, 0x0e, 0x6b, 0xc7, 0x43, + 0xc2, 0x05, 0x7e, 0xb9, 0xc8, 0x6b, 0x1a, 0x16, 0xd5, 0xcd, 0xcf, 0x74, 0xfb, 0x4f, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x23, 0x67, 0xe2, 0xa2, 0xf3, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/liquid/types/tx.pb.go b/x/liquid/types/tx.pb.go index 1fde9eba..5b90167e 100644 --- a/x/liquid/types/tx.pb.go +++ b/x/liquid/types/tx.pb.go @@ -254,34 +254,34 @@ func init() { func init() { proto.RegisterFile("kava/liquid/v1beta1/tx.proto", fileDescriptor_738981106e50f269) } var fileDescriptor_738981106e50f269 = []byte{ - // 421 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x53, 0xbd, 0xae, 0xda, 0x30, - 0x14, 0x8e, 0x7b, 0x2b, 0x54, 0x5c, 0xe9, 0x4a, 0x4d, 0xef, 0x10, 0xd0, 0x55, 0x40, 0x0c, 0x88, - 0x25, 0x4e, 0xa1, 0x43, 0x87, 0x76, 0x69, 0xca, 0xca, 0x92, 0x2e, 0xa8, 0x4b, 0xe5, 0x24, 0x56, - 0xb0, 0x00, 0x9b, 0xda, 0x4e, 0x44, 0xdf, 0xa2, 0x0f, 0xd0, 0xc7, 0xe0, 0x21, 0x18, 0x11, 0x53, - 0xdb, 0x01, 0x55, 0xf0, 0x22, 0x55, 0x12, 0x13, 0xca, 0x9f, 0xc4, 0x78, 0x27, 0xdb, 0xe7, 0x3b, - 0xdf, 0xf1, 0xf9, 0xbe, 0x63, 0xc3, 0xc7, 0x31, 0x4e, 0xb1, 0x3b, 0xa1, 0xdf, 0x12, 0x1a, 0xb9, - 0x69, 0x37, 0x20, 0x0a, 0x77, 0x5d, 0x35, 0x47, 0x33, 0xc1, 0x15, 0x37, 0x5f, 0x67, 0x28, 0x2a, - 0x50, 0xa4, 0xd1, 0xba, 0x1d, 0x72, 0x39, 0xe5, 0xd2, 0x0d, 0xb0, 0x24, 0x25, 0x25, 0xe4, 0x94, - 0x15, 0xa4, 0x7a, 0xad, 0xc0, 0xbf, 0xe6, 0x27, 0xb7, 0x38, 0x68, 0xe8, 0x21, 0xe6, 0x31, 0x2f, - 0xe2, 0xd9, 0xae, 0x88, 0xb6, 0x7e, 0x02, 0xf8, 0x6a, 0x20, 0xe3, 0x01, 0x65, 0xaa, 0x4f, 0x04, - 0x4d, 0xb1, 0xa2, 0x29, 0x31, 0xdf, 0xc0, 0x8a, 0x24, 0x2c, 0x22, 0xc2, 0x02, 0x4d, 0xd0, 0xa9, - 0x7a, 0xd6, 0x7a, 0xe1, 0x3c, 0xe8, 0x6a, 0x1f, 0xa3, 0x48, 0x10, 0x29, 0x3f, 0x2b, 0x41, 0x59, - 0xec, 0xeb, 0x3c, 0xf3, 0x11, 0x56, 0x53, 0x3c, 0xa1, 0x11, 0x56, 0x5c, 0x58, 0xcf, 0x32, 0x92, - 0x7f, 0x08, 0x98, 0xef, 0x60, 0x05, 0x4f, 0x79, 0xc2, 0x94, 0x75, 0xd7, 0x04, 0x9d, 0x97, 0xbd, - 0x1a, 0xd2, 0xc5, 0x32, 0x1d, 0x7b, 0x71, 0xe8, 0x13, 0xa7, 0xcc, 0x7b, 0xbe, 0xdc, 0x34, 0x0c, - 0x5f, 0xa7, 0xb7, 0x86, 0xb0, 0x76, 0xd6, 0x9d, 0x4f, 0xe4, 0x8c, 0x33, 0x49, 0xcc, 0xf7, 0xf0, - 0x85, 0x20, 0x21, 0xa1, 0x29, 0x89, 0xf2, 0x3e, 0x6f, 0xa8, 0x5b, 0x12, 0xf6, 0xc2, 0xbd, 0x44, - 0xb0, 0xa7, 0x28, 0x3c, 0xc9, 0x85, 0x1f, 0x77, 0x57, 0x0a, 0x1f, 0x9e, 0x08, 0xaf, 0x7a, 0x1f, - 0x32, 0xf2, 0x9f, 0x4d, 0xa3, 0x1d, 0x53, 0x35, 0x4a, 0x02, 0x14, 0xf2, 0xa9, 0x9e, 0xbe, 0x5e, - 0x1c, 0x19, 0x8d, 0x5d, 0xf5, 0x7d, 0x46, 0x24, 0xea, 0x93, 0x70, 0xbd, 0x70, 0xa0, 0x6e, 0xa4, - 0x4f, 0xc2, 0x83, 0x2b, 0xbd, 0xdf, 0x00, 0xde, 0x0d, 0x64, 0x6c, 0x8e, 0xe0, 0xfd, 0xc9, 0x93, - 0x68, 0xa3, 0x0b, 0xef, 0x11, 0x9d, 0x0d, 0xa7, 0x8e, 0x6e, 0xcb, 0x2b, 0xb5, 0x8c, 0xe0, 0xfd, - 0xc9, 0x0c, 0xae, 0xde, 0x74, 0x9c, 0x77, 0xfd, 0xa6, 0xcb, 0xae, 0x79, 0xde, 0x72, 0x6b, 0x83, - 0xd5, 0xd6, 0x06, 0x7f, 0xb7, 0x36, 0xf8, 0xb1, 0xb3, 0x8d, 0xd5, 0xce, 0x36, 0x7e, 0xed, 0x6c, - 0xe3, 0x4b, 0xe7, 0x3f, 0xd7, 0xb2, 0x9a, 0xce, 0x04, 0x07, 0x32, 0xdf, 0xb9, 0xf3, 0xfd, 0xff, - 0xcc, 0xbd, 0x0b, 0x2a, 0xf9, 0xaf, 0x79, 0xfb, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x40, 0x82, 0xe3, - 0xbf, 0xbb, 0x03, 0x00, 0x00, + // 429 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x53, 0xbd, 0x6e, 0xdb, 0x30, + 0x10, 0x16, 0x9b, 0xc2, 0xa8, 0x59, 0x20, 0x40, 0xd5, 0x0c, 0xb2, 0x11, 0x28, 0x41, 0x86, 0x20, + 0x1d, 0x44, 0x3a, 0xe9, 0xd0, 0xa1, 0x5d, 0xaa, 0x78, 0xf5, 0xa2, 0x2e, 0x41, 0x97, 0x82, 0x92, + 0x08, 0x8a, 0x88, 0x4d, 0xba, 0x24, 0x25, 0xa4, 0x6f, 0xd1, 0x07, 0xe8, 0x63, 0xe4, 0x21, 0x32, + 0x1a, 0x9e, 0xda, 0x0e, 0x46, 0x61, 0xbf, 0x48, 0x21, 0x89, 0x96, 0xeb, 0x3f, 0xc0, 0x63, 0x27, + 0x89, 0xf7, 0xdd, 0x77, 0xbc, 0xef, 0x3b, 0x1e, 0x3c, 0xbd, 0x27, 0x05, 0xc1, 0x43, 0xfe, 0x35, + 0xe7, 0x29, 0x2e, 0xae, 0x63, 0x6a, 0xc8, 0x35, 0x36, 0x0f, 0x68, 0xac, 0xa4, 0x91, 0xee, 0xeb, + 0x12, 0x45, 0x35, 0x8a, 0x2c, 0xda, 0xf5, 0x13, 0xa9, 0x47, 0x52, 0xe3, 0x98, 0x68, 0xda, 0x50, + 0x12, 0xc9, 0x45, 0x4d, 0xea, 0x76, 0x6a, 0xfc, 0x4b, 0x75, 0xc2, 0xf5, 0xc1, 0x42, 0x27, 0x4c, + 0x32, 0x59, 0xc7, 0xcb, 0xbf, 0x3a, 0x7a, 0xf1, 0x03, 0xc0, 0x57, 0x03, 0xcd, 0x06, 0x5c, 0x98, + 0x3e, 0x55, 0xbc, 0x20, 0x86, 0x17, 0xd4, 0xed, 0xc1, 0x96, 0xa6, 0x22, 0xa5, 0xca, 0x03, 0xe7, + 0xe0, 0xaa, 0x1d, 0x7a, 0xd3, 0xc7, 0xe0, 0xc4, 0x56, 0xfb, 0x98, 0xa6, 0x8a, 0x6a, 0xfd, 0xc9, + 0x28, 0x2e, 0x58, 0x64, 0xf3, 0xdc, 0x53, 0xd8, 0x2e, 0xc8, 0x90, 0xa7, 0xc4, 0x48, 0xe5, 0x3d, + 0x2b, 0x49, 0xd1, 0x2a, 0xe0, 0xbe, 0x83, 0x2d, 0x32, 0x92, 0xb9, 0x30, 0xde, 0xd1, 0x39, 0xb8, + 0x7a, 0x79, 0xd3, 0x41, 0xb6, 0x58, 0xa9, 0x63, 0x29, 0x0e, 0xdd, 0x4a, 0x2e, 0xc2, 0xe7, 0x4f, + 0xb3, 0x33, 0x27, 0xb2, 0xe9, 0x17, 0x77, 0xb0, 0xb3, 0xd5, 0x5d, 0x44, 0xf5, 0x58, 0x0a, 0x4d, + 0xdd, 0xf7, 0xf0, 0x85, 0xa2, 0x09, 0xe5, 0x05, 0x4d, 0xab, 0x3e, 0x0f, 0xa8, 0xdb, 0x10, 0x96, + 0xc2, 0xc3, 0x5c, 0x89, 0xff, 0x51, 0x78, 0x5e, 0x09, 0x5f, 0xef, 0xae, 0x11, 0x7e, 0xb7, 0x21, + 0xbc, 0x1d, 0x7e, 0x28, 0xc9, 0xbf, 0x67, 0x67, 0x97, 0x8c, 0x9b, 0x2c, 0x8f, 0x51, 0x22, 0x47, + 0x76, 0xfa, 0xf6, 0x13, 0xe8, 0xf4, 0x1e, 0x9b, 0x6f, 0x63, 0xaa, 0x51, 0x9f, 0x26, 0xd3, 0xc7, + 0x00, 0xda, 0x46, 0xfa, 0x34, 0x59, 0xb9, 0x72, 0xf3, 0x0b, 0xc0, 0xa3, 0x81, 0x66, 0x6e, 0x06, + 0x8f, 0x37, 0x9e, 0xc4, 0x25, 0xda, 0xf1, 0x1e, 0xd1, 0xd6, 0x70, 0xba, 0xe8, 0xb0, 0xbc, 0x46, + 0x4b, 0x06, 0x8f, 0x37, 0x66, 0xb0, 0xf7, 0xa6, 0xf5, 0xbc, 0xfd, 0x37, 0xed, 0x76, 0x2d, 0xbc, + 0x7d, 0x9a, 0xfb, 0x60, 0x32, 0xf7, 0xc1, 0x9f, 0xb9, 0x0f, 0xbe, 0x2f, 0x7c, 0x67, 0xb2, 0xf0, + 0x9d, 0x9f, 0x0b, 0xdf, 0xf9, 0xfc, 0xe6, 0x1f, 0xd7, 0x7a, 0x6c, 0x48, 0x62, 0x8d, 0x7b, 0x2c, + 0x48, 0x32, 0xc2, 0x05, 0x7e, 0x58, 0x2e, 0x68, 0x65, 0x5e, 0xdc, 0xaa, 0xd6, 0xe6, 0xed, 0xdf, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x66, 0x13, 0x6b, 0x83, 0xbc, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/pricefeed/types/genesis.pb.go b/x/pricefeed/types/genesis.pb.go index 3b2d8074..12d34d2b 100644 --- a/x/pricefeed/types/genesis.pb.go +++ b/x/pricefeed/types/genesis.pb.go @@ -86,7 +86,7 @@ func init() { } var fileDescriptor_fffec798191784d2 = []byte{ - // 262 bytes of a gzipped FileDescriptorProto + // 268 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xc9, 0x4e, 0x2c, 0x4b, 0xd4, 0x2f, 0x28, 0xca, 0x4c, 0x4e, 0x4d, 0x4b, 0x4d, 0x4d, 0xd1, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, @@ -98,12 +98,12 @@ var fileDescriptor_fffec798191784d2 = []byte{ 0x82, 0xea, 0x11, 0x8a, 0xe3, 0xe2, 0x2d, 0xc8, 0x2f, 0x2e, 0x49, 0x4d, 0x89, 0x07, 0x6b, 0x28, 0x96, 0x60, 0x52, 0x60, 0xd6, 0xe0, 0x36, 0x52, 0xc6, 0x69, 0x08, 0x58, 0x71, 0x00, 0x48, 0xdc, 0x49, 0x04, 0x64, 0xd2, 0xaa, 0xfb, 0xf2, 0x3c, 0x48, 0x82, 0xc5, 0x41, 0x3c, 0x05, 0x48, 0x3c, - 0x27, 0xdf, 0x07, 0x0f, 0xe5, 0x18, 0x57, 0x3c, 0x92, 0x63, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, + 0x27, 0xbf, 0x07, 0x0f, 0xe5, 0x18, 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, 0xed, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, - 0x7d, 0x90, 0xa5, 0xba, 0x39, 0x89, 0x49, 0xc5, 0x60, 0x96, 0x7e, 0x05, 0x52, 0x58, 0x94, 0x54, - 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x03, 0xc1, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xcf, 0xf3, - 0x1e, 0xef, 0x7e, 0x01, 0x00, 0x00, + 0xc6, 0x63, 0x39, 0x86, 0x28, 0x9d, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, + 0x7d, 0x83, 0xf4, 0x9c, 0xc4, 0xa4, 0x62, 0x7d, 0x83, 0x74, 0xdd, 0xe4, 0x8c, 0xc4, 0xcc, 0x3c, + 0xfd, 0x0a, 0xa4, 0xc0, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x87, 0x82, 0x31, 0x20, + 0x00, 0x00, 0xff, 0xff, 0xbb, 0x51, 0xdc, 0x9c, 0x7f, 0x01, 0x00, 0x00, } func (this *GenesisState) VerboseEqual(that interface{}) error { diff --git a/x/pricefeed/types/query.pb.go b/x/pricefeed/types/query.pb.go index a4111a2d..1d92b38a 100644 --- a/x/pricefeed/types/query.pb.go +++ b/x/pricefeed/types/query.pb.go @@ -701,63 +701,63 @@ func init() { } var fileDescriptor_84567be3085e4c6c = []byte{ - // 884 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xcf, 0x6f, 0x1b, 0x45, - 0x14, 0xc7, 0x3d, 0xa9, 0x7f, 0x4e, 0xa1, 0x88, 0xa9, 0x13, 0x2c, 0xd3, 0xee, 0x86, 0x95, 0x08, - 0x6d, 0x1c, 0xef, 0xaa, 0xa9, 0xa8, 0x50, 0xc5, 0xa5, 0x26, 0x07, 0x7a, 0xa8, 0x80, 0x15, 0x97, - 0x72, 0xb1, 0xc6, 0xde, 0xa9, 0xbb, 0x4a, 0xec, 0xd9, 0xec, 0x8c, 0xe3, 0x46, 0x08, 0x09, 0x21, - 0x24, 0xca, 0x01, 0x29, 0x82, 0x13, 0x37, 0xb8, 0x21, 0x24, 0xfe, 0x8f, 0x1c, 0x23, 0x71, 0x41, - 0x1c, 0x92, 0xe0, 0x70, 0xe3, 0x9f, 0x40, 0x3b, 0xf3, 0x76, 0xf1, 0x26, 0xde, 0x64, 0x2d, 0x4e, - 0xc9, 0xbe, 0x7d, 0x3f, 0x3e, 0xef, 0xbb, 0x33, 0x5f, 0x63, 0x6b, 0x9b, 0xee, 0x51, 0x27, 0x08, - 0xfd, 0x3e, 0x7b, 0xc6, 0x98, 0xe7, 0xec, 0xdd, 0xeb, 0x31, 0x49, 0xef, 0x39, 0xbb, 0x63, 0x16, - 0xee, 0xdb, 0x41, 0xc8, 0x25, 0x27, 0x2b, 0x51, 0x8e, 0x9d, 0xe4, 0xd8, 0x90, 0xd3, 0xac, 0x0f, - 0xf8, 0x80, 0xab, 0x14, 0x27, 0xfa, 0x4f, 0x67, 0x37, 0x6f, 0x0d, 0x38, 0x1f, 0xec, 0x30, 0x87, - 0x06, 0xbe, 0x43, 0x47, 0x23, 0x2e, 0xa9, 0xf4, 0xf9, 0x48, 0xc0, 0x5b, 0x13, 0xde, 0xaa, 0xa7, - 0xde, 0xf8, 0x99, 0x23, 0xfd, 0x21, 0x13, 0x92, 0x0e, 0x03, 0x48, 0xc8, 0x02, 0x12, 0x92, 0x87, - 0x4c, 0xe7, 0x58, 0x75, 0x4c, 0x3e, 0x89, 0xf8, 0x3e, 0xa6, 0x21, 0x1d, 0x0a, 0x97, 0xed, 0x8e, - 0x99, 0x90, 0xd6, 0x53, 0x7c, 0x33, 0x15, 0x15, 0x01, 0x1f, 0x09, 0x46, 0xde, 0xc7, 0xe5, 0x40, - 0x45, 0x1a, 0x68, 0x15, 0xdd, 0xb9, 0xbe, 0x69, 0xd8, 0xf3, 0xd7, 0xb1, 0x75, 0x5d, 0xa7, 0x78, - 0x78, 0x6c, 0x16, 0x5c, 0xa8, 0x79, 0x58, 0x7c, 0xf9, 0x93, 0x59, 0xb0, 0x1e, 0xe0, 0xd7, 0x75, - 0xeb, 0xa8, 0x08, 0xe6, 0x91, 0x37, 0x71, 0x6d, 0x48, 0xc3, 0x6d, 0x26, 0xbb, 0xbe, 0xa7, 0x7a, - 0xd7, 0xdc, 0xaa, 0x0e, 0x3c, 0xf6, 0xa0, 0xce, 0x8b, 0x41, 0x75, 0x1d, 0x10, 0x7d, 0x88, 0x4b, - 0x6a, 0x3a, 0x00, 0x6d, 0x64, 0x01, 0x7d, 0x30, 0x0e, 0x43, 0x36, 0x92, 0xa9, 0x62, 0xc0, 0xd3, - 0x0d, 0x60, 0x4a, 0x7d, 0x76, 0x4a, 0x22, 0xc7, 0x97, 0x28, 0xd6, 0x03, 0xc2, 0x30, 0xbd, 0x8f, - 0xcb, 0xaa, 0x38, 0xd2, 0xe3, 0xda, 0xc2, 0xe3, 0x6f, 0x47, 0xe3, 0x7f, 0x3d, 0x31, 0x97, 0xe7, - 0xbd, 0x15, 0x2e, 0xb4, 0x06, 0xb0, 0x87, 0x78, 0x59, 0x11, 0xb8, 0x74, 0x92, 0x62, 0xcb, 0x23, - 0xdd, 0x4b, 0x84, 0x57, 0xce, 0x17, 0xc3, 0x06, 0xcf, 0x31, 0x0e, 0xe9, 0xa4, 0x9b, 0xda, 0xa2, - 0x95, 0xf9, 0x55, 0xb9, 0x90, 0xcc, 0x4b, 0x2f, 0x71, 0x0b, 0x96, 0xa8, 0xcf, 0x79, 0x29, 0xdc, - 0x5a, 0x18, 0x4f, 0x04, 0x94, 0xf7, 0x40, 0xc8, 0x8f, 0x42, 0xda, 0xdf, 0x59, 0x68, 0x89, 0x07, - 0xb8, 0x9e, 0xae, 0x84, 0x0d, 0x1a, 0xb8, 0xc2, 0x75, 0x48, 0xe1, 0xd7, 0xdc, 0xf8, 0x11, 0xea, - 0x96, 0x61, 0xe2, 0x13, 0xd5, 0x2e, 0xf9, 0xa4, 0x13, 0x68, 0x97, 0x84, 0xa1, 0xdd, 0x53, 0x5c, - 0xd1, 0x83, 0x63, 0x35, 0xd6, 0xb2, 0xd4, 0xd0, 0x95, 0x89, 0x10, 0x6f, 0x80, 0x10, 0xaf, 0xa5, - 0xe3, 0xc2, 0x8d, 0xfb, 0x01, 0xcf, 0x3f, 0x08, 0xdf, 0x9c, 0xa3, 0x15, 0xb9, 0x7b, 0x41, 0x82, - 0xce, 0x2b, 0xd3, 0x63, 0xb3, 0xaa, 0xdb, 0x3d, 0xde, 0xfa, 0x4f, 0x10, 0xf2, 0x36, 0xbe, 0xa1, - 0x77, 0xec, 0x52, 0xcf, 0x0b, 0x99, 0x10, 0x8d, 0x25, 0x25, 0xd9, 0xab, 0x3a, 0xfa, 0x48, 0x07, - 0xc9, 0x56, 0x7c, 0x37, 0xae, 0xa9, 0x6e, 0x76, 0x04, 0xf8, 0xe7, 0xb1, 0xb9, 0x36, 0xf0, 0xe5, - 0xf3, 0x71, 0xcf, 0xee, 0xf3, 0xa1, 0xd3, 0xe7, 0x62, 0xc8, 0x05, 0xfc, 0x69, 0x0b, 0x6f, 0xdb, - 0x91, 0xfb, 0x01, 0x13, 0xf6, 0x16, 0xeb, 0xc3, 0xbd, 0x88, 0xee, 0x3c, 0x7b, 0x11, 0xf8, 0xe1, - 0x7e, 0xa3, 0xa8, 0xae, 0x58, 0xd3, 0xd6, 0xb6, 0x63, 0xc7, 0xb6, 0x63, 0x7f, 0x1a, 0xdb, 0x4e, - 0xa7, 0x1a, 0x8d, 0x38, 0x38, 0x31, 0x91, 0x0b, 0x35, 0xd6, 0x37, 0x08, 0xd7, 0xe7, 0x1d, 0xef, - 0x45, 0xd6, 0x4d, 0xf6, 0x58, 0xfa, 0x1f, 0x7b, 0x58, 0xbf, 0x21, 0x7c, 0x23, 0xfd, 0x69, 0x16, - 0x61, 0xb8, 0x8d, 0x71, 0x8f, 0x0a, 0xd6, 0xa5, 0x42, 0x30, 0x09, 0x72, 0xd7, 0xa2, 0xc8, 0xa3, - 0x28, 0x40, 0x4c, 0x7c, 0x7d, 0x77, 0xcc, 0x65, 0xfc, 0x5e, 0x09, 0xee, 0x62, 0x15, 0xd2, 0x09, - 0x33, 0xa7, 0xb4, 0x98, 0x3a, 0xa5, 0x64, 0x05, 0x97, 0x69, 0x5f, 0xfa, 0x7b, 0xac, 0x51, 0x5a, - 0x45, 0x77, 0xaa, 0x2e, 0x3c, 0x6d, 0x7e, 0x5d, 0xc1, 0x25, 0x75, 0x42, 0xc9, 0xb7, 0x08, 0x97, - 0xb5, 0xa1, 0x92, 0xf5, 0xac, 0xc3, 0x78, 0xd1, 0xc3, 0x9b, 0xad, 0x5c, 0xb9, 0x5a, 0x0a, 0x6b, - 0xed, 0xab, 0xdf, 0xff, 0xfe, 0x61, 0x69, 0x95, 0x18, 0x4e, 0xc6, 0x6f, 0x86, 0xf6, 0x70, 0xf2, - 0x3d, 0xc2, 0x25, 0xf5, 0x21, 0xc9, 0xdd, 0xcb, 0xdb, 0xcf, 0xb8, 0x7b, 0x73, 0x3d, 0x4f, 0x2a, - 0x80, 0x6c, 0x2a, 0x90, 0x0d, 0xb2, 0x9e, 0x09, 0xa2, 0xec, 0xc4, 0xf9, 0x3c, 0xf9, 0x72, 0x5f, - 0x68, 0x81, 0x54, 0x98, 0xe4, 0x18, 0x95, 0x57, 0xa0, 0x94, 0x51, 0xe6, 0x10, 0x48, 0x03, 0xfc, - 0x8c, 0x70, 0x2d, 0xb1, 0x59, 0xd2, 0xbe, 0x74, 0xc4, 0x79, 0x2f, 0x6f, 0xda, 0x79, 0xd3, 0x01, - 0xea, 0x5d, 0x05, 0xe5, 0x90, 0x76, 0x16, 0x54, 0x48, 0x27, 0x73, 0xf4, 0xfa, 0x11, 0xe1, 0x0a, - 0xd8, 0x28, 0xb9, 0x5c, 0x84, 0xb4, 0x4d, 0x37, 0x37, 0xf2, 0x25, 0x03, 0xdd, 0x7d, 0x45, 0xd7, - 0x26, 0xad, 0x2c, 0x3a, 0xb8, 0x02, 0x29, 0xb6, 0xef, 0x10, 0xae, 0x80, 0x27, 0x5f, 0xc1, 0x96, - 0x36, 0xf4, 0x2b, 0xd8, 0xce, 0xd9, 0xbc, 0xf5, 0x8e, 0x62, 0x7b, 0x8b, 0x98, 0x59, 0x6c, 0x60, - 0xda, 0x9d, 0x27, 0xa7, 0x7f, 0x19, 0xe8, 0x97, 0xa9, 0x81, 0x0e, 0xa7, 0x06, 0x3a, 0x9a, 0x1a, - 0xe8, 0x74, 0x6a, 0xa0, 0x83, 0x33, 0xa3, 0x70, 0x74, 0x66, 0x14, 0xfe, 0x38, 0x33, 0x0a, 0x9f, - 0xb5, 0x66, 0x7c, 0x28, 0x6a, 0xd6, 0xde, 0xa1, 0x3d, 0xa1, 0xdb, 0xbe, 0x98, 0x69, 0xac, 0x0c, - 0xa9, 0x57, 0x56, 0xae, 0x79, 0xff, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, 0x99, 0x27, 0xa2, - 0x2c, 0x0a, 0x00, 0x00, + // 890 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0x4d, 0x6f, 0x1b, 0x45, + 0x18, 0xc7, 0x3d, 0xa9, 0x5f, 0xa7, 0x50, 0xc4, 0xd4, 0x09, 0x96, 0x69, 0x77, 0xc3, 0x4a, 0x84, + 0x36, 0xb1, 0x77, 0xdb, 0x54, 0x54, 0xa8, 0xe2, 0x52, 0x93, 0x03, 0x3d, 0xf0, 0xb6, 0xe2, 0x52, + 0x2e, 0xd6, 0x78, 0x77, 0xea, 0xac, 0x12, 0x7b, 0x36, 0x3b, 0xe3, 0xb8, 0x11, 0x42, 0x42, 0x08, + 0x89, 0x72, 0x40, 0xaa, 0xe0, 0xc4, 0x0d, 0x6e, 0x08, 0x89, 0xef, 0xd1, 0x63, 0x25, 0x2e, 0x88, + 0x43, 0x5a, 0x1c, 0x6e, 0x7c, 0x09, 0xb4, 0x33, 0xcf, 0x2e, 0xde, 0xd4, 0x9b, 0xac, 0xc5, 0x29, + 0xd9, 0x67, 0x9f, 0x97, 0xdf, 0xf3, 0xdf, 0x99, 0xbf, 0xb1, 0xb5, 0x47, 0x0f, 0xa9, 0x13, 0x46, + 0x81, 0xc7, 0x1e, 0x30, 0xe6, 0x3b, 0x87, 0x37, 0x07, 0x4c, 0xd2, 0x9b, 0xce, 0xc1, 0x84, 0x45, + 0x47, 0x76, 0x18, 0x71, 0xc9, 0xc9, 0x5a, 0x9c, 0x63, 0xa7, 0x39, 0x36, 0xe4, 0xb4, 0x9b, 0x43, + 0x3e, 0xe4, 0x2a, 0xc5, 0x89, 0xff, 0xd3, 0xd9, 0xed, 0x2b, 0x43, 0xce, 0x87, 0xfb, 0xcc, 0xa1, + 0x61, 0xe0, 0xd0, 0xf1, 0x98, 0x4b, 0x2a, 0x03, 0x3e, 0x16, 0xf0, 0xd6, 0x84, 0xb7, 0xea, 0x69, + 0x30, 0x79, 0xe0, 0xc8, 0x60, 0xc4, 0x84, 0xa4, 0xa3, 0x10, 0x12, 0xf2, 0x80, 0x84, 0xe4, 0x11, + 0xd3, 0x39, 0x56, 0x13, 0x93, 0x4f, 0x62, 0xbe, 0x8f, 0x69, 0x44, 0x47, 0xc2, 0x65, 0x07, 0x13, + 0x26, 0xa4, 0x75, 0x1f, 0x5f, 0xce, 0x44, 0x45, 0xc8, 0xc7, 0x82, 0x91, 0x77, 0x71, 0x35, 0x54, + 0x91, 0x16, 0x5a, 0x47, 0xd7, 0x2e, 0x6e, 0x1b, 0xf6, 0xe2, 0x75, 0x6c, 0x5d, 0xd7, 0x2b, 0x3f, + 0x39, 0x36, 0x4b, 0x2e, 0xd4, 0xdc, 0x29, 0x3f, 0xfa, 0xc9, 0x2c, 0x59, 0xb7, 0xf1, 0xab, 0xba, + 0x75, 0x5c, 0x04, 0xf3, 0xc8, 0xeb, 0xb8, 0x31, 0xa2, 0xd1, 0x1e, 0x93, 0xfd, 0xc0, 0x57, 0xbd, + 0x1b, 0x6e, 0x5d, 0x07, 0xee, 0xf9, 0x50, 0xe7, 0x27, 0xa0, 0xba, 0x0e, 0x88, 0xde, 0xc7, 0x15, + 0x35, 0x1d, 0x80, 0x3a, 0x79, 0x40, 0xef, 0x4d, 0xa2, 0x88, 0x8d, 0x65, 0xa6, 0x18, 0xf0, 0x74, + 0x03, 0x98, 0xd2, 0x9c, 0x9f, 0x92, 0xca, 0xf1, 0x25, 0x4a, 0xf4, 0x80, 0x30, 0x4c, 0xf7, 0x70, + 0x55, 0x15, 0xc7, 0x7a, 0x5c, 0x58, 0x7a, 0xfc, 0xd5, 0x78, 0xfc, 0xaf, 0xcf, 0xcc, 0xd5, 0x45, + 0x6f, 0x85, 0x0b, 0xad, 0x01, 0xec, 0x0e, 0x5e, 0x55, 0x04, 0x2e, 0x9d, 0x66, 0xd8, 0x8a, 0x48, + 0xf7, 0x08, 0xe1, 0xb5, 0xd3, 0xc5, 0xb0, 0xc1, 0x2e, 0xc6, 0x11, 0x9d, 0xf6, 0x33, 0x5b, 0x6c, + 0xe5, 0x7e, 0x55, 0x2e, 0x24, 0xf3, 0xb3, 0x4b, 0x5c, 0x81, 0x25, 0x9a, 0x0b, 0x5e, 0x0a, 0xb7, + 0x11, 0x25, 0x13, 0x01, 0xe5, 0x1d, 0x10, 0xf2, 0xa3, 0x88, 0x7a, 0xfb, 0x4b, 0x2d, 0x71, 0x1b, + 0x37, 0xb3, 0x95, 0xb0, 0x41, 0x0b, 0xd7, 0xb8, 0x0e, 0x29, 0xfc, 0x86, 0x9b, 0x3c, 0x42, 0xdd, + 0x2a, 0x4c, 0xfc, 0x40, 0xb5, 0x4b, 0x3f, 0xe9, 0x14, 0xda, 0xa5, 0x61, 0x68, 0x77, 0x1f, 0xd7, + 0xf4, 0xe0, 0x44, 0x8d, 0x8d, 0x3c, 0x35, 0x74, 0x65, 0x2a, 0xc4, 0x6b, 0x20, 0xc4, 0x2b, 0xd9, + 0xb8, 0x70, 0x93, 0x7e, 0xc0, 0xf3, 0x0f, 0xc2, 0x97, 0x17, 0x68, 0x45, 0xae, 0xbf, 0x20, 0x41, + 0xef, 0xa5, 0xd9, 0xb1, 0x59, 0xd7, 0xed, 0xee, 0xed, 0xfc, 0x27, 0x08, 0x79, 0x13, 0x5f, 0xd2, + 0x3b, 0xf6, 0xa9, 0xef, 0x47, 0x4c, 0x88, 0xd6, 0x8a, 0x92, 0xec, 0x65, 0x1d, 0xbd, 0xab, 0x83, + 0x64, 0x27, 0xb9, 0x1b, 0x17, 0x54, 0x37, 0x3b, 0x06, 0xfc, 0xf3, 0xd8, 0xdc, 0x18, 0x06, 0x72, + 0x77, 0x32, 0xb0, 0x3d, 0x3e, 0x72, 0x3c, 0x2e, 0x46, 0x5c, 0xc0, 0x9f, 0xae, 0xf0, 0xf7, 0x1c, + 0x79, 0x14, 0x32, 0x61, 0xef, 0x30, 0x0f, 0xee, 0x45, 0x7c, 0xe7, 0xd9, 0xc3, 0x30, 0x88, 0x8e, + 0x5a, 0x65, 0x75, 0xc5, 0xda, 0xb6, 0xb6, 0x1d, 0x3b, 0xb1, 0x1d, 0xfb, 0xd3, 0xc4, 0x76, 0x7a, + 0xf5, 0x78, 0xc4, 0xe3, 0x67, 0x26, 0x72, 0xa1, 0xc6, 0xfa, 0x06, 0xe1, 0xe6, 0xa2, 0xe3, 0xbd, + 0xcc, 0xba, 0xe9, 0x1e, 0x2b, 0xff, 0x63, 0x0f, 0xeb, 0x37, 0x84, 0x2f, 0x65, 0x3f, 0xcd, 0x32, + 0x0c, 0x57, 0x31, 0x1e, 0x50, 0xc1, 0xfa, 0x54, 0x08, 0x26, 0x41, 0xee, 0x46, 0x1c, 0xb9, 0x1b, + 0x07, 0x88, 0x89, 0x2f, 0x1e, 0x4c, 0xb8, 0x4c, 0xde, 0x2b, 0xc1, 0x5d, 0xac, 0x42, 0x3a, 0x61, + 0xee, 0x94, 0x96, 0x33, 0xa7, 0x94, 0xac, 0xe1, 0x2a, 0xf5, 0x64, 0x70, 0xc8, 0x5a, 0x95, 0x75, + 0x74, 0xad, 0xee, 0xc2, 0xd3, 0xf6, 0xd7, 0x35, 0x5c, 0x51, 0x27, 0x94, 0x7c, 0x8b, 0x70, 0x55, + 0x1b, 0x2a, 0xd9, 0xcc, 0x3b, 0x8c, 0x2f, 0x7a, 0x78, 0x7b, 0xab, 0x50, 0xae, 0x96, 0xc2, 0xda, + 0xf8, 0xea, 0xf7, 0xbf, 0x7f, 0x58, 0x59, 0x27, 0x86, 0x93, 0xf3, 0x9b, 0xa1, 0x3d, 0x9c, 0x7c, + 0x8f, 0x70, 0x45, 0x7d, 0x48, 0x72, 0xfd, 0xec, 0xf6, 0x73, 0xee, 0xde, 0xde, 0x2c, 0x92, 0x0a, + 0x20, 0xdb, 0x0a, 0xa4, 0x43, 0x36, 0x73, 0x41, 0x94, 0x9d, 0x38, 0x9f, 0xa7, 0x5f, 0xee, 0x0b, + 0x2d, 0x90, 0x0a, 0x93, 0x02, 0xa3, 0x8a, 0x0a, 0x94, 0x31, 0xca, 0x02, 0x02, 0x69, 0x80, 0x9f, + 0x11, 0x6e, 0xa4, 0x36, 0x4b, 0xba, 0x67, 0x8e, 0x38, 0xed, 0xe5, 0x6d, 0xbb, 0x68, 0x3a, 0x40, + 0xbd, 0xad, 0xa0, 0x1c, 0xd2, 0xcd, 0x83, 0x8a, 0xe8, 0x74, 0x81, 0x5e, 0x3f, 0x22, 0x5c, 0x03, + 0x1b, 0x25, 0x67, 0x8b, 0x90, 0xb5, 0xe9, 0x76, 0xa7, 0x58, 0x32, 0xd0, 0xdd, 0x52, 0x74, 0x5d, + 0xb2, 0x95, 0x47, 0x07, 0x57, 0x20, 0xc3, 0xf6, 0x1d, 0xc2, 0x35, 0xf0, 0xe4, 0x73, 0xd8, 0xb2, + 0x86, 0x7e, 0x0e, 0xdb, 0x29, 0x9b, 0xb7, 0xde, 0x52, 0x6c, 0x6f, 0x10, 0x33, 0x8f, 0x0d, 0x4c, + 0xbb, 0xf7, 0xe1, 0xf3, 0xbf, 0x0c, 0xf4, 0xcb, 0xcc, 0x40, 0x4f, 0x66, 0x06, 0x7a, 0x3a, 0x33, + 0xd0, 0xf3, 0x99, 0x81, 0x1e, 0x9f, 0x18, 0xa5, 0xa7, 0x27, 0x46, 0xe9, 0x8f, 0x13, 0xa3, 0xf4, + 0x59, 0x67, 0xce, 0x87, 0x6e, 0x0c, 0xf7, 0xe9, 0x40, 0x38, 0x37, 0x86, 0x5d, 0x6f, 0x97, 0x06, + 0x63, 0xe7, 0xe1, 0x5c, 0x67, 0xe5, 0x48, 0x83, 0xaa, 0xb2, 0xcd, 0x5b, 0xff, 0x06, 0x00, 0x00, + 0xff, 0xff, 0x16, 0xed, 0x42, 0x1f, 0x2d, 0x0a, 0x00, 0x00, } func (this *QueryParamsRequest) VerboseEqual(that interface{}) error { diff --git a/x/pricefeed/types/store.pb.go b/x/pricefeed/types/store.pb.go index 6b8f2ae2..b9c0f525 100644 --- a/x/pricefeed/types/store.pb.go +++ b/x/pricefeed/types/store.pb.go @@ -273,39 +273,40 @@ func init() { } var fileDescriptor_9df40639f5e16f9a = []byte{ - // 508 bytes of a gzipped FileDescriptorProto + // 515 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0x3f, 0x6f, 0xd3, 0x40, - 0x14, 0xcf, 0x25, 0x6d, 0xfe, 0x5c, 0x02, 0x48, 0x06, 0x55, 0x26, 0x12, 0x76, 0x94, 0x01, 0x19, - 0xa1, 0x9c, 0xd5, 0xb2, 0xb2, 0xc4, 0x64, 0x20, 0x43, 0xa5, 0xc8, 0x30, 0xb1, 0x44, 0x67, 0xfb, - 0xd5, 0x58, 0x89, 0x39, 0x73, 0x77, 0x89, 0x9a, 0x89, 0xaf, 0xd0, 0x8f, 0x81, 0x90, 0xd8, 0xf8, - 0x10, 0x1d, 0x2b, 0x26, 0xc4, 0x90, 0x16, 0xe7, 0x03, 0xb0, 0x33, 0x21, 0xdf, 0xd9, 0x55, 0x07, - 0x06, 0x2a, 0x98, 0xee, 0xde, 0xef, 0xfd, 0xde, 0xbf, 0xdf, 0xbd, 0xc3, 0xc3, 0x05, 0x5d, 0x53, - 0x37, 0xe3, 0x49, 0x08, 0x27, 0x00, 0x91, 0xbb, 0x3e, 0x0c, 0x40, 0xd2, 0x43, 0x57, 0x48, 0xc6, - 0x81, 0x64, 0x9c, 0x49, 0x66, 0x1c, 0x14, 0x1c, 0x72, 0xcd, 0x21, 0x25, 0xa7, 0xff, 0x30, 0x64, - 0x22, 0x65, 0x62, 0xae, 0x58, 0xae, 0x36, 0x74, 0x48, 0xff, 0x41, 0xcc, 0x62, 0xa6, 0xf1, 0xe2, - 0x56, 0xa2, 0x76, 0xcc, 0x58, 0xbc, 0x04, 0x57, 0x59, 0xc1, 0xea, 0xc4, 0x95, 0x49, 0x0a, 0x42, - 0xd2, 0x34, 0xd3, 0x84, 0xe1, 0x2b, 0xdc, 0x9c, 0x51, 0x4e, 0x53, 0x61, 0x4c, 0x71, 0x2b, 0xa5, - 0x7c, 0x01, 0x52, 0x98, 0x68, 0xd0, 0x70, 0xba, 0x47, 0x16, 0xf9, 0x73, 0x17, 0xe4, 0x58, 0xd1, - 0xbc, 0x7b, 0xe7, 0x5b, 0xbb, 0xf6, 0xe9, 0xd2, 0x6e, 0x69, 0x5b, 0xf8, 0x55, 0xfc, 0xf0, 0x27, - 0xc2, 0x4d, 0x0d, 0x1a, 0x4f, 0x70, 0x47, 0xa3, 0xf3, 0x24, 0x32, 0xd1, 0x00, 0x39, 0x1d, 0xaf, - 0x97, 0x6f, 0xed, 0xb6, 0x76, 0x4f, 0x27, 0x7e, 0x5b, 0xbb, 0xa7, 0x91, 0xf1, 0x08, 0xe3, 0x80, - 0x0a, 0x98, 0x53, 0x21, 0x40, 0x9a, 0xf5, 0x82, 0xeb, 0x77, 0x0a, 0x64, 0x5c, 0x00, 0x86, 0x8d, - 0xbb, 0xef, 0x57, 0x4c, 0x56, 0xfe, 0x86, 0xf2, 0x63, 0x05, 0x69, 0x42, 0x80, 0x5b, 0x8c, 0xd3, - 0x70, 0x09, 0xc2, 0xdc, 0x1b, 0x34, 0x9c, 0x9e, 0xf7, 0xf2, 0xd7, 0xd6, 0x1e, 0xc5, 0x89, 0x7c, - 0xbb, 0x0a, 0x48, 0xc8, 0xd2, 0x52, 0xaf, 0xf2, 0x18, 0x89, 0x68, 0xe1, 0xca, 0x4d, 0x06, 0x82, - 0x8c, 0xc3, 0x70, 0x1c, 0x45, 0x1c, 0x84, 0xf8, 0xfa, 0x65, 0x74, 0xbf, 0x54, 0xb5, 0x44, 0xbc, - 0x8d, 0x04, 0xe1, 0x57, 0x89, 0x8d, 0x03, 0xdc, 0xa4, 0xa1, 0x4c, 0xd6, 0x60, 0xee, 0x0f, 0x90, - 0xd3, 0xf6, 0x4b, 0x6b, 0xf8, 0xb9, 0x8e, 0xbb, 0x33, 0x26, 0x24, 0x44, 0xb3, 0x42, 0xae, 0xdb, - 0x8c, 0xcd, 0xf0, 0x5d, 0x9d, 0x7d, 0x4e, 0x75, 0x49, 0x35, 0xfa, 0xff, 0xec, 0xfe, 0x8e, 0xce, - 0x5f, 0x62, 0xc6, 0x04, 0xef, 0xab, 0x37, 0xd5, 0x12, 0x7a, 0xa4, 0x78, 0xc6, 0xef, 0x5b, 0xfb, - 0xf1, 0x5f, 0xd4, 0x9a, 0x40, 0xe8, 0xeb, 0x60, 0xe3, 0x39, 0x6e, 0xc2, 0x69, 0x96, 0xf0, 0x8d, - 0xb9, 0x37, 0x40, 0x4e, 0xf7, 0xa8, 0x4f, 0xf4, 0xaa, 0x91, 0x6a, 0xd5, 0xc8, 0xeb, 0x6a, 0xd5, - 0xbc, 0x76, 0x51, 0xe2, 0xec, 0xd2, 0x46, 0x7e, 0x19, 0x33, 0xfc, 0x80, 0x7b, 0x2f, 0x56, 0x9c, - 0xc3, 0x3b, 0x79, 0x6b, 0xbd, 0xae, 0xdb, 0xaf, 0xff, 0x43, 0xfb, 0xde, 0xf1, 0xd5, 0x0f, 0x0b, - 0x7d, 0xcc, 0x2d, 0x74, 0x9e, 0x5b, 0xe8, 0x22, 0xb7, 0xd0, 0x55, 0x6e, 0xa1, 0xb3, 0x9d, 0x55, - 0xbb, 0xd8, 0x59, 0xb5, 0x6f, 0x3b, 0xab, 0xf6, 0xe6, 0xe9, 0x8d, 0x84, 0xc5, 0x47, 0x18, 0x2d, - 0x69, 0x20, 0xd4, 0xcd, 0x3d, 0xbd, 0xf1, 0x7d, 0x55, 0xe6, 0xa0, 0xa9, 0xa6, 0x7e, 0xf6, 0x3b, - 0x00, 0x00, 0xff, 0xff, 0x18, 0xb5, 0x5b, 0xc1, 0xdd, 0x03, 0x00, 0x00, + 0x14, 0xcf, 0x25, 0x6d, 0xfe, 0x5c, 0x02, 0x48, 0x06, 0x55, 0x26, 0x12, 0x76, 0xe4, 0x01, 0x19, + 0x89, 0x9c, 0xdb, 0xb2, 0xb2, 0xc4, 0x64, 0x20, 0x03, 0x28, 0x32, 0x4c, 0x2c, 0xd1, 0xd9, 0x7e, + 0x75, 0xad, 0xc4, 0x3d, 0x73, 0x77, 0x89, 0x9a, 0x89, 0xaf, 0xd0, 0x8f, 0x81, 0x90, 0xd8, 0xf8, + 0x10, 0x1d, 0x2b, 0x26, 0xc4, 0x90, 0x16, 0xe7, 0x03, 0xb0, 0x33, 0x21, 0xfb, 0xec, 0xaa, 0x03, + 0x03, 0x15, 0x4c, 0xc9, 0xfb, 0xbd, 0xdf, 0xfb, 0xbd, 0xf7, 0x7e, 0xf7, 0x8c, 0xad, 0x39, 0x5d, + 0x51, 0x27, 0xe5, 0x71, 0x00, 0x47, 0x00, 0xa1, 0xb3, 0x3a, 0xf0, 0x41, 0xd2, 0x03, 0x47, 0x48, + 0xc6, 0x81, 0xa4, 0x9c, 0x49, 0xa6, 0xed, 0xe5, 0x1c, 0x72, 0xcd, 0x21, 0x25, 0xa7, 0xff, 0x30, + 0x60, 0x22, 0x61, 0x62, 0x56, 0xb0, 0x1c, 0x15, 0xa8, 0x92, 0xfe, 0x83, 0x88, 0x45, 0x4c, 0xe1, + 0xf9, 0xbf, 0x12, 0x35, 0x23, 0xc6, 0xa2, 0x05, 0x38, 0x45, 0xe4, 0x2f, 0x8f, 0x1c, 0x19, 0x27, + 0x20, 0x24, 0x4d, 0x52, 0x45, 0xb0, 0xde, 0xe0, 0xe6, 0x94, 0x72, 0x9a, 0x08, 0x6d, 0x82, 0x5b, + 0x09, 0xe5, 0x73, 0x90, 0x42, 0x47, 0x83, 0x86, 0xdd, 0x3d, 0x34, 0xc8, 0x9f, 0xa7, 0x20, 0xaf, + 0x0a, 0x9a, 0x7b, 0xef, 0x7c, 0x63, 0xd6, 0x3e, 0x5d, 0x9a, 0x2d, 0x15, 0x0b, 0xaf, 0xaa, 0xb7, + 0x7e, 0x22, 0xdc, 0x54, 0xa0, 0xf6, 0x04, 0x77, 0x14, 0x3a, 0x8b, 0x43, 0x1d, 0x0d, 0x90, 0xdd, + 0x71, 0x7b, 0xd9, 0xc6, 0x6c, 0xab, 0xf4, 0x64, 0xec, 0xb5, 0x55, 0x7a, 0x12, 0x6a, 0x8f, 0x30, + 0xf6, 0xa9, 0x80, 0x19, 0x15, 0x02, 0xa4, 0x5e, 0xcf, 0xb9, 0x5e, 0x27, 0x47, 0x46, 0x39, 0xa0, + 0x99, 0xb8, 0xfb, 0x7e, 0xc9, 0x64, 0x95, 0x6f, 0x14, 0x79, 0x5c, 0x40, 0x8a, 0xe0, 0xe3, 0x16, + 0xe3, 0x34, 0x58, 0x80, 0xd0, 0x77, 0x06, 0x0d, 0xbb, 0xe7, 0xbe, 0xfc, 0xb5, 0x31, 0x87, 0x51, + 0x2c, 0x8f, 0x97, 0x3e, 0x09, 0x58, 0x52, 0xfa, 0x55, 0xfe, 0x0c, 0x45, 0x38, 0x77, 0xe4, 0x3a, + 0x05, 0x41, 0x46, 0x41, 0x30, 0x0a, 0x43, 0x0e, 0x42, 0x7c, 0xfd, 0x32, 0xbc, 0x5f, 0xba, 0x5a, + 0x22, 0xee, 0x5a, 0x82, 0xf0, 0x2a, 0x61, 0x6d, 0x0f, 0x37, 0x69, 0x20, 0xe3, 0x15, 0xe8, 0xbb, + 0x03, 0x64, 0xb7, 0xbd, 0x32, 0xb2, 0x3e, 0xd7, 0x71, 0x77, 0xca, 0x84, 0x84, 0x70, 0x9a, 0xdb, + 0x75, 0x9b, 0xb5, 0x19, 0xbe, 0xab, 0xd4, 0x67, 0x54, 0xb5, 0x2c, 0x56, 0xff, 0x9f, 0xd3, 0xdf, + 0x51, 0xfa, 0x25, 0xa6, 0x8d, 0xf1, 0x6e, 0xf1, 0xa6, 0xca, 0x42, 0x97, 0xe4, 0xcf, 0xf8, 0x7d, + 0x63, 0x3e, 0xfe, 0x8b, 0x5e, 0x63, 0x08, 0x3c, 0x55, 0xac, 0x3d, 0xc7, 0x4d, 0x38, 0x4d, 0x63, + 0xbe, 0xd6, 0x77, 0x06, 0xc8, 0xee, 0x1e, 0xf6, 0x89, 0x3a, 0x35, 0x52, 0x9d, 0x1a, 0x79, 0x5b, + 0x9d, 0x9a, 0xdb, 0xce, 0x5b, 0x9c, 0x5d, 0x9a, 0xc8, 0x2b, 0x6b, 0xac, 0x0f, 0xb8, 0xf7, 0x62, + 0xc9, 0x39, 0x9c, 0xc8, 0x5b, 0xfb, 0x75, 0x3d, 0x7e, 0xfd, 0x1f, 0xc6, 0x77, 0x5f, 0x5f, 0xfd, + 0x30, 0xd0, 0xc7, 0xcc, 0x40, 0xe7, 0x99, 0x81, 0x2e, 0x32, 0x03, 0x5d, 0x65, 0x06, 0x3a, 0xdb, + 0x1a, 0xb5, 0x8b, 0xad, 0x51, 0xfb, 0xb6, 0x35, 0x6a, 0xef, 0x9e, 0xde, 0x10, 0xdc, 0x8f, 0x16, + 0xd4, 0x17, 0xce, 0x7e, 0x34, 0x0c, 0x8e, 0x69, 0x7c, 0xe2, 0x9c, 0xde, 0xf8, 0x7e, 0x0b, 0x69, + 0xbf, 0x59, 0xac, 0xfd, 0xec, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0x53, 0x45, 0x84, 0xde, + 0x03, 0x00, 0x00, } func (this *Params) VerboseEqual(that interface{}) error { diff --git a/x/pricefeed/types/tx.pb.go b/x/pricefeed/types/tx.pb.go index 358f29a7..d1d251f0 100644 --- a/x/pricefeed/types/tx.pb.go +++ b/x/pricefeed/types/tx.pb.go @@ -120,31 +120,31 @@ func init() { func init() { proto.RegisterFile("kava/pricefeed/v1beta1/tx.proto", fileDescriptor_afd93c8e4685da16) } var fileDescriptor_afd93c8e4685da16 = []byte{ - // 370 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xbd, 0x6e, 0xea, 0x30, - 0x14, 0x80, 0xe3, 0x0b, 0x17, 0x81, 0x2f, 0x53, 0x84, 0x50, 0x94, 0xc1, 0x41, 0xe8, 0xaa, 0xa2, - 0x6a, 0xb1, 0x05, 0xdd, 0xaa, 0x4e, 0x88, 0x85, 0x21, 0x12, 0x8a, 0x3a, 0x75, 0x41, 0xf9, 0x71, - 0xd2, 0x08, 0x52, 0x47, 0xb1, 0x41, 0xf0, 0x06, 0x1d, 0x79, 0x84, 0x8e, 0x7d, 0x14, 0x46, 0xb6, - 0x56, 0x1d, 0x28, 0x0d, 0x2f, 0x52, 0xc5, 0x81, 0x36, 0x43, 0x87, 0x4e, 0x39, 0xf1, 0xf9, 0xce, - 0x39, 0xfe, 0x8e, 0x0c, 0x8d, 0xa9, 0xbd, 0xb0, 0x49, 0x9c, 0x84, 0x2e, 0xf5, 0x29, 0xf5, 0xc8, - 0xa2, 0xe7, 0x50, 0x61, 0xf7, 0x88, 0x58, 0xe2, 0x38, 0x61, 0x82, 0xa9, 0xcd, 0x0c, 0xc0, 0x5f, - 0x00, 0x3e, 0x02, 0x7a, 0x23, 0x60, 0x01, 0x93, 0x08, 0xc9, 0xa2, 0x9c, 0xd6, 0x8d, 0x80, 0xb1, - 0x60, 0x46, 0x89, 0xfc, 0x73, 0xe6, 0x3e, 0x11, 0x61, 0x44, 0xb9, 0xb0, 0xa3, 0x38, 0x07, 0xda, - 0x2f, 0x00, 0xd6, 0x4d, 0x1e, 0x8c, 0x19, 0x17, 0xe3, 0xac, 0xa7, 0xaa, 0xc2, 0xb2, 0x9f, 0xb0, - 0x48, 0x03, 0x2d, 0xd0, 0xa9, 0x59, 0x32, 0x56, 0xcf, 0x61, 0x2d, 0xb2, 0x93, 0x29, 0x15, 0x93, - 0xd0, 0xd3, 0xfe, 0x64, 0x89, 0x41, 0x3d, 0xdd, 0x19, 0x55, 0x53, 0x1e, 0x8e, 0x86, 0x56, 0x35, - 0x4f, 0x8f, 0x3c, 0x75, 0x08, 0xff, 0xca, 0xbb, 0x69, 0x25, 0x89, 0xe1, 0xcd, 0xce, 0x50, 0xde, - 0x76, 0xc6, 0x59, 0x10, 0x8a, 0xfb, 0xb9, 0x83, 0x5d, 0x16, 0x11, 0x97, 0xf1, 0x88, 0xf1, 0xe3, - 0xa7, 0xcb, 0xbd, 0x29, 0x11, 0xab, 0x98, 0x72, 0x3c, 0xa4, 0xae, 0x95, 0x17, 0xab, 0x37, 0xb0, - 0x42, 0x97, 0x71, 0x98, 0xac, 0xb4, 0x72, 0x0b, 0x74, 0xfe, 0xf5, 0x75, 0x9c, 0x7b, 0xe0, 0x93, - 0x07, 0xbe, 0x3d, 0x79, 0x0c, 0xaa, 0xd9, 0x88, 0xf5, 0xbb, 0x01, 0xac, 0x63, 0xcd, 0x75, 0xf9, - 0xf1, 0xc9, 0x50, 0xda, 0x4d, 0xd8, 0x28, 0x8a, 0x59, 0x94, 0xc7, 0xec, 0x81, 0xd3, 0xbe, 0x0f, - 0x4b, 0x26, 0x0f, 0xd4, 0x09, 0xac, 0x7d, 0x4b, 0xff, 0xc7, 0x3f, 0x6f, 0x15, 0x17, 0x3b, 0xe8, - 0x97, 0xbf, 0xa1, 0x4e, 0x73, 0x06, 0xe6, 0xfe, 0x03, 0x81, 0xe7, 0x14, 0x81, 0x4d, 0x8a, 0xc0, - 0x36, 0x45, 0x60, 0x9f, 0x22, 0xb0, 0x3e, 0x20, 0x65, 0x7b, 0x40, 0xca, 0xeb, 0x01, 0x29, 0x77, - 0x17, 0x85, 0xa5, 0x64, 0x9d, 0xbb, 0x33, 0xdb, 0xe1, 0x32, 0x22, 0xcb, 0xc2, 0x13, 0x90, 0xdb, - 0x71, 0x2a, 0x52, 0xfd, 0xea, 0x33, 0x00, 0x00, 0xff, 0xff, 0x6f, 0x4a, 0x12, 0x82, 0x21, 0x02, - 0x00, 0x00, + // 376 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x3f, 0x8f, 0xda, 0x30, + 0x14, 0xc0, 0xe3, 0x42, 0x11, 0xb8, 0x4c, 0x11, 0x42, 0x51, 0x06, 0x07, 0xa1, 0xaa, 0xa2, 0x12, + 0xd8, 0x40, 0xb7, 0xaa, 0x13, 0x62, 0x61, 0xa0, 0x42, 0x51, 0xa7, 0x2e, 0x28, 0x7f, 0x1c, 0x13, + 0x41, 0x70, 0x14, 0x1b, 0x04, 0xdf, 0xa0, 0x23, 0x1f, 0xa1, 0x63, 0x3f, 0x0a, 0x23, 0x5b, 0xab, + 0x0e, 0x1c, 0x17, 0xbe, 0xc8, 0x29, 0x0e, 0xdc, 0x65, 0xb8, 0xe1, 0xa6, 0xbc, 0xf8, 0xfd, 0xde, + 0x7b, 0xfe, 0x3d, 0x19, 0x5a, 0x4b, 0x67, 0xeb, 0x90, 0x38, 0x09, 0x3d, 0x1a, 0x50, 0xea, 0x93, + 0xed, 0xc0, 0xa5, 0xd2, 0x19, 0x10, 0xb9, 0xc3, 0x71, 0xc2, 0x25, 0xd7, 0x9b, 0x19, 0x80, 0x9f, + 0x01, 0x7c, 0x03, 0xcc, 0x06, 0xe3, 0x8c, 0x2b, 0x84, 0x64, 0x51, 0x4e, 0x9b, 0x16, 0xe3, 0x9c, + 0xad, 0x28, 0x51, 0x7f, 0xee, 0x26, 0x20, 0x32, 0x8c, 0xa8, 0x90, 0x4e, 0x14, 0xe7, 0x40, 0xfb, + 0x2f, 0x80, 0xf5, 0xa9, 0x60, 0x33, 0x2e, 0xe4, 0x2c, 0xeb, 0xa9, 0xeb, 0xb0, 0x1c, 0x24, 0x3c, + 0x32, 0x40, 0x0b, 0x74, 0x6a, 0xb6, 0x8a, 0xf5, 0xcf, 0xb0, 0x16, 0x39, 0xc9, 0x92, 0xca, 0x79, + 0xe8, 0x1b, 0xef, 0xb2, 0xc4, 0xa8, 0x9e, 0x9e, 0xad, 0xea, 0x54, 0x1d, 0x4e, 0xc6, 0x76, 0x35, + 0x4f, 0x4f, 0x7c, 0x7d, 0x0c, 0xdf, 0xab, 0xbb, 0x19, 0x25, 0x85, 0xe1, 0xe3, 0xd9, 0xd2, 0xfe, + 0x9f, 0xad, 0x4f, 0x2c, 0x94, 0x8b, 0x8d, 0x8b, 0x3d, 0x1e, 0x11, 0x8f, 0x8b, 0x88, 0x8b, 0xdb, + 0xa7, 0x27, 0xfc, 0x25, 0x91, 0xfb, 0x98, 0x0a, 0x3c, 0xa6, 0x9e, 0x9d, 0x17, 0xeb, 0xdf, 0x60, + 0x85, 0xee, 0xe2, 0x30, 0xd9, 0x1b, 0xe5, 0x16, 0xe8, 0x7c, 0x18, 0x9a, 0x38, 0xf7, 0xc0, 0x77, + 0x0f, 0xfc, 0xe3, 0xee, 0x31, 0xaa, 0x66, 0x23, 0x0e, 0x0f, 0x16, 0xb0, 0x6f, 0x35, 0x5f, 0xcb, + 0xbf, 0x7e, 0x5b, 0x5a, 0xbb, 0x09, 0x1b, 0x45, 0x31, 0x9b, 0x8a, 0x98, 0xaf, 0x05, 0x1d, 0x06, + 0xb0, 0x34, 0x15, 0x4c, 0x9f, 0xc3, 0xda, 0x8b, 0xf4, 0x47, 0xfc, 0xfa, 0x56, 0x71, 0xb1, 0x83, + 0xd9, 0x7d, 0x0b, 0x75, 0x9f, 0x33, 0xfa, 0x7e, 0x79, 0x44, 0xe0, 0x4f, 0x8a, 0xc0, 0x31, 0x45, + 0xe0, 0x94, 0x22, 0x70, 0x49, 0x11, 0x38, 0x5c, 0x91, 0x76, 0xba, 0x22, 0xed, 0xdf, 0x15, 0x69, + 0x3f, 0xbb, 0x85, 0xa5, 0xf4, 0xd9, 0xca, 0x71, 0x05, 0xe9, 0xb3, 0x9e, 0xb7, 0x70, 0xc2, 0x35, + 0xd9, 0x15, 0xde, 0x80, 0x5a, 0x8f, 0x5b, 0x51, 0xee, 0x5f, 0x9e, 0x02, 0x00, 0x00, 0xff, 0xff, + 0xea, 0xfe, 0x67, 0x4a, 0x22, 0x02, 0x00, 0x00, } func (this *MsgPostPrice) VerboseEqual(that interface{}) error { diff --git a/x/router/types/tx.pb.go b/x/router/types/tx.pb.go index 5f0dc219..5cc769b7 100644 --- a/x/router/types/tx.pb.go +++ b/x/router/types/tx.pb.go @@ -366,37 +366,37 @@ func init() { func init() { proto.RegisterFile("kava/router/v1beta1/tx.proto", fileDescriptor_63015631bbbf9425) } var fileDescriptor_63015631bbbf9425 = []byte{ - // 472 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x54, 0xcf, 0x6b, 0x13, 0x41, - 0x14, 0xde, 0x31, 0xa5, 0x90, 0x57, 0x51, 0xd8, 0x96, 0x9a, 0x2c, 0x65, 0x8c, 0xa9, 0x87, 0x80, - 0xed, 0x2c, 0x6d, 0xa1, 0x9e, 0x8d, 0xc5, 0x5b, 0x2e, 0x11, 0x11, 0xbc, 0x94, 0xd9, 0xec, 0x38, - 0x1d, 0x4c, 0x66, 0xc2, 0xcc, 0x6c, 0x5a, 0x6f, 0xfe, 0x09, 0x9e, 0xbc, 0xea, 0xcd, 0x7f, 0xc0, - 0xbf, 0x41, 0x72, 0x2c, 0x9e, 0x3c, 0x89, 0x26, 0xff, 0x88, 0xec, 0xcf, 0x34, 0x65, 0x17, 0xd3, - 0x83, 0xd0, 0xdb, 0xdb, 0xf7, 0x7d, 0xef, 0x7b, 0xdf, 0x07, 0x6f, 0x07, 0x76, 0xde, 0xd1, 0x09, - 0xf5, 0xb5, 0x8a, 0x2c, 0xd3, 0xfe, 0xe4, 0x20, 0x60, 0x96, 0x1e, 0xf8, 0xf6, 0x82, 0x8c, 0xb5, - 0xb2, 0xca, 0xdd, 0x8c, 0x51, 0x92, 0xa2, 0x24, 0x43, 0x3d, 0x3c, 0x50, 0x66, 0xa4, 0x8c, 0x1f, - 0x50, 0xc3, 0x8a, 0x91, 0x81, 0x12, 0x32, 0x1d, 0xf2, 0x9a, 0x29, 0x7e, 0x9a, 0x7c, 0xf9, 0xe9, - 0x47, 0x06, 0x6d, 0x71, 0xc5, 0x55, 0xda, 0x8f, 0xab, 0xb4, 0xdb, 0xfe, 0x8c, 0xe0, 0x5e, 0xcf, - 0xf0, 0x9e, 0x90, 0xf6, 0x84, 0x8d, 0x95, 0x11, 0xd6, 0x3d, 0x86, 0x7a, 0x98, 0x96, 0x4a, 0x37, - 0x50, 0x0b, 0x75, 0xea, 0xdd, 0xc6, 0x8f, 0x6f, 0xfb, 0x5b, 0x99, 0xda, 0xb3, 0x30, 0xd4, 0xcc, - 0x98, 0x97, 0x56, 0x0b, 0xc9, 0xfb, 0x0b, 0xaa, 0xbb, 0x03, 0xf5, 0x09, 0x1d, 0x8a, 0x90, 0xc6, - 0x73, 0x77, 0xe2, 0xb9, 0xfe, 0xa2, 0xe1, 0x3e, 0x85, 0x75, 0x3a, 0x52, 0x91, 0xb4, 0x8d, 0x5a, - 0x0b, 0x75, 0x36, 0x0e, 0x9b, 0x24, 0xd3, 0x8b, 0xa3, 0xe4, 0xf9, 0xc8, 0x73, 0x25, 0x64, 0x77, - 0x6d, 0xfa, 0xeb, 0xa1, 0xd3, 0xcf, 0xe8, 0xed, 0x06, 0x6c, 0x2f, 0x1b, 0xec, 0x33, 0x33, 0x56, - 0xd2, 0xb0, 0xf6, 0x57, 0x94, 0x40, 0x27, 0x6c, 0xc8, 0x38, 0xb5, 0xec, 0x16, 0x67, 0x68, 0x01, - 0x2e, 0x37, 0x5a, 0x64, 0xf9, 0x84, 0xe0, 0x7e, 0xcf, 0xf0, 0xd7, 0xc2, 0x9e, 0x85, 0x9a, 0x9e, - 0x77, 0x23, 0x2d, 0xdd, 0x3d, 0x58, 0x7b, 0xab, 0xd5, 0xe8, 0x9f, 0xfe, 0x13, 0xd6, 0xff, 0xb2, - 0xde, 0x84, 0x07, 0xd7, 0x7c, 0x15, 0x9e, 0xbf, 0x20, 0x68, 0x5e, 0xc3, 0x5e, 0xc9, 0x30, 0x0b, - 0x79, 0x3b, 0xdc, 0xef, 0xc2, 0xa3, 0x4a, 0x87, 0x79, 0x8e, 0xc3, 0xef, 0x35, 0xa8, 0xf5, 0x0c, - 0x77, 0x4f, 0x61, 0xe3, 0xea, 0x0d, 0xed, 0x92, 0x92, 0x3f, 0x90, 0x2c, 0xdf, 0xa2, 0xf7, 0x64, - 0x05, 0x52, 0xbe, 0xc8, 0x3d, 0x87, 0xcd, 0xb2, 0x63, 0xad, 0xd4, 0x28, 0x21, 0x7b, 0x47, 0x37, - 0x20, 0x17, 0x8b, 0x03, 0xb8, 0xbb, 0x74, 0x59, 0x8f, 0xab, 0x44, 0xae, 0xb2, 0xbc, 0xbd, 0x55, - 0x58, 0xc5, 0x8e, 0x0f, 0x08, 0xb6, 0x2b, 0x4e, 0x81, 0xac, 0x22, 0xb4, 0xe0, 0x7b, 0xc7, 0x37, - 0xe3, 0xe7, 0x16, 0xba, 0x2f, 0xa6, 0x7f, 0xb0, 0x33, 0x9d, 0x61, 0x74, 0x39, 0xc3, 0xe8, 0xf7, - 0x0c, 0xa3, 0x8f, 0x73, 0xec, 0x5c, 0xce, 0xb1, 0xf3, 0x73, 0x8e, 0x9d, 0x37, 0x1d, 0x2e, 0xec, - 0x59, 0x14, 0x90, 0x81, 0x1a, 0xf9, 0xb1, 0xfe, 0xfe, 0x90, 0x06, 0x26, 0xa9, 0xfc, 0x8b, 0xfc, - 0x15, 0xb6, 0xef, 0xc7, 0xcc, 0x04, 0xeb, 0xc9, 0xdb, 0x78, 0xf4, 0x37, 0x00, 0x00, 0xff, 0xff, - 0x14, 0x23, 0x1c, 0x49, 0xa1, 0x05, 0x00, 0x00, + // 478 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x54, 0x4d, 0x6b, 0x53, 0x41, + 0x14, 0x7d, 0x63, 0x4a, 0x21, 0xb7, 0xa2, 0xf0, 0x5a, 0x6a, 0xf2, 0x28, 0x63, 0x4c, 0x5d, 0x54, + 0x6c, 0x67, 0xfa, 0x01, 0x75, 0x6d, 0x2c, 0xb8, 0xca, 0x26, 0x22, 0x82, 0x9b, 0x32, 0x2f, 0x6f, + 0x9c, 0x0c, 0x26, 0x33, 0x61, 0x66, 0x92, 0xd6, 0x9d, 0x3f, 0xc1, 0x95, 0x5b, 0xdd, 0xf9, 0x07, + 0xfc, 0x0d, 0x92, 0x65, 0x71, 0xe5, 0x4a, 0x34, 0xf9, 0x23, 0xf2, 0xf2, 0x3e, 0xd2, 0x94, 0x3c, + 0x4c, 0x17, 0x85, 0xee, 0x66, 0xee, 0x39, 0xf7, 0xde, 0x73, 0xe0, 0xcc, 0xc0, 0xd6, 0x7b, 0x36, + 0x64, 0xd4, 0xe8, 0x81, 0xe3, 0x86, 0x0e, 0x0f, 0x42, 0xee, 0xd8, 0x01, 0x75, 0xe7, 0xa4, 0x6f, + 0xb4, 0xd3, 0xfe, 0x7a, 0x8c, 0x92, 0x04, 0x25, 0x29, 0x1a, 0xe0, 0xb6, 0xb6, 0x3d, 0x6d, 0x69, + 0xc8, 0x2c, 0xcf, 0x5b, 0xda, 0x5a, 0xaa, 0xa4, 0x29, 0xa8, 0x26, 0xf8, 0xe9, 0xf4, 0x46, 0x93, + 0x4b, 0x0a, 0x6d, 0x08, 0x2d, 0x74, 0x52, 0x8f, 0x4f, 0x49, 0xb5, 0xfe, 0x05, 0xc1, 0xbd, 0xa6, + 0x15, 0x4d, 0xa9, 0xdc, 0x09, 0xef, 0x6b, 0x2b, 0x9d, 0x7f, 0x0c, 0xe5, 0x28, 0x39, 0x6a, 0x53, + 0x41, 0x35, 0xb4, 0x53, 0x6e, 0x54, 0x7e, 0x7e, 0xdf, 0xdb, 0x48, 0xa7, 0x3d, 0x8f, 0x22, 0xc3, + 0xad, 0x7d, 0xe5, 0x8c, 0x54, 0xa2, 0x35, 0xa3, 0xfa, 0x5b, 0x50, 0x1e, 0xb2, 0xae, 0x8c, 0x58, + 0xdc, 0x77, 0x27, 0xee, 0x6b, 0xcd, 0x0a, 0xfe, 0x33, 0x58, 0x65, 0x3d, 0x3d, 0x50, 0xae, 0x52, + 0xaa, 0xa1, 0x9d, 0xb5, 0xc3, 0x2a, 0x49, 0xe7, 0xc5, 0x56, 0x32, 0x7f, 0xe4, 0x85, 0x96, 0xaa, + 0xb1, 0x32, 0xfa, 0xfd, 0xd0, 0x6b, 0xa5, 0xf4, 0x7a, 0x05, 0x36, 0xe7, 0x05, 0xb6, 0xb8, 0xed, + 0x6b, 0x65, 0x79, 0xfd, 0x1b, 0x9a, 0x42, 0x27, 0xbc, 0xcb, 0x05, 0x73, 0xfc, 0x16, 0x7b, 0xa8, + 0x01, 0x5e, 0x2c, 0x34, 0xf7, 0xf2, 0x19, 0xc1, 0xfd, 0xa6, 0x15, 0x6f, 0xa4, 0xeb, 0x44, 0x86, + 0x9d, 0x35, 0x06, 0x46, 0xf9, 0xbb, 0xb0, 0xf2, 0xce, 0xe8, 0xde, 0x7f, 0xf5, 0x4f, 0x59, 0x37, + 0x25, 0xbd, 0x0a, 0x0f, 0xae, 0xe8, 0xca, 0x35, 0x7f, 0x45, 0x50, 0xbd, 0x82, 0xbd, 0x56, 0x51, + 0x6a, 0xf2, 0x76, 0xa8, 0xdf, 0x86, 0x47, 0x85, 0x0a, 0x33, 0x1f, 0x87, 0x3f, 0x4a, 0x50, 0x6a, + 0x5a, 0xe1, 0x9f, 0xc2, 0xda, 0xe5, 0x0c, 0x6d, 0x93, 0x05, 0x2f, 0x90, 0xcc, 0x67, 0x31, 0x78, + 0xba, 0x04, 0x29, 0x5b, 0xe4, 0x9f, 0xc1, 0xfa, 0xa2, 0xb0, 0x16, 0xce, 0x58, 0x40, 0x0e, 0x8e, + 0xae, 0x41, 0xce, 0x17, 0x87, 0x70, 0x77, 0x2e, 0x59, 0x8f, 0x8b, 0x86, 0x5c, 0x66, 0x05, 0xbb, + 0xcb, 0xb0, 0xf2, 0x1d, 0x1f, 0x11, 0x6c, 0x16, 0x44, 0x81, 0x2c, 0x33, 0x68, 0xc6, 0x0f, 0x8e, + 0xaf, 0xc7, 0xcf, 0x24, 0x34, 0x5e, 0x8e, 0xfe, 0x62, 0x6f, 0x34, 0xc6, 0xe8, 0x62, 0x8c, 0xd1, + 0x9f, 0x31, 0x46, 0x9f, 0x26, 0xd8, 0xbb, 0x98, 0x60, 0xef, 0xd7, 0x04, 0x7b, 0x6f, 0x9f, 0x08, + 0xe9, 0x3a, 0x83, 0x90, 0xb4, 0x75, 0x8f, 0xee, 0x8b, 0x2e, 0x0b, 0x2d, 0xdd, 0x17, 0x7b, 0xed, + 0x0e, 0x93, 0x8a, 0x9e, 0x67, 0xdf, 0xb0, 0xfb, 0xd0, 0xe7, 0x36, 0x5c, 0x9d, 0x7e, 0x8e, 0x47, + 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xc1, 0x38, 0x34, 0x6e, 0xa2, 0x05, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/savings/types/genesis.pb.go b/x/savings/types/genesis.pb.go index 5c2f1f55..156a7dad 100644 --- a/x/savings/types/genesis.pb.go +++ b/x/savings/types/genesis.pb.go @@ -86,7 +86,7 @@ func init() { } var fileDescriptor_f5dcde4d417fcec8 = []byte{ - // 245 bytes of a gzipped FileDescriptorProto + // 252 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xca, 0x4e, 0x2c, 0x4b, 0xd4, 0x2f, 0x4e, 0x2c, 0xcb, 0xcc, 0x4b, 0x2f, 0xd6, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, @@ -97,12 +97,12 @@ var fileDescriptor_f5dcde4d417fcec8 = []byte{ 0x1e, 0x36, 0xfb, 0xf4, 0x02, 0xc0, 0x6a, 0x9c, 0x58, 0x4e, 0xdc, 0x93, 0x67, 0x08, 0x82, 0xea, 0x10, 0xf2, 0xe6, 0xe2, 0x48, 0x49, 0x2d, 0xc8, 0x2f, 0xce, 0x2c, 0x29, 0x96, 0x60, 0x52, 0x60, 0xd6, 0xe0, 0x36, 0x92, 0xc5, 0xae, 0xdb, 0x05, 0xa2, 0xca, 0x49, 0x00, 0xa4, 0x7d, 0xd5, 0x7d, - 0x79, 0x0e, 0xa8, 0x40, 0x71, 0x10, 0xdc, 0x00, 0x27, 0xe7, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, + 0x79, 0x0e, 0xa8, 0x40, 0x71, 0x10, 0xdc, 0x00, 0x27, 0x97, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, - 0x3c, 0x96, 0x63, 0x88, 0xd2, 0x4c, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, - 0x07, 0x19, 0xaf, 0x9b, 0x93, 0x98, 0x54, 0x0c, 0x66, 0xe9, 0x57, 0xc0, 0x3d, 0x5b, 0x52, 0x59, - 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xf6, 0xa5, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xb9, 0x68, 0xf5, - 0x36, 0x59, 0x01, 0x00, 0x00, + 0x3c, 0x96, 0x63, 0x88, 0xd2, 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, + 0x37, 0x48, 0xcf, 0x49, 0x4c, 0x2a, 0xd6, 0x37, 0x48, 0xd7, 0x4d, 0xce, 0x48, 0xcc, 0xcc, 0xd3, + 0xaf, 0x80, 0xfb, 0xb6, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0xec, 0x4d, 0x63, 0x40, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x05, 0x7d, 0xc8, 0x49, 0x5a, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/savings/types/query.pb.go b/x/savings/types/query.pb.go index 5e1340de..d15840bc 100644 --- a/x/savings/types/query.pb.go +++ b/x/savings/types/query.pb.go @@ -330,46 +330,46 @@ func init() { func init() { proto.RegisterFile("kava/savings/v1beta1/query.proto", fileDescriptor_f78c91efc5db144f) } var fileDescriptor_f78c91efc5db144f = []byte{ - // 619 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xb1, 0x8f, 0x12, 0x41, - 0x14, 0xc6, 0x19, 0x38, 0xc8, 0x39, 0x34, 0x66, 0x5c, 0x75, 0x21, 0xb8, 0x90, 0xcd, 0xe5, 0xe4, - 0x30, 0xec, 0x7a, 0xd8, 0x5d, 0x27, 0x67, 0xb4, 0xb0, 0xd1, 0x3d, 0x13, 0x13, 0x9b, 0xcb, 0x00, - 0x93, 0x65, 0x73, 0xb0, 0xb3, 0xb7, 0x33, 0x8b, 0xd2, 0x6a, 0x63, 0x62, 0x63, 0x62, 0xa1, 0xa5, - 0x85, 0x95, 0x89, 0x9d, 0xf1, 0x6f, 0xb8, 0xf2, 0xa2, 0x8d, 0x95, 0x1a, 0xf0, 0x0f, 0x31, 0x3b, - 0x33, 0xbb, 0x07, 0xc7, 0xe6, 0xa4, 0x82, 0x79, 0xf3, 0x7d, 0xdf, 0xfc, 0xe6, 0xcd, 0x03, 0xd8, - 0x38, 0xc2, 0x13, 0x6c, 0x33, 0x3c, 0xf1, 0x7c, 0x97, 0xd9, 0x93, 0xdd, 0x1e, 0xe1, 0x78, 0xd7, - 0x3e, 0x8e, 0x48, 0x38, 0xb5, 0x82, 0x90, 0x72, 0x8a, 0xb4, 0x58, 0x61, 0x29, 0x85, 0xa5, 0x14, - 0xd5, 0x56, 0x9f, 0xb2, 0x31, 0x65, 0x76, 0x0f, 0x33, 0x22, 0xe5, 0xa9, 0x39, 0xc0, 0xae, 0xe7, - 0x63, 0xee, 0x51, 0x5f, 0x26, 0x54, 0x8d, 0x45, 0x6d, 0xa2, 0xea, 0x53, 0x2f, 0xd9, 0xaf, 0xc8, - 0xfd, 0x43, 0xb1, 0xb2, 0xe5, 0x42, 0x6d, 0x69, 0x2e, 0x75, 0xa9, 0xac, 0xc7, 0xdf, 0x54, 0xb5, - 0xe6, 0x52, 0xea, 0x8e, 0x88, 0x8d, 0x03, 0xcf, 0xc6, 0xbe, 0x4f, 0xb9, 0x38, 0x2d, 0xf1, 0x64, - 0x5f, 0x89, 0x71, 0x1a, 0x12, 0xa9, 0x30, 0x35, 0x88, 0x1e, 0xc7, 0xc8, 0x8f, 0x70, 0x88, 0xc7, - 0xcc, 0x21, 0xc7, 0x11, 0x61, 0xdc, 0x7c, 0x0a, 0xaf, 0x2c, 0x55, 0x59, 0x40, 0x7d, 0x46, 0xd0, - 0x1e, 0x2c, 0x05, 0xa2, 0xa2, 0x83, 0x06, 0x68, 0x96, 0x3b, 0x35, 0x2b, 0xab, 0x21, 0x96, 0x74, - 0x75, 0x37, 0x4e, 0x7e, 0xd5, 0x73, 0x8e, 0x72, 0xec, 0x6d, 0xbc, 0xfe, 0x58, 0xcf, 0x99, 0x9f, - 0x00, 0xd4, 0x44, 0xf2, 0x3d, 0x12, 0x50, 0xe6, 0xf1, 0xe4, 0x44, 0xa4, 0xc1, 0xe2, 0x80, 0xf8, - 0x74, 0x2c, 0x92, 0x2f, 0x39, 0x72, 0x81, 0x2c, 0x58, 0xa4, 0xcf, 0x7d, 0x12, 0xea, 0xf9, 0xb8, - 0xda, 0xd5, 0xbf, 0x7f, 0x6d, 0x6b, 0xaa, 0x29, 0x77, 0x07, 0x83, 0x90, 0x30, 0x76, 0xc0, 0x43, - 0xcf, 0x77, 0x1d, 0x29, 0x43, 0xf7, 0x21, 0x3c, 0x6b, 0xb9, 0x5e, 0x10, 0x90, 0xdb, 0x96, 0x72, - 0xc4, 0x3d, 0xb7, 0xe4, 0x73, 0x9e, 0x91, 0xba, 0x44, 0x11, 0x38, 0x0b, 0x4e, 0xf3, 0x0b, 0x80, - 0x57, 0xcf, 0x61, 0xaa, 0x16, 0x3c, 0x84, 0x9b, 0x03, 0x55, 0xd3, 0x41, 0xa3, 0xd0, 0x2c, 0x77, - 0x6e, 0x64, 0x37, 0x41, 0x39, 0xbb, 0x97, 0xe3, 0x2e, 0x7c, 0xfe, 0x5d, 0xdf, 0x4c, 0xa3, 0xd2, - 0x00, 0xf4, 0x60, 0x09, 0x37, 0x2f, 0x70, 0x6f, 0xfe, 0x17, 0x57, 0x92, 0x2c, 0xf1, 0x56, 0xe0, - 0x75, 0x81, 0xfb, 0x84, 0x72, 0x3c, 0x3a, 0x88, 0x82, 0x60, 0x34, 0x4d, 0x9e, 0xf2, 0x3d, 0x80, - 0xfa, 0xea, 0x9e, 0xba, 0xcd, 0x35, 0x58, 0x1a, 0x12, 0xcf, 0x1d, 0x72, 0xd1, 0xf6, 0x82, 0xa3, - 0x56, 0xa8, 0x0f, 0x4b, 0x21, 0x61, 0xd1, 0x88, 0xeb, 0x79, 0x71, 0xc7, 0xca, 0x12, 0x54, 0x82, - 0xb3, 0x4f, 0x3d, 0xbf, 0x7b, 0x5b, 0xdd, 0xaf, 0xe9, 0x7a, 0x7c, 0x18, 0xf5, 0xac, 0x3e, 0x1d, - 0xab, 0xb9, 0x55, 0x1f, 0x6d, 0x36, 0x38, 0xb2, 0xf9, 0x34, 0x20, 0x4c, 0x18, 0x98, 0xa3, 0xa2, - 0x3b, 0xdf, 0x0a, 0xb0, 0x28, 0xc8, 0xd0, 0x2b, 0x00, 0x4b, 0x72, 0x68, 0x50, 0x33, 0xbb, 0x9b, - 0xab, 0x33, 0x5a, 0xdd, 0x59, 0x43, 0x29, 0xaf, 0x69, 0x6e, 0xbd, 0xfc, 0xf1, 0xf7, 0x5d, 0xde, - 0x40, 0x35, 0x3b, 0xf3, 0xf7, 0x20, 0x27, 0x14, 0xbd, 0x01, 0x30, 0x7d, 0x24, 0xd4, 0xba, 0x20, - 0xfd, 0xdc, 0xec, 0x56, 0x6f, 0xad, 0xa5, 0x55, 0x2c, 0xdb, 0x82, 0xa5, 0x81, 0x8c, 0x6c, 0x96, - 0x74, 0x36, 0x3e, 0x00, 0x58, 0x5e, 0x78, 0x32, 0xd4, 0xbe, 0xe0, 0x90, 0xd5, 0x67, 0xaf, 0x5a, - 0xeb, 0xca, 0x15, 0x56, 0x4b, 0x60, 0x6d, 0x21, 0x33, 0x1b, 0x8b, 0xc7, 0x96, 0x43, 0x26, 0x3c, - 0xdd, 0xfd, 0x93, 0x99, 0x01, 0x4e, 0x67, 0x06, 0xf8, 0x33, 0x33, 0xc0, 0xdb, 0xb9, 0x91, 0x3b, - 0x9d, 0x1b, 0xb9, 0x9f, 0x73, 0x23, 0xf7, 0x6c, 0x67, 0x61, 0x08, 0xe2, 0x9c, 0xf6, 0x08, 0xf7, - 0x98, 0x4c, 0x7c, 0x91, 0x66, 0x8a, 0x59, 0xe8, 0x95, 0xc4, 0xff, 0xcf, 0x9d, 0x7f, 0x01, 0x00, - 0x00, 0xff, 0xff, 0xa9, 0x76, 0x1d, 0x1f, 0x76, 0x05, 0x00, 0x00, + // 623 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0x4f, 0x6f, 0x12, 0x41, + 0x18, 0xc6, 0x19, 0x68, 0x49, 0x9d, 0x5e, 0xcc, 0xb8, 0xea, 0x96, 0xe0, 0x42, 0x36, 0x4d, 0x45, + 0x0c, 0xbb, 0x14, 0x6f, 0xbd, 0x89, 0x8d, 0x1e, 0xbc, 0xe8, 0xd6, 0xc4, 0xc4, 0x4b, 0x33, 0xc0, + 0x64, 0xd8, 0x14, 0x76, 0xb6, 0x3b, 0x03, 0xca, 0x55, 0x2f, 0x26, 0x5e, 0x4c, 0x3c, 0xe8, 0xd1, + 0x83, 0x27, 0x13, 0x6f, 0xc6, 0xcf, 0xd0, 0x63, 0xa3, 0x17, 0x4f, 0x6a, 0xc0, 0x0f, 0x62, 0x76, + 0x66, 0x76, 0x0b, 0x65, 0x53, 0x39, 0xc1, 0xbc, 0xf3, 0x3c, 0xef, 0xfc, 0xde, 0x3f, 0x00, 0xab, + 0x47, 0x78, 0x8c, 0x5d, 0x8e, 0xc7, 0x7e, 0x40, 0xb9, 0x3b, 0xde, 0xed, 0x10, 0x81, 0x77, 0xdd, + 0xe3, 0x11, 0x89, 0x26, 0x4e, 0x18, 0x31, 0xc1, 0x90, 0x11, 0x2b, 0x1c, 0xad, 0x70, 0xb4, 0xa2, + 0x54, 0xef, 0x32, 0x3e, 0x64, 0xdc, 0xed, 0x60, 0x4e, 0x94, 0x3c, 0x35, 0x87, 0x98, 0xfa, 0x01, + 0x16, 0x3e, 0x0b, 0x54, 0x86, 0x92, 0x35, 0xaf, 0x4d, 0x54, 0x5d, 0xe6, 0x27, 0xf7, 0x5b, 0xea, + 0xfe, 0x50, 0x9e, 0x5c, 0x75, 0xd0, 0x57, 0x06, 0x65, 0x94, 0xa9, 0x78, 0xfc, 0x4d, 0x47, 0xcb, + 0x94, 0x31, 0x3a, 0x20, 0x2e, 0x0e, 0x7d, 0x17, 0x07, 0x01, 0x13, 0xf2, 0xb5, 0xc4, 0x93, 0x5d, + 0x12, 0x17, 0x2c, 0x22, 0x4a, 0x61, 0x1b, 0x10, 0x3d, 0x8e, 0x91, 0x1f, 0xe1, 0x08, 0x0f, 0xb9, + 0x47, 0x8e, 0x47, 0x84, 0x0b, 0xfb, 0x29, 0xbc, 0xb2, 0x10, 0xe5, 0x21, 0x0b, 0x38, 0x41, 0x7b, + 0xb0, 0x18, 0xca, 0x88, 0x09, 0xaa, 0xa0, 0xb6, 0xd9, 0x2a, 0x3b, 0x59, 0x0d, 0x71, 0x94, 0xab, + 0xbd, 0x76, 0xf2, 0xab, 0x92, 0xf3, 0xb4, 0x63, 0x6f, 0xed, 0xf5, 0xc7, 0x4a, 0xce, 0xfe, 0x04, + 0xa0, 0x21, 0x33, 0xef, 0x93, 0x90, 0x71, 0x5f, 0x24, 0x2f, 0x22, 0x03, 0xae, 0xf7, 0x48, 0xc0, + 0x86, 0x32, 0xf3, 0x25, 0x4f, 0x1d, 0x90, 0x03, 0xd7, 0xd9, 0xf3, 0x80, 0x44, 0x66, 0x3e, 0x8e, + 0xb6, 0xcd, 0xef, 0x5f, 0x1b, 0x86, 0x6e, 0xca, 0xdd, 0x5e, 0x2f, 0x22, 0x9c, 0x1f, 0x88, 0xc8, + 0x0f, 0xa8, 0xa7, 0x64, 0xe8, 0x3e, 0x84, 0x67, 0x2d, 0x37, 0x0b, 0x12, 0x72, 0xc7, 0xd1, 0x8e, + 0xb8, 0xe7, 0x8e, 0x1a, 0xe7, 0x19, 0x29, 0x25, 0x9a, 0xc0, 0x9b, 0x73, 0xda, 0x5f, 0x00, 0xbc, + 0x7a, 0x0e, 0x53, 0xb7, 0xe0, 0x21, 0xdc, 0xe8, 0xe9, 0x98, 0x09, 0xaa, 0x85, 0xda, 0x66, 0xeb, + 0x46, 0x76, 0x13, 0xb4, 0xb3, 0x7d, 0x39, 0xee, 0xc2, 0xe7, 0xdf, 0x95, 0x8d, 0x34, 0x55, 0x9a, + 0x00, 0x3d, 0x58, 0xc0, 0xcd, 0x4b, 0xdc, 0x9b, 0xff, 0xc5, 0x55, 0x24, 0x0b, 0xbc, 0x5b, 0xf0, + 0xba, 0xc4, 0x7d, 0xc2, 0x04, 0x1e, 0x1c, 0x8c, 0xc2, 0x70, 0x30, 0x49, 0x46, 0xf9, 0x1e, 0x40, + 0x73, 0xf9, 0x4e, 0x57, 0x73, 0x0d, 0x16, 0xfb, 0xc4, 0xa7, 0x7d, 0x21, 0xdb, 0x5e, 0xf0, 0xf4, + 0x09, 0x75, 0x61, 0x31, 0x22, 0x7c, 0x34, 0x10, 0x66, 0x5e, 0xd6, 0xb8, 0xb5, 0x00, 0x95, 0xe0, + 0xdc, 0x63, 0x7e, 0xd0, 0x6e, 0xea, 0xfa, 0x6a, 0xd4, 0x17, 0xfd, 0x51, 0xc7, 0xe9, 0xb2, 0xa1, + 0xde, 0x5b, 0xfd, 0xd1, 0xe0, 0xbd, 0x23, 0x57, 0x4c, 0x42, 0xc2, 0xa5, 0x81, 0x7b, 0x3a, 0x75, + 0xeb, 0x5b, 0x01, 0xae, 0x4b, 0x32, 0xf4, 0x0a, 0xc0, 0xa2, 0x5a, 0x1a, 0x54, 0xcb, 0xee, 0xe6, + 0xf2, 0x8e, 0x96, 0x6e, 0xad, 0xa0, 0x54, 0x65, 0xda, 0xdb, 0x2f, 0x7f, 0xfc, 0x7d, 0x97, 0xb7, + 0x50, 0xd9, 0xcd, 0xfc, 0x3d, 0xa8, 0x0d, 0x45, 0x6f, 0x00, 0x4c, 0x87, 0x84, 0xea, 0x17, 0x64, + 0x3f, 0xb7, 0xbb, 0xa5, 0xdb, 0x2b, 0x69, 0x35, 0xcb, 0x8e, 0x64, 0xa9, 0x22, 0x2b, 0x9b, 0x25, + 0xdd, 0x8d, 0x0f, 0x00, 0x6e, 0xce, 0x8d, 0x0c, 0x35, 0x2e, 0x78, 0x64, 0x79, 0xec, 0x25, 0x67, + 0x55, 0xb9, 0xc6, 0xaa, 0x4b, 0xac, 0x6d, 0x64, 0x67, 0x63, 0x89, 0xd8, 0x72, 0xc8, 0xa5, 0xa7, + 0xbd, 0x7f, 0x32, 0xb5, 0xc0, 0xe9, 0xd4, 0x02, 0x7f, 0xa6, 0x16, 0x78, 0x3b, 0xb3, 0x72, 0xa7, + 0x33, 0x2b, 0xf7, 0x73, 0x66, 0xe5, 0x9e, 0xd5, 0xe7, 0x96, 0xa0, 0x49, 0x07, 0xb8, 0xc3, 0xdd, + 0x26, 0x6d, 0x74, 0xfb, 0xd8, 0x0f, 0xdc, 0x17, 0x69, 0x52, 0xb9, 0x0c, 0x9d, 0xa2, 0xfc, 0x03, + 0xba, 0xf3, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x85, 0x56, 0x54, 0x77, 0x05, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/savings/types/store.pb.go b/x/savings/types/store.pb.go index 02ee9143..1f1ec43a 100644 --- a/x/savings/types/store.pb.go +++ b/x/savings/types/store.pb.go @@ -111,28 +111,29 @@ func init() { func init() { proto.RegisterFile("kava/savings/v1beta1/store.proto", fileDescriptor_f7110366fa182786) } var fileDescriptor_f7110366fa182786 = []byte{ - // 335 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x51, 0xc1, 0x4e, 0xc2, 0x40, - 0x14, 0xec, 0x4a, 0x82, 0xa1, 0x1e, 0x34, 0x95, 0x03, 0x70, 0x58, 0x1a, 0x4e, 0xe5, 0xd0, 0x5d, - 0x91, 0x2f, 0xa0, 0x92, 0xe8, 0xd1, 0x70, 0xf4, 0x42, 0xb6, 0xed, 0x5a, 0x1b, 0x6c, 0x5f, 0xd3, - 0xb7, 0x10, 0xf9, 0x0b, 0xbf, 0xc3, 0xb3, 0x1f, 0xc1, 0x91, 0x78, 0x30, 0x9e, 0x50, 0xe1, 0x2f, - 0x3c, 0x99, 0xb6, 0x2b, 0x7a, 0xf4, 0xb4, 0x6f, 0xe7, 0xcd, 0x4c, 0x26, 0xf3, 0x4c, 0x7b, 0x26, - 0x16, 0x82, 0xa3, 0x58, 0xc4, 0x69, 0x84, 0x7c, 0x31, 0xf0, 0xa5, 0x12, 0x03, 0x8e, 0x0a, 0x72, - 0xc9, 0xb2, 0x1c, 0x14, 0x58, 0xcd, 0x82, 0xc1, 0x34, 0x83, 0x69, 0x46, 0x87, 0x06, 0x80, 0x09, - 0x20, 0xf7, 0x05, 0xca, 0xbd, 0x2c, 0x80, 0x38, 0xad, 0x54, 0x9d, 0x76, 0xb5, 0x9f, 0x96, 0x3f, - 0x5e, 0x7d, 0xf4, 0xaa, 0x19, 0x41, 0x04, 0x15, 0x5e, 0x4c, 0x15, 0xda, 0x1b, 0x9a, 0xf5, 0x6b, - 0x91, 0x8b, 0x04, 0xad, 0xbe, 0x79, 0x82, 0xf3, 0x2c, 0x83, 0x5c, 0xc9, 0x70, 0x1a, 0xca, 0x14, - 0x12, 0x6c, 0x11, 0xbb, 0xe6, 0x34, 0x26, 0xc7, 0x7b, 0x7c, 0x5c, 0xc2, 0xbd, 0x57, 0x62, 0x1e, - 0x8e, 0x65, 0x06, 0x18, 0x2b, 0xeb, 0xd6, 0x6c, 0x84, 0xd5, 0x08, 0x79, 0x8b, 0xd8, 0xc4, 0x69, - 0x78, 0x57, 0x5f, 0x9b, 0xae, 0x1b, 0xc5, 0xea, 0x6e, 0xee, 0xb3, 0x00, 0x12, 0x1d, 0x43, 0x3f, - 0x2e, 0x86, 0x33, 0xae, 0x96, 0x99, 0x44, 0x36, 0x0a, 0x82, 0x51, 0x18, 0xe6, 0x12, 0xf1, 0xe5, - 0xd9, 0x3d, 0xd5, 0x61, 0x35, 0xe2, 0x2d, 0x95, 0xc4, 0xc9, 0xaf, 0xb5, 0x15, 0x98, 0x75, 0x91, - 0xc0, 0x3c, 0x55, 0xad, 0x03, 0xbb, 0xe6, 0x1c, 0x9d, 0xb7, 0x99, 0x16, 0x14, 0x55, 0xfc, 0xf4, - 0xc3, 0x2e, 0x20, 0x4e, 0xbd, 0xb3, 0xd5, 0xa6, 0x6b, 0x3c, 0xbd, 0x77, 0x9d, 0x7f, 0x64, 0x28, - 0x04, 0x38, 0xd1, 0xd6, 0xde, 0xe5, 0xea, 0x93, 0x1a, 0xab, 0x2d, 0x25, 0xeb, 0x2d, 0x25, 0x1f, - 0x5b, 0x4a, 0x1e, 0x77, 0xd4, 0x58, 0xef, 0xa8, 0xf1, 0xb6, 0xa3, 0xc6, 0x4d, 0xff, 0x8f, 0x5f, - 0x71, 0x1d, 0xf7, 0x5e, 0xf8, 0x58, 0x4e, 0xfc, 0x61, 0x7f, 0xcb, 0xd2, 0xd6, 0xaf, 0x97, 0xed, - 0x0e, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xef, 0x42, 0x46, 0x9e, 0xe8, 0x01, 0x00, 0x00, + // 341 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x51, 0xc1, 0x4e, 0xea, 0x40, + 0x14, 0x6d, 0x1f, 0x09, 0x2f, 0xf4, 0x2d, 0x9e, 0xa9, 0x2c, 0x80, 0xc5, 0xd0, 0xb0, 0xaa, 0x26, + 0x9d, 0x01, 0xf9, 0x02, 0x2a, 0x0b, 0x96, 0x86, 0xa5, 0x1b, 0x32, 0x9d, 0x8e, 0xa5, 0xc1, 0xf6, + 0x36, 0xbd, 0x03, 0x91, 0xbf, 0xf0, 0x3b, 0x5c, 0xfb, 0x11, 0x2c, 0x89, 0x0b, 0xe3, 0x0a, 0x15, + 0xfe, 0xc2, 0x95, 0x69, 0x3b, 0xa2, 0x4b, 0x57, 0x73, 0xef, 0xb9, 0xe7, 0x9c, 0x9c, 0x9c, 0xb1, + 0x9c, 0x05, 0x5f, 0x71, 0x86, 0x7c, 0x15, 0xa7, 0x11, 0xb2, 0xd5, 0x20, 0x90, 0x8a, 0x0f, 0x18, + 0x2a, 0xc8, 0x25, 0xcd, 0x72, 0x50, 0x60, 0x37, 0x0b, 0x06, 0xd5, 0x0c, 0xaa, 0x19, 0x1d, 0x22, + 0x00, 0x13, 0x40, 0x16, 0x70, 0x94, 0x47, 0x99, 0x80, 0x38, 0xad, 0x54, 0x9d, 0x76, 0x75, 0x9f, + 0x95, 0x1b, 0xab, 0x16, 0x7d, 0x6a, 0x46, 0x10, 0x41, 0x85, 0x17, 0x53, 0x85, 0xf6, 0x86, 0x56, + 0xfd, 0x8a, 0xe7, 0x3c, 0x41, 0xfb, 0xcc, 0x3a, 0xc1, 0x65, 0x96, 0x41, 0xae, 0x64, 0x38, 0x0b, + 0x65, 0x0a, 0x09, 0xb6, 0x4c, 0xa7, 0xe6, 0x36, 0xa6, 0xff, 0x8f, 0xf8, 0xb8, 0x84, 0x7b, 0xcf, + 0xa6, 0xf5, 0x77, 0x2c, 0x33, 0xc0, 0x58, 0xd9, 0x37, 0x56, 0x23, 0xac, 0x46, 0xc8, 0x5b, 0xa6, + 0x63, 0xba, 0x0d, 0x7f, 0xf2, 0xb1, 0xeb, 0x7a, 0x51, 0xac, 0xe6, 0xcb, 0x80, 0x0a, 0x48, 0x74, + 0x0c, 0xfd, 0x78, 0x18, 0x2e, 0x98, 0x5a, 0x67, 0x12, 0xe9, 0x48, 0x88, 0x51, 0x18, 0xe6, 0x12, + 0xf1, 0xe9, 0xd1, 0x3b, 0xd5, 0x61, 0x35, 0xe2, 0xaf, 0x95, 0xc4, 0xe9, 0xb7, 0xb5, 0x2d, 0xac, + 0x3a, 0x4f, 0x60, 0x99, 0xaa, 0xd6, 0x1f, 0xa7, 0xe6, 0xfe, 0xbb, 0x68, 0x53, 0x2d, 0x28, 0xaa, + 0xf8, 0xea, 0x87, 0x5e, 0x42, 0x9c, 0xfa, 0xfd, 0xcd, 0xae, 0x6b, 0x3c, 0xbc, 0x76, 0xdd, 0x5f, + 0x64, 0x28, 0x04, 0x38, 0xd5, 0xd6, 0xfe, 0x64, 0xf3, 0x4e, 0x8c, 0xcd, 0x9e, 0x98, 0xdb, 0x3d, + 0x31, 0xdf, 0xf6, 0xc4, 0xbc, 0x3f, 0x10, 0x63, 0x7b, 0x20, 0xc6, 0xcb, 0x81, 0x18, 0xd7, 0xe7, + 0x3f, 0xfc, 0xfa, 0xd1, 0x2d, 0x0f, 0x90, 0xf5, 0x23, 0x4f, 0xcc, 0x79, 0x9c, 0xb2, 0xbb, 0xe3, + 0x67, 0x96, 0xbe, 0x41, 0xbd, 0xac, 0x77, 0xf8, 0x19, 0x00, 0x00, 0xff, 0xff, 0x69, 0xf4, 0xaf, + 0xe1, 0xe9, 0x01, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { diff --git a/x/savings/types/tx.pb.go b/x/savings/types/tx.pb.go index 392172d5..e1492ec0 100644 --- a/x/savings/types/tx.pb.go +++ b/x/savings/types/tx.pb.go @@ -221,30 +221,31 @@ func init() { func init() { proto.RegisterFile("kava/savings/v1beta1/tx.proto", fileDescriptor_c0bf8679b144267a) } var fileDescriptor_c0bf8679b144267a = []byte{ - // 368 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x52, 0xcd, 0x4e, 0xea, 0x40, - 0x14, 0xee, 0x5c, 0x12, 0xee, 0x65, 0xd8, 0xf5, 0xd6, 0x04, 0x9a, 0x58, 0x90, 0x55, 0x59, 0x30, - 0x15, 0x4c, 0xdc, 0x0b, 0x6e, 0xd9, 0x60, 0x8c, 0xc6, 0x8d, 0x99, 0xfe, 0x64, 0x98, 0x20, 0x9d, - 0xa6, 0x67, 0x40, 0x7c, 0x0b, 0x5f, 0x43, 0xd6, 0xc6, 0x67, 0x60, 0x49, 0x5c, 0xb9, 0x52, 0x03, - 0x2f, 0x62, 0xda, 0x4e, 0x81, 0x85, 0x86, 0xad, 0xab, 0x9e, 0x99, 0xef, 0x27, 0xdf, 0x7c, 0x3d, - 0xf8, 0x70, 0x44, 0xa7, 0xd4, 0x01, 0x3a, 0xe5, 0x21, 0x03, 0x67, 0xda, 0x76, 0x03, 0x49, 0xdb, - 0x8e, 0x9c, 0x91, 0x28, 0x16, 0x52, 0xe8, 0x46, 0x02, 0x13, 0x05, 0x13, 0x05, 0x9b, 0x96, 0x27, - 0x60, 0x2c, 0xc0, 0x71, 0x29, 0x04, 0x1b, 0x8d, 0x27, 0x78, 0x98, 0xa9, 0xcc, 0x6a, 0x86, 0xdf, - 0xa6, 0x27, 0x27, 0x3b, 0x28, 0xc8, 0x60, 0x82, 0x89, 0xec, 0x3e, 0x99, 0xb2, 0xdb, 0xc6, 0x13, - 0xc2, 0xb8, 0x0f, 0xec, 0x3c, 0x88, 0x04, 0x70, 0xa9, 0x9f, 0xe2, 0x92, 0x9f, 0x8d, 0x22, 0xae, - 0xa0, 0x3a, 0xb2, 0x4b, 0xdd, 0xca, 0xeb, 0x73, 0xcb, 0x50, 0x4e, 0x67, 0xbe, 0x1f, 0x07, 0x00, - 0x17, 0x32, 0xe6, 0x21, 0x1b, 0x6c, 0xa9, 0xba, 0x87, 0x8b, 0x74, 0x2c, 0x26, 0xa1, 0xac, 0xfc, - 0xa9, 0x17, 0xec, 0x72, 0xa7, 0x4a, 0x94, 0x22, 0x09, 0x9a, 0xa7, 0x27, 0x3d, 0xc1, 0xc3, 0xee, - 0xf1, 0xe2, 0xbd, 0xa6, 0xcd, 0x3f, 0x6a, 0x36, 0xe3, 0x72, 0x38, 0x71, 0x89, 0x27, 0xc6, 0x2a, - 0xa8, 0xfa, 0xb4, 0xc0, 0x1f, 0x39, 0xf2, 0x21, 0x0a, 0x20, 0x15, 0xc0, 0x40, 0x59, 0x37, 0x0c, - 0xac, 0x6f, 0xa3, 0x0e, 0x02, 0x88, 0x44, 0x08, 0x41, 0x63, 0x8e, 0x70, 0xb9, 0x0f, 0xec, 0x8a, - 0xcb, 0xa1, 0x1f, 0xd3, 0xfb, 0xdf, 0xfd, 0x84, 0x03, 0xfc, 0x7f, 0x27, 0x6b, 0xfe, 0x86, 0xce, - 0x0b, 0xc2, 0x85, 0x3e, 0x30, 0xfd, 0x12, 0xff, 0xcd, 0xff, 0x44, 0x9d, 0x7c, 0xb7, 0x00, 0x64, - 0x5b, 0x80, 0x69, 0xef, 0x63, 0xe4, 0xf6, 0xfa, 0x35, 0xfe, 0xb7, 0xa9, 0xe7, 0xe8, 0x47, 0x55, - 0x4e, 0x31, 0x9b, 0x7b, 0x29, 0xb9, 0x73, 0xb7, 0xb7, 0x58, 0x59, 0x68, 0xb9, 0xb2, 0xd0, 0xe7, - 0xca, 0x42, 0x8f, 0x6b, 0x4b, 0x5b, 0xae, 0x2d, 0xed, 0x6d, 0x6d, 0x69, 0x37, 0xcd, 0x9d, 0x6e, - 0x12, 0xbb, 0xd6, 0x1d, 0x75, 0x21, 0x9d, 0x9c, 0xd9, 0x66, 0xeb, 0xd3, 0x8a, 0xdc, 0x62, 0xba, - 0x8a, 0x27, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x17, 0x24, 0x24, 0x12, 0x03, 0x00, 0x00, + // 374 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x52, 0x3d, 0x6f, 0xe2, 0x30, + 0x18, 0x8e, 0x0f, 0x89, 0x3b, 0xcc, 0x96, 0xcb, 0x49, 0x10, 0xe9, 0x02, 0xc7, 0x94, 0x3b, 0x09, + 0x1b, 0x38, 0xa9, 0x7b, 0x29, 0x2b, 0x0b, 0x55, 0xd5, 0xaa, 0x4b, 0xe5, 0x7c, 0xc8, 0x58, 0x94, + 0x38, 0xca, 0x6b, 0x28, 0xfd, 0x17, 0xfd, 0x1b, 0x65, 0xae, 0xfa, 0x1b, 0x18, 0x51, 0xa7, 0x4e, + 0x6d, 0x05, 0x7f, 0xa4, 0x22, 0x71, 0x80, 0xa1, 0x15, 0x6b, 0xa7, 0xd8, 0x7e, 0x3e, 0xf4, 0xbc, + 0x4f, 0x5e, 0xfc, 0x7b, 0xc4, 0xa6, 0x8c, 0x02, 0x9b, 0x8a, 0x88, 0x03, 0x9d, 0xb6, 0xbd, 0x50, + 0xb1, 0x36, 0x55, 0x33, 0x12, 0x27, 0x52, 0x49, 0xd3, 0xda, 0xc0, 0x44, 0xc3, 0x44, 0xc3, 0xb6, + 0xe3, 0x4b, 0x18, 0x4b, 0xa0, 0x1e, 0x83, 0x70, 0xab, 0xf1, 0xa5, 0x88, 0x32, 0x95, 0x5d, 0xcd, + 0xf0, 0xab, 0xf4, 0x46, 0xb3, 0x8b, 0x86, 0x2c, 0x2e, 0xb9, 0xcc, 0xde, 0x37, 0xa7, 0xec, 0xb5, + 0x71, 0x8f, 0x30, 0xee, 0x03, 0xef, 0x85, 0xb1, 0x04, 0xa1, 0xcc, 0x23, 0x5c, 0x0a, 0xb2, 0xa3, + 0x4c, 0x2a, 0xa8, 0x8e, 0xdc, 0x52, 0xb7, 0xf2, 0xf4, 0xd0, 0xb4, 0xb4, 0xd3, 0x71, 0x10, 0x24, + 0x21, 0xc0, 0xa9, 0x4a, 0x44, 0xc4, 0x07, 0x3b, 0xaa, 0xe9, 0xe3, 0x22, 0x1b, 0xcb, 0x49, 0xa4, + 0x2a, 0xdf, 0xea, 0x05, 0xb7, 0xdc, 0xa9, 0x12, 0xad, 0xd8, 0x04, 0xcd, 0xd3, 0x93, 0x13, 0x29, + 0xa2, 0x6e, 0x6b, 0xf1, 0x52, 0x33, 0xe6, 0xaf, 0x35, 0x97, 0x0b, 0x35, 0x9c, 0x78, 0xc4, 0x97, + 0x63, 0x1d, 0x54, 0x7f, 0x9a, 0x10, 0x8c, 0xa8, 0xba, 0x8d, 0x43, 0x48, 0x05, 0x30, 0xd0, 0xd6, + 0x0d, 0x0b, 0x9b, 0xbb, 0xa8, 0x83, 0x10, 0x62, 0x19, 0x41, 0xd8, 0x98, 0x23, 0x5c, 0xee, 0x03, + 0x3f, 0x17, 0x6a, 0x18, 0x24, 0xec, 0xe6, 0x6b, 0x8f, 0xf0, 0x0b, 0xff, 0xdc, 0xcb, 0x9a, 0xcf, + 0xd0, 0x79, 0x44, 0xb8, 0xd0, 0x07, 0x6e, 0x9e, 0xe1, 0xef, 0xf9, 0x9f, 0xa8, 0x93, 0x8f, 0x16, + 0x80, 0xec, 0x0a, 0xb0, 0xdd, 0x43, 0x8c, 0xdc, 0xde, 0xbc, 0xc0, 0x3f, 0xb6, 0xf5, 0xfc, 0xf9, + 0x54, 0x95, 0x53, 0xec, 0xbf, 0x07, 0x29, 0xb9, 0x73, 0xb7, 0xb7, 0x58, 0x39, 0x68, 0xb9, 0x72, + 0xd0, 0xdb, 0xca, 0x41, 0x77, 0x6b, 0xc7, 0x58, 0xae, 0x1d, 0xe3, 0x79, 0xed, 0x18, 0x97, 0xff, + 0xf6, 0xba, 0x69, 0xf1, 0x6b, 0xe6, 0x01, 0x6d, 0xf1, 0xa6, 0x3f, 0x64, 0x22, 0xa2, 0xb3, 0xed, + 0xda, 0xa7, 0x1d, 0x79, 0xc5, 0x74, 0x17, 0xff, 0xbf, 0x07, 0x00, 0x00, 0xff, 0xff, 0xc5, 0xcb, + 0x03, 0x6a, 0x13, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/swap/types/genesis.pb.go b/x/swap/types/genesis.pb.go index a58cc8c4..72acb655 100644 --- a/x/swap/types/genesis.pb.go +++ b/x/swap/types/genesis.pb.go @@ -94,7 +94,7 @@ func init() { func init() { proto.RegisterFile("kava/swap/v1beta1/genesis.proto", fileDescriptor_b1a1a1687f484a21) } var fileDescriptor_b1a1a1687f484a21 = []byte{ - // 283 bytes of a gzipped FileDescriptorProto + // 289 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcf, 0x4e, 0x2c, 0x4b, 0xd4, 0x2f, 0x2e, 0x4f, 0x2c, 0xd0, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x04, 0x29, 0xd0, @@ -107,12 +107,13 @@ var fileDescriptor_b1a1a1687f484a21 = []byte{ 0x23, 0x59, 0x6c, 0xda, 0xf3, 0xf3, 0x73, 0x82, 0xc0, 0xaa, 0x9c, 0x84, 0x41, 0x46, 0xac, 0xba, 0x2f, 0xcf, 0x8d, 0x10, 0x2b, 0x0e, 0xe2, 0x2e, 0x40, 0x70, 0x84, 0x22, 0xb9, 0x78, 0x8b, 0x33, 0x12, 0x8b, 0x52, 0xe1, 0xe6, 0x32, 0x83, 0xcd, 0x95, 0xc3, 0x62, 0x6e, 0x30, 0x48, 0x1d, 0xd4, - 0x60, 0x11, 0xa8, 0xc1, 0x3c, 0x48, 0x82, 0xc5, 0x41, 0x3c, 0xc5, 0x48, 0x3c, 0x27, 0x87, 0x13, + 0x60, 0x11, 0xa8, 0xc1, 0x3c, 0x48, 0x82, 0xc5, 0x41, 0x3c, 0xc5, 0x48, 0x3c, 0x27, 0xc7, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, - 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x52, 0x4b, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, - 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x07, 0xd9, 0xa3, 0x9b, 0x93, 0x98, 0x54, 0x0c, 0x66, 0xe9, 0x57, - 0x40, 0x82, 0xb2, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c, 0x88, 0xc6, 0x80, 0x00, 0x00, - 0x00, 0xff, 0xff, 0xca, 0xb8, 0xb9, 0x95, 0xae, 0x01, 0x00, 0x00, + 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, + 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x37, 0x48, 0xcf, 0x49, 0x4c, 0x2a, 0xd6, 0x37, 0x48, 0xd7, 0x4d, + 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0xaf, 0x80, 0x84, 0x65, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, + 0x38, 0x14, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9e, 0xfc, 0xbc, 0xdc, 0xaf, 0x01, 0x00, + 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/swap/types/query.pb.go b/x/swap/types/query.pb.go index fc239a03..85e6da04 100644 --- a/x/swap/types/query.pb.go +++ b/x/swap/types/query.pb.go @@ -405,54 +405,55 @@ func init() { func init() { proto.RegisterFile("kava/swap/v1beta1/query.proto", fileDescriptor_652c07bb38685396) } var fileDescriptor_652c07bb38685396 = []byte{ - // 747 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcf, 0x4f, 0x13, 0x4d, - 0x18, 0xee, 0xf6, 0xd7, 0x07, 0x53, 0x92, 0x2f, 0xcc, 0xc7, 0x17, 0xdb, 0x05, 0xb6, 0x58, 0x05, - 0x1a, 0x93, 0xee, 0x0a, 0x26, 0x9a, 0xa8, 0x07, 0xad, 0x04, 0xc3, 0x49, 0x5d, 0x8c, 0x07, 0x2f, - 0xcd, 0x94, 0x9d, 0x2c, 0x1b, 0xb6, 0x3b, 0xcb, 0xce, 0xb4, 0x88, 0x27, 0xc3, 0xc9, 0xa3, 0x89, - 0x37, 0x4f, 0x9e, 0x8d, 0xde, 0xf8, 0x0f, 0xbc, 0x70, 0x24, 0x78, 0x31, 0x1e, 0xd0, 0x80, 0x47, - 0xff, 0x08, 0x33, 0x3f, 0xb6, 0x94, 0x76, 0xb1, 0x6a, 0x38, 0x75, 0x77, 0xde, 0xf7, 0x7d, 0x9e, - 0xe7, 0x7d, 0xdf, 0x67, 0xa7, 0x60, 0x7a, 0x03, 0x75, 0x90, 0x45, 0xb7, 0x50, 0x68, 0x75, 0x16, - 0x9a, 0x98, 0xa1, 0x05, 0x6b, 0xb3, 0x8d, 0xa3, 0x6d, 0x33, 0x8c, 0x08, 0x23, 0x70, 0x9c, 0x87, - 0x4d, 0x1e, 0x36, 0x55, 0x58, 0xbf, 0xb2, 0x46, 0x68, 0x8b, 0x50, 0xab, 0x89, 0x28, 0x96, 0xb9, - 0xdd, 0xca, 0x10, 0xb9, 0x5e, 0x80, 0x98, 0x47, 0x02, 0x59, 0xae, 0x1b, 0xbd, 0xb9, 0x71, 0xd6, - 0x1a, 0xf1, 0xe2, 0x78, 0x49, 0xc6, 0x1b, 0xe2, 0xcd, 0x92, 0x2f, 0x2a, 0x34, 0xe1, 0x12, 0x97, - 0xc8, 0x73, 0xfe, 0xa4, 0x4e, 0xa7, 0x5c, 0x42, 0x5c, 0x1f, 0x5b, 0x28, 0xf4, 0x2c, 0x14, 0x04, - 0x84, 0x09, 0xb6, 0xb8, 0x66, 0x6a, 0xb0, 0x19, 0x21, 0x5d, 0x44, 0x2b, 0x3a, 0x80, 0x8f, 0xb8, - 0xdc, 0x87, 0x28, 0x42, 0x2d, 0x6a, 0xe3, 0xcd, 0x36, 0xa6, 0xec, 0x66, 0xf6, 0xe5, 0xdb, 0x72, - 0xaa, 0xf2, 0x18, 0xfc, 0x77, 0x2a, 0x46, 0x43, 0x12, 0x50, 0x0c, 0x6f, 0x80, 0x7c, 0x28, 0x4e, - 0x8a, 0xda, 0x8c, 0x56, 0x2d, 0x2c, 0x96, 0xcc, 0x81, 0x79, 0x98, 0xb2, 0xa4, 0x9e, 0xdd, 0x3b, - 0x2c, 0xa7, 0x6c, 0x95, 0xae, 0x50, 0x19, 0x18, 0x97, 0xa8, 0x84, 0xf8, 0x31, 0x21, 0xbc, 0x00, - 0xfe, 0x09, 0x09, 0xf1, 0x1b, 0x9e, 0x23, 0x40, 0x47, 0xed, 0x3c, 0x7f, 0x5d, 0x71, 0xe0, 0x32, - 0x00, 0x27, 0x03, 0x2c, 0xa6, 0x05, 0xe1, 0x9c, 0xa9, 0x86, 0xc2, 0x27, 0x68, 0xca, 0xcd, 0x9c, - 0x10, 0xbb, 0x58, 0x81, 0xda, 0x3d, 0x95, 0x95, 0x37, 0x5a, 0xdc, 0xa8, 0xa4, 0x55, 0xbd, 0xdc, - 0x02, 0x39, 0x4e, 0xc4, 0x5b, 0xc9, 0x54, 0x0b, 0x8b, 0xe5, 0xa4, 0x56, 0x08, 0xf1, 0xe3, 0x7c, - 0xd5, 0x90, 0xac, 0x81, 0xf7, 0x13, 0xb4, 0xcd, 0x0f, 0xd5, 0x26, 0x91, 0x4e, 0x89, 0xfb, 0xa1, - 0x81, 0xb1, 0x5e, 0x1a, 0x08, 0x41, 0x36, 0x40, 0x2d, 0xac, 0x66, 0x21, 0x9e, 0x21, 0x02, 0x39, - 0x6e, 0x12, 0x5a, 0x4c, 0x0b, 0xa9, 0xa5, 0x53, 0x44, 0x31, 0xc5, 0x3d, 0xe2, 0x05, 0xf5, 0xab, - 0x5c, 0xe4, 0xbb, 0xaf, 0xe5, 0xaa, 0xeb, 0xb1, 0xf5, 0x76, 0xd3, 0x5c, 0x23, 0x2d, 0x65, 0x23, - 0xf5, 0x53, 0xa3, 0xce, 0x86, 0xc5, 0xb6, 0x43, 0x4c, 0x45, 0x01, 0xb5, 0x25, 0x32, 0x6c, 0x80, - 0x31, 0x46, 0x18, 0xf2, 0x1b, 0x74, 0x1d, 0x45, 0x98, 0x16, 0x33, 0x9c, 0xbe, 0x7e, 0x9b, 0xc3, - 0x7d, 0x39, 0x2c, 0xcf, 0xfd, 0x06, 0xdc, 0x4a, 0xc0, 0x0e, 0x76, 0x6b, 0x40, 0x49, 0x5b, 0x09, - 0x98, 0x5d, 0x10, 0x88, 0xab, 0x02, 0x50, 0x39, 0xe0, 0x83, 0x06, 0x26, 0xc4, 0x2e, 0x96, 0x70, - 0x48, 0xa8, 0xc7, 0xba, 0x2e, 0x30, 0x41, 0x8e, 0x6c, 0x05, 0x38, 0x92, 0x7d, 0xd7, 0x8b, 0x07, - 0xbb, 0xb5, 0x09, 0x05, 0x75, 0xd7, 0x71, 0x22, 0x4c, 0xe9, 0x2a, 0x8b, 0xbc, 0xc0, 0xb5, 0x65, - 0x5a, 0xaf, 0x6b, 0xd2, 0xbf, 0x70, 0x4d, 0xe6, 0x6f, 0x5d, 0xa3, 0xf4, 0xbe, 0xd7, 0xc0, 0xff, - 0x7d, 0x7a, 0xd5, 0x9e, 0x96, 0xc0, 0x88, 0xa3, 0xce, 0x94, 0x83, 0x2a, 0x09, 0x0e, 0x52, 0x65, - 0x7d, 0x26, 0xea, 0x56, 0x9e, 0x9b, 0x8f, 0x94, 0xdc, 0x8f, 0x69, 0xf0, 0x6f, 0x1f, 0x25, 0xbc, - 0x0e, 0x46, 0x15, 0x1d, 0x19, 0x3e, 0xdd, 0x93, 0xd4, 0xb3, 0x27, 0xec, 0x81, 0x31, 0x69, 0x92, - 0x06, 0x5f, 0x85, 0xa3, 0xac, 0xb2, 0xfc, 0xc7, 0x56, 0x49, 0x56, 0x50, 0x90, 0xd8, 0x0f, 0x38, - 0x34, 0x0c, 0xba, 0x54, 0x1d, 0xe4, 0xb7, 0x71, 0x31, 0x7b, 0xfe, 0xfe, 0x57, 0x7c, 0x4f, 0x38, - 0xbe, 0x9c, 0xe2, 0xe2, 0x8b, 0x0c, 0xc8, 0x89, 0xa5, 0xc3, 0xe7, 0x20, 0x2f, 0xaf, 0x33, 0x38, - 0x9b, 0xb0, 0xdc, 0xc1, 0xdb, 0x53, 0x9f, 0x1b, 0x96, 0x26, 0x97, 0x52, 0xb9, 0xb8, 0xf3, 0xe9, - 0xfb, 0xeb, 0xf4, 0x24, 0x2c, 0x59, 0x83, 0x57, 0xb4, 0xbc, 0x32, 0x61, 0x07, 0xe4, 0xc4, 0x85, - 0x05, 0x2f, 0x9f, 0x89, 0xd9, 0x73, 0x8d, 0xea, 0xb3, 0x43, 0xb2, 0x14, 0xf1, 0x8c, 0x20, 0xd6, - 0x61, 0x31, 0x89, 0x58, 0xd0, 0xed, 0x68, 0x60, 0x24, 0x76, 0x3b, 0x9c, 0x3f, 0x0b, 0xb5, 0xef, - 0xfb, 0xd5, 0xab, 0xc3, 0x13, 0x95, 0x82, 0x4b, 0x42, 0xc1, 0x34, 0x9c, 0x4c, 0x50, 0x10, 0x7f, - 0x17, 0xf5, 0x3b, 0x7b, 0x47, 0x86, 0xb6, 0x7f, 0x64, 0x68, 0xdf, 0x8e, 0x0c, 0xed, 0xd5, 0xb1, - 0x91, 0xda, 0x3f, 0x36, 0x52, 0x9f, 0x8f, 0x8d, 0xd4, 0xd3, 0x5e, 0x7f, 0x71, 0x80, 0x9a, 0x8f, - 0x9a, 0x54, 0x42, 0x3d, 0x93, 0x60, 0x62, 0xbb, 0xcd, 0xbc, 0xf8, 0x93, 0xbb, 0xf6, 0x33, 0x00, - 0x00, 0xff, 0xff, 0x7b, 0x1b, 0x3a, 0x0f, 0xd1, 0x07, 0x00, 0x00, + // 753 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcf, 0x4f, 0x13, 0x4f, + 0x14, 0xef, 0xf6, 0xd7, 0x17, 0xa6, 0x24, 0xdf, 0x30, 0x62, 0x6c, 0x0b, 0x6c, 0xb1, 0x0a, 0x34, + 0x26, 0xdd, 0x05, 0x4c, 0x34, 0x51, 0x2f, 0x54, 0x82, 0xe1, 0xa4, 0x2e, 0xc6, 0x83, 0x97, 0x66, + 0xda, 0x9d, 0x2c, 0x1b, 0xb6, 0x3b, 0xcb, 0xce, 0xb4, 0x88, 0x27, 0xc3, 0xc9, 0xa3, 0x89, 0x37, + 0x4f, 0x9e, 0x8d, 0xde, 0xf8, 0x0f, 0xbc, 0x70, 0x24, 0x78, 0x31, 0x1e, 0xd0, 0x80, 0x47, 0xff, + 0x08, 0x33, 0x3f, 0xb6, 0x94, 0x76, 0xb1, 0x6a, 0x38, 0x75, 0x77, 0xde, 0x7b, 0x9f, 0xcf, 0xe7, + 0xbd, 0xf7, 0xd9, 0x29, 0x98, 0xde, 0x44, 0x1d, 0x64, 0xd2, 0x6d, 0x14, 0x98, 0x9d, 0xc5, 0x06, + 0x66, 0x68, 0xd1, 0xdc, 0x6a, 0xe3, 0x70, 0xc7, 0x08, 0x42, 0xc2, 0x08, 0x1c, 0xe7, 0x61, 0x83, + 0x87, 0x0d, 0x15, 0x2e, 0xde, 0x68, 0x12, 0xda, 0x22, 0xd4, 0x6c, 0x20, 0x8a, 0x65, 0x6e, 0xb7, + 0x32, 0x40, 0x8e, 0xeb, 0x23, 0xe6, 0x12, 0x5f, 0x96, 0x17, 0xf5, 0xde, 0xdc, 0x28, 0xab, 0x49, + 0xdc, 0x28, 0x5e, 0x90, 0xf1, 0xba, 0x78, 0x33, 0xe5, 0x8b, 0x0a, 0x4d, 0x38, 0xc4, 0x21, 0xf2, + 0x9c, 0x3f, 0xa9, 0xd3, 0x29, 0x87, 0x10, 0xc7, 0xc3, 0x26, 0x0a, 0x5c, 0x13, 0xf9, 0x3e, 0x61, + 0x82, 0x2d, 0xaa, 0x99, 0x1a, 0x6c, 0x46, 0x48, 0x17, 0xd1, 0x72, 0x11, 0xc0, 0xc7, 0x5c, 0xee, + 0x23, 0x14, 0xa2, 0x16, 0xb5, 0xf0, 0x56, 0x1b, 0x53, 0x76, 0x27, 0xfd, 0xea, 0x5d, 0x29, 0x51, + 0x7e, 0x02, 0x2e, 0x9d, 0x89, 0xd1, 0x80, 0xf8, 0x14, 0xc3, 0xdb, 0x20, 0x1b, 0x88, 0x93, 0xbc, + 0x36, 0xa3, 0x55, 0x72, 0x4b, 0x05, 0x63, 0x60, 0x1e, 0x86, 0x2c, 0xa9, 0xa5, 0xf7, 0x8f, 0x4a, + 0x09, 0x4b, 0xa5, 0x2b, 0x54, 0x06, 0xc6, 0x25, 0x2a, 0x21, 0x5e, 0x44, 0x08, 0xaf, 0x80, 0xff, + 0x02, 0x42, 0xbc, 0xba, 0x6b, 0x0b, 0xd0, 0x51, 0x2b, 0xcb, 0x5f, 0xd7, 0x6c, 0xb8, 0x0a, 0xc0, + 0xe9, 0x00, 0xf3, 0x49, 0x41, 0x38, 0x67, 0xa8, 0xa1, 0xf0, 0x09, 0x1a, 0x72, 0x33, 0xa7, 0xc4, + 0x0e, 0x56, 0xa0, 0x56, 0x4f, 0x65, 0xf9, 0xad, 0x16, 0x35, 0x2a, 0x69, 0x55, 0x2f, 0x77, 0x41, + 0x86, 0x13, 0xf1, 0x56, 0x52, 0x95, 0xdc, 0x52, 0x29, 0xae, 0x15, 0x42, 0xbc, 0x28, 0x5f, 0x35, + 0x24, 0x6b, 0xe0, 0x83, 0x18, 0x6d, 0xf3, 0x43, 0xb5, 0x49, 0xa4, 0x33, 0xe2, 0x7e, 0x6a, 0x60, + 0xac, 0x97, 0x06, 0x42, 0x90, 0xf6, 0x51, 0x0b, 0xab, 0x59, 0x88, 0x67, 0x88, 0x40, 0x86, 0x9b, + 0x84, 0xe6, 0x93, 0x42, 0x6a, 0xe1, 0x0c, 0x51, 0x44, 0x71, 0x9f, 0xb8, 0x7e, 0x6d, 0x81, 0x8b, + 0x7c, 0xff, 0xad, 0x54, 0x71, 0x5c, 0xb6, 0xd1, 0x6e, 0x18, 0x4d, 0xd2, 0x52, 0x36, 0x52, 0x3f, + 0x55, 0x6a, 0x6f, 0x9a, 0x6c, 0x27, 0xc0, 0x54, 0x14, 0x50, 0x4b, 0x22, 0xc3, 0x3a, 0x18, 0x63, + 0x84, 0x21, 0xaf, 0x4e, 0x37, 0x50, 0x88, 0x69, 0x3e, 0xc5, 0xe9, 0x6b, 0xf7, 0x38, 0xdc, 0xd7, + 0xa3, 0xd2, 0xdc, 0x1f, 0xc0, 0xad, 0xf9, 0xec, 0x70, 0xaf, 0x0a, 0x94, 0xb4, 0x35, 0x9f, 0x59, + 0x39, 0x81, 0xb8, 0x2e, 0x00, 0x95, 0x03, 0x3e, 0x6a, 0x60, 0x42, 0xec, 0x62, 0x05, 0x07, 0x84, + 0xba, 0xac, 0xeb, 0x02, 0x03, 0x64, 0xc8, 0xb6, 0x8f, 0x43, 0xd9, 0x77, 0x2d, 0x7f, 0xb8, 0x57, + 0x9d, 0x50, 0x50, 0xcb, 0xb6, 0x1d, 0x62, 0x4a, 0xd7, 0x59, 0xe8, 0xfa, 0x8e, 0x25, 0xd3, 0x7a, + 0x5d, 0x93, 0xfc, 0x8d, 0x6b, 0x52, 0xff, 0xea, 0x1a, 0xa5, 0xf7, 0x83, 0x06, 0x2e, 0xf7, 0xe9, + 0x55, 0x7b, 0x5a, 0x01, 0x23, 0xb6, 0x3a, 0x53, 0x0e, 0x2a, 0xc7, 0x38, 0x48, 0x95, 0xf5, 0x99, + 0xa8, 0x5b, 0x79, 0x61, 0x3e, 0x52, 0x72, 0x3f, 0x25, 0xc1, 0xff, 0x7d, 0x94, 0xf0, 0x16, 0x18, + 0x55, 0x74, 0x64, 0xf8, 0x74, 0x4f, 0x53, 0xcf, 0x9f, 0xb0, 0x0b, 0xc6, 0xa4, 0x49, 0xea, 0x7c, + 0x15, 0xb6, 0xb2, 0xca, 0xea, 0x5f, 0x5b, 0x25, 0x5e, 0x41, 0x4e, 0x62, 0x3f, 0xe4, 0xd0, 0xd0, + 0xef, 0x52, 0x75, 0x90, 0xd7, 0xc6, 0xf9, 0xf4, 0xc5, 0xfb, 0x5f, 0xf1, 0x3d, 0xe5, 0xf8, 0x72, + 0x8a, 0x4b, 0x2f, 0x53, 0x20, 0x23, 0x96, 0x0e, 0x5f, 0x80, 0xac, 0xbc, 0xce, 0xe0, 0x6c, 0xcc, + 0x72, 0x07, 0x6f, 0xcf, 0xe2, 0xdc, 0xb0, 0x34, 0xb9, 0x94, 0xf2, 0xd5, 0xdd, 0xcf, 0x3f, 0xde, + 0x24, 0x27, 0x61, 0xc1, 0x1c, 0xbc, 0xa2, 0xe5, 0x95, 0x09, 0x3b, 0x20, 0x23, 0x2e, 0x2c, 0x78, + 0xfd, 0x5c, 0xcc, 0x9e, 0x6b, 0xb4, 0x38, 0x3b, 0x24, 0x4b, 0x11, 0xcf, 0x08, 0xe2, 0x22, 0xcc, + 0xc7, 0x11, 0x0b, 0xba, 0x5d, 0x0d, 0x8c, 0x44, 0x6e, 0x87, 0xf3, 0xe7, 0xa1, 0xf6, 0x7d, 0xbf, + 0xc5, 0xca, 0xf0, 0x44, 0xa5, 0xe0, 0x9a, 0x50, 0x30, 0x0d, 0x27, 0x63, 0x14, 0x44, 0xdf, 0x45, + 0x6d, 0x79, 0xff, 0x58, 0xd7, 0x0e, 0x8e, 0x75, 0xed, 0xfb, 0xb1, 0xae, 0xbd, 0x3e, 0xd1, 0x13, + 0x07, 0x27, 0x7a, 0xe2, 0xcb, 0x89, 0x9e, 0x78, 0x36, 0xdf, 0xb3, 0xd9, 0x05, 0xc7, 0x43, 0x0d, + 0x6a, 0x2e, 0x38, 0xd5, 0xe6, 0x06, 0x72, 0x7d, 0xf3, 0xb9, 0x44, 0x13, 0xeb, 0x6d, 0x64, 0xc5, + 0xbf, 0xdc, 0xcd, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x27, 0xfc, 0x40, 0x60, 0xd2, 0x07, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/swap/types/swap.pb.go b/x/swap/types/swap.pb.go index e1a71cd7..6186cf0e 100644 --- a/x/swap/types/swap.pb.go +++ b/x/swap/types/swap.pb.go @@ -261,40 +261,40 @@ func init() { func init() { proto.RegisterFile("kava/swap/v1beta1/swap.proto", fileDescriptor_9df359be90eb28cb) } var fileDescriptor_9df359be90eb28cb = []byte{ - // 521 bytes of a gzipped FileDescriptorProto + // 526 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0x3f, 0x6f, 0xd3, 0x5e, 0x14, 0x8d, 0xd3, 0x28, 0xf9, 0xe5, 0x25, 0xbf, 0x01, 0x53, 0x89, 0xb4, 0x42, 0x76, 0x15, 0x24, - 0xd4, 0x25, 0xb6, 0x5a, 0x36, 0x84, 0x10, 0x31, 0x01, 0x91, 0x89, 0xca, 0x0c, 0x08, 0x96, 0xa7, - 0x67, 0xfb, 0x36, 0xb5, 0xe2, 0xf8, 0x5a, 0x7e, 0x8f, 0x84, 0x7e, 0x0b, 0xc4, 0xc4, 0xc8, 0xcc, - 0xdc, 0x4f, 0xc0, 0xd4, 0xb1, 0xea, 0x84, 0x18, 0x02, 0x4a, 0xbe, 0x05, 0x2c, 0xe8, 0xfd, 0xa1, - 0x35, 0x42, 0x48, 0x54, 0x4c, 0xbe, 0xf7, 0x9e, 0x77, 0xce, 0xbd, 0xf7, 0x58, 0x97, 0xdc, 0x9c, - 0xb2, 0x39, 0xf3, 0xf9, 0x82, 0x15, 0xfe, 0x7c, 0x2f, 0x02, 0xc1, 0xf6, 0x54, 0xe2, 0x15, 0x25, - 0x0a, 0xb4, 0xaf, 0x49, 0xd4, 0x53, 0x05, 0x83, 0x6e, 0x3b, 0x31, 0xf2, 0x19, 0x72, 0x3f, 0x62, - 0x1c, 0x2e, 0x28, 0x31, 0xa6, 0xb9, 0xa6, 0x6c, 0x6f, 0x69, 0x9c, 0xaa, 0xcc, 0xd7, 0x89, 0x81, - 0x36, 0x27, 0x38, 0x41, 0x5d, 0x97, 0x91, 0xae, 0xf6, 0x3f, 0x5a, 0xa4, 0x79, 0xc0, 0x4a, 0x36, - 0xe3, 0xf6, 0x0b, 0xf2, 0x3f, 0xcb, 0x32, 0x5c, 0x40, 0x42, 0x0b, 0xc4, 0x8c, 0xf7, 0xac, 0x9d, - 0x8d, 0xdd, 0xce, 0xbe, 0xe3, 0xfd, 0x36, 0x86, 0x37, 0xd4, 0xef, 0x0e, 0x10, 0xb3, 0x60, 0xf3, - 0x74, 0xe9, 0xd6, 0x3e, 0x7c, 0x71, 0xbb, 0x95, 0x22, 0x0f, 0xbb, 0xac, 0x92, 0xd9, 0xcf, 0xc9, - 0x7f, 0x92, 0x4f, 0x0f, 0x01, 0x7a, 0xf5, 0x1d, 0x6b, 0xb7, 0x1d, 0xdc, 0x93, 0xac, 0xcf, 0x4b, - 0xf7, 0xf6, 0x24, 0x15, 0x47, 0xaf, 0x22, 0x2f, 0xc6, 0x99, 0x19, 0xd7, 0x7c, 0x06, 0x3c, 0x99, - 0xfa, 0xe2, 0xb8, 0x00, 0xee, 0x8d, 0x20, 0x3e, 0x3f, 0x19, 0x10, 0xb3, 0xcd, 0x08, 0xe2, 0xb0, - 0x25, 0xd5, 0x1e, 0x03, 0xdc, 0x6d, 0xbc, 0x7b, 0xef, 0xd6, 0xfa, 0x8f, 0x48, 0xa7, 0xd2, 0xdc, - 0xbe, 0x41, 0x5a, 0x02, 0xa7, 0x90, 0x53, 0xd6, 0xb3, 0x64, 0xb3, 0xb0, 0xa9, 0xd2, 0xe1, 0x25, - 0x10, 0xe9, 0x29, 0x0c, 0x10, 0x18, 0x99, 0xb7, 0x75, 0x42, 0xa4, 0x40, 0x08, 0x31, 0x96, 0x89, - 0x7d, 0x8b, 0xb4, 0xa4, 0x0f, 0x34, 0x4d, 0xb4, 0x4c, 0x40, 0x56, 0x4b, 0xb7, 0x29, 0x1f, 0x8c, - 0x47, 0x61, 0x53, 0x42, 0xe3, 0xc4, 0xbe, 0x4f, 0x48, 0x09, 0x1c, 0xca, 0x39, 0x70, 0xca, 0x94, - 0x6a, 0x67, 0x7f, 0xcb, 0x33, 0xa3, 0xca, 0xbf, 0x74, 0xe1, 0xd9, 0x43, 0x4c, 0xf3, 0xa0, 0x21, - 0xd7, 0x0e, 0xdb, 0x3f, 0x29, 0xc3, 0x5f, 0xf8, 0x51, 0x6f, 0xe3, 0x8a, 0xfc, 0xc0, 0xa6, 0xa4, - 0x2b, 0x50, 0xb0, 0x8c, 0xf2, 0x23, 0x56, 0x02, 0xef, 0x35, 0xae, 0xec, 0xee, 0x38, 0x17, 0x15, - 0x77, 0xc7, 0xb9, 0x08, 0x3b, 0x4a, 0xf1, 0x99, 0x12, 0xec, 0x7f, 0xb7, 0x48, 0x47, 0x85, 0xc6, - 0x95, 0x43, 0xd2, 0x4e, 0xa0, 0x40, 0x9e, 0x0a, 0x2c, 0x95, 0x2f, 0xdd, 0xe0, 0xc9, 0xb7, 0xa5, - 0x3b, 0xf8, 0x8b, 0x4e, 0xc3, 0x38, 0x1e, 0x26, 0x49, 0x09, 0x9c, 0x9f, 0x9f, 0x0c, 0xae, 0x9b, - 0x86, 0xa6, 0x12, 0x1c, 0x0b, 0xe0, 0xe1, 0xa5, 0x74, 0xd5, 0xfd, 0xfa, 0x1f, 0xdd, 0xa7, 0xa4, - 0xab, 0xf7, 0xa6, 0xb8, 0xc8, 0x21, 0x51, 0xfe, 0xfd, 0xf3, 0xf6, 0x5a, 0xf1, 0xa9, 0x14, 0x0c, - 0x1e, 0x9c, 0xae, 0x1c, 0xeb, 0x6c, 0xe5, 0x58, 0x5f, 0x57, 0x8e, 0xf5, 0x66, 0xed, 0xd4, 0xce, - 0xd6, 0x4e, 0xed, 0xd3, 0xda, 0xa9, 0xbd, 0xac, 0x8a, 0xcb, 0x03, 0x19, 0x64, 0x2c, 0xe2, 0x2a, - 0xf2, 0x5f, 0xeb, 0x8b, 0x56, 0x0d, 0xa2, 0xa6, 0xba, 0xb3, 0x3b, 0x3f, 0x02, 0x00, 0x00, 0xff, - 0xff, 0xee, 0x4a, 0x16, 0x69, 0xeb, 0x03, 0x00, 0x00, + 0xe8, 0x12, 0xbb, 0x2d, 0x1b, 0x42, 0x48, 0x36, 0x01, 0x91, 0x89, 0xca, 0x0c, 0x08, 0x16, 0xeb, + 0xd9, 0xbe, 0x4d, 0xac, 0x38, 0xbe, 0x96, 0xdf, 0x23, 0xa1, 0xdf, 0x02, 0x31, 0x31, 0x32, 0x33, + 0xf7, 0x13, 0x30, 0x75, 0xac, 0x3a, 0x21, 0x86, 0x80, 0x92, 0x6f, 0x01, 0x0b, 0x7a, 0x7f, 0x68, + 0x8d, 0x10, 0x12, 0x15, 0x93, 0xdf, 0xbd, 0xe7, 0x9d, 0x73, 0xee, 0x3d, 0xd6, 0x23, 0x37, 0xa7, + 0x74, 0x4e, 0x5d, 0xb6, 0xa0, 0x85, 0x3b, 0xdf, 0x8f, 0x80, 0xd3, 0x7d, 0x59, 0x38, 0x45, 0x89, + 0x1c, 0xcd, 0x6b, 0x02, 0x75, 0x64, 0x43, 0xa3, 0xdb, 0x56, 0x8c, 0x6c, 0x86, 0xcc, 0x8d, 0x28, + 0x83, 0x0b, 0x4a, 0x8c, 0x69, 0xae, 0x28, 0xdb, 0x5b, 0x0a, 0x0f, 0x65, 0xe5, 0xaa, 0x42, 0x43, + 0x9b, 0x63, 0x1c, 0xa3, 0xea, 0x8b, 0x93, 0xea, 0xf6, 0x3f, 0x1a, 0xa4, 0x79, 0x48, 0x4b, 0x3a, + 0x63, 0xe6, 0x0b, 0xf2, 0x3f, 0xcd, 0x32, 0x5c, 0x40, 0x12, 0x16, 0x88, 0x19, 0xeb, 0x19, 0x3b, + 0x1b, 0xbb, 0x9d, 0x03, 0xcb, 0xf9, 0x6d, 0x0c, 0xc7, 0x53, 0xf7, 0x0e, 0x11, 0x33, 0x7f, 0xf3, + 0x74, 0x69, 0xd7, 0x3e, 0x7c, 0xb1, 0xbb, 0x95, 0x26, 0x0b, 0xba, 0xb4, 0x52, 0x99, 0xcf, 0xc9, + 0x7f, 0x82, 0x1f, 0x1e, 0x01, 0xf4, 0xea, 0x3b, 0xc6, 0x6e, 0xdb, 0xbf, 0x2f, 0x58, 0x9f, 0x97, + 0xf6, 0xed, 0x71, 0xca, 0x27, 0xaf, 0x22, 0x27, 0xc6, 0x99, 0x1e, 0x57, 0x7f, 0x06, 0x2c, 0x99, + 0xba, 0xfc, 0xb8, 0x00, 0xe6, 0x0c, 0x21, 0x3e, 0x3f, 0x19, 0x10, 0xbd, 0xcd, 0x10, 0xe2, 0xa0, + 0x25, 0xd4, 0x1e, 0x03, 0xdc, 0x6b, 0xbc, 0x7b, 0x6f, 0xd7, 0xfa, 0x8f, 0x48, 0xa7, 0x62, 0x6e, + 0xde, 0x20, 0x2d, 0x8e, 0x53, 0xc8, 0x43, 0xda, 0x33, 0x84, 0x59, 0xd0, 0x94, 0xa5, 0x77, 0x09, + 0x44, 0x6a, 0x0a, 0x0d, 0xf8, 0x5a, 0xe6, 0x6d, 0x9d, 0x10, 0x21, 0x10, 0x40, 0x8c, 0x65, 0x62, + 0xde, 0x22, 0x2d, 0x91, 0x43, 0x98, 0x26, 0x4a, 0xc6, 0x27, 0xab, 0xa5, 0xdd, 0x14, 0x17, 0x46, + 0xc3, 0xa0, 0x29, 0xa0, 0x51, 0x62, 0x3e, 0x20, 0xa4, 0x04, 0x06, 0xe5, 0x1c, 0x58, 0x48, 0xa5, + 0x6a, 0xe7, 0x60, 0xcb, 0xd1, 0xa3, 0x8a, 0xbf, 0x74, 0x91, 0xd9, 0x43, 0x4c, 0x73, 0xbf, 0x21, + 0xd6, 0x0e, 0xda, 0x3f, 0x29, 0xde, 0x2f, 0xfc, 0xa8, 0xb7, 0x71, 0x45, 0xbe, 0x6f, 0x86, 0xa4, + 0xcb, 0x91, 0xd3, 0x2c, 0x64, 0x13, 0x5a, 0x02, 0xeb, 0x35, 0xae, 0x9c, 0xee, 0x28, 0xe7, 0x95, + 0x74, 0x47, 0x39, 0x0f, 0x3a, 0x52, 0xf1, 0x99, 0x14, 0xec, 0x7f, 0x37, 0x48, 0x47, 0x1e, 0x75, + 0x2a, 0x47, 0xa4, 0x9d, 0x40, 0x81, 0x2c, 0xe5, 0x58, 0xca, 0x5c, 0xba, 0xfe, 0x93, 0x6f, 0x4b, + 0x7b, 0xf0, 0x17, 0x4e, 0x5e, 0x1c, 0x7b, 0x49, 0x52, 0x02, 0x63, 0xe7, 0x27, 0x83, 0xeb, 0xda, + 0x50, 0x77, 0xfc, 0x63, 0x0e, 0x2c, 0xb8, 0x94, 0xae, 0xa6, 0x5f, 0xff, 0x63, 0xfa, 0x21, 0xe9, + 0xaa, 0xbd, 0x43, 0x5c, 0xe4, 0x90, 0xc8, 0xfc, 0xfe, 0x79, 0x7b, 0xa5, 0xf8, 0x54, 0x08, 0xfa, + 0xde, 0xe9, 0xca, 0x32, 0xce, 0x56, 0x96, 0xf1, 0x75, 0x65, 0x19, 0x6f, 0xd6, 0x56, 0xed, 0x6c, + 0x6d, 0xd5, 0x3e, 0xad, 0xad, 0xda, 0xcb, 0x3b, 0x15, 0xf1, 0xbd, 0x71, 0x46, 0x23, 0xe6, 0xee, + 0x8d, 0x07, 0xf1, 0x84, 0xa6, 0xb9, 0xfb, 0x5a, 0x3d, 0x69, 0xe9, 0x10, 0x35, 0xe5, 0x43, 0xbb, + 0xfb, 0x23, 0x00, 0x00, 0xff, 0xff, 0xbd, 0xb7, 0x43, 0xe0, 0xec, 0x03, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { diff --git a/x/swap/types/tx.pb.go b/x/swap/types/tx.pb.go index 0eea5aa7..f20e2072 100644 --- a/x/swap/types/tx.pb.go +++ b/x/swap/types/tx.pb.go @@ -384,46 +384,46 @@ func init() { func init() { proto.RegisterFile("kava/swap/v1beta1/tx.proto", fileDescriptor_5b753029ccc8a1ef) } var fileDescriptor_5b753029ccc8a1ef = []byte{ - // 613 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x55, 0xcd, 0x6a, 0xdb, 0x4c, - 0x14, 0xb5, 0x6c, 0x7f, 0x89, 0x3d, 0xe6, 0x5b, 0x74, 0xea, 0x80, 0x22, 0x88, 0x6c, 0x0c, 0x0d, - 0x5e, 0xd4, 0x52, 0x93, 0x42, 0x29, 0xa5, 0xd0, 0x46, 0x71, 0x0c, 0x5d, 0x98, 0x82, 0x12, 0x68, - 0xe9, 0xc6, 0x8c, 0xa4, 0xa9, 0x2c, 0x6c, 0x6b, 0x54, 0xcd, 0x24, 0x76, 0xdf, 0xa0, 0xab, 0xd2, - 0x47, 0xe8, 0xae, 0x2f, 0xe0, 0x87, 0x08, 0x5d, 0x85, 0xac, 0x4a, 0x17, 0xa1, 0xd8, 0x2f, 0x52, - 0x34, 0xfa, 0xf1, 0x4f, 0x84, 0x6b, 0x67, 0xd5, 0xae, 0x3c, 0xa3, 0x73, 0xcf, 0xb9, 0x33, 0xe7, - 0x5e, 0xdf, 0x01, 0x52, 0x0f, 0x5d, 0x20, 0x95, 0x0e, 0x91, 0xa7, 0x5e, 0x1c, 0x18, 0x98, 0xa1, - 0x03, 0x95, 0x8d, 0x14, 0xcf, 0x27, 0x8c, 0xc0, 0x7b, 0x01, 0xa6, 0x04, 0x98, 0x12, 0x61, 0x92, - 0x6c, 0x12, 0x3a, 0x20, 0x54, 0x35, 0x10, 0xc5, 0x09, 0xc1, 0x24, 0x8e, 0x1b, 0x52, 0xa4, 0xdd, - 0x10, 0xef, 0xf0, 0x9d, 0x1a, 0x6e, 0x22, 0xa8, 0x6c, 0x13, 0x9b, 0x84, 0xdf, 0x83, 0x55, 0xf8, - 0xb5, 0x36, 0xce, 0x02, 0xd0, 0xa6, 0x76, 0x13, 0x7b, 0x84, 0x3a, 0x0c, 0x3e, 0x01, 0x45, 0x2b, - 0x5c, 0x12, 0x5f, 0x14, 0xaa, 0x42, 0xbd, 0xa8, 0x89, 0xd7, 0xe3, 0x46, 0x39, 0x52, 0x3a, 0xb2, - 0x2c, 0x1f, 0x53, 0x7a, 0xca, 0x7c, 0xc7, 0xb5, 0xf5, 0x59, 0x28, 0x7c, 0x0a, 0xb6, 0x19, 0xe9, - 0x61, 0xb7, 0x83, 0xc4, 0x6c, 0x55, 0xa8, 0x97, 0x0e, 0x77, 0x95, 0x88, 0x12, 0x9c, 0x34, 0x3e, - 0xbe, 0x72, 0x4c, 0x1c, 0x57, 0xcb, 0x5f, 0xde, 0x54, 0x32, 0xfa, 0x16, 0x8f, 0x3f, 0x9a, 0x31, - 0x0d, 0x31, 0xb7, 0x09, 0x53, 0x83, 0x6f, 0x41, 0x81, 0xf6, 0x1d, 0xcf, 0x43, 0x36, 0x16, 0xf3, - 0xfc, 0xa8, 0xcf, 0x03, 0xfc, 0xe7, 0x4d, 0x65, 0xdf, 0x76, 0x58, 0xf7, 0xdc, 0x50, 0x4c, 0x32, - 0x88, 0x3c, 0x88, 0x7e, 0x1a, 0xd4, 0xea, 0xa9, 0xec, 0xa3, 0x87, 0xa9, 0xd2, 0xc4, 0xe6, 0xf5, - 0xb8, 0x01, 0xa2, 0x5c, 0x4d, 0x6c, 0xea, 0x89, 0x1a, 0x94, 0x40, 0xc1, 0xc2, 0xc8, 0xea, 0x3b, - 0x2e, 0x16, 0xff, 0xab, 0x0a, 0xf5, 0x9c, 0x9e, 0xec, 0x9f, 0xe5, 0x3f, 0x7d, 0xad, 0x64, 0x6a, - 0x65, 0x00, 0x67, 0xae, 0xe9, 0x98, 0x7a, 0xc4, 0xa5, 0xb8, 0xf6, 0x2d, 0x0b, 0x4a, 0x6d, 0x6a, - 0xbf, 0x71, 0x58, 0xd7, 0xf2, 0xd1, 0x10, 0x3e, 0x04, 0xf9, 0xf7, 0x3e, 0x19, 0xfc, 0xd1, 0x48, - 0x1e, 0x05, 0x5b, 0x60, 0x8b, 0x76, 0x91, 0x8f, 0x29, 0xb7, 0xb0, 0xa8, 0x29, 0x1b, 0xdc, 0xe6, - 0x95, 0xcb, 0xf4, 0x88, 0x0d, 0x5f, 0x80, 0xd2, 0xc0, 0x71, 0x3b, 0x71, 0x3d, 0xd6, 0x74, 0xb5, - 0x38, 0x70, 0xdc, 0xb3, 0xb0, 0x24, 0x0b, 0x02, 0x06, 0xf7, 0x76, 0x13, 0x01, 0x6d, 0x0d, 0xff, - 0x76, 0xc0, 0xfd, 0x39, 0xa3, 0x12, 0x03, 0xbf, 0x67, 0xc1, 0x4e, 0x9b, 0xda, 0xa7, 0x43, 0xe4, - 0x9d, 0x8c, 0x90, 0xc9, 0x5a, 0xc4, 0xe7, 0x92, 0x34, 0x68, 0x4c, 0x1f, 0x7f, 0x38, 0xc7, 0x94, - 0xe1, 0x35, 0x1a, 0x33, 0x09, 0x85, 0xc7, 0xe0, 0x7f, 0x1c, 0x28, 0x75, 0x36, 0x6c, 0xcf, 0x12, - 0x67, 0x9d, 0xfd, 0xcb, 0x3d, 0x5a, 0x01, 0x7b, 0xa9, 0x5e, 0xa6, 0xb9, 0xdd, 0x22, 0xfe, 0x49, - 0x72, 0xe1, 0xbb, 0xbb, 0x7d, 0xf7, 0x31, 0xb0, 0x54, 0xa7, 0xb5, 0x8d, 0x9e, 0xab, 0xd3, 0xdf, - 0xe2, 0xf6, 0xa2, 0x97, 0xb1, 0xdb, 0x87, 0x9f, 0x73, 0x20, 0xd7, 0xa6, 0x36, 0x7c, 0x0d, 0xb6, - 0xe3, 0x69, 0xbb, 0xa7, 0xdc, 0x9a, 0xf0, 0xca, 0x6c, 0xac, 0x48, 0x0f, 0x56, 0xc2, 0xb1, 0x30, - 0xd4, 0x41, 0x21, 0x99, 0x38, 0x72, 0x3a, 0x25, 0xc6, 0xa5, 0xfd, 0xd5, 0x78, 0xa2, 0xe9, 0x01, - 0x98, 0xf2, 0x27, 0xac, 0xa7, 0xb3, 0x6f, 0x47, 0x4a, 0x8f, 0xd6, 0x8d, 0x5c, 0xce, 0xb8, 0xd4, - 0x88, 0x2b, 0x32, 0x2e, 0x46, 0xae, 0xca, 0x98, 0x5e, 0x10, 0xed, 0xe5, 0xe5, 0x44, 0x16, 0xae, - 0x26, 0xb2, 0xf0, 0x6b, 0x22, 0x0b, 0x5f, 0xa6, 0x72, 0xe6, 0x6a, 0x2a, 0x67, 0x7e, 0x4c, 0xe5, - 0xcc, 0xbb, 0xf9, 0x6e, 0x09, 0x54, 0x1b, 0x7d, 0x64, 0x50, 0xbe, 0x52, 0x47, 0xe1, 0x5b, 0xcd, - 0x3b, 0xc6, 0xd8, 0xe2, 0x6f, 0xe8, 0xe3, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd0, 0xde, 0xef, - 0x15, 0xc5, 0x07, 0x00, 0x00, + // 617 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x95, 0x4d, 0x8f, 0xd2, 0x40, + 0x18, 0xc7, 0x29, 0x20, 0x0b, 0x43, 0x3c, 0x38, 0xb2, 0x49, 0xb7, 0xc9, 0x16, 0x42, 0xe2, 0xca, + 0x41, 0x5a, 0x76, 0x4d, 0x8c, 0x31, 0x26, 0x86, 0x2e, 0x4b, 0xe2, 0x81, 0x98, 0x74, 0x37, 0xd1, + 0x78, 0x21, 0xd3, 0x76, 0x2c, 0x0d, 0xd0, 0xa9, 0x9d, 0xd9, 0x05, 0xbf, 0x81, 0x27, 0xe3, 0x47, + 0xf0, 0xe6, 0x17, 0xe0, 0x43, 0x6c, 0x3c, 0x6d, 0xf6, 0x64, 0x3c, 0x6c, 0x0c, 0x7c, 0x11, 0xd3, + 0x57, 0x5e, 0xb6, 0x41, 0xd8, 0x93, 0x9e, 0xe8, 0xf4, 0xff, 0xfc, 0x9f, 0x99, 0xfe, 0x9e, 0x87, + 0x67, 0x80, 0xd0, 0x47, 0x17, 0x48, 0xa6, 0x23, 0xe4, 0xc8, 0x17, 0x87, 0x1a, 0x66, 0xe8, 0x50, + 0x66, 0x63, 0xc9, 0x71, 0x09, 0x23, 0xf0, 0x81, 0xa7, 0x49, 0x9e, 0x26, 0x85, 0x9a, 0x20, 0xea, + 0x84, 0x0e, 0x09, 0x95, 0x35, 0x44, 0x71, 0x6c, 0xd0, 0x89, 0x65, 0x07, 0x16, 0x61, 0x2f, 0xd0, + 0xbb, 0xfe, 0x4a, 0x0e, 0x16, 0xa1, 0x54, 0x32, 0x89, 0x49, 0x82, 0xf7, 0xde, 0x53, 0xf0, 0xb6, + 0x3a, 0x49, 0x03, 0xd0, 0xa1, 0x66, 0x0b, 0x3b, 0x84, 0x5a, 0x0c, 0x3e, 0x03, 0x05, 0x23, 0x78, + 0x24, 0x2e, 0xcf, 0x55, 0xb8, 0x5a, 0x41, 0xe1, 0xaf, 0x27, 0xf5, 0x52, 0x98, 0xa9, 0x69, 0x18, + 0x2e, 0xa6, 0xf4, 0x94, 0xb9, 0x96, 0x6d, 0xaa, 0xf3, 0x50, 0xf8, 0x1c, 0xec, 0x30, 0xd2, 0xc7, + 0x76, 0x17, 0xf1, 0xe9, 0x0a, 0x57, 0x2b, 0x1e, 0xed, 0x49, 0xa1, 0xc5, 0x3b, 0x69, 0x74, 0x7c, + 0xe9, 0x98, 0x58, 0xb6, 0x92, 0xbd, 0xbc, 0x29, 0xa7, 0xd4, 0x9c, 0x1f, 0xdf, 0x9c, 0x3b, 0x35, + 0x3e, 0xb3, 0x8d, 0x53, 0x81, 0xef, 0x40, 0x9e, 0x0e, 0x2c, 0xc7, 0x41, 0x26, 0xe6, 0xb3, 0xfe, + 0x51, 0x5f, 0x7a, 0xfa, 0xaf, 0x9b, 0xf2, 0x81, 0x69, 0xb1, 0xde, 0xb9, 0x26, 0xe9, 0x64, 0x18, + 0x32, 0x08, 0x7f, 0xea, 0xd4, 0xe8, 0xcb, 0xec, 0x93, 0x83, 0xa9, 0xd4, 0xc2, 0xfa, 0xf5, 0xa4, + 0x0e, 0xc2, 0xbd, 0x5a, 0x58, 0x57, 0xe3, 0x6c, 0x50, 0x00, 0x79, 0x03, 0x23, 0x63, 0x60, 0xd9, + 0x98, 0xbf, 0x57, 0xe1, 0x6a, 0x19, 0x35, 0x5e, 0xbf, 0xc8, 0x7e, 0xfe, 0x56, 0x4e, 0x55, 0x4b, + 0x00, 0xce, 0xa9, 0xa9, 0x98, 0x3a, 0xc4, 0xa6, 0xb8, 0xfa, 0x3d, 0x0d, 0x8a, 0x1d, 0x6a, 0xbe, + 0xb5, 0x58, 0xcf, 0x70, 0xd1, 0x08, 0x3e, 0x01, 0xd9, 0x0f, 0x2e, 0x19, 0xfe, 0x15, 0xa4, 0x1f, + 0x05, 0xdb, 0x20, 0x47, 0x7b, 0xc8, 0xc5, 0xd4, 0x47, 0x58, 0x50, 0xa4, 0x2d, 0xbe, 0xe6, 0xb5, + 0xcd, 0xd4, 0xd0, 0x0d, 0x5f, 0x81, 0xe2, 0xd0, 0xb2, 0xbb, 0x51, 0x3d, 0x36, 0xa4, 0x5a, 0x18, + 0x5a, 0xf6, 0x59, 0x50, 0x92, 0xa5, 0x04, 0x9a, 0xcf, 0x76, 0x9b, 0x04, 0xca, 0x06, 0xfc, 0x76, + 0xc1, 0xc3, 0x05, 0x50, 0x31, 0xc0, 0x1f, 0x69, 0xb0, 0xdb, 0xa1, 0xe6, 0xe9, 0x08, 0x39, 0x27, + 0x63, 0xa4, 0xb3, 0x36, 0x71, 0xfd, 0x94, 0xd4, 0x6b, 0x4c, 0x17, 0x7f, 0x3c, 0xc7, 0x94, 0xe1, + 0x0d, 0x1a, 0x33, 0x0e, 0x85, 0xc7, 0xe0, 0x3e, 0xf6, 0x32, 0x75, 0xb7, 0x6c, 0xcf, 0xa2, 0xef, + 0x3a, 0xfb, 0x9f, 0x7b, 0xb4, 0x0c, 0xf6, 0x13, 0x59, 0x26, 0xd1, 0x6e, 0x13, 0xf7, 0x24, 0xfe, + 0xe0, 0xbb, 0xd3, 0xbe, 0xfb, 0x18, 0x58, 0xa9, 0xd3, 0xc6, 0xa0, 0x17, 0xea, 0xf4, 0xaf, 0xd0, + 0x5e, 0x66, 0x19, 0xd1, 0x3e, 0xfa, 0x92, 0x01, 0x99, 0x0e, 0x35, 0xe1, 0x1b, 0xb0, 0x13, 0x4d, + 0xdb, 0x7d, 0xe9, 0xd6, 0x84, 0x97, 0xe6, 0x63, 0x45, 0x78, 0xb4, 0x56, 0x8e, 0x12, 0x43, 0x15, + 0xe4, 0xe3, 0x89, 0x23, 0x26, 0x5b, 0x22, 0x5d, 0x38, 0x58, 0xaf, 0xc7, 0x39, 0x1d, 0x00, 0x13, + 0xfe, 0x84, 0xb5, 0x64, 0xf7, 0xed, 0x48, 0xa1, 0xb1, 0x69, 0xe4, 0xea, 0x8e, 0x2b, 0x8d, 0xb8, + 0x66, 0xc7, 0xe5, 0xc8, 0x75, 0x3b, 0x26, 0x17, 0x44, 0x69, 0x5e, 0x4e, 0x45, 0xee, 0x6a, 0x2a, + 0x72, 0xbf, 0xa7, 0x22, 0xf7, 0x75, 0x26, 0xa6, 0xae, 0x66, 0x62, 0xea, 0xe7, 0x4c, 0x4c, 0xbd, + 0x7f, 0xbc, 0xd0, 0x2d, 0x0d, 0x73, 0x80, 0x34, 0x2a, 0x37, 0xcc, 0xba, 0xde, 0x43, 0x96, 0x2d, + 0x8f, 0x83, 0xcb, 0xda, 0x6f, 0x19, 0x2d, 0xe7, 0x5f, 0xa2, 0x4f, 0xff, 0x04, 0x00, 0x00, 0xff, + 0xff, 0x82, 0x53, 0x5e, 0x21, 0xc6, 0x07, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/validator-vesting/types/query.pb.go b/x/validator-vesting/types/query.pb.go index b8a8442d..8c4a5d3e 100644 --- a/x/validator-vesting/types/query.pb.go +++ b/x/validator-vesting/types/query.pb.go @@ -578,46 +578,46 @@ func init() { } var fileDescriptor_2198ebff70588a65 = []byte{ - // 619 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x96, 0xcb, 0x6e, 0xd3, 0x4c, - 0x14, 0xc7, 0x33, 0x9f, 0xf4, 0x55, 0x62, 0xba, 0x40, 0x8c, 0x8a, 0x68, 0x4d, 0xe3, 0x14, 0x23, - 0x21, 0x90, 0x88, 0xad, 0x34, 0x55, 0x4b, 0x2f, 0xd0, 0x0b, 0x5d, 0xd0, 0x1d, 0x4d, 0x8a, 0x40, - 0x6c, 0xa2, 0x49, 0x62, 0xb9, 0x56, 0x1d, 0x8f, 0xeb, 0x19, 0x9b, 0x86, 0x25, 0x4f, 0x80, 0xc4, - 0xab, 0x74, 0xc3, 0x03, 0x20, 0x65, 0xc1, 0xa2, 0x82, 0x0d, 0x20, 0x51, 0x41, 0xc2, 0x83, 0x20, - 0x8f, 0x27, 0xaa, 0xeb, 0xb8, 0x29, 0x76, 0x14, 0x58, 0x25, 0xb1, 0xcf, 0xe5, 0xf7, 0xf7, 0x39, - 0xf3, 0x77, 0xe0, 0xbd, 0x03, 0xec, 0x63, 0xcd, 0xc7, 0x96, 0xd9, 0xc4, 0x8c, 0xb8, 0xbe, 0x4e, - 0x99, 0x69, 0x1b, 0x9a, 0x5f, 0xaa, 0xeb, 0x0c, 0x97, 0xb4, 0x43, 0x4f, 0x77, 0xdb, 0xaa, 0xe3, - 0x12, 0x46, 0x50, 0x3e, 0x08, 0x55, 0xe3, 0xa1, 0xaa, 0x08, 0x95, 0x66, 0x1a, 0x84, 0xb6, 0x08, - 0xad, 0xf1, 0x60, 0x2d, 0xfc, 0x11, 0x66, 0x4a, 0x53, 0x06, 0x31, 0x48, 0x78, 0x3d, 0xf8, 0x26, - 0xae, 0xce, 0x1a, 0x84, 0x18, 0x96, 0xae, 0x61, 0xc7, 0xd4, 0xb0, 0x6d, 0x13, 0x86, 0x99, 0x49, - 0x6c, 0x91, 0xa3, 0x14, 0x60, 0x7e, 0x37, 0x68, 0xfe, 0xd8, 0x74, 0x1b, 0x9e, 0x85, 0x83, 0x56, - 0x55, 0xcf, 0x71, 0xac, 0x76, 0x45, 0x3f, 0xf4, 0x74, 0xca, 0x14, 0x1f, 0xca, 0x17, 0x05, 0x50, - 0x87, 0xd8, 0x54, 0x47, 0x7b, 0x70, 0x02, 0xb7, 0x88, 0x67, 0xb3, 0x69, 0x30, 0x07, 0xee, 0x5e, - 0xd9, 0x5a, 0xeb, 0x9c, 0x16, 0x72, 0xdf, 0x4e, 0x0b, 0x77, 0x0c, 0x93, 0xed, 0x7b, 0x75, 0xb5, - 0x41, 0x5a, 0x82, 0x53, 0x7c, 0x14, 0x69, 0xf3, 0x40, 0x63, 0x6d, 0x47, 0xa7, 0xea, 0x8e, 0xcd, - 0x3e, 0x1d, 0x17, 0xa1, 0x90, 0xb1, 0x63, 0xb3, 0x8a, 0xa8, 0xa5, 0xcc, 0xc0, 0x1b, 0xbc, 0xef, - 0x1e, 0x61, 0xd8, 0x3a, 0x8f, 0xe4, 0xc0, 0xe9, 0xc1, 0x5b, 0x63, 0x85, 0xb9, 0x0d, 0x6f, 0x25, - 0x3f, 0x84, 0x27, 0x9b, 0x95, 0xed, 0x3e, 0xd6, 0x6b, 0xa8, 0x0c, 0x0b, 0xfa, 0x37, 0x80, 0xcf, - 0xaa, 0xdb, 0x2f, 0x2e, 0x05, 0x0c, 0x83, 0xc6, 0x0a, 0xa8, 0xc0, 0xb9, 0xe4, 0xde, 0xd5, 0xe7, - 0x4f, 0xfb, 0x7c, 0xed, 0x8b, 0x44, 0xf0, 0x98, 0xb1, 0xe2, 0xe5, 0xe1, 0xcd, 0xf8, 0x4a, 0x45, - 0x47, 0xcb, 0xe0, 0x6c, 0xf2, 0xed, 0xbf, 0x0d, 0x15, 0x1d, 0x67, 0x02, 0xd4, 0xf8, 0x07, 0x39, - 0xff, 0x7e, 0x12, 0xfe, 0xcf, 0xdb, 0xa2, 0x8f, 0x00, 0x5e, 0x1b, 0x18, 0x15, 0x5a, 0x53, 0x87, - 0xfa, 0x97, 0x3a, 0xd4, 0x6d, 0xa4, 0x87, 0x19, 0xb3, 0x43, 0xc9, 0xca, 0xca, 0x9b, 0xcf, 0xbf, - 0xde, 0xfd, 0xb7, 0x80, 0xe6, 0xb5, 0xf3, 0x7e, 0x5b, 0x8c, 0x1b, 0x6e, 0xe3, 0xac, 0x44, 0x8d, - 0x86, 0xe0, 0xc7, 0x00, 0x4e, 0x46, 0x1e, 0x25, 0x5a, 0xfc, 0x13, 0x94, 0x41, 0x77, 0x92, 0x96, - 0x52, 0xe7, 0x09, 0xf8, 0x05, 0x0e, 0xaf, 0xa2, 0xfb, 0x97, 0xc1, 0xb3, 0x20, 0xb9, 0x8f, 0xfd, - 0x1d, 0xc0, 0xeb, 0x89, 0x8e, 0x83, 0x36, 0x32, 0x3d, 0xcb, 0xc8, 0xda, 0x4b, 0x9b, 0x23, 0x54, - 0x10, 0xa2, 0xd6, 0xb9, 0xa8, 0x65, 0xb4, 0x94, 0x7e, 0x22, 0xb5, 0x7d, 0xec, 0x36, 0x93, 0xf5, - 0x05, 0x7b, 0x9e, 0x51, 0x5f, 0xe4, 0x04, 0x65, 0xd4, 0x17, 0x3d, 0x64, 0x23, 0xe9, 0xf3, 0x68, - 0xf3, 0x08, 0x7d, 0x05, 0x70, 0x2a, 0xc9, 0xf0, 0xd0, 0x7a, 0x26, 0xb8, 0x33, 0x3b, 0x95, 0x36, - 0xb2, 0x17, 0x10, 0xe2, 0x1e, 0x71, 0x71, 0x0f, 0xd0, 0x62, 0x06, 0x71, 0xf4, 0x95, 0x83, 0x3e, - 0x00, 0x78, 0x35, 0x66, 0x99, 0x68, 0x25, 0xe5, 0xf1, 0x88, 0xee, 0xe3, 0x6a, 0xa6, 0x5c, 0x21, - 0x66, 0x99, 0x8b, 0x29, 0xa3, 0x52, 0x9a, 0xe3, 0x15, 0xee, 0x60, 0x4c, 0x07, 0xdf, 0xbe, 0xb4, - 0x3a, 0xa2, 0x7b, 0xb7, 0x9a, 0x29, 0x77, 0x24, 0x1d, 0xc1, 0xae, 0x6d, 0xed, 0x76, 0x7e, 0xca, - 0xb9, 0x4e, 0x57, 0x06, 0x27, 0x5d, 0x19, 0xfc, 0xe8, 0xca, 0xe0, 0x6d, 0x4f, 0xce, 0x9d, 0xf4, - 0xe4, 0xdc, 0x97, 0x9e, 0x9c, 0x7b, 0x59, 0x8e, 0xbc, 0x17, 0x82, 0xd2, 0x45, 0x0b, 0xd7, 0x69, - 0xd8, 0xe4, 0x28, 0xa1, 0x0d, 0x7f, 0x51, 0xd4, 0x27, 0xf8, 0xdf, 0xc8, 0xf2, 0xef, 0x00, 0x00, - 0x00, 0xff, 0xff, 0xbd, 0x0f, 0x0a, 0x7d, 0xe1, 0x0a, 0x00, 0x00, + // 624 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x96, 0x4d, 0x6f, 0xd3, 0x30, + 0x18, 0xc7, 0x6b, 0x24, 0x26, 0xe1, 0x1d, 0x10, 0xd6, 0x10, 0x5b, 0x58, 0xd3, 0x11, 0x24, 0x04, + 0x12, 0x8d, 0xd7, 0xad, 0xda, 0xd8, 0x0b, 0xec, 0x85, 0x1d, 0xd8, 0x0d, 0xda, 0x21, 0x10, 0x97, + 0xca, 0x6d, 0xa3, 0x34, 0x5a, 0x1a, 0x67, 0xb5, 0x53, 0x56, 0x8e, 0x7c, 0x02, 0x24, 0xbe, 0xca, + 0x2e, 0x7c, 0x00, 0xa4, 0x1e, 0x38, 0x4c, 0x70, 0x01, 0x24, 0x26, 0x68, 0xf9, 0x20, 0x28, 0x8e, + 0xab, 0x65, 0x6d, 0xd6, 0x91, 0x54, 0x85, 0x53, 0xdb, 0xe4, 0x79, 0xfc, 0xfc, 0xfe, 0x7e, 0x1e, + 0xff, 0x5d, 0x78, 0x6f, 0x9f, 0x34, 0x09, 0x6e, 0x12, 0xdb, 0xaa, 0x12, 0x4e, 0x1b, 0x4d, 0x83, + 0x71, 0xcb, 0x31, 0x71, 0x33, 0x57, 0x36, 0x38, 0xc9, 0xe1, 0x03, 0xcf, 0x68, 0xb4, 0x74, 0xb7, + 0x41, 0x39, 0x45, 0x69, 0x3f, 0x54, 0xef, 0x0f, 0xd5, 0x65, 0xa8, 0x32, 0x53, 0xa1, 0xac, 0x4e, + 0x59, 0x49, 0x04, 0xe3, 0xe0, 0x47, 0x90, 0xa9, 0x4c, 0x99, 0xd4, 0xa4, 0xc1, 0x73, 0xff, 0x9b, + 0x7c, 0x3a, 0x6b, 0x52, 0x6a, 0xda, 0x06, 0x26, 0xae, 0x85, 0x89, 0xe3, 0x50, 0x4e, 0xb8, 0x45, + 0x1d, 0x99, 0xa3, 0x65, 0x60, 0xfa, 0x99, 0x5f, 0xfc, 0xb1, 0xd5, 0xa8, 0x78, 0x36, 0xf1, 0x4b, + 0x15, 0x3d, 0xd7, 0xb5, 0x5b, 0x05, 0xe3, 0xc0, 0x33, 0x18, 0xd7, 0x9a, 0x50, 0x3d, 0x2f, 0x80, + 0xb9, 0xd4, 0x61, 0x06, 0xda, 0x83, 0x13, 0xa4, 0x4e, 0x3d, 0x87, 0x4f, 0x83, 0x39, 0x70, 0xf7, + 0xca, 0xf6, 0x7a, 0xfb, 0x24, 0x93, 0xfa, 0x7e, 0x92, 0xb9, 0x63, 0x5a, 0xbc, 0xe6, 0x95, 0xf5, + 0x0a, 0xad, 0x4b, 0x4e, 0xf9, 0x91, 0x65, 0xd5, 0x7d, 0xcc, 0x5b, 0xae, 0xc1, 0xf4, 0x5d, 0x87, + 0x7f, 0x3e, 0xca, 0x42, 0x29, 0x63, 0xd7, 0xe1, 0x05, 0xb9, 0x96, 0x36, 0x03, 0x6f, 0x88, 0xba, + 0x7b, 0x94, 0x13, 0xfb, 0x2c, 0x92, 0x0b, 0xa7, 0x07, 0x5f, 0x8d, 0x15, 0xe6, 0x36, 0xbc, 0x15, + 0xbd, 0x09, 0x4f, 0xb6, 0x0a, 0x3b, 0x3d, 0xac, 0x37, 0x50, 0x1b, 0x16, 0xf4, 0x7f, 0x00, 0x9f, + 0x17, 0x77, 0x5e, 0x5e, 0x08, 0x18, 0x04, 0x8d, 0x15, 0x50, 0x83, 0x73, 0xd1, 0xb5, 0x8b, 0x2f, + 0x9e, 0xf6, 0xf8, 0x5a, 0xe7, 0x89, 0x10, 0x31, 0x63, 0xc5, 0x4b, 0xc3, 0x9b, 0xfd, 0x23, 0x15, + 0x6e, 0x2d, 0x87, 0xb3, 0xd1, 0xaf, 0xff, 0x35, 0x54, 0xb8, 0x9d, 0x11, 0x50, 0xe3, 0x6f, 0xe4, + 0xc2, 0x87, 0x49, 0x78, 0x59, 0x94, 0x45, 0x9f, 0x00, 0xbc, 0x36, 0xd0, 0x2a, 0xb4, 0xae, 0x0f, + 0xf5, 0x2f, 0x7d, 0xa8, 0xdb, 0x28, 0x0f, 0x13, 0x66, 0x07, 0x92, 0xb5, 0xd5, 0xb7, 0x5f, 0x7e, + 0xbf, 0xbf, 0x94, 0x47, 0x0b, 0xf8, 0xac, 0xdf, 0x66, 0xfb, 0x0d, 0xb7, 0x72, 0xba, 0x44, 0x89, + 0x05, 0xe0, 0x47, 0x00, 0x4e, 0x86, 0xb6, 0x12, 0x2d, 0xfd, 0x0d, 0xca, 0xa0, 0x3b, 0x29, 0xcb, + 0xb1, 0xf3, 0x24, 0x7c, 0x5e, 0xc0, 0xeb, 0xe8, 0xfe, 0x45, 0xf0, 0xdc, 0x4f, 0xee, 0x61, 0xff, + 0x00, 0xf0, 0x7a, 0xa4, 0xe3, 0xa0, 0xcd, 0x44, 0x7b, 0x19, 0x1a, 0x7b, 0x65, 0x6b, 0x84, 0x15, + 0xa4, 0xa8, 0x0d, 0x21, 0x6a, 0x05, 0x2d, 0xc7, 0xef, 0x48, 0xa9, 0x46, 0x1a, 0xd5, 0x68, 0x7d, + 0xfe, 0x9c, 0x27, 0xd4, 0x17, 0x3a, 0x41, 0x09, 0xf5, 0x85, 0x0f, 0xd9, 0x48, 0xfa, 0x3c, 0x56, + 0x3d, 0x44, 0xdf, 0x00, 0x9c, 0x8a, 0x32, 0x3c, 0xb4, 0x91, 0x08, 0xee, 0xd4, 0x4e, 0x95, 0xcd, + 0xe4, 0x0b, 0x48, 0x71, 0x8f, 0x84, 0xb8, 0x07, 0x68, 0x29, 0x81, 0x38, 0xf6, 0xda, 0x45, 0x1f, + 0x01, 0xbc, 0xda, 0x67, 0x99, 0x68, 0x35, 0xe6, 0xf1, 0x08, 0xcf, 0xe3, 0x5a, 0xa2, 0x5c, 0x29, + 0x66, 0x45, 0x88, 0x59, 0x44, 0xb9, 0x38, 0xc7, 0x2b, 0x98, 0xc1, 0x3e, 0x1d, 0x62, 0xfa, 0xe2, + 0xea, 0x08, 0xcf, 0xdd, 0x5a, 0xa2, 0xdc, 0x91, 0x74, 0xf8, 0xb3, 0xb6, 0x5d, 0x68, 0xff, 0x52, + 0x53, 0xed, 0x8e, 0x0a, 0x8e, 0x3b, 0x2a, 0xf8, 0xd9, 0x51, 0xc1, 0xbb, 0xae, 0x9a, 0x3a, 0xee, + 0xaa, 0xa9, 0xaf, 0x5d, 0x35, 0xf5, 0x2a, 0x1f, 0xba, 0x17, 0xe6, 0x4d, 0x9b, 0x94, 0x19, 0x9e, + 0x37, 0xb3, 0x95, 0x1a, 0xb1, 0x1c, 0x7c, 0x18, 0x51, 0x47, 0xdc, 0x14, 0xe5, 0x09, 0xf1, 0x3f, + 0x72, 0xf1, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x36, 0x23, 0xce, 0x5c, 0xe2, 0x0a, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used.