From 4a8a7d69f516ef5a217d3ee64f079161ffb1dd4b Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Mon, 9 Dec 2024 16:37:05 +0100 Subject: [PATCH 1/9] Add proto definitions --- .../tokenfactory/authorityMetadata.proto | 17 +++ .../paloma/tokenfactory/genesis.proto | 32 +++++ .../paloma/tokenfactory/params.proto | 18 +++ .../paloma/tokenfactory/query.proto | 72 ++++++++++++ .../palomachain/paloma/tokenfactory/tx.proto | 110 ++++++++++++++++++ 5 files changed, 249 insertions(+) create mode 100644 proto/palomachain/paloma/tokenfactory/authorityMetadata.proto create mode 100644 proto/palomachain/paloma/tokenfactory/genesis.proto create mode 100644 proto/palomachain/paloma/tokenfactory/params.proto create mode 100644 proto/palomachain/paloma/tokenfactory/query.proto create mode 100644 proto/palomachain/paloma/tokenfactory/tx.proto diff --git a/proto/palomachain/paloma/tokenfactory/authorityMetadata.proto b/proto/palomachain/paloma/tokenfactory/authorityMetadata.proto new file mode 100644 index 00000000..8849e6b0 --- /dev/null +++ b/proto/palomachain/paloma/tokenfactory/authorityMetadata.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; +package palomachain.paloma.tokenfactory; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; + +// DenomAuthorityMetadata specifies metadata for addresses that have specific +// capabilities over a token factory denom. Right now there is only one Admin +// permission, but is planned to be extended to the future. +message DenomAuthorityMetadata { + option (gogoproto.equal) = true; + + // Can be empty for no admin, or a valid osmosis address + string admin = 1 [ (gogoproto.moretags) = "yaml:\"admin\"" ]; +} diff --git a/proto/palomachain/paloma/tokenfactory/genesis.proto b/proto/palomachain/paloma/tokenfactory/genesis.proto new file mode 100644 index 00000000..abf8b87d --- /dev/null +++ b/proto/palomachain/paloma/tokenfactory/genesis.proto @@ -0,0 +1,32 @@ +syntax = "proto3"; +package palomachain.paloma.tokenfactory; + +import "gogoproto/gogo.proto"; +import "palomachain/paloma/tokenfactory/authorityMetadata.proto"; +import "palomachain/paloma/tokenfactory/params.proto"; + +option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; + +// GenesisState defines the tokenfactory module's genesis state. +message GenesisState { + // params defines the paramaters of the module. + Params params = 1 [ (gogoproto.nullable) = false ]; + + repeated GenesisDenom factory_denoms = 2 [ + (gogoproto.moretags) = "yaml:\"factory_denoms\"", + (gogoproto.nullable) = false + ]; +} + +// GenesisDenom defines a tokenfactory denom that is defined within genesis +// state. The structure contains DenomAuthorityMetadata which defines the +// denom's admin. +message GenesisDenom { + option (gogoproto.equal) = true; + + string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; + DenomAuthorityMetadata authority_metadata = 2 [ + (gogoproto.moretags) = "yaml:\"authority_metadata\"", + (gogoproto.nullable) = false + ]; +} diff --git a/proto/palomachain/paloma/tokenfactory/params.proto b/proto/palomachain/paloma/tokenfactory/params.proto new file mode 100644 index 00000000..aba69d78 --- /dev/null +++ b/proto/palomachain/paloma/tokenfactory/params.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; +package palomachain.paloma.tokenfactory; + +import "gogoproto/gogo.proto"; +import "cosmos_proto/cosmos.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "palomachain/paloma/tokenfactory/authorityMetadata.proto"; + +option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; + +// Params defines the parameters for the tokenfactory module. +message Params { + repeated cosmos.base.v1beta1.Coin denom_creation_fee = 1 [ + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"denom_creation_fee\"", + (gogoproto.nullable) = false + ]; +} diff --git a/proto/palomachain/paloma/tokenfactory/query.proto b/proto/palomachain/paloma/tokenfactory/query.proto new file mode 100644 index 00000000..c746db8f --- /dev/null +++ b/proto/palomachain/paloma/tokenfactory/query.proto @@ -0,0 +1,72 @@ +syntax = "proto3"; +package palomachain.paloma.tokenfactory; + +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; +import "palomachain/paloma/tokenfactory/authorityMetadata.proto"; +import "palomachain/paloma/tokenfactory/params.proto"; + +option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; + +// Query defines the gRPC querier service. +service Query { + // Params defines a gRPC query method that returns the tokenfactory module's + // parameters. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/palomachain/paloma/tokenfactory/params"; + } + + // DenomAuthorityMetadata defines a gRPC query method for fetching + // DenomAuthorityMetadata for a particular denom. + rpc DenomAuthorityMetadata(QueryDenomAuthorityMetadataRequest) + returns (QueryDenomAuthorityMetadataResponse) { + option (google.api.http).get = + "/palomachain/paloma/tokenfactory/denoms/{denom}/authority_metadata"; + } + + // DenomsFromCreator defines a gRPC query method for fetching all + // denominations created by a specific admin/creator. + rpc DenomsFromCreator(QueryDenomsFromCreatorRequest) + returns (QueryDenomsFromCreatorResponse) { + option (google.api.http).get = + "/palomachain/paloma/tokenfactory/denoms_from_creator/{creator}"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1 [ (gogoproto.nullable) = false ]; +} + +// QueryDenomAuthorityMetadataRequest defines the request structure for the +// DenomAuthorityMetadata gRPC query. +message QueryDenomAuthorityMetadataRequest { + string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; +} + +// QueryDenomAuthorityMetadataResponse defines the response structure for the +// DenomAuthorityMetadata gRPC query. +message QueryDenomAuthorityMetadataResponse { + DenomAuthorityMetadata authority_metadata = 1 [ + (gogoproto.moretags) = "yaml:\"authority_metadata\"", + (gogoproto.nullable) = false + ]; +} + +// QueryDenomsFromCreatorRequest defines the request structure for the +// DenomsFromCreator gRPC query. +message QueryDenomsFromCreatorRequest { + string creator = 1 [ (gogoproto.moretags) = "yaml:\"creator\"" ]; +} + +// QueryDenomsFromCreatorRequest defines the response structure for the +// DenomsFromCreator gRPC query. +message QueryDenomsFromCreatorResponse { + repeated string denoms = 1 [ (gogoproto.moretags) = "yaml:\"denoms\"" ]; +} + diff --git a/proto/palomachain/paloma/tokenfactory/tx.proto b/proto/palomachain/paloma/tokenfactory/tx.proto new file mode 100644 index 00000000..f031f4bd --- /dev/null +++ b/proto/palomachain/paloma/tokenfactory/tx.proto @@ -0,0 +1,110 @@ +syntax = "proto3"; +package palomachain.paloma.tokenfactory; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/bank/v1beta1/bank.proto"; + +option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; + +// Msg defines the tokefactory module's gRPC message service. +service Msg { + rpc CreateDenom(MsgCreateDenom) returns (MsgCreateDenomResponse); + rpc SetDenomMetadata(MsgSetDenomMetadata) + returns (MsgSetDenomMetadataResponse); + + // general purpose CRUD is deactivated for now + // rpc Mint(MsgMint) returns (MsgMintResponse); + // rpc Burn(MsgBurn) returns (MsgBurnResponse); + // rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse); + // + // ForceTransfer is deactivated for now because we need to think through edge + // cases rpc ForceTransfer(MsgForceTransfer) returns + // (MsgForceTransferResponse); +} + +// MsgCreateDenom defines the message structure for the CreateDenom gRPC service +// method. It allows an account to create a new denom. It requires a sender +// address and a sub denomination. The (sender_address, sub_denomination) tuple +// must be unique and cannot be re-used. +// +// The resulting denom created is defined as +// . The resulting denom's admin is +// originally set to be the creator, but this can be changed later. The token +// denom does not indicate the current admin. +message MsgCreateDenom { + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + // subdenom can be up to 44 "alphanumeric" characters long. + string subdenom = 2 [ (gogoproto.moretags) = "yaml:\"subdenom\"" ]; +} + +// MsgCreateDenomResponse is the return value of MsgCreateDenom +// It returns the full string of the newly created denom +message MsgCreateDenomResponse { + string new_token_denom = 1 + [ (gogoproto.moretags) = "yaml:\"new_token_denom\"" ]; +} + +// MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set +// the denom's bank metadata +message MsgSetDenomMetadata { + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + cosmos.bank.v1beta1.Metadata metadata = 2 [ + (gogoproto.moretags) = "yaml:\"metadata\"", + (gogoproto.nullable) = false + ]; +} + +// MsgSetDenomMetadataResponse defines the response structure for an executed +// MsgSetDenomMetadata message. +message MsgSetDenomMetadataResponse {} + +// MsgMint is the sdk.Msg type for allowing an admin account to mint +// more of a token. For now, we only support minting to the sender account +// message MsgMint { +// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; +// cosmos.base.v1beta1.Coin amount = 2 [ +// (gogoproto.moretags) = "yaml:\"amount\"", +// (gogoproto.nullable) = false +// ]; +// } +// +// message MsgMintResponse {} + +// MsgBurn is the sdk.Msg type for allowing an admin account to burn +// a token. For now, we only support burning from the sender account. +// message MsgBurn { +// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; +// cosmos.base.v1beta1.Coin amount = 2 [ +// (gogoproto.moretags) = "yaml:\"amount\"", +// (gogoproto.nullable) = false +// ]; +// } +// +// message MsgBurnResponse {} + +// MsgChangeAdmin is the sdk.Msg type for allowing an admin account to reassign +// adminship of a denom to a new account +// message MsgChangeAdmin { +// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; +// string denom = 2 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; +// string new_admin = 3 [ (gogoproto.moretags) = "yaml:\"new_admin\"" ]; +// } + +// MsgChangeAdminResponse defines the response structure for an executed +// MsgChangeAdmin message. +// message MsgChangeAdminResponse {} + +// message MsgForceTransfer { +// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; +// cosmos.base.v1beta1.Coin amount = 2 [ +// (gogoproto.moretags) = "yaml:\"amount\"", +// (gogoproto.nullable) = false +// ]; +// string transferFromAddress = 3 +// [ (gogoproto.moretags) = "yaml:\"transfer_from_address\"" ]; +// string transferToAddress = 4 +// [ (gogoproto.moretags) = "yaml:\"transfer_to_address\"" ]; +// } + +// message MsgForceTransferResponse {} From 47330cbf5cd245bf2cca014c87477b2880021e56 Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Tue, 10 Dec 2024 16:14:46 +0100 Subject: [PATCH 2/9] Type definitions --- .../palomachain/paloma/tokenfactory/tx.proto | 95 +- x/tokenfactory/types/authorityMetadata.go | 15 + x/tokenfactory/types/authorityMetadata.pb.go | 351 +++ x/tokenfactory/types/codec.go | 32 + x/tokenfactory/types/denoms.go | 67 + x/tokenfactory/types/denoms_test.go | 129 + x/tokenfactory/types/errors.go | 22 + x/tokenfactory/types/events.go | 16 + x/tokenfactory/types/expected_keepers.go | 38 + x/tokenfactory/types/genesis.go | 51 + x/tokenfactory/types/genesis.pb.go | 649 +++++ x/tokenfactory/types/genesis_test.go | 140 + x/tokenfactory/types/keys.go | 49 + x/tokenfactory/types/msgs.go | 196 ++ x/tokenfactory/types/msgs_test.go | 388 +++ x/tokenfactory/types/params.go | 53 + x/tokenfactory/types/params.pb.go | 342 +++ x/tokenfactory/types/query.pb.go | 1332 ++++++++++ x/tokenfactory/types/query.pb.gw.go | 355 +++ x/tokenfactory/types/tx.pb.go | 2253 +++++++++++++++++ 20 files changed, 6539 insertions(+), 34 deletions(-) create mode 100644 x/tokenfactory/types/authorityMetadata.go create mode 100644 x/tokenfactory/types/authorityMetadata.pb.go create mode 100644 x/tokenfactory/types/codec.go create mode 100644 x/tokenfactory/types/denoms.go create mode 100644 x/tokenfactory/types/denoms_test.go create mode 100644 x/tokenfactory/types/errors.go create mode 100644 x/tokenfactory/types/events.go create mode 100644 x/tokenfactory/types/expected_keepers.go create mode 100644 x/tokenfactory/types/genesis.go create mode 100644 x/tokenfactory/types/genesis.pb.go create mode 100644 x/tokenfactory/types/genesis_test.go create mode 100644 x/tokenfactory/types/keys.go create mode 100644 x/tokenfactory/types/msgs.go create mode 100644 x/tokenfactory/types/msgs_test.go create mode 100644 x/tokenfactory/types/params.go create mode 100644 x/tokenfactory/types/params.pb.go create mode 100644 x/tokenfactory/types/query.pb.go create mode 100644 x/tokenfactory/types/query.pb.gw.go create mode 100644 x/tokenfactory/types/tx.pb.go diff --git a/proto/palomachain/paloma/tokenfactory/tx.proto b/proto/palomachain/paloma/tokenfactory/tx.proto index f031f4bd..60ab41cc 100644 --- a/proto/palomachain/paloma/tokenfactory/tx.proto +++ b/proto/palomachain/paloma/tokenfactory/tx.proto @@ -4,6 +4,9 @@ package palomachain.paloma.tokenfactory; import "gogoproto/gogo.proto"; import "cosmos/base/v1beta1/coin.proto"; import "cosmos/bank/v1beta1/bank.proto"; +import "cosmos/msg/v1/msg.proto"; + +import "palomachain/paloma/valset/common.proto"; option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; @@ -13,11 +16,10 @@ service Msg { rpc SetDenomMetadata(MsgSetDenomMetadata) returns (MsgSetDenomMetadataResponse); - // general purpose CRUD is deactivated for now - // rpc Mint(MsgMint) returns (MsgMintResponse); - // rpc Burn(MsgBurn) returns (MsgBurnResponse); - // rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse); - // + rpc Mint(MsgMint) returns (MsgMintResponse); + rpc Burn(MsgBurn) returns (MsgBurnResponse); + rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse); + // ForceTransfer is deactivated for now because we need to think through edge // cases rpc ForceTransfer(MsgForceTransfer) returns // (MsgForceTransferResponse); @@ -33,9 +35,14 @@ service Msg { // originally set to be the creator, but this can be changed later. The token // denom does not indicate the current admin. message MsgCreateDenom { - string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + option (cosmos.msg.v1.signer) = "metadata"; // subdenom can be up to 44 "alphanumeric" characters long. - string subdenom = 2 [ (gogoproto.moretags) = "yaml:\"subdenom\"" ]; + string subdenom = 1 [ (gogoproto.moretags) = "yaml:\"subdenom\"" ]; + palomachain.paloma.valset.MsgMetadata metadata = 2 + [ + (gogoproto.moretags) = "yaml:\"metadata\"", + (gogoproto.nullable) = false + ]; } // MsgCreateDenomResponse is the return value of MsgCreateDenom @@ -48,11 +55,16 @@ message MsgCreateDenomResponse { // MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set // the denom's bank metadata message MsgSetDenomMetadata { - string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; - cosmos.bank.v1beta1.Metadata metadata = 2 [ - (gogoproto.moretags) = "yaml:\"metadata\"", + option (cosmos.msg.v1.signer) = "metadata"; + cosmos.bank.v1beta1.Metadata denom_metadata = 1 [ + (gogoproto.moretags) = "yaml:\"denom_metadata\"", (gogoproto.nullable) = false ]; + palomachain.paloma.valset.MsgMetadata metadata = 2 + [ + (gogoproto.moretags) = "yaml:\"metadata\"", + (gogoproto.nullable) = false + ]; } // MsgSetDenomMetadataResponse defines the response structure for an executed @@ -61,39 +73,54 @@ message MsgSetDenomMetadataResponse {} // MsgMint is the sdk.Msg type for allowing an admin account to mint // more of a token. For now, we only support minting to the sender account -// message MsgMint { -// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; -// cosmos.base.v1beta1.Coin amount = 2 [ -// (gogoproto.moretags) = "yaml:\"amount\"", -// (gogoproto.nullable) = false -// ]; -// } -// -// message MsgMintResponse {} +message MsgMint { + option (cosmos.msg.v1.signer) = "metadata"; + cosmos.base.v1beta1.Coin amount = 1 [ + (gogoproto.moretags) = "yaml:\"amount\"", + (gogoproto.nullable) = false + ]; + palomachain.paloma.valset.MsgMetadata metadata = 2 + [ + (gogoproto.moretags) = "yaml:\"metadata\"", + (gogoproto.nullable) = false + ]; +} + +message MsgMintResponse {} // MsgBurn is the sdk.Msg type for allowing an admin account to burn // a token. For now, we only support burning from the sender account. -// message MsgBurn { -// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; -// cosmos.base.v1beta1.Coin amount = 2 [ -// (gogoproto.moretags) = "yaml:\"amount\"", -// (gogoproto.nullable) = false -// ]; -// } -// -// message MsgBurnResponse {} +message MsgBurn { + option (cosmos.msg.v1.signer) = "metadata"; + cosmos.base.v1beta1.Coin amount = 1 [ + (gogoproto.moretags) = "yaml:\"amount\"", + (gogoproto.nullable) = false + ]; + palomachain.paloma.valset.MsgMetadata metadata = 2 + [ + (gogoproto.moretags) = "yaml:\"metadata\"", + (gogoproto.nullable) = false + ]; +} + +message MsgBurnResponse {} // MsgChangeAdmin is the sdk.Msg type for allowing an admin account to reassign // adminship of a denom to a new account -// message MsgChangeAdmin { -// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; -// string denom = 2 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; -// string new_admin = 3 [ (gogoproto.moretags) = "yaml:\"new_admin\"" ]; -// } +message MsgChangeAdmin { + option (cosmos.msg.v1.signer) = "metadata"; + string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; + string new_admin = 2 [ (gogoproto.moretags) = "yaml:\"new_admin\"" ]; + palomachain.paloma.valset.MsgMetadata metadata = 3 + [ + (gogoproto.moretags) = "yaml:\"metadata\"", + (gogoproto.nullable) = false + ]; +} // MsgChangeAdminResponse defines the response structure for an executed // MsgChangeAdmin message. -// message MsgChangeAdminResponse {} +message MsgChangeAdminResponse {} // message MsgForceTransfer { // string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; diff --git a/x/tokenfactory/types/authorityMetadata.go b/x/tokenfactory/types/authorityMetadata.go new file mode 100644 index 00000000..b45bffca --- /dev/null +++ b/x/tokenfactory/types/authorityMetadata.go @@ -0,0 +1,15 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func (metadata DenomAuthorityMetadata) Validate() error { + if metadata.Admin != "" { + _, err := sdk.AccAddressFromBech32(metadata.Admin) + if err != nil { + return err + } + } + return nil +} diff --git a/x/tokenfactory/types/authorityMetadata.pb.go b/x/tokenfactory/types/authorityMetadata.pb.go new file mode 100644 index 00000000..335b5fce --- /dev/null +++ b/x/tokenfactory/types/authorityMetadata.pb.go @@ -0,0 +1,351 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: palomachain/paloma/tokenfactory/authorityMetadata.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-sdk/types" + _ "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 + +// DenomAuthorityMetadata specifies metadata for addresses that have specific +// capabilities over a token factory denom. Right now there is only one Admin +// permission, but is planned to be extended to the future. +type DenomAuthorityMetadata struct { + // Can be empty for no admin, or a valid osmosis address + Admin string `protobuf:"bytes,1,opt,name=admin,proto3" json:"admin,omitempty" yaml:"admin"` +} + +func (m *DenomAuthorityMetadata) Reset() { *m = DenomAuthorityMetadata{} } +func (m *DenomAuthorityMetadata) String() string { return proto.CompactTextString(m) } +func (*DenomAuthorityMetadata) ProtoMessage() {} +func (*DenomAuthorityMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_0e118f93d35eb685, []int{0} +} +func (m *DenomAuthorityMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DenomAuthorityMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DenomAuthorityMetadata.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 *DenomAuthorityMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_DenomAuthorityMetadata.Merge(m, src) +} +func (m *DenomAuthorityMetadata) XXX_Size() int { + return m.Size() +} +func (m *DenomAuthorityMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_DenomAuthorityMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_DenomAuthorityMetadata proto.InternalMessageInfo + +func (m *DenomAuthorityMetadata) GetAdmin() string { + if m != nil { + return m.Admin + } + return "" +} + +func init() { + proto.RegisterType((*DenomAuthorityMetadata)(nil), "palomachain.paloma.tokenfactory.DenomAuthorityMetadata") +} + +func init() { + proto.RegisterFile("palomachain/paloma/tokenfactory/authorityMetadata.proto", fileDescriptor_0e118f93d35eb685) +} + +var fileDescriptor_0e118f93d35eb685 = []byte{ + // 239 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2f, 0x48, 0xcc, 0xc9, + 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x4b, 0xf2, 0xb3, 0x53, 0xf3, + 0xd2, 0x12, 0x93, 0x4b, 0xf2, 0x8b, 0x2a, 0xf5, 0x13, 0x4b, 0x4b, 0x32, 0xf2, 0x8b, 0x32, 0x4b, + 0x2a, 0x7d, 0x53, 0x4b, 0x12, 0x53, 0x12, 0x4b, 0x12, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, + 0xe4, 0x91, 0x34, 0xea, 0x41, 0xd8, 0x7a, 0xc8, 0x1a, 0xa5, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, + 0x6a, 0xf5, 0x41, 0x2c, 0x88, 0x36, 0x29, 0xb9, 0xe4, 0xfc, 0xe2, 0xdc, 0xfc, 0x62, 0xfd, 0xa4, + 0xc4, 0xe2, 0x54, 0xfd, 0x32, 0xc3, 0xa4, 0xd4, 0x92, 0x44, 0x43, 0xfd, 0xe4, 0x7c, 0x90, 0x19, + 0x20, 0x79, 0x25, 0x37, 0x2e, 0x31, 0x97, 0xd4, 0xbc, 0xfc, 0x5c, 0x47, 0x74, 0x6b, 0x85, 0xd4, + 0xb8, 0x58, 0x13, 0x53, 0x72, 0x33, 0xf3, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x9d, 0x04, 0x3e, + 0xdd, 0x93, 0xe7, 0xa9, 0x4c, 0xcc, 0xcd, 0xb1, 0x52, 0x02, 0x0b, 0x2b, 0x05, 0x41, 0xa4, 0xad, + 0x58, 0x5e, 0x2c, 0x90, 0x67, 0x74, 0xf2, 0x3f, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, + 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, + 0x86, 0x28, 0xd3, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x2c, 0x9e, + 0x2f, 0x33, 0xd2, 0xaf, 0x40, 0x0d, 0x81, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0xfb, + 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x56, 0x0f, 0xe7, 0xf2, 0x31, 0x01, 0x00, 0x00, +} + +func (this *DenomAuthorityMetadata) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*DenomAuthorityMetadata) + if !ok { + that2, ok := that.(DenomAuthorityMetadata) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Admin != that1.Admin { + return false + } + return true +} +func (m *DenomAuthorityMetadata) 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 *DenomAuthorityMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DenomAuthorityMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Admin) > 0 { + i -= len(m.Admin) + copy(dAtA[i:], m.Admin) + i = encodeVarintAuthorityMetadata(dAtA, i, uint64(len(m.Admin))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintAuthorityMetadata(dAtA []byte, offset int, v uint64) int { + offset -= sovAuthorityMetadata(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *DenomAuthorityMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Admin) + if l > 0 { + n += 1 + l + sovAuthorityMetadata(uint64(l)) + } + return n +} + +func sovAuthorityMetadata(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozAuthorityMetadata(x uint64) (n int) { + return sovAuthorityMetadata(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *DenomAuthorityMetadata) 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 ErrIntOverflowAuthorityMetadata + } + 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: DenomAuthorityMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DenomAuthorityMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuthorityMetadata + } + 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 ErrInvalidLengthAuthorityMetadata + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAuthorityMetadata + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Admin = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuthorityMetadata(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAuthorityMetadata + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipAuthorityMetadata(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, ErrIntOverflowAuthorityMetadata + } + 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, ErrIntOverflowAuthorityMetadata + } + 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, ErrIntOverflowAuthorityMetadata + } + 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, ErrInvalidLengthAuthorityMetadata + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupAuthorityMetadata + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthAuthorityMetadata + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthAuthorityMetadata = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowAuthorityMetadata = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupAuthorityMetadata = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/tokenfactory/types/codec.go b/x/tokenfactory/types/codec.go new file mode 100644 index 00000000..c735a68c --- /dev/null +++ b/x/tokenfactory/types/codec.go @@ -0,0 +1,32 @@ +package types + +import ( + "github.com/cosmos/cosmos-sdk/codec" + cdctypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/msgservice" +) + +func RegisterCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgCreateDenom{}, "paloma/tokenfactory/create-denom", nil) + cdc.RegisterConcrete(&MsgMint{}, "paloma/tokenfactory/mint", nil) + cdc.RegisterConcrete(&MsgBurn{}, "paloma/tokenfactory/burn", nil) + cdc.RegisterConcrete(&MsgChangeAdmin{}, "paloma/tokenfactory/change-admin", nil) +} + +func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + registry.RegisterImplementations( + (*sdk.Msg)(nil), + &MsgCreateDenom{}, + &MsgMint{}, + &MsgBurn{}, + // &MsgForceTransfer{}, + &MsgChangeAdmin{}, + ) + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) +} + +var ( + amino = codec.NewLegacyAmino() + ModuleCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry()) +) diff --git a/x/tokenfactory/types/denoms.go b/x/tokenfactory/types/denoms.go new file mode 100644 index 00000000..4de6076f --- /dev/null +++ b/x/tokenfactory/types/denoms.go @@ -0,0 +1,67 @@ +package types + +import ( + "strings" + + sdkerrors "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +const ( + ModuleDenomPrefix = "factory" + + // MaxSubdenomLength + MaxHrpLength = 60 comes from SDK max denom length = 128 + // and the structure of tokenfactory denoms. + MaxSubdenomLength = 44 + MaxHrpLength = 16 + MaxCreatorLength = 59 + MaxHrpLength +) + +// GetTokenDenom constructs a denom string for tokens created by tokenfactory +// based on an input creator address and a subdenom +// The denom constructed is factory/{creator}/{subdenom} +func GetTokenDenom(creator, subdenom string) (string, error) { + if len(subdenom) > MaxSubdenomLength { + return "", ErrSubdenomTooLong + } + if len(creator) > MaxCreatorLength { + return "", ErrCreatorTooLong + } + if strings.Contains(creator, "/") { + return "", ErrInvalidCreator + } + denom := strings.Join([]string{ModuleDenomPrefix, creator, subdenom}, "/") + return denom, sdk.ValidateDenom(denom) +} + +// DeconstructDenom takes a token denom string and verifies that it is a valid +// denom of the tokenfactory module, and is of the form `factory/{creator}/{subdenom}` +// If valid, it returns the creator address and subdenom +func DeconstructDenom(denom string) (creator string, subdenom string, err error) { + err = sdk.ValidateDenom(denom) + if err != nil { + return "", "", err + } + + strParts := strings.Split(denom, "/") + if len(strParts) < 3 { + return "", "", sdkerrors.Wrapf(ErrInvalidDenom, "not enough parts of denom %s", denom) + } + + if strParts[0] != ModuleDenomPrefix { + return "", "", sdkerrors.Wrapf(ErrInvalidDenom, "denom prefix is incorrect. Is: %s. Should be: %s", strParts[0], ModuleDenomPrefix) + } + + creator = strParts[1] + creatorAddr, err := sdk.AccAddressFromBech32(creator) + if err != nil { + return "", "", sdkerrors.Wrapf(ErrInvalidDenom, "Invalid creator address (%s)", err) + } + + // Handle the case where a denom has a slash in its subdenom. For example, + // when we did the split, we'd turn factory/accaddr/atomderivative/sikka into ["factory", "accaddr", "atomderivative", "sikka"] + // So we have to join [2:] with a "/" as the delimiter to get back the correct subdenom which should be "atomderivative/sikka" + subdenom = strings.Join(strParts[2:], "/") + + return creatorAddr.String(), subdenom, nil +} diff --git a/x/tokenfactory/types/denoms_test.go b/x/tokenfactory/types/denoms_test.go new file mode 100644 index 00000000..7c84260c --- /dev/null +++ b/x/tokenfactory/types/denoms_test.go @@ -0,0 +1,129 @@ +package types_test + +import ( + "testing" + + testutilcommmon "github.com/palomachain/paloma/v2/testutil/common" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" + "github.com/stretchr/testify/require" +) + +func TestDeconstructDenom(t *testing.T) { + testutilcommmon.SetupPalomaPrefixes() + for _, tc := range []struct { + desc string + denom string + expectedSubdenom string + err error + }{ + { + desc: "empty is invalid", + denom: "", + err: types.ErrInvalidDenom, + }, + { + desc: "normal", + denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + expectedSubdenom: "bitcoin", + }, + { + desc: "multiple slashes in subdenom", + denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin/1", + expectedSubdenom: "bitcoin/1", + }, + { + desc: "no subdenom", + denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/", + expectedSubdenom: "", + }, + { + desc: "incorrect prefix", + denom: "ibc/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + err: types.ErrInvalidDenom, + }, + { + desc: "subdenom of only slashes", + denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/////", + expectedSubdenom: "////", + }, + { + desc: "too long name", + denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/adsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsf", + err: types.ErrInvalidDenom, + }, + } { + t.Run(tc.desc, func(t *testing.T) { + expectedCreator := "paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm" + creator, subdenom, err := types.DeconstructDenom(tc.denom) + if tc.err != nil { + require.ErrorContains(t, err, tc.err.Error()) + } else { + require.NoError(t, err) + require.Equal(t, expectedCreator, creator) + require.Equal(t, tc.expectedSubdenom, subdenom) + } + }) + } +} + +func TestGetTokenDenom(t *testing.T) { + testutilcommmon.SetupPalomaPrefixes() + for _, tc := range []struct { + desc string + creator string + subdenom string + valid bool + }{ + { + desc: "normal", + creator: "paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm", + subdenom: "bitcoin", + valid: true, + }, + { + desc: "multiple slashes in subdenom", + creator: "paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm", + subdenom: "bitcoin/1", + valid: true, + }, + { + desc: "no subdenom", + creator: "paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm", + subdenom: "", + valid: true, + }, + { + desc: "subdenom of only slashes", + creator: "paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm", + subdenom: "/////", + valid: true, + }, + { + desc: "too long name", + creator: "paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm", + subdenom: "adsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsf", + valid: false, + }, + { + desc: "subdenom is exactly max length", + creator: "paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm", + subdenom: "bitcoinfsadfsdfeadfsafwefsefsefsdfsdafasefsf", + valid: true, + }, + { + desc: "creator is exactly max length", + creator: "paloma1t7egva48prqmzl59x5ngv4zx0dtrwewcdqdjr8jhgjhgkhjklhkjhkjhgjhgjgjghelu", + subdenom: "bitcoin", + valid: true, + }, + } { + t.Run(tc.desc, func(t *testing.T) { + _, err := types.GetTokenDenom(tc.creator, tc.subdenom) + if tc.valid { + require.NoError(t, err) + } else { + require.Error(t, err) + } + }) + } +} diff --git a/x/tokenfactory/types/errors.go b/x/tokenfactory/types/errors.go new file mode 100644 index 00000000..5f76a78e --- /dev/null +++ b/x/tokenfactory/types/errors.go @@ -0,0 +1,22 @@ +package types + +// DONTCOVER + +import ( + fmt "fmt" + + sdkerrors "cosmossdk.io/errors" +) + +// x/tokenfactory module sentinel errors +var ( + ErrDenomExists = sdkerrors.Register(ModuleName, 2, "attempting to create a denom that already exists (has bank metadata)") + ErrUnauthorized = sdkerrors.Register(ModuleName, 3, "unauthorized account") + ErrInvalidDenom = sdkerrors.Register(ModuleName, 4, "invalid denom") + ErrInvalidCreator = sdkerrors.Register(ModuleName, 5, "invalid creator") + ErrInvalidAuthorityMetadata = sdkerrors.Register(ModuleName, 6, "invalid authority metadata") + ErrInvalidGenesis = sdkerrors.Register(ModuleName, 7, "invalid genesis") + ErrSubdenomTooLong = sdkerrors.Register(ModuleName, 8, fmt.Sprintf("subdenom too long, max length is %d bytes", MaxSubdenomLength)) + ErrCreatorTooLong = sdkerrors.Register(ModuleName, 9, fmt.Sprintf("creator too long, max length is %d bytes", MaxCreatorLength)) + ErrDenomDoesNotExist = sdkerrors.Register(ModuleName, 10, "denom does not exist") +) diff --git a/x/tokenfactory/types/events.go b/x/tokenfactory/types/events.go new file mode 100644 index 00000000..373eb9b0 --- /dev/null +++ b/x/tokenfactory/types/events.go @@ -0,0 +1,16 @@ +package types + +//nolint:gosec +const ( + AttributeAmount = "amount" + AttributeCreator = "creator" + AttributeSubdenom = "subdenom" + AttributeNewTokenDenom = "new_token_denom" + AttributeMintToAddress = "mint_to_address" + AttributeBurnFromAddress = "burn_from_address" + AttributeTransferFromAddress = "transfer_from_address" + AttributeTransferToAddress = "transfer_to_address" + AttributeDenom = "denom" + AttributeNewAdmin = "new_admin" + AttributeDenomMetadata = "denom_metadata" +) diff --git a/x/tokenfactory/types/expected_keepers.go b/x/tokenfactory/types/expected_keepers.go new file mode 100644 index 00000000..b8543169 --- /dev/null +++ b/x/tokenfactory/types/expected_keepers.go @@ -0,0 +1,38 @@ +package types + +import ( + context "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdktypes "github.com/cosmos/cosmos-sdk/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" +) + +type BankKeeper interface { + // Methods imported from bank should be defined here + GetDenomMetaData(ctx context.Context, denom string) (banktypes.Metadata, bool) + SetDenomMetaData(ctx context.Context, denomMetaData banktypes.Metadata) + + HasSupply(ctx context.Context, denom string) bool + + SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error + SendCoinsFromAccountToModule(ctx context.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error + MintCoins(ctx context.Context, moduleName string, amt sdk.Coins) error + BurnCoins(ctx context.Context, moduleName string, amt sdk.Coins) error + + SendCoins(ctx context.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) error + HasBalance(ctx context.Context, addr sdk.AccAddress, amt sdk.Coin) bool + GetAllBalances(ctx context.Context, addr sdk.AccAddress) sdk.Coins + SpendableCoins(ctx context.Context, addr sdk.AccAddress) sdk.Coins + GetBalance(ctx context.Context, addr sdk.AccAddress, denom string) sdk.Coin +} + +type AccountKeeper interface { + SetModuleAccount(ctx context.Context, macc sdktypes.ModuleAccountI) + GetAccount(ctx context.Context, addr sdk.AccAddress) sdktypes.AccountI +} + +// CommunityPoolKeeper defines the contract needed to be fulfilled for community pool interactions. +type CommunityPoolKeeper interface { + FundCommunityPool(ctx context.Context, amount sdk.Coins, sender sdk.AccAddress) error +} diff --git a/x/tokenfactory/types/genesis.go b/x/tokenfactory/types/genesis.go new file mode 100644 index 00000000..351335b1 --- /dev/null +++ b/x/tokenfactory/types/genesis.go @@ -0,0 +1,51 @@ +package types + +import ( + sdkerrors "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +// this line is used by starport scaffolding # genesis/types/import + +// DefaultIndex is the default capability global index +const DefaultIndex uint64 = 1 + +// DefaultGenesis returns the default Capability genesis state +func DefaultGenesis() *GenesisState { + return &GenesisState{ + Params: DefaultParams(), + FactoryDenoms: []GenesisDenom{}, + } +} + +// Validate performs basic genesis state validation returning an error upon any +// failure. +func (gs GenesisState) Validate() error { + err := gs.Params.Validate() + if err != nil { + return err + } + + seenDenoms := map[string]bool{} + + for _, denom := range gs.GetFactoryDenoms() { + if seenDenoms[denom.GetDenom()] { + return sdkerrors.Wrapf(ErrInvalidGenesis, "duplicate denom: %s", denom.GetDenom()) + } + seenDenoms[denom.GetDenom()] = true + + _, _, err := DeconstructDenom(denom.GetDenom()) + if err != nil { + return err + } + + if denom.AuthorityMetadata.Admin != "" { + _, err = sdk.AccAddressFromBech32(denom.AuthorityMetadata.Admin) + if err != nil { + return sdkerrors.Wrapf(ErrInvalidAuthorityMetadata, "Invalid admin address (%s)", err) + } + } + } + + return nil +} diff --git a/x/tokenfactory/types/genesis.pb.go b/x/tokenfactory/types/genesis.pb.go new file mode 100644 index 00000000..42bc0d8c --- /dev/null +++ b/x/tokenfactory/types/genesis.pb.go @@ -0,0 +1,649 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: palomachain/paloma/tokenfactory/genesis.proto + +package types + +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 + +// GenesisState defines the tokenfactory module's genesis state. +type GenesisState struct { + // params defines the paramaters of the module. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + FactoryDenoms []GenesisDenom `protobuf:"bytes,2,rep,name=factory_denoms,json=factoryDenoms,proto3" json:"factory_denoms" yaml:"factory_denoms"` +} + +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_2ba655a7d6276c04, []int{0} +} +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 + +func (m *GenesisState) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func (m *GenesisState) GetFactoryDenoms() []GenesisDenom { + if m != nil { + return m.FactoryDenoms + } + return nil +} + +// GenesisDenom defines a tokenfactory denom that is defined within genesis +// state. The structure contains DenomAuthorityMetadata which defines the +// denom's admin. +type GenesisDenom struct { + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"` + AuthorityMetadata DenomAuthorityMetadata `protobuf:"bytes,2,opt,name=authority_metadata,json=authorityMetadata,proto3" json:"authority_metadata" yaml:"authority_metadata"` +} + +func (m *GenesisDenom) Reset() { *m = GenesisDenom{} } +func (m *GenesisDenom) String() string { return proto.CompactTextString(m) } +func (*GenesisDenom) ProtoMessage() {} +func (*GenesisDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_2ba655a7d6276c04, []int{1} +} +func (m *GenesisDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisDenom.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 *GenesisDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisDenom.Merge(m, src) +} +func (m *GenesisDenom) XXX_Size() int { + return m.Size() +} +func (m *GenesisDenom) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisDenom proto.InternalMessageInfo + +func (m *GenesisDenom) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +func (m *GenesisDenom) GetAuthorityMetadata() DenomAuthorityMetadata { + if m != nil { + return m.AuthorityMetadata + } + return DenomAuthorityMetadata{} +} + +func init() { + proto.RegisterType((*GenesisState)(nil), "palomachain.paloma.tokenfactory.GenesisState") + proto.RegisterType((*GenesisDenom)(nil), "palomachain.paloma.tokenfactory.GenesisDenom") +} + +func init() { + proto.RegisterFile("palomachain/paloma/tokenfactory/genesis.proto", fileDescriptor_2ba655a7d6276c04) +} + +var fileDescriptor_2ba655a7d6276c04 = []byte{ + // 356 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2d, 0x48, 0xcc, 0xc9, + 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x4b, 0xf2, 0xb3, 0x53, 0xf3, + 0xd2, 0x12, 0x93, 0x4b, 0xf2, 0x8b, 0x2a, 0xf5, 0xd3, 0x53, 0xf3, 0x52, 0x8b, 0x33, 0x8b, 0xf5, + 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xe4, 0x91, 0x94, 0xeb, 0x41, 0xd8, 0x7a, 0xc8, 0xca, 0xa5, + 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x6a, 0xf5, 0x41, 0x2c, 0x88, 0x36, 0x29, 0x73, 0x42, 0xb6, + 0x24, 0x96, 0x96, 0x64, 0xe4, 0x17, 0x65, 0x96, 0x54, 0xfa, 0xa6, 0x96, 0x24, 0xa6, 0x24, 0x96, + 0x24, 0x42, 0x35, 0xea, 0x10, 0xd2, 0x58, 0x90, 0x58, 0x94, 0x98, 0x0b, 0x75, 0x9d, 0xd2, 0x29, + 0x46, 0x2e, 0x1e, 0x77, 0x88, 0x7b, 0x83, 0x4b, 0x12, 0x4b, 0x52, 0x85, 0x5c, 0xb9, 0xd8, 0x20, + 0x0a, 0x24, 0x18, 0x15, 0x18, 0x35, 0xb8, 0x8d, 0xd4, 0xf5, 0x08, 0xb8, 0x5f, 0x2f, 0x00, 0xac, + 0xdc, 0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0xa8, 0x66, 0xa1, 0x62, 0x2e, 0x3e, 0xa8, 0x7c, + 0x7c, 0x4a, 0x6a, 0x5e, 0x7e, 0x6e, 0xb1, 0x04, 0x93, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0x2e, 0x41, + 0xe3, 0xa0, 0xae, 0x71, 0x01, 0xe9, 0x72, 0x92, 0x05, 0x19, 0xfa, 0xe9, 0x9e, 0xbc, 0x68, 0x65, + 0x62, 0x6e, 0x8e, 0x95, 0x12, 0xaa, 0x91, 0x4a, 0x41, 0xbc, 0x50, 0x01, 0x17, 0x08, 0xff, 0x04, + 0xc2, 0x33, 0x60, 0x11, 0x21, 0x35, 0x2e, 0x56, 0xb0, 0x52, 0xb0, 0x5f, 0x38, 0x9d, 0x04, 0x3e, + 0xdd, 0x93, 0xe7, 0x81, 0x98, 0x04, 0x16, 0x56, 0x0a, 0x82, 0x48, 0x0b, 0x75, 0x32, 0x72, 0x09, + 0xc1, 0xc3, 0x33, 0x3e, 0x17, 0x1a, 0xa0, 0x12, 0x4c, 0xe0, 0x10, 0x30, 0x27, 0xe8, 0x64, 0xb0, + 0x65, 0x8e, 0xe8, 0xf1, 0xe1, 0xa4, 0x08, 0x75, 0xbc, 0x24, 0xc4, 0x4a, 0x4c, 0x0b, 0x94, 0x82, + 0x04, 0x31, 0x62, 0xd1, 0x8a, 0xe5, 0xc5, 0x02, 0x79, 0x46, 0x27, 0xff, 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, 0x32, 0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, + 0xcf, 0xd5, 0xc7, 0x12, 0xd5, 0x65, 0x46, 0xfa, 0x15, 0xa8, 0xf1, 0x5d, 0x52, 0x59, 0x90, 0x5a, + 0x9c, 0xc4, 0x06, 0x8e, 0x6f, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x32, 0xa8, 0x4f, + 0xbe, 0x02, 0x00, 0x00, +} + +func (this *GenesisDenom) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*GenesisDenom) + if !ok { + that2, ok := that.(GenesisDenom) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Denom != that1.Denom { + return false + } + if !this.AuthorityMetadata.Equal(&that1.AuthorityMetadata) { + return false + } + return true +} +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.FactoryDenoms) > 0 { + for iNdEx := len(m.FactoryDenoms) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.FactoryDenoms[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + 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 *GenesisDenom) 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 *GenesisDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.AuthorityMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0xa + } + 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 *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + if len(m.FactoryDenoms) > 0 { + for _, e := range m.FactoryDenoms { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *GenesisDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + l = m.AuthorityMetadata.Size() + 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 *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 != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FactoryDenoms", 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.FactoryDenoms = append(m.FactoryDenoms, GenesisDenom{}) + if err := m.FactoryDenoms[len(m.FactoryDenoms)-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 *GenesisDenom) 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: GenesisDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + 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 ErrInvalidLengthGenesis + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthorityMetadata", 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.AuthorityMetadata.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 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/tokenfactory/types/genesis_test.go b/x/tokenfactory/types/genesis_test.go new file mode 100644 index 00000000..ff8aff75 --- /dev/null +++ b/x/tokenfactory/types/genesis_test.go @@ -0,0 +1,140 @@ +package types_test + +import ( + "testing" + + testutilcommmon "github.com/palomachain/paloma/v2/testutil/common" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" + "github.com/stretchr/testify/require" +) + +func TestGenesisState_Validate(t *testing.T) { + testutilcommmon.SetupPalomaPrefixes() + for _, tc := range []struct { + desc string + genState *types.GenesisState + valid bool + }{ + { + desc: "default is valid", + genState: types.DefaultGenesis(), + valid: true, + }, + { + desc: "valid genesis state", + genState: &types.GenesisState{ + FactoryDenoms: []types.GenesisDenom{ + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + AuthorityMetadata: types.DenomAuthorityMetadata{ + Admin: "paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm", + }, + }, + }, + }, + valid: true, + }, + { + desc: "different admin from creator", + genState: &types.GenesisState{ + FactoryDenoms: []types.GenesisDenom{ + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + AuthorityMetadata: types.DenomAuthorityMetadata{ + Admin: "paloma1kludne80z0tcq9t7j9fqa630fechsjhxhpafac", + }, + }, + }, + }, + valid: true, + }, + { + desc: "empty admin", + genState: &types.GenesisState{ + FactoryDenoms: []types.GenesisDenom{ + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + AuthorityMetadata: types.DenomAuthorityMetadata{ + Admin: "", + }, + }, + }, + }, + valid: true, + }, + { + desc: "no admin", + genState: &types.GenesisState{ + FactoryDenoms: []types.GenesisDenom{ + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + }, + }, + }, + valid: true, + }, + { + desc: "invalid admin", + genState: &types.GenesisState{ + FactoryDenoms: []types.GenesisDenom{ + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + AuthorityMetadata: types.DenomAuthorityMetadata{ + Admin: "moose", + }, + }, + }, + }, + valid: false, + }, + { + desc: "multiple denoms", + genState: &types.GenesisState{ + FactoryDenoms: []types.GenesisDenom{ + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + AuthorityMetadata: types.DenomAuthorityMetadata{ + Admin: "", + }, + }, + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/litecoin", + AuthorityMetadata: types.DenomAuthorityMetadata{ + Admin: "", + }, + }, + }, + }, + valid: true, + }, + { + desc: "duplicate denoms", + genState: &types.GenesisState{ + FactoryDenoms: []types.GenesisDenom{ + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + AuthorityMetadata: types.DenomAuthorityMetadata{ + Admin: "", + }, + }, + { + Denom: "factory/paloma1wm4y8yhppxud6j5wvwr7fyynhh09tmv5x5sfzm/bitcoin", + AuthorityMetadata: types.DenomAuthorityMetadata{ + Admin: "", + }, + }, + }, + }, + valid: false, + }, + } { + t.Run(tc.desc, func(t *testing.T) { + err := tc.genState.Validate() + if tc.valid { + require.NoError(t, err) + } else { + require.Error(t, err) + } + }) + } +} diff --git a/x/tokenfactory/types/keys.go b/x/tokenfactory/types/keys.go new file mode 100644 index 00000000..fac4a6e3 --- /dev/null +++ b/x/tokenfactory/types/keys.go @@ -0,0 +1,49 @@ +package types + +import ( + "strings" +) + +const ( + // ModuleName defines the module name + ModuleName = "tokenfactory" + + // StoreKey defines the primary module store key + StoreKey = ModuleName + + // RouterKey is the message route for slashing + RouterKey = ModuleName + + // QuerierRoute defines the module's query routing key + QuerierRoute = ModuleName + + // MemStoreKey defines the in-memory store key + MemStoreKey = "mem_tokenfactory" +) + +// KeySeparator is used to combine parts of the keys in the store +const KeySeparator = "|" + +var ( + DenomAuthorityMetadataKey = "authoritymetadata" + DenomsPrefixKey = "denoms" + CreatorPrefixKey = "creator" + AdminPrefixKey = "admin" +) + +// GetDenomPrefixStore returns the store prefix where all the data associated with a specific denom +// is stored +func GetDenomPrefixStore(denom string) []byte { + return []byte(strings.Join([]string{DenomsPrefixKey, denom, ""}, KeySeparator)) +} + +// GetCreatorsPrefix returns the store prefix where the list of the denoms created by a specific +// creator are stored +func GetCreatorPrefix(creator string) []byte { + return []byte(strings.Join([]string{CreatorPrefixKey, creator, ""}, KeySeparator)) +} + +// GetCreatorsPrefix returns the store prefix where a list of all creator addresses are stored +func GetCreatorsPrefix() []byte { + return []byte(strings.Join([]string{CreatorPrefixKey, ""}, KeySeparator)) +} diff --git a/x/tokenfactory/types/msgs.go b/x/tokenfactory/types/msgs.go new file mode 100644 index 00000000..66519196 --- /dev/null +++ b/x/tokenfactory/types/msgs.go @@ -0,0 +1,196 @@ +package types + +import ( + sdkerrors "cosmossdk.io/errors" + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + sdktypeerrors "github.com/cosmos/cosmos-sdk/types/errors" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + "github.com/palomachain/paloma/v2/util/libmeta" + valsettypes "github.com/palomachain/paloma/v2/x/valset/types" +) + +const ( + TypeMsgCreateDenom = "create_denom" + TypeMsgMint = "tf_mint" + TypeMsgBurn = "tf_burn" + TypeMsgChangeAdmin = "change_admin" + TypeMsgSetDenomMetadata = "set_denom_metadata" +) + +var ( + _ sdk.Msg = &MsgCreateDenom{} + _ sdk.Msg = &MsgMint{} + _ sdk.Msg = &MsgBurn{} + _ sdk.Msg = &MsgChangeAdmin{} + _ sdk.Msg = &MsgSetDenomMetadata{} +) + +func NewMsgCreateDenom(sender, subdenom string) *MsgCreateDenom { + return &MsgCreateDenom{ + Subdenom: subdenom, + Metadata: valsettypes.MsgMetadata{ + Creator: sender, + Signers: []string{sender}, + }, + } +} + +func (m MsgCreateDenom) Route() string { return RouterKey } +func (m MsgCreateDenom) Type() string { return TypeMsgCreateDenom } +func (m MsgCreateDenom) ValidateBasic() error { + if err := libmeta.ValidateBasic(&m); err != nil { + return err + } + + _, err := GetTokenDenom(m.Metadata.Creator, m.Subdenom) + if err != nil { + return sdkerrors.Wrap(ErrInvalidDenom, err.Error()) + } + + return nil +} + +func (m MsgCreateDenom) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +func (m MsgCreateDenom) GetSigners() []sdk.AccAddress { + return libmeta.GetSigners(&m) +} + +func NewMsgMint(sender string, amount sdk.Coin) *MsgMint { + return &MsgMint{ + Amount: amount, + Metadata: valsettypes.MsgMetadata{ + Creator: sender, + Signers: []string{sender}, + }, + } +} + +func (m MsgMint) Route() string { return RouterKey } +func (m MsgMint) Type() string { return TypeMsgMint } +func (m MsgMint) ValidateBasic() error { + if err := libmeta.ValidateBasic(&m); err != nil { + return err + } + + if !m.Amount.IsValid() || m.Amount.Amount.Equal(sdkmath.ZeroInt()) { + return sdkerrors.Wrap(sdktypeerrors.ErrInvalidCoins, m.Amount.String()) + } + + return nil +} + +func (m MsgMint) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +func (m MsgMint) GetSigners() []sdk.AccAddress { + return libmeta.GetSigners(&m) +} + +func NewMsgBurn(sender string, amount sdk.Coin) *MsgBurn { + return &MsgBurn{ + Amount: amount, + Metadata: valsettypes.MsgMetadata{ + Creator: sender, + Signers: []string{sender}, + }, + } +} + +func (m MsgBurn) Route() string { return RouterKey } +func (m MsgBurn) Type() string { return TypeMsgBurn } +func (m MsgBurn) ValidateBasic() error { + if err := libmeta.ValidateBasic(&m); err != nil { + return err + } + + if !m.Amount.IsValid() || m.Amount.Amount.Equal(sdkmath.ZeroInt()) { + return sdkerrors.Wrap(sdktypeerrors.ErrInvalidCoins, m.Amount.String()) + } + + return nil +} + +func (m MsgBurn) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +func (m MsgBurn) GetSigners() []sdk.AccAddress { + return libmeta.GetSigners(&m) +} + +func NewMsgChangeAdmin(sender, denom, newAdmin string) *MsgChangeAdmin { + return &MsgChangeAdmin{ + Denom: denom, + NewAdmin: newAdmin, + Metadata: valsettypes.MsgMetadata{ + Creator: sender, + Signers: []string{sender}, + }, + } +} + +func (m MsgChangeAdmin) Route() string { return RouterKey } +func (m MsgChangeAdmin) Type() string { return TypeMsgChangeAdmin } +func (m MsgChangeAdmin) ValidateBasic() error { + if err := libmeta.ValidateBasic(&m); err != nil { + return err + } + + _, _, err := DeconstructDenom(m.Denom) + if err != nil { + return err + } + + return nil +} + +func (m MsgChangeAdmin) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +func (m MsgChangeAdmin) GetSigners() []sdk.AccAddress { + return libmeta.GetSigners(&m) +} + +func NewMsgSetDenomMetadata(sender string, metadata banktypes.Metadata) *MsgSetDenomMetadata { + return &MsgSetDenomMetadata{ + DenomMetadata: metadata, + Metadata: valsettypes.MsgMetadata{ + Creator: sender, + Signers: []string{sender}, + }, + } +} + +func (m MsgSetDenomMetadata) Route() string { return RouterKey } +func (m MsgSetDenomMetadata) Type() string { return TypeMsgSetDenomMetadata } +func (m MsgSetDenomMetadata) ValidateBasic() error { + if err := libmeta.ValidateBasic(&m); err != nil { + return err + } + + err := m.DenomMetadata.Validate() + if err != nil { + return err + } + + _, _, err = DeconstructDenom(m.DenomMetadata.Base) + if err != nil { + return err + } + + return nil +} + +func (m MsgSetDenomMetadata) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +func (m MsgSetDenomMetadata) GetSigners() []sdk.AccAddress { + return libmeta.GetSigners(&m) +} diff --git a/x/tokenfactory/types/msgs_test.go b/x/tokenfactory/types/msgs_test.go new file mode 100644 index 00000000..10a0141b --- /dev/null +++ b/x/tokenfactory/types/msgs_test.go @@ -0,0 +1,388 @@ +package types_test + +import ( + fmt "fmt" + "testing" + + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + testutilcommmon "github.com/palomachain/paloma/v2/testutil/common" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" +) + +func TestMsgCreateDenom(t *testing.T) { + testutilcommmon.SetupPalomaPrefixes() + pk1 := ed25519.GenPrivKey().PubKey() + addr1 := sdk.AccAddress(pk1.Address()) + + createMsg := func(after func(msg types.MsgCreateDenom) types.MsgCreateDenom) types.MsgCreateDenom { + properMsg := *types.NewMsgCreateDenom( + addr1.String(), + "bitcoin", + ) + + return after(properMsg) + } + + msg := createMsg(func(msg types.MsgCreateDenom) types.MsgCreateDenom { + return msg + }) + require.Equal(t, msg.Route(), types.RouterKey) + require.Equal(t, msg.Type(), "create_denom") + signers := msg.GetSigners() + require.Equal(t, len(signers), 1) + require.Equal(t, signers[0].String(), addr1.String()) + + tests := []struct { + name string + msg types.MsgCreateDenom + expectPass bool + }{ + { + name: "proper msg", + msg: createMsg(func(msg types.MsgCreateDenom) types.MsgCreateDenom { + return msg + }), + expectPass: true, + }, + { + name: "empty sender", + msg: createMsg(func(msg types.MsgCreateDenom) types.MsgCreateDenom { + msg.Metadata.Creator = "" + return msg + }), + expectPass: false, + }, + { + name: "invalid subdenom", + msg: createMsg(func(msg types.MsgCreateDenom) types.MsgCreateDenom { + msg.Subdenom = "thissubdenomismuchtoolongasdkfjaasdfdsafsdlkfnmlksadmflksmdlfmlsakmfdsafasdfasdf" + return msg + }), + expectPass: false, + }, + } + + for _, test := range tests { + if test.expectPass { + require.NoError(t, test.msg.ValidateBasic(), "test: %v", test.name) + } else { + require.Error(t, test.msg.ValidateBasic(), "test: %v", test.name) + } + } +} + +func TestMsgMint(t *testing.T) { + testutilcommmon.SetupPalomaPrefixes() + pk1 := ed25519.GenPrivKey().PubKey() + addr1 := sdk.AccAddress(pk1.Address()) + + createMsg := func(after func(msg types.MsgMint) types.MsgMint) types.MsgMint { + properMsg := *types.NewMsgMint( + addr1.String(), + sdk.NewCoin("bitcoin", sdkmath.NewInt(500000000)), + ) + + return after(properMsg) + } + + msg := createMsg(func(msg types.MsgMint) types.MsgMint { + return msg + }) + require.Equal(t, msg.Route(), types.RouterKey) + require.Equal(t, msg.Type(), "tf_mint") + signers := msg.GetSigners() + require.Equal(t, len(signers), 1) + require.Equal(t, signers[0].String(), addr1.String()) + + tests := []struct { + name string + msg types.MsgMint + expectPass bool + }{ + { + name: "proper msg", + msg: createMsg(func(msg types.MsgMint) types.MsgMint { + return msg + }), + expectPass: true, + }, + { + name: "empty sender", + msg: createMsg(func(msg types.MsgMint) types.MsgMint { + msg.Metadata.Creator = "" + return msg + }), + expectPass: false, + }, + { + name: "zero amount", + msg: createMsg(func(msg types.MsgMint) types.MsgMint { + msg.Amount = sdk.NewCoin("bitcoin", sdkmath.ZeroInt()) + return msg + }), + expectPass: false, + }, + { + name: "negative amount", + msg: createMsg(func(msg types.MsgMint) types.MsgMint { + msg.Amount.Amount = sdkmath.NewInt(-10000000) + return msg + }), + expectPass: false, + }, + } + + for _, test := range tests { + if test.expectPass { + require.NoError(t, test.msg.ValidateBasic(), "test: %v", test.name) + } else { + require.Error(t, test.msg.ValidateBasic(), "test: %v", test.name) + } + } +} + +func TestMsgBurn(t *testing.T) { + testutilcommmon.SetupPalomaPrefixes() + pk1 := ed25519.GenPrivKey().PubKey() + addr1 := sdk.AccAddress(pk1.Address()) + + baseMsg := types.NewMsgBurn( + addr1.String(), + sdk.NewCoin("bitcoin", sdkmath.NewInt(500000000)), + ) + + require.Equal(t, baseMsg.Route(), types.RouterKey) + require.Equal(t, baseMsg.Type(), "tf_burn") + signers := baseMsg.GetSigners() + require.Equal(t, len(signers), 1) + require.Equal(t, signers[0].String(), addr1.String()) + + tests := []struct { + name string + msg func() *types.MsgBurn + expectPass bool + }{ + { + name: "proper msg", + msg: func() *types.MsgBurn { + msg := baseMsg + return msg + }, + expectPass: true, + }, + { + name: "empty sender", + msg: func() *types.MsgBurn { + msg := baseMsg + msg.Metadata.Creator = "" + return msg + }, + expectPass: false, + }, + { + name: "zero amount", + msg: func() *types.MsgBurn { + msg := baseMsg + msg.Amount.Amount = sdkmath.ZeroInt() + return msg + }, + expectPass: false, + }, + { + name: "negative amount", + msg: func() *types.MsgBurn { + msg := baseMsg + msg.Amount.Amount = sdkmath.NewInt(-10000000) + return msg + }, + expectPass: false, + }, + } + + for _, test := range tests { + if test.expectPass { + require.NoError(t, test.msg().ValidateBasic(), "test: %v", test.name) + } else { + require.Error(t, test.msg().ValidateBasic(), "test: %v", test.name) + } + } +} + +func TestMsgChangeAdmin(t *testing.T) { + testutilcommmon.SetupPalomaPrefixes() + pk1 := ed25519.GenPrivKey().PubKey() + addr1 := sdk.AccAddress(pk1.Address()) + pk2 := ed25519.GenPrivKey().PubKey() + addr2 := sdk.AccAddress(pk2.Address()) + tokenFactoryDenom := fmt.Sprintf("factory/%s/bitcoin", addr1.String()) + + baseMsg := types.NewMsgChangeAdmin( + addr1.String(), + tokenFactoryDenom, + addr2.String(), + ) + + require.Equal(t, baseMsg.Route(), types.RouterKey) + require.Equal(t, baseMsg.Type(), "change_admin") + signers := baseMsg.GetSigners() + require.Equal(t, len(signers), 1) + require.Equal(t, signers[0].String(), addr1.String()) + + tests := []struct { + name string + msg func() *types.MsgChangeAdmin + expectPass bool + }{ + { + name: "proper msg", + msg: func() *types.MsgChangeAdmin { + msg := baseMsg + return msg + }, + expectPass: true, + }, + { + name: "empty sender", + msg: func() *types.MsgChangeAdmin { + msg := baseMsg + msg.Metadata.Creator = "" + return msg + }, + expectPass: false, + }, + { + name: "empty newAdmin", + msg: func() *types.MsgChangeAdmin { + msg := baseMsg + msg.NewAdmin = "" + return msg + }, + expectPass: false, + }, + { + name: "invalid denom", + msg: func() *types.MsgChangeAdmin { + msg := baseMsg + msg.Denom = "bitcoin" + return msg + }, + expectPass: false, + }, + } + + for _, test := range tests { + if test.expectPass { + require.NoError(t, test.msg().ValidateBasic(), "test: %v", test.name) + } else { + require.Error(t, test.msg().ValidateBasic(), "test: %v", test.name) + } + } +} + +func TestMsgSetDenomMetadata(t *testing.T) { + testutilcommmon.SetupPalomaPrefixes() + pk1 := ed25519.GenPrivKey().PubKey() + addr1 := sdk.AccAddress(pk1.Address()) + tokenFactoryDenom := fmt.Sprintf("factory/%s/bitcoin", addr1.String()) + denomMetadata := banktypes.Metadata{ + Description: "nakamoto", + DenomUnits: []*banktypes.DenomUnit{ + { + Denom: tokenFactoryDenom, + Exponent: 0, + }, + { + Denom: "sats", + Exponent: 6, + }, + }, + Display: "sats", + Base: tokenFactoryDenom, + Name: "bitcoin", + Symbol: "BTC", + } + invalidDenomMetadata := banktypes.Metadata{ + Description: "nakamoto", + DenomUnits: []*banktypes.DenomUnit{ + { + Denom: "bitcoin", + Exponent: 0, + }, + { + Denom: "sats", + Exponent: 6, + }, + }, + Display: "sats", + Base: "bitcoin", + Name: "bitcoin", + Symbol: "BTC", + } + + baseMsg := types.NewMsgSetDenomMetadata( + addr1.String(), + denomMetadata, + ) + + require.Equal(t, baseMsg.Route(), types.RouterKey) + require.Equal(t, baseMsg.Type(), "set_denom_metadata") + signers := baseMsg.GetSigners() + require.Equal(t, len(signers), 1) + require.Equal(t, signers[0].String(), addr1.String()) + + tests := []struct { + name string + msg func() *types.MsgSetDenomMetadata + expectPass bool + }{ + { + name: "proper msg", + msg: func() *types.MsgSetDenomMetadata { + msg := baseMsg + return msg + }, + expectPass: true, + }, + { + name: "empty sender", + msg: func() *types.MsgSetDenomMetadata { + msg := baseMsg + msg.Metadata.Creator = "" + return msg + }, + expectPass: false, + }, + { + name: "invalid metadata", + msg: func() *types.MsgSetDenomMetadata { + msg := baseMsg + msg.DenomMetadata.Name = "" + return msg + }, + + expectPass: false, + }, + { + name: "invalid base", + msg: func() *types.MsgSetDenomMetadata { + msg := baseMsg + msg.DenomMetadata = invalidDenomMetadata + return msg + }, + expectPass: false, + }, + } + + for _, test := range tests { + if test.expectPass { + require.NoError(t, test.msg().ValidateBasic(), "test: %v", test.name) + } else { + require.Error(t, test.msg().ValidateBasic(), "test: %v", test.name) + } + } +} diff --git a/x/tokenfactory/types/params.go b/x/tokenfactory/types/params.go new file mode 100644 index 00000000..e1b57376 --- /dev/null +++ b/x/tokenfactory/types/params.go @@ -0,0 +1,53 @@ +package types + +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" +) + +var KeyDenomCreationFee = []byte("DenomCreationFee") + +func ParamKeyTable() paramtypes.KeyTable { + return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) +} + +func NewParams(denomCreationFee sdk.Coins) Params { + return Params{ + DenomCreationFee: denomCreationFee, + } +} + +func DefaultParams() Params { + return Params{ + DenomCreationFee: sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 10_000_000)), // 10 GRAIN + } +} + +func (p Params) Validate() error { + if err := validateDenomCreationFee(p.DenomCreationFee); err != nil { + return err + } + + return nil +} + +func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { + return paramtypes.ParamSetPairs{ + paramtypes.NewParamSetPair(KeyDenomCreationFee, &p.DenomCreationFee, validateDenomCreationFee), + } +} + +func validateDenomCreationFee(i interface{}) error { + v, ok := i.(sdk.Coins) + if !ok { + return fmt.Errorf("invalid parameter type: %T", i) + } + + if v.Validate() != nil { + return fmt.Errorf("invalid denom creation fee: %+v", i) + } + + return nil +} diff --git a/x/tokenfactory/types/params.pb.go b/x/tokenfactory/types/params.pb.go new file mode 100644 index 00000000..a4468dcc --- /dev/null +++ b/x/tokenfactory/types/params.pb.go @@ -0,0 +1,342 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: palomachain/paloma/tokenfactory/params.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + types "github.com/cosmos/cosmos-sdk/types" + _ "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 + +// Params defines the parameters for the tokenfactory module. +type Params struct { + DenomCreationFee github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=denom_creation_fee,json=denomCreationFee,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"denom_creation_fee" yaml:"denom_creation_fee"` +} + +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_df468eede633b91c, []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) GetDenomCreationFee() github_com_cosmos_cosmos_sdk_types.Coins { + if m != nil { + return m.DenomCreationFee + } + return nil +} + +func init() { + proto.RegisterType((*Params)(nil), "palomachain.paloma.tokenfactory.Params") +} + +func init() { + proto.RegisterFile("palomachain/paloma/tokenfactory/params.proto", fileDescriptor_df468eede633b91c) +} + +var fileDescriptor_df468eede633b91c = []byte{ + // 308 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x50, 0xbd, 0x4e, 0xf3, 0x30, + 0x14, 0x8d, 0xf5, 0x49, 0x1d, 0xfa, 0x2d, 0xa8, 0x62, 0xa0, 0x1d, 0x1c, 0xd4, 0xa9, 0x03, 0xd8, + 0x6a, 0x11, 0x42, 0x62, 0x6c, 0x25, 0xb6, 0x0a, 0xc4, 0xc8, 0x52, 0xdd, 0xb8, 0x6e, 0x13, 0xb5, + 0xce, 0x8d, 0x62, 0xb7, 0x22, 0x6f, 0xc1, 0xc4, 0xce, 0xca, 0x93, 0x74, 0xec, 0xc8, 0x54, 0x50, + 0xf2, 0x06, 0x3c, 0x01, 0x8a, 0xed, 0x21, 0x08, 0x24, 0x26, 0x9f, 0xab, 0xf3, 0xe3, 0x73, 0x6f, + 0xfb, 0x2c, 0x83, 0x35, 0x2a, 0x10, 0x31, 0x24, 0x29, 0x77, 0x98, 0x1b, 0x5c, 0xc9, 0x74, 0x01, + 0xc2, 0x60, 0x5e, 0xf0, 0x0c, 0x72, 0x50, 0x9a, 0x65, 0x39, 0x1a, 0xec, 0x84, 0x0d, 0x35, 0x73, + 0x98, 0x35, 0xd5, 0xbd, 0xe3, 0x25, 0x2e, 0xd1, 0x6a, 0x79, 0x8d, 0x9c, 0xad, 0xd7, 0x15, 0xa8, + 0x15, 0xea, 0x99, 0x23, 0xdc, 0xe0, 0x29, 0xea, 0x26, 0x1e, 0x81, 0x96, 0x7c, 0x3b, 0x8c, 0xa4, + 0x81, 0x21, 0x17, 0x58, 0xc7, 0x5b, 0xfe, 0xea, 0xaf, 0x7e, 0xb0, 0x31, 0x31, 0xe6, 0x89, 0x29, + 0xa6, 0xd2, 0xc0, 0x1c, 0x0c, 0x38, 0x63, 0xff, 0x85, 0xb4, 0x5b, 0x77, 0xb6, 0x7b, 0xe7, 0x99, + 0xb4, 0x3b, 0x73, 0x99, 0xa2, 0x9a, 0x89, 0x5c, 0x82, 0x49, 0x30, 0x9d, 0x2d, 0xa4, 0x3c, 0x21, + 0xa7, 0xff, 0x06, 0xff, 0x47, 0x5d, 0xe6, 0xfb, 0xd4, 0x0d, 0x98, 0x6f, 0xc0, 0x26, 0x98, 0xa4, + 0xe3, 0xe9, 0xee, 0x10, 0x06, 0x9f, 0x87, 0xb0, 0x5b, 0x80, 0x5a, 0x5f, 0xf7, 0x7f, 0x46, 0xf4, + 0x5f, 0xdf, 0xc3, 0xc1, 0x32, 0x31, 0xf1, 0x26, 0x62, 0x02, 0x95, 0xdf, 0xcc, 0x3f, 0xe7, 0x7a, + 0xbe, 0xe2, 0xa6, 0xc8, 0xa4, 0xb6, 0x69, 0xfa, 0xfe, 0xc8, 0x06, 0x4c, 0xbc, 0xff, 0x46, 0xca, + 0xf1, 0xed, 0xae, 0xa4, 0x64, 0x5f, 0x52, 0xf2, 0x51, 0x52, 0xf2, 0x54, 0xd1, 0x60, 0x5f, 0xd1, + 0xe0, 0xad, 0xa2, 0xc1, 0xc3, 0x65, 0x23, 0xf5, 0x97, 0x0b, 0x6c, 0x47, 0xfc, 0xf1, 0xfb, 0x19, + 0xec, 0x47, 0x51, 0xcb, 0xee, 0x7e, 0xf1, 0x15, 0x00, 0x00, 0xff, 0xff, 0x7b, 0x96, 0x43, 0xdf, + 0xd6, 0x01, 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 len(m.DenomCreationFee) > 0 { + for iNdEx := len(m.DenomCreationFee) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DenomCreationFee[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintParams(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintParams(dAtA []byte, offset int, v uint64) int { + offset -= sovParams(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 len(m.DenomCreationFee) > 0 { + for _, e := range m.DenomCreationFee { + l = e.Size() + n += 1 + l + sovParams(uint64(l)) + } + } + return n +} + +func sovParams(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozParams(x uint64) (n int) { + return sovParams(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 ErrIntOverflowParams + } + 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 != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DenomCreationFee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthParams + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DenomCreationFee = append(m.DenomCreationFee, types.Coin{}) + if err := m.DenomCreationFee[len(m.DenomCreationFee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipParams(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthParams + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipParams(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, ErrIntOverflowParams + } + 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, ErrIntOverflowParams + } + 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, ErrIntOverflowParams + } + 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, ErrInvalidLengthParams + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupParams + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthParams + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthParams = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowParams = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/tokenfactory/types/query.pb.go b/x/tokenfactory/types/query.pb.go new file mode 100644 index 00000000..1d9a2828 --- /dev/null +++ b/x/tokenfactory/types/query.pb.go @@ -0,0 +1,1332 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: palomachain/paloma/tokenfactory/query.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-sdk/types/query" + _ "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" + 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 + +// QueryParamsRequest is the request type for the Query/Params RPC method. +type QueryParamsRequest struct { +} + +func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } +func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryParamsRequest) ProtoMessage() {} +func (*QueryParamsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_fc2a909c5c9a6da9, []int{0} +} +func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsRequest.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 *QueryParamsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsRequest.Merge(m, src) +} +func (m *QueryParamsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo + +// QueryParamsResponse is the response type for the Query/Params RPC method. +type QueryParamsResponse struct { + // params defines the parameters of the module. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } +func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryParamsResponse) ProtoMessage() {} +func (*QueryParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_fc2a909c5c9a6da9, []int{1} +} +func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsResponse.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 *QueryParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsResponse.Merge(m, src) +} +func (m *QueryParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo + +func (m *QueryParamsResponse) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +// QueryDenomAuthorityMetadataRequest defines the request structure for the +// DenomAuthorityMetadata gRPC query. +type QueryDenomAuthorityMetadataRequest struct { + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"` +} + +func (m *QueryDenomAuthorityMetadataRequest) Reset() { *m = QueryDenomAuthorityMetadataRequest{} } +func (m *QueryDenomAuthorityMetadataRequest) String() string { return proto.CompactTextString(m) } +func (*QueryDenomAuthorityMetadataRequest) ProtoMessage() {} +func (*QueryDenomAuthorityMetadataRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_fc2a909c5c9a6da9, []int{2} +} +func (m *QueryDenomAuthorityMetadataRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDenomAuthorityMetadataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDenomAuthorityMetadataRequest.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 *QueryDenomAuthorityMetadataRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDenomAuthorityMetadataRequest.Merge(m, src) +} +func (m *QueryDenomAuthorityMetadataRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryDenomAuthorityMetadataRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDenomAuthorityMetadataRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDenomAuthorityMetadataRequest proto.InternalMessageInfo + +func (m *QueryDenomAuthorityMetadataRequest) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +// QueryDenomAuthorityMetadataResponse defines the response structure for the +// DenomAuthorityMetadata gRPC query. +type QueryDenomAuthorityMetadataResponse struct { + AuthorityMetadata DenomAuthorityMetadata `protobuf:"bytes,1,opt,name=authority_metadata,json=authorityMetadata,proto3" json:"authority_metadata" yaml:"authority_metadata"` +} + +func (m *QueryDenomAuthorityMetadataResponse) Reset() { *m = QueryDenomAuthorityMetadataResponse{} } +func (m *QueryDenomAuthorityMetadataResponse) String() string { return proto.CompactTextString(m) } +func (*QueryDenomAuthorityMetadataResponse) ProtoMessage() {} +func (*QueryDenomAuthorityMetadataResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_fc2a909c5c9a6da9, []int{3} +} +func (m *QueryDenomAuthorityMetadataResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDenomAuthorityMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDenomAuthorityMetadataResponse.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 *QueryDenomAuthorityMetadataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDenomAuthorityMetadataResponse.Merge(m, src) +} +func (m *QueryDenomAuthorityMetadataResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryDenomAuthorityMetadataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDenomAuthorityMetadataResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDenomAuthorityMetadataResponse proto.InternalMessageInfo + +func (m *QueryDenomAuthorityMetadataResponse) GetAuthorityMetadata() DenomAuthorityMetadata { + if m != nil { + return m.AuthorityMetadata + } + return DenomAuthorityMetadata{} +} + +// QueryDenomsFromCreatorRequest defines the request structure for the +// DenomsFromCreator gRPC query. +type QueryDenomsFromCreatorRequest struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"` +} + +func (m *QueryDenomsFromCreatorRequest) Reset() { *m = QueryDenomsFromCreatorRequest{} } +func (m *QueryDenomsFromCreatorRequest) String() string { return proto.CompactTextString(m) } +func (*QueryDenomsFromCreatorRequest) ProtoMessage() {} +func (*QueryDenomsFromCreatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_fc2a909c5c9a6da9, []int{4} +} +func (m *QueryDenomsFromCreatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDenomsFromCreatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDenomsFromCreatorRequest.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 *QueryDenomsFromCreatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDenomsFromCreatorRequest.Merge(m, src) +} +func (m *QueryDenomsFromCreatorRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryDenomsFromCreatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDenomsFromCreatorRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDenomsFromCreatorRequest proto.InternalMessageInfo + +func (m *QueryDenomsFromCreatorRequest) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +// QueryDenomsFromCreatorRequest defines the response structure for the +// DenomsFromCreator gRPC query. +type QueryDenomsFromCreatorResponse struct { + Denoms []string `protobuf:"bytes,1,rep,name=denoms,proto3" json:"denoms,omitempty" yaml:"denoms"` +} + +func (m *QueryDenomsFromCreatorResponse) Reset() { *m = QueryDenomsFromCreatorResponse{} } +func (m *QueryDenomsFromCreatorResponse) String() string { return proto.CompactTextString(m) } +func (*QueryDenomsFromCreatorResponse) ProtoMessage() {} +func (*QueryDenomsFromCreatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_fc2a909c5c9a6da9, []int{5} +} +func (m *QueryDenomsFromCreatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDenomsFromCreatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDenomsFromCreatorResponse.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 *QueryDenomsFromCreatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDenomsFromCreatorResponse.Merge(m, src) +} +func (m *QueryDenomsFromCreatorResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryDenomsFromCreatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDenomsFromCreatorResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDenomsFromCreatorResponse proto.InternalMessageInfo + +func (m *QueryDenomsFromCreatorResponse) GetDenoms() []string { + if m != nil { + return m.Denoms + } + return nil +} + +func init() { + proto.RegisterType((*QueryParamsRequest)(nil), "palomachain.paloma.tokenfactory.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "palomachain.paloma.tokenfactory.QueryParamsResponse") + proto.RegisterType((*QueryDenomAuthorityMetadataRequest)(nil), "palomachain.paloma.tokenfactory.QueryDenomAuthorityMetadataRequest") + proto.RegisterType((*QueryDenomAuthorityMetadataResponse)(nil), "palomachain.paloma.tokenfactory.QueryDenomAuthorityMetadataResponse") + proto.RegisterType((*QueryDenomsFromCreatorRequest)(nil), "palomachain.paloma.tokenfactory.QueryDenomsFromCreatorRequest") + proto.RegisterType((*QueryDenomsFromCreatorResponse)(nil), "palomachain.paloma.tokenfactory.QueryDenomsFromCreatorResponse") +} + +func init() { + proto.RegisterFile("palomachain/paloma/tokenfactory/query.proto", fileDescriptor_fc2a909c5c9a6da9) +} + +var fileDescriptor_fc2a909c5c9a6da9 = []byte{ + // 575 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4f, 0x6b, 0x13, 0x41, + 0x14, 0xcf, 0x6a, 0x1b, 0xe9, 0xf8, 0x07, 0x33, 0x16, 0xd1, 0xa0, 0xbb, 0x3a, 0x82, 0x6d, 0xb5, + 0xec, 0xd0, 0x54, 0x29, 0x78, 0xa8, 0xba, 0x8d, 0x3d, 0xa8, 0x45, 0xdd, 0xa3, 0x08, 0x61, 0x92, + 0x4e, 0x37, 0x8b, 0xd9, 0x7d, 0xdb, 0x9d, 0x49, 0x31, 0x94, 0x5e, 0xbc, 0x79, 0x13, 0xfc, 0x0a, + 0x7e, 0x01, 0xbf, 0x45, 0x8f, 0x05, 0x2f, 0x1e, 0x24, 0x48, 0xe2, 0x5d, 0xc8, 0x17, 0x50, 0x32, + 0x33, 0xd5, 0xd4, 0xc4, 0x6e, 0x6a, 0x4f, 0x3b, 0xbc, 0xf7, 0x7b, 0xbf, 0xf7, 0xfb, 0xbd, 0xf7, + 0x58, 0x74, 0x3b, 0x61, 0x0d, 0x88, 0x58, 0xad, 0xce, 0xc2, 0x98, 0xea, 0x37, 0x95, 0xf0, 0x9a, + 0xc7, 0x1b, 0xac, 0x26, 0x21, 0x6d, 0xd1, 0xcd, 0x26, 0x4f, 0x5b, 0x6e, 0x92, 0x82, 0x04, 0xec, + 0x0c, 0x80, 0x5d, 0xfd, 0x76, 0x07, 0xc1, 0xc5, 0xe9, 0x00, 0x02, 0x50, 0x58, 0xda, 0x7f, 0xe9, + 0xb2, 0xe2, 0x95, 0x00, 0x20, 0x68, 0x70, 0xca, 0x92, 0x90, 0xb2, 0x38, 0x06, 0xc9, 0x64, 0x08, + 0xb1, 0x30, 0xd9, 0x5b, 0x35, 0x10, 0x11, 0x08, 0x5a, 0x65, 0x82, 0xeb, 0x6e, 0x74, 0x6b, 0xa1, + 0xca, 0x25, 0x5b, 0xa0, 0x09, 0x0b, 0xc2, 0x58, 0x81, 0x0d, 0x76, 0x29, 0x4b, 0x2d, 0x6b, 0xca, + 0x3a, 0xa4, 0xa1, 0x6c, 0xad, 0x71, 0xc9, 0xd6, 0x99, 0x64, 0xa6, 0x70, 0x3e, 0xab, 0x30, 0x61, + 0x29, 0x8b, 0x8c, 0x24, 0x32, 0x8d, 0xf0, 0x8b, 0xbe, 0x90, 0xe7, 0x2a, 0xe8, 0xf3, 0xcd, 0x26, + 0x17, 0x92, 0xbc, 0x42, 0x17, 0x0e, 0x44, 0x45, 0x02, 0xb1, 0xe0, 0xf8, 0x11, 0xca, 0xeb, 0xe2, + 0x4b, 0xd6, 0x35, 0x6b, 0xf6, 0x74, 0x69, 0xc6, 0xcd, 0x98, 0x92, 0xab, 0x09, 0xbc, 0x89, 0xdd, + 0xb6, 0x93, 0xf3, 0x4d, 0x31, 0x79, 0x8a, 0x88, 0x62, 0x2f, 0xf3, 0x18, 0xa2, 0x87, 0x7f, 0xdb, + 0x30, 0x1a, 0xf0, 0x4d, 0x34, 0xb9, 0xde, 0x07, 0xa8, 0x5e, 0x53, 0xde, 0xf9, 0x5e, 0xdb, 0x39, + 0xd3, 0x62, 0x51, 0xe3, 0x1e, 0x51, 0x61, 0xe2, 0xeb, 0x34, 0xf9, 0x64, 0xa1, 0x1b, 0x87, 0xd2, + 0x19, 0xf1, 0xef, 0x2c, 0x84, 0x7f, 0xcf, 0xac, 0x12, 0x99, 0xb4, 0x71, 0xb2, 0x94, 0xe9, 0x64, + 0x34, 0xbb, 0x77, 0xbd, 0xef, 0xac, 0xd7, 0x76, 0x2e, 0x6b, 0x69, 0xc3, 0x0d, 0x88, 0x5f, 0x18, + 0xda, 0x14, 0x59, 0x43, 0x57, 0xff, 0x48, 0x16, 0xab, 0x29, 0x44, 0x2b, 0x29, 0x67, 0x12, 0xd2, + 0x7d, 0xf3, 0xf3, 0xe8, 0x54, 0x4d, 0x47, 0x8c, 0x7d, 0xdc, 0x6b, 0x3b, 0xe7, 0x74, 0x0f, 0x93, + 0x20, 0xfe, 0x3e, 0x84, 0x3c, 0x41, 0xf6, 0xbf, 0xe8, 0x8c, 0xf9, 0x39, 0x94, 0x57, 0xd3, 0xea, + 0x6f, 0xee, 0xe4, 0xec, 0x94, 0x57, 0xe8, 0xb5, 0x9d, 0xb3, 0x03, 0xd3, 0x14, 0xc4, 0x37, 0x80, + 0xd2, 0xcf, 0x09, 0x34, 0xa9, 0xd8, 0xf0, 0x47, 0x0b, 0xe5, 0xf5, 0x02, 0xf1, 0x62, 0xe6, 0x7c, + 0x86, 0xaf, 0xa8, 0x78, 0xe7, 0x68, 0x45, 0x5a, 0x2a, 0xa1, 0x6f, 0x3f, 0x7f, 0xff, 0x70, 0x62, + 0x0e, 0xcf, 0xd0, 0xf1, 0x0e, 0x19, 0xff, 0xb0, 0xd0, 0xc5, 0xd1, 0xdb, 0xc1, 0x2b, 0xe3, 0x29, + 0x38, 0xf4, 0x10, 0x8b, 0xe5, 0xe3, 0x91, 0x18, 0x5b, 0x8f, 0x95, 0xad, 0x32, 0xf6, 0x32, 0x6d, + 0xe9, 0x3d, 0xd0, 0x6d, 0xf5, 0xdd, 0xa1, 0xc3, 0x27, 0x85, 0xbf, 0x5a, 0xa8, 0x30, 0xb4, 0x6b, + 0xbc, 0x7c, 0x04, 0x9d, 0x23, 0x6e, 0xae, 0x78, 0xff, 0xbf, 0xeb, 0x8d, 0xc5, 0x55, 0x65, 0xf1, + 0x01, 0x5e, 0x1e, 0xd3, 0x62, 0x65, 0x23, 0x85, 0xa8, 0x62, 0x8e, 0x98, 0x6e, 0x9b, 0xc7, 0x8e, + 0xf7, 0x6c, 0xb7, 0x63, 0x5b, 0x7b, 0x1d, 0xdb, 0xfa, 0xd6, 0xb1, 0xad, 0xf7, 0x5d, 0x3b, 0xb7, + 0xd7, 0xb5, 0x73, 0x5f, 0xba, 0x76, 0xee, 0xe5, 0xdd, 0x20, 0x94, 0xf5, 0x66, 0xd5, 0xad, 0x41, + 0x34, 0xaa, 0xc7, 0x56, 0x89, 0xbe, 0x39, 0xd8, 0x48, 0xb6, 0x12, 0x2e, 0xaa, 0x79, 0xf5, 0xaf, + 0x5b, 0xfc, 0x15, 0x00, 0x00, 0xff, 0xff, 0x27, 0x9c, 0x70, 0x9e, 0x02, 0x06, 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 { + // Params defines a gRPC query method that returns the tokenfactory module's + // parameters. + Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) + // DenomAuthorityMetadata defines a gRPC query method for fetching + // DenomAuthorityMetadata for a particular denom. + DenomAuthorityMetadata(ctx context.Context, in *QueryDenomAuthorityMetadataRequest, opts ...grpc.CallOption) (*QueryDenomAuthorityMetadataResponse, error) + // DenomsFromCreator defines a gRPC query method for fetching all + // denominations created by a specific admin/creator. + DenomsFromCreator(ctx context.Context, in *QueryDenomsFromCreatorRequest, opts ...grpc.CallOption) (*QueryDenomsFromCreatorResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { + out := new(QueryParamsResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Query/Params", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) DenomAuthorityMetadata(ctx context.Context, in *QueryDenomAuthorityMetadataRequest, opts ...grpc.CallOption) (*QueryDenomAuthorityMetadataResponse, error) { + out := new(QueryDenomAuthorityMetadataResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Query/DenomAuthorityMetadata", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) DenomsFromCreator(ctx context.Context, in *QueryDenomsFromCreatorRequest, opts ...grpc.CallOption) (*QueryDenomsFromCreatorResponse, error) { + out := new(QueryDenomsFromCreatorResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Query/DenomsFromCreator", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // Params defines a gRPC query method that returns the tokenfactory module's + // parameters. + Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) + // DenomAuthorityMetadata defines a gRPC query method for fetching + // DenomAuthorityMetadata for a particular denom. + DenomAuthorityMetadata(context.Context, *QueryDenomAuthorityMetadataRequest) (*QueryDenomAuthorityMetadataResponse, error) + // DenomsFromCreator defines a gRPC query method for fetching all + // denominations created by a specific admin/creator. + DenomsFromCreator(context.Context, *QueryDenomsFromCreatorRequest) (*QueryDenomsFromCreatorResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +} +func (*UnimplementedQueryServer) DenomAuthorityMetadata(ctx context.Context, req *QueryDenomAuthorityMetadataRequest) (*QueryDenomAuthorityMetadataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DenomAuthorityMetadata not implemented") +} +func (*UnimplementedQueryServer) DenomsFromCreator(ctx context.Context, req *QueryDenomsFromCreatorRequest) (*QueryDenomsFromCreatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DenomsFromCreator not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryParamsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Params(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Query/Params", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_DenomAuthorityMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryDenomAuthorityMetadataRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).DenomAuthorityMetadata(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Query/DenomAuthorityMetadata", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).DenomAuthorityMetadata(ctx, req.(*QueryDenomAuthorityMetadataRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_DenomsFromCreator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryDenomsFromCreatorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).DenomsFromCreator(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Query/DenomsFromCreator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).DenomsFromCreator(ctx, req.(*QueryDenomsFromCreatorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "palomachain.paloma.tokenfactory.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Params", + Handler: _Query_Params_Handler, + }, + { + MethodName: "DenomAuthorityMetadata", + Handler: _Query_DenomAuthorityMetadata_Handler, + }, + { + MethodName: "DenomsFromCreator", + Handler: _Query_DenomsFromCreator_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "palomachain/paloma/tokenfactory/query.proto", +} + +func (m *QueryParamsRequest) 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 *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryParamsResponse) 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 *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryDenomAuthorityMetadataRequest) 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 *QueryDenomAuthorityMetadataRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDenomAuthorityMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryDenomAuthorityMetadataResponse) 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 *QueryDenomAuthorityMetadataResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDenomAuthorityMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.AuthorityMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryDenomsFromCreatorRequest) 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 *QueryDenomsFromCreatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDenomsFromCreatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryDenomsFromCreatorResponse) 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 *QueryDenomsFromCreatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDenomsFromCreatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Denoms) > 0 { + for iNdEx := len(m.Denoms) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Denoms[iNdEx]) + copy(dAtA[i:], m.Denoms[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Denoms[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 *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryDenomAuthorityMetadataRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDenomAuthorityMetadataResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.AuthorityMetadata.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryDenomsFromCreatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDenomsFromCreatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Denoms) > 0 { + for _, s := range m.Denoms { + 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 *QueryParamsRequest) 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: QueryParamsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsRequest: 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 *QueryParamsResponse) 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: QueryParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsResponse: 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 ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 (m *QueryDenomAuthorityMetadataRequest) 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: QueryDenomAuthorityMetadataRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDenomAuthorityMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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.Denom = 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 (m *QueryDenomAuthorityMetadataResponse) 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: QueryDenomAuthorityMetadataResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDenomAuthorityMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthorityMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.AuthorityMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 (m *QueryDenomsFromCreatorRequest) 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: QueryDenomsFromCreatorRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDenomsFromCreatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = 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 (m *QueryDenomsFromCreatorResponse) 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: QueryDenomsFromCreatorResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDenomsFromCreatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denoms", 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.Denoms = append(m.Denoms, 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/tokenfactory/types/query.pb.gw.go b/x/tokenfactory/types/query.pb.gw.go new file mode 100644 index 00000000..a2f5e77c --- /dev/null +++ b/x/tokenfactory/types/query.pb.gw.go @@ -0,0 +1,355 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: palomachain/paloma/tokenfactory/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_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := server.Params(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_DenomAuthorityMetadata_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryDenomAuthorityMetadataRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["denom"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom") + } + + protoReq.Denom, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err) + } + + msg, err := client.DenomAuthorityMetadata(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_DenomAuthorityMetadata_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryDenomAuthorityMetadataRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["denom"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom") + } + + protoReq.Denom, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err) + } + + msg, err := server.DenomAuthorityMetadata(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_DenomsFromCreator_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryDenomsFromCreatorRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["creator"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "creator") + } + + protoReq.Creator, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "creator", err) + } + + msg, err := client.DenomsFromCreator(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_DenomsFromCreator_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryDenomsFromCreatorRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["creator"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "creator") + } + + protoReq.Creator, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "creator", err) + } + + msg, err := server.DenomsFromCreator(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_Params_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_Params_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_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_DenomAuthorityMetadata_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_DenomAuthorityMetadata_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_DenomAuthorityMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_DenomsFromCreator_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_DenomsFromCreator_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_DenomsFromCreator_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_Params_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_Params_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_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_DenomAuthorityMetadata_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_DenomAuthorityMetadata_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_DenomAuthorityMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_DenomsFromCreator_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_DenomsFromCreator_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_DenomsFromCreator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "tokenfactory", "params"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_DenomAuthorityMetadata_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"palomachain", "paloma", "tokenfactory", "denoms", "denom", "authority_metadata"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_DenomsFromCreator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"palomachain", "paloma", "tokenfactory", "denoms_from_creator", "creator"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_Params_0 = runtime.ForwardResponseMessage + + forward_Query_DenomAuthorityMetadata_0 = runtime.ForwardResponseMessage + + forward_Query_DenomsFromCreator_0 = runtime.ForwardResponseMessage +) diff --git a/x/tokenfactory/types/tx.pb.go b/x/tokenfactory/types/tx.pb.go new file mode 100644 index 00000000..e1492a1d --- /dev/null +++ b/x/tokenfactory/types/tx.pb.go @@ -0,0 +1,2253 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: palomachain/paloma/tokenfactory/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + types2 "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/cosmos-sdk/types/msgservice" + types1 "github.com/cosmos/cosmos-sdk/x/bank/types" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + types "github.com/palomachain/paloma/v2/x/valset/types" + 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 + +// MsgCreateDenom defines the message structure for the CreateDenom gRPC service +// method. It allows an account to create a new denom. It requires a sender +// address and a sub denomination. The (sender_address, sub_denomination) tuple +// must be unique and cannot be re-used. +// +// The resulting denom created is defined as +// . The resulting denom's admin is +// originally set to be the creator, but this can be changed later. The token +// denom does not indicate the current admin. +type MsgCreateDenom struct { + // subdenom can be up to 44 "alphanumeric" characters long. + Subdenom string `protobuf:"bytes,1,opt,name=subdenom,proto3" json:"subdenom,omitempty" yaml:"subdenom"` + Metadata types.MsgMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata" yaml:"metadata"` +} + +func (m *MsgCreateDenom) Reset() { *m = MsgCreateDenom{} } +func (m *MsgCreateDenom) String() string { return proto.CompactTextString(m) } +func (*MsgCreateDenom) ProtoMessage() {} +func (*MsgCreateDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{0} +} +func (m *MsgCreateDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCreateDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCreateDenom.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 *MsgCreateDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCreateDenom.Merge(m, src) +} +func (m *MsgCreateDenom) XXX_Size() int { + return m.Size() +} +func (m *MsgCreateDenom) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCreateDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCreateDenom proto.InternalMessageInfo + +func (m *MsgCreateDenom) GetSubdenom() string { + if m != nil { + return m.Subdenom + } + return "" +} + +func (m *MsgCreateDenom) GetMetadata() types.MsgMetadata { + if m != nil { + return m.Metadata + } + return types.MsgMetadata{} +} + +// MsgCreateDenomResponse is the return value of MsgCreateDenom +// It returns the full string of the newly created denom +type MsgCreateDenomResponse struct { + NewTokenDenom string `protobuf:"bytes,1,opt,name=new_token_denom,json=newTokenDenom,proto3" json:"new_token_denom,omitempty" yaml:"new_token_denom"` +} + +func (m *MsgCreateDenomResponse) Reset() { *m = MsgCreateDenomResponse{} } +func (m *MsgCreateDenomResponse) String() string { return proto.CompactTextString(m) } +func (*MsgCreateDenomResponse) ProtoMessage() {} +func (*MsgCreateDenomResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{1} +} +func (m *MsgCreateDenomResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCreateDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCreateDenomResponse.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 *MsgCreateDenomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCreateDenomResponse.Merge(m, src) +} +func (m *MsgCreateDenomResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgCreateDenomResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCreateDenomResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCreateDenomResponse proto.InternalMessageInfo + +func (m *MsgCreateDenomResponse) GetNewTokenDenom() string { + if m != nil { + return m.NewTokenDenom + } + return "" +} + +// MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set +// the denom's bank metadata +type MsgSetDenomMetadata struct { + DenomMetadata types1.Metadata `protobuf:"bytes,1,opt,name=denom_metadata,json=denomMetadata,proto3" json:"denom_metadata" yaml:"denom_metadata"` + Metadata types.MsgMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata" yaml:"metadata"` +} + +func (m *MsgSetDenomMetadata) Reset() { *m = MsgSetDenomMetadata{} } +func (m *MsgSetDenomMetadata) String() string { return proto.CompactTextString(m) } +func (*MsgSetDenomMetadata) ProtoMessage() {} +func (*MsgSetDenomMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{2} +} +func (m *MsgSetDenomMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSetDenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSetDenomMetadata.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 *MsgSetDenomMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSetDenomMetadata.Merge(m, src) +} +func (m *MsgSetDenomMetadata) XXX_Size() int { + return m.Size() +} +func (m *MsgSetDenomMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSetDenomMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSetDenomMetadata proto.InternalMessageInfo + +func (m *MsgSetDenomMetadata) GetDenomMetadata() types1.Metadata { + if m != nil { + return m.DenomMetadata + } + return types1.Metadata{} +} + +func (m *MsgSetDenomMetadata) GetMetadata() types.MsgMetadata { + if m != nil { + return m.Metadata + } + return types.MsgMetadata{} +} + +// MsgSetDenomMetadataResponse defines the response structure for an executed +// MsgSetDenomMetadata message. +type MsgSetDenomMetadataResponse struct { +} + +func (m *MsgSetDenomMetadataResponse) Reset() { *m = MsgSetDenomMetadataResponse{} } +func (m *MsgSetDenomMetadataResponse) String() string { return proto.CompactTextString(m) } +func (*MsgSetDenomMetadataResponse) ProtoMessage() {} +func (*MsgSetDenomMetadataResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{3} +} +func (m *MsgSetDenomMetadataResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSetDenomMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSetDenomMetadataResponse.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 *MsgSetDenomMetadataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSetDenomMetadataResponse.Merge(m, src) +} +func (m *MsgSetDenomMetadataResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgSetDenomMetadataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSetDenomMetadataResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSetDenomMetadataResponse proto.InternalMessageInfo + +// MsgMint is the sdk.Msg type for allowing an admin account to mint +// more of a token. For now, we only support minting to the sender account +type MsgMint struct { + Amount types2.Coin `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount" yaml:"amount"` + Metadata types.MsgMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata" yaml:"metadata"` +} + +func (m *MsgMint) Reset() { *m = MsgMint{} } +func (m *MsgMint) String() string { return proto.CompactTextString(m) } +func (*MsgMint) ProtoMessage() {} +func (*MsgMint) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{4} +} +func (m *MsgMint) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgMint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgMint.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 *MsgMint) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgMint.Merge(m, src) +} +func (m *MsgMint) XXX_Size() int { + return m.Size() +} +func (m *MsgMint) XXX_DiscardUnknown() { + xxx_messageInfo_MsgMint.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgMint proto.InternalMessageInfo + +func (m *MsgMint) GetAmount() types2.Coin { + if m != nil { + return m.Amount + } + return types2.Coin{} +} + +func (m *MsgMint) GetMetadata() types.MsgMetadata { + if m != nil { + return m.Metadata + } + return types.MsgMetadata{} +} + +type MsgMintResponse struct { +} + +func (m *MsgMintResponse) Reset() { *m = MsgMintResponse{} } +func (m *MsgMintResponse) String() string { return proto.CompactTextString(m) } +func (*MsgMintResponse) ProtoMessage() {} +func (*MsgMintResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{5} +} +func (m *MsgMintResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgMintResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgMintResponse.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 *MsgMintResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgMintResponse.Merge(m, src) +} +func (m *MsgMintResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgMintResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgMintResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgMintResponse proto.InternalMessageInfo + +// MsgBurn is the sdk.Msg type for allowing an admin account to burn +// a token. For now, we only support burning from the sender account. +type MsgBurn struct { + Amount types2.Coin `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount" yaml:"amount"` + Metadata types.MsgMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata" yaml:"metadata"` +} + +func (m *MsgBurn) Reset() { *m = MsgBurn{} } +func (m *MsgBurn) String() string { return proto.CompactTextString(m) } +func (*MsgBurn) ProtoMessage() {} +func (*MsgBurn) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{6} +} +func (m *MsgBurn) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgBurn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgBurn.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 *MsgBurn) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgBurn.Merge(m, src) +} +func (m *MsgBurn) XXX_Size() int { + return m.Size() +} +func (m *MsgBurn) XXX_DiscardUnknown() { + xxx_messageInfo_MsgBurn.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgBurn proto.InternalMessageInfo + +func (m *MsgBurn) GetAmount() types2.Coin { + if m != nil { + return m.Amount + } + return types2.Coin{} +} + +func (m *MsgBurn) GetMetadata() types.MsgMetadata { + if m != nil { + return m.Metadata + } + return types.MsgMetadata{} +} + +type MsgBurnResponse struct { +} + +func (m *MsgBurnResponse) Reset() { *m = MsgBurnResponse{} } +func (m *MsgBurnResponse) String() string { return proto.CompactTextString(m) } +func (*MsgBurnResponse) ProtoMessage() {} +func (*MsgBurnResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{7} +} +func (m *MsgBurnResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgBurnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgBurnResponse.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 *MsgBurnResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgBurnResponse.Merge(m, src) +} +func (m *MsgBurnResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgBurnResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgBurnResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgBurnResponse proto.InternalMessageInfo + +// MsgChangeAdmin is the sdk.Msg type for allowing an admin account to reassign +// adminship of a denom to a new account +type MsgChangeAdmin struct { + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"` + NewAdmin string `protobuf:"bytes,2,opt,name=new_admin,json=newAdmin,proto3" json:"new_admin,omitempty" yaml:"new_admin"` + Metadata types.MsgMetadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata" yaml:"metadata"` +} + +func (m *MsgChangeAdmin) Reset() { *m = MsgChangeAdmin{} } +func (m *MsgChangeAdmin) String() string { return proto.CompactTextString(m) } +func (*MsgChangeAdmin) ProtoMessage() {} +func (*MsgChangeAdmin) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{8} +} +func (m *MsgChangeAdmin) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgChangeAdmin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgChangeAdmin.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 *MsgChangeAdmin) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgChangeAdmin.Merge(m, src) +} +func (m *MsgChangeAdmin) XXX_Size() int { + return m.Size() +} +func (m *MsgChangeAdmin) XXX_DiscardUnknown() { + xxx_messageInfo_MsgChangeAdmin.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgChangeAdmin proto.InternalMessageInfo + +func (m *MsgChangeAdmin) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +func (m *MsgChangeAdmin) GetNewAdmin() string { + if m != nil { + return m.NewAdmin + } + return "" +} + +func (m *MsgChangeAdmin) GetMetadata() types.MsgMetadata { + if m != nil { + return m.Metadata + } + return types.MsgMetadata{} +} + +// MsgChangeAdminResponse defines the response structure for an executed +// MsgChangeAdmin message. +type MsgChangeAdminResponse struct { +} + +func (m *MsgChangeAdminResponse) Reset() { *m = MsgChangeAdminResponse{} } +func (m *MsgChangeAdminResponse) String() string { return proto.CompactTextString(m) } +func (*MsgChangeAdminResponse) ProtoMessage() {} +func (*MsgChangeAdminResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{9} +} +func (m *MsgChangeAdminResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgChangeAdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgChangeAdminResponse.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 *MsgChangeAdminResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgChangeAdminResponse.Merge(m, src) +} +func (m *MsgChangeAdminResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgChangeAdminResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgChangeAdminResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgChangeAdminResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgCreateDenom)(nil), "palomachain.paloma.tokenfactory.MsgCreateDenom") + proto.RegisterType((*MsgCreateDenomResponse)(nil), "palomachain.paloma.tokenfactory.MsgCreateDenomResponse") + proto.RegisterType((*MsgSetDenomMetadata)(nil), "palomachain.paloma.tokenfactory.MsgSetDenomMetadata") + proto.RegisterType((*MsgSetDenomMetadataResponse)(nil), "palomachain.paloma.tokenfactory.MsgSetDenomMetadataResponse") + proto.RegisterType((*MsgMint)(nil), "palomachain.paloma.tokenfactory.MsgMint") + proto.RegisterType((*MsgMintResponse)(nil), "palomachain.paloma.tokenfactory.MsgMintResponse") + proto.RegisterType((*MsgBurn)(nil), "palomachain.paloma.tokenfactory.MsgBurn") + proto.RegisterType((*MsgBurnResponse)(nil), "palomachain.paloma.tokenfactory.MsgBurnResponse") + proto.RegisterType((*MsgChangeAdmin)(nil), "palomachain.paloma.tokenfactory.MsgChangeAdmin") + proto.RegisterType((*MsgChangeAdminResponse)(nil), "palomachain.paloma.tokenfactory.MsgChangeAdminResponse") +} + +func init() { + proto.RegisterFile("palomachain/paloma/tokenfactory/tx.proto", fileDescriptor_a83d7259c91f1067) +} + +var fileDescriptor_a83d7259c91f1067 = []byte{ + // 648 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x3d, 0x6f, 0xd3, 0x4e, + 0x18, 0x8f, 0xff, 0xed, 0xbf, 0xb4, 0x57, 0xd2, 0x16, 0xf7, 0x15, 0xa3, 0xda, 0xd5, 0x0d, 0x55, + 0xc4, 0xe0, 0x23, 0x05, 0x84, 0x54, 0xb1, 0xe0, 0x32, 0xb0, 0x44, 0x48, 0x86, 0x09, 0x90, 0xaa, + 0xb3, 0x73, 0xb8, 0x51, 0xeb, 0xbb, 0x28, 0x77, 0x69, 0xda, 0x95, 0x81, 0x99, 0x2f, 0x82, 0xc4, + 0x37, 0x60, 0xed, 0xd8, 0x0d, 0xa6, 0x08, 0x25, 0x12, 0xec, 0xf9, 0x04, 0xe8, 0x5e, 0xe2, 0x38, + 0x69, 0x24, 0x0c, 0x12, 0x95, 0x98, 0x72, 0x97, 0xe7, 0xe5, 0xf7, 0xfc, 0x9e, 0xb7, 0x33, 0xa8, + 0x34, 0xf1, 0x09, 0x4b, 0x71, 0x7c, 0x84, 0x1b, 0x14, 0xe9, 0x33, 0x12, 0xec, 0x98, 0xd0, 0xb7, + 0x38, 0x16, 0xac, 0x75, 0x8e, 0xc4, 0x99, 0xdf, 0x6c, 0x31, 0xc1, 0x6c, 0x2f, 0xa7, 0xe9, 0xeb, + 0xb3, 0x9f, 0xd7, 0x74, 0xd6, 0x12, 0x96, 0x30, 0xa5, 0x8b, 0xe4, 0x49, 0x9b, 0x39, 0x6e, 0xcc, + 0x78, 0xca, 0x38, 0x8a, 0x30, 0x27, 0xe8, 0xb4, 0x1a, 0x11, 0x81, 0xab, 0x28, 0x66, 0xd2, 0xc7, + 0x84, 0x9c, 0x1e, 0x67, 0x72, 0x79, 0x31, 0xf2, 0x4d, 0x23, 0x4f, 0x79, 0x82, 0x4e, 0xab, 0xf2, + 0xc7, 0x08, 0x76, 0xa7, 0x44, 0x7e, 0x8a, 0x4f, 0x38, 0x11, 0x28, 0x66, 0x69, 0xca, 0x0c, 0x00, + 0xfc, 0x68, 0x81, 0xa5, 0x1a, 0x4f, 0x0e, 0x5a, 0x04, 0x0b, 0xf2, 0x94, 0x50, 0x96, 0xda, 0x08, + 0xcc, 0xf3, 0x76, 0x54, 0x97, 0xe7, 0x2d, 0x6b, 0xc7, 0xaa, 0x2c, 0x04, 0xab, 0x83, 0xae, 0xb7, + 0x7c, 0x8e, 0xd3, 0x93, 0x7d, 0x38, 0x94, 0xc0, 0x30, 0x53, 0xb2, 0x5f, 0x83, 0xf9, 0x94, 0x08, + 0x5c, 0xc7, 0x02, 0x6f, 0xfd, 0xb7, 0x63, 0x55, 0x16, 0xf7, 0x76, 0xfd, 0x29, 0xe9, 0xd0, 0xf0, + 0x7e, 0x8d, 0x27, 0x35, 0xa3, 0x1d, 0x6c, 0x5e, 0x74, 0xbd, 0xd2, 0xc8, 0xf9, 0xd0, 0x0b, 0x0c, + 0x33, 0x87, 0xfb, 0xe5, 0x77, 0x3f, 0x3e, 0xdd, 0xcd, 0xae, 0xf0, 0x0d, 0xd8, 0x18, 0x0f, 0x37, + 0x24, 0xbc, 0xc9, 0x28, 0x27, 0x76, 0x00, 0x96, 0x29, 0xe9, 0x1c, 0xaa, 0xa4, 0x1f, 0xe6, 0xa3, + 0x77, 0x06, 0x5d, 0x6f, 0x43, 0x03, 0x4c, 0x28, 0xc0, 0xb0, 0x4c, 0x49, 0xe7, 0xa5, 0xfc, 0x43, + 0xf9, 0x82, 0xdf, 0x2d, 0xb0, 0x5a, 0xe3, 0xc9, 0x0b, 0x22, 0xd4, 0x7d, 0x18, 0xa7, 0x1d, 0x83, + 0x25, 0x65, 0x70, 0x98, 0xf1, 0xb4, 0x14, 0xcf, 0x6d, 0x5f, 0xe7, 0xdf, 0x57, 0x25, 0x31, 0xf5, + 0xf1, 0x33, 0x7a, 0xdb, 0x86, 0xde, 0xba, 0x46, 0x1f, 0x77, 0x01, 0xc3, 0x72, 0x7d, 0x0c, 0xe4, + 0x3a, 0xd3, 0xb8, 0x0d, 0xee, 0x4c, 0xe1, 0x39, 0xcc, 0x25, 0xfc, 0x6c, 0x81, 0x1b, 0x12, 0xa0, + 0x41, 0x85, 0xfd, 0x0c, 0xcc, 0xe1, 0x94, 0xb5, 0xa9, 0x30, 0x9c, 0x6f, 0x8f, 0x38, 0x73, 0x92, + 0x71, 0x3e, 0x60, 0x0d, 0x1a, 0xac, 0x9b, 0x38, 0xca, 0x3a, 0x0e, 0x6d, 0x06, 0x43, 0x63, 0x7f, + 0xad, 0x04, 0x6f, 0x81, 0x65, 0x43, 0x60, 0x92, 0x54, 0xd0, 0x6e, 0xd1, 0x7f, 0x9a, 0x94, 0x24, + 0x90, 0x91, 0xfa, 0x62, 0xe6, 0xf7, 0x08, 0xd3, 0x84, 0x3c, 0xa9, 0xa7, 0x0d, 0x6a, 0xef, 0x82, + 0xff, 0xf3, 0xed, 0xbf, 0x32, 0xe8, 0x7a, 0x37, 0x73, 0x0d, 0x08, 0x43, 0x2d, 0xb6, 0xab, 0x60, + 0x41, 0xce, 0x03, 0x96, 0x46, 0x2a, 0xf4, 0x85, 0x60, 0x6d, 0xd0, 0xf5, 0x56, 0x46, 0xa3, 0xa2, + 0x44, 0x30, 0x9c, 0xa7, 0xa4, 0xa3, 0x5d, 0xe7, 0xc9, 0xce, 0xfc, 0x65, 0xb2, 0x5b, 0x7a, 0xd2, + 0x47, 0xc4, 0x86, 0x9c, 0xf7, 0x2e, 0x66, 0xc1, 0x4c, 0x8d, 0x27, 0x76, 0x07, 0x2c, 0x8e, 0xed, + 0x2d, 0xff, 0x17, 0x3b, 0xd8, 0x1f, 0xdf, 0x1c, 0xce, 0xa3, 0xdf, 0x34, 0xc8, 0x56, 0xcd, 0x7b, + 0x0b, 0xac, 0x5c, 0xd9, 0x11, 0x0f, 0x8a, 0x78, 0x9b, 0xb4, 0x72, 0x1e, 0xff, 0x89, 0x55, 0x16, + 0x48, 0x04, 0x66, 0xd5, 0x8c, 0x56, 0x8a, 0x78, 0x91, 0x9a, 0xce, 0xbd, 0xa2, 0x9a, 0x79, 0x0c, + 0x35, 0x32, 0x85, 0x30, 0xa4, 0x66, 0x31, 0x8c, 0x7c, 0x17, 0xab, 0x4a, 0xe6, 0x3a, 0xb8, 0x58, + 0x25, 0x47, 0x06, 0x05, 0x2b, 0x79, 0xb5, 0x95, 0x82, 0xe7, 0x17, 0x3d, 0xd7, 0xba, 0xec, 0xb9, + 0xd6, 0xb7, 0x9e, 0x6b, 0x7d, 0xe8, 0xbb, 0xa5, 0xcb, 0xbe, 0x5b, 0xfa, 0xda, 0x77, 0x4b, 0xaf, + 0x1e, 0x26, 0x0d, 0x71, 0xd4, 0x8e, 0xfc, 0x98, 0xa5, 0x68, 0xda, 0x5b, 0xba, 0x87, 0xce, 0x26, + 0x3e, 0x05, 0xce, 0x9b, 0x84, 0x47, 0x73, 0xea, 0x59, 0xbd, 0xff, 0x33, 0x00, 0x00, 0xff, 0xff, + 0x5b, 0xda, 0xcd, 0x46, 0x3a, 0x08, 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 { + CreateDenom(ctx context.Context, in *MsgCreateDenom, opts ...grpc.CallOption) (*MsgCreateDenomResponse, error) + SetDenomMetadata(ctx context.Context, in *MsgSetDenomMetadata, opts ...grpc.CallOption) (*MsgSetDenomMetadataResponse, error) + Mint(ctx context.Context, in *MsgMint, opts ...grpc.CallOption) (*MsgMintResponse, error) + Burn(ctx context.Context, in *MsgBurn, opts ...grpc.CallOption) (*MsgBurnResponse, error) + ChangeAdmin(ctx context.Context, in *MsgChangeAdmin, opts ...grpc.CallOption) (*MsgChangeAdminResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) CreateDenom(ctx context.Context, in *MsgCreateDenom, opts ...grpc.CallOption) (*MsgCreateDenomResponse, error) { + out := new(MsgCreateDenomResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Msg/CreateDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) SetDenomMetadata(ctx context.Context, in *MsgSetDenomMetadata, opts ...grpc.CallOption) (*MsgSetDenomMetadataResponse, error) { + out := new(MsgSetDenomMetadataResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Msg/SetDenomMetadata", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) Mint(ctx context.Context, in *MsgMint, opts ...grpc.CallOption) (*MsgMintResponse, error) { + out := new(MsgMintResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Msg/Mint", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) Burn(ctx context.Context, in *MsgBurn, opts ...grpc.CallOption) (*MsgBurnResponse, error) { + out := new(MsgBurnResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Msg/Burn", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) ChangeAdmin(ctx context.Context, in *MsgChangeAdmin, opts ...grpc.CallOption) (*MsgChangeAdminResponse, error) { + out := new(MsgChangeAdminResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Msg/ChangeAdmin", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + CreateDenom(context.Context, *MsgCreateDenom) (*MsgCreateDenomResponse, error) + SetDenomMetadata(context.Context, *MsgSetDenomMetadata) (*MsgSetDenomMetadataResponse, error) + Mint(context.Context, *MsgMint) (*MsgMintResponse, error) + Burn(context.Context, *MsgBurn) (*MsgBurnResponse, error) + ChangeAdmin(context.Context, *MsgChangeAdmin) (*MsgChangeAdminResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) CreateDenom(ctx context.Context, req *MsgCreateDenom) (*MsgCreateDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateDenom not implemented") +} +func (*UnimplementedMsgServer) SetDenomMetadata(ctx context.Context, req *MsgSetDenomMetadata) (*MsgSetDenomMetadataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetDenomMetadata not implemented") +} +func (*UnimplementedMsgServer) Mint(ctx context.Context, req *MsgMint) (*MsgMintResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Mint not implemented") +} +func (*UnimplementedMsgServer) Burn(ctx context.Context, req *MsgBurn) (*MsgBurnResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Burn not implemented") +} +func (*UnimplementedMsgServer) ChangeAdmin(ctx context.Context, req *MsgChangeAdmin) (*MsgChangeAdminResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ChangeAdmin not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_CreateDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCreateDenom) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CreateDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Msg/CreateDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CreateDenom(ctx, req.(*MsgCreateDenom)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_SetDenomMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSetDenomMetadata) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).SetDenomMetadata(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Msg/SetDenomMetadata", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).SetDenomMetadata(ctx, req.(*MsgSetDenomMetadata)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_Mint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMint) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).Mint(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Msg/Mint", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Mint(ctx, req.(*MsgMint)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_Burn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgBurn) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).Burn(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Msg/Burn", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Burn(ctx, req.(*MsgBurn)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_ChangeAdmin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgChangeAdmin) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).ChangeAdmin(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Msg/ChangeAdmin", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ChangeAdmin(ctx, req.(*MsgChangeAdmin)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "palomachain.paloma.tokenfactory.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateDenom", + Handler: _Msg_CreateDenom_Handler, + }, + { + MethodName: "SetDenomMetadata", + Handler: _Msg_SetDenomMetadata_Handler, + }, + { + MethodName: "Mint", + Handler: _Msg_Mint_Handler, + }, + { + MethodName: "Burn", + Handler: _Msg_Burn_Handler, + }, + { + MethodName: "ChangeAdmin", + Handler: _Msg_ChangeAdmin_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "palomachain/paloma/tokenfactory/tx.proto", +} + +func (m *MsgCreateDenom) 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 *MsgCreateDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCreateDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Subdenom) > 0 { + i -= len(m.Subdenom) + copy(dAtA[i:], m.Subdenom) + i = encodeVarintTx(dAtA, i, uint64(len(m.Subdenom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgCreateDenomResponse) 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 *MsgCreateDenomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCreateDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NewTokenDenom) > 0 { + i -= len(m.NewTokenDenom) + copy(dAtA[i:], m.NewTokenDenom) + i = encodeVarintTx(dAtA, i, uint64(len(m.NewTokenDenom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgSetDenomMetadata) 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 *MsgSetDenomMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSetDenomMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.DenomMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MsgSetDenomMetadataResponse) 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 *MsgSetDenomMetadataResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSetDenomMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgMint) 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 *MsgMint) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMint) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MsgMintResponse) 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 *MsgMintResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMintResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgBurn) 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 *MsgBurn) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgBurn) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MsgBurnResponse) 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 *MsgBurnResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgBurnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgChangeAdmin) 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 *MsgChangeAdmin) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgChangeAdmin) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.NewAdmin) > 0 { + i -= len(m.NewAdmin) + copy(dAtA[i:], m.NewAdmin) + i = encodeVarintTx(dAtA, i, uint64(len(m.NewAdmin))) + i-- + dAtA[i] = 0x12 + } + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintTx(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgChangeAdminResponse) 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 *MsgChangeAdminResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgChangeAdminResponse) 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 *MsgCreateDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Subdenom) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Metadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgCreateDenomResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NewTokenDenom) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgSetDenomMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.DenomMetadata.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.Metadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgSetDenomMetadataResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgMint) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.Metadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgMintResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgBurn) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.Metadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgBurnResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgChangeAdmin) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.NewAdmin) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Metadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgChangeAdminResponse) 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 *MsgCreateDenom) 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: MsgCreateDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Subdenom", 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.Subdenom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 + } + if err := m.Metadata.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 *MsgCreateDenomResponse) 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: MsgCreateDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewTokenDenom", 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.NewTokenDenom = string(dAtA[iNdEx:postIndex]) + 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 *MsgSetDenomMetadata) 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: MsgSetDenomMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSetDenomMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DenomMetadata", 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 + } + if err := m.DenomMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 + } + if err := m.Metadata.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 *MsgSetDenomMetadataResponse) 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: MsgSetDenomMetadataResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSetDenomMetadataResponse: 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 *MsgMint) 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: MsgMint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 + } + if err := m.Metadata.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 *MsgMintResponse) 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: MsgMintResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMintResponse: 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 *MsgBurn) 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: MsgBurn: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgBurn: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 + } + if err := m.Metadata.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 *MsgBurnResponse) 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: MsgBurnResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgBurnResponse: 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 *MsgChangeAdmin) 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: MsgChangeAdmin: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgChangeAdmin: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewAdmin", 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.NewAdmin = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 + } + if err := m.Metadata.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 *MsgChangeAdminResponse) 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: MsgChangeAdminResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgChangeAdminResponse: 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") +) From 2939ceef94a22f4b483f983f61178772d8819874 Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Thu, 12 Dec 2024 21:44:32 +0100 Subject: [PATCH 3/9] Add keeper implementation --- .../tokenfactory/authorityMetadata.proto | 8 +- .../palomachain/paloma/tokenfactory/tx.proto | 77 ++- x/tokenfactory/keeper/admins.go | 47 ++ x/tokenfactory/keeper/bank.go | 51 ++ x/tokenfactory/keeper/denom.go | 104 +++ x/tokenfactory/keeper/genesis.go | 56 ++ x/tokenfactory/keeper/grpc_query.go | 28 + x/tokenfactory/keeper/keeper.go | 95 +++ x/tokenfactory/keeper/msg_server.go | 174 +++++ x/tokenfactory/types/authorityMetadata.pb.go | 48 +- x/tokenfactory/types/codec.go | 2 +- x/tokenfactory/types/errors.go | 1 + x/tokenfactory/types/expected_keepers.go | 4 +- x/tokenfactory/types/mocks/AccountKeeper.go | 56 ++ x/tokenfactory/types/mocks/BankKeeper.go | 250 +++++++ .../types/mocks/CommunityPoolKeeper.go | 49 ++ x/tokenfactory/types/msgs.go | 24 + x/tokenfactory/types/msgs_test.go | 5 +- x/tokenfactory/types/tx.pb.go | 652 ++++++++++++++++-- x/tokenfactory/types/tx.pb.gw.go | 550 +++++++++++++++ 20 files changed, 2173 insertions(+), 108 deletions(-) create mode 100644 x/tokenfactory/keeper/admins.go create mode 100644 x/tokenfactory/keeper/bank.go create mode 100644 x/tokenfactory/keeper/denom.go create mode 100644 x/tokenfactory/keeper/genesis.go create mode 100644 x/tokenfactory/keeper/grpc_query.go create mode 100644 x/tokenfactory/keeper/keeper.go create mode 100644 x/tokenfactory/keeper/msg_server.go create mode 100644 x/tokenfactory/types/mocks/AccountKeeper.go create mode 100644 x/tokenfactory/types/mocks/BankKeeper.go create mode 100644 x/tokenfactory/types/mocks/CommunityPoolKeeper.go create mode 100644 x/tokenfactory/types/tx.pb.gw.go diff --git a/proto/palomachain/paloma/tokenfactory/authorityMetadata.proto b/proto/palomachain/paloma/tokenfactory/authorityMetadata.proto index 8849e6b0..85d54976 100644 --- a/proto/palomachain/paloma/tokenfactory/authorityMetadata.proto +++ b/proto/palomachain/paloma/tokenfactory/authorityMetadata.proto @@ -3,6 +3,7 @@ package palomachain.paloma.tokenfactory; import "gogoproto/gogo.proto"; import "cosmos/base/v1beta1/coin.proto"; +import "cosmos_proto/cosmos.proto"; option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; @@ -12,6 +13,9 @@ option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; message DenomAuthorityMetadata { option (gogoproto.equal) = true; - // Can be empty for no admin, or a valid osmosis address - string admin = 1 [ (gogoproto.moretags) = "yaml:\"admin\"" ]; + // Can be empty for no admin, or a valid paloma address + string admin = 1 [ + (gogoproto.moretags) = "yaml:\"admin\"", + (cosmos_proto.scalar) = "cosmos.AddressString" + ]; } diff --git a/proto/palomachain/paloma/tokenfactory/tx.proto b/proto/palomachain/paloma/tokenfactory/tx.proto index 60ab41cc..9a85cf63 100644 --- a/proto/palomachain/paloma/tokenfactory/tx.proto +++ b/proto/palomachain/paloma/tokenfactory/tx.proto @@ -1,28 +1,49 @@ syntax = "proto3"; package palomachain.paloma.tokenfactory; -import "gogoproto/gogo.proto"; +import "cosmos_proto/cosmos.proto"; import "cosmos/base/v1beta1/coin.proto"; import "cosmos/bank/v1beta1/bank.proto"; import "cosmos/msg/v1/msg.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "palomachain/paloma/tokenfactory/params.proto"; import "palomachain/paloma/valset/common.proto"; option go_package = "github.com/palomachain/paloma/v2/x/tokenfactory/types"; // Msg defines the tokefactory module's gRPC message service. service Msg { - rpc CreateDenom(MsgCreateDenom) returns (MsgCreateDenomResponse); - rpc SetDenomMetadata(MsgSetDenomMetadata) - returns (MsgSetDenomMetadataResponse); - - rpc Mint(MsgMint) returns (MsgMintResponse); - rpc Burn(MsgBurn) returns (MsgBurnResponse); - rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse); - - // ForceTransfer is deactivated for now because we need to think through edge - // cases rpc ForceTransfer(MsgForceTransfer) returns - // (MsgForceTransferResponse); + rpc CreateDenom(MsgCreateDenom) returns (MsgCreateDenomResponse){ + option (google.api.http).post = + "/palomachain/paloma/tokenfactory/denom"; + } + + rpc SetDenomMetadata(MsgSetDenomMetadata) returns (MsgSetDenomMetadataResponse){ + option (google.api.http).post = + "/palomachain/paloma/tokenfactory/denom-metadata"; + } + + rpc Mint(MsgMint) returns (MsgMintResponse){ + option (google.api.http).post = + "/palomachain/paloma/tokenfactory/mint"; + } + + rpc Burn(MsgBurn) returns (MsgBurnResponse){ + option (google.api.http).post = + "/palomachain/paloma/tokenfactory/burn"; + } + + rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse){ + option (google.api.http).put = + "/palomachain/paloma/tokenfactory/admin"; + } + + rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse) { + option (google.api.http).put = + "/palomachain/paloma/tokenfactory/params"; + } } // MsgCreateDenom defines the message structure for the CreateDenom gRPC service @@ -122,16 +143,22 @@ message MsgChangeAdmin { // MsgChangeAdmin message. message MsgChangeAdminResponse {} -// message MsgForceTransfer { -// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; -// cosmos.base.v1beta1.Coin amount = 2 [ -// (gogoproto.moretags) = "yaml:\"amount\"", -// (gogoproto.nullable) = false -// ]; -// string transferFromAddress = 3 -// [ (gogoproto.moretags) = "yaml:\"transfer_from_address\"" ]; -// string transferToAddress = 4 -// [ (gogoproto.moretags) = "yaml:\"transfer_to_address\"" ]; -// } - -// message MsgForceTransferResponse {} +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + + // params defines the x/tokenfactory parameters to update. + // + // NOTE: All parameters must be supplied. + Params params = 2 [ (gogoproto.nullable) = false ]; + + palomachain.paloma.valset.MsgMetadata metadata = 3 + [ (gogoproto.nullable) = false ]; +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +message MsgUpdateParamsResponse { +} diff --git a/x/tokenfactory/keeper/admins.go b/x/tokenfactory/keeper/admins.go new file mode 100644 index 00000000..b5379d04 --- /dev/null +++ b/x/tokenfactory/keeper/admins.go @@ -0,0 +1,47 @@ +package keeper + +import ( + "context" + + "github.com/gogo/protobuf/proto" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" +) + +func (k Keeper) GetAuthorityMetadata(ctx context.Context, denom string) (types.DenomAuthorityMetadata, error) { + bz := k.GetDenomPrefixStore(ctx, denom).Get([]byte(types.DenomAuthorityMetadataKey)) + + metadata := types.DenomAuthorityMetadata{} + err := proto.Unmarshal(bz, &metadata) + if err != nil { + return types.DenomAuthorityMetadata{}, err + } + return metadata, nil +} + +func (k Keeper) setAuthorityMetadata(ctx context.Context, denom string, metadata types.DenomAuthorityMetadata) error { + err := metadata.Validate() + if err != nil { + return err + } + + store := k.GetDenomPrefixStore(ctx, denom) + + bz, err := proto.Marshal(&metadata) + if err != nil { + return err + } + + store.Set([]byte(types.DenomAuthorityMetadataKey), bz) + return nil +} + +func (k Keeper) setAdmin(ctx context.Context, denom string, admin string) error { + metadata, err := k.GetAuthorityMetadata(ctx, denom) + if err != nil { + return err + } + + metadata.Admin = admin + + return k.setAuthorityMetadata(ctx, denom, metadata) +} diff --git a/x/tokenfactory/keeper/bank.go b/x/tokenfactory/keeper/bank.go new file mode 100644 index 00000000..6effe7ff --- /dev/null +++ b/x/tokenfactory/keeper/bank.go @@ -0,0 +1,51 @@ +package keeper + +import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" +) + +func (k Keeper) mintTo(ctx context.Context, amount sdk.Coin, mintTo string) error { + _, _, err := types.DeconstructDenom(amount.Denom) + if err != nil { + return err + } + + err = k.bankKeeper.MintCoins(ctx, types.ModuleName, sdk.NewCoins(amount)) + if err != nil { + return err + } + + addr, err := sdk.AccAddressFromBech32(mintTo) + if err != nil { + return err + } + + return k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, + addr, + sdk.NewCoins(amount)) +} + +func (k Keeper) burnFrom(ctx context.Context, amount sdk.Coin, burnFrom string) error { + _, _, err := types.DeconstructDenom(amount.Denom) + if err != nil { + return err + } + + addr, err := sdk.AccAddressFromBech32(burnFrom) + if err != nil { + return err + } + + err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, + addr, + types.ModuleName, + sdk.NewCoins(amount)) + if err != nil { + return err + } + + return k.bankKeeper.BurnCoins(ctx, types.ModuleName, sdk.NewCoins(amount)) +} diff --git a/x/tokenfactory/keeper/denom.go b/x/tokenfactory/keeper/denom.go new file mode 100644 index 00000000..3ab70051 --- /dev/null +++ b/x/tokenfactory/keeper/denom.go @@ -0,0 +1,104 @@ +package keeper + +import ( + "context" + "fmt" + + storetypes "cosmossdk.io/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" +) + +func (k Keeper) CreateDenom(ctx context.Context, creatorAddr string, subdenom string) (newTokenDenom string, err error) { + denom, err := k.validateCreateDenom(ctx, creatorAddr, subdenom) + if err != nil { + return "", err + } + + err = k.chargeForCreateDenom(ctx, creatorAddr, subdenom) + if err != nil { + return "", err + } + + err = k.createDenomAfterValidation(ctx, creatorAddr, denom) + return denom, err +} + +func (k Keeper) createDenomAfterValidation(ctx context.Context, creatorAddr string, denom string) (err error) { + denomMetaData := banktypes.Metadata{ + DenomUnits: []*banktypes.DenomUnit{{ + Denom: denom, + Exponent: 0, + }}, + Base: denom, + } + + k.bankKeeper.SetDenomMetaData(ctx, denomMetaData) + + authorityMetadata := types.DenomAuthorityMetadata{ + Admin: creatorAddr, + } + err = k.setAuthorityMetadata(ctx, denom, authorityMetadata) + if err != nil { + return err + } + + k.addDenomFromCreator(ctx, creatorAddr, denom) + return nil +} + +func (k Keeper) validateCreateDenom(ctx context.Context, creatorAddr string, subdenom string) (newTokenDenom string, err error) { + if k.bankKeeper.HasSupply(ctx, subdenom) { + return "", fmt.Errorf("temporary error until IBC bug is sorted out, " + + "can't create subdenoms that are the same as a native denom") + } + + denom, err := types.GetTokenDenom(creatorAddr, subdenom) + if err != nil { + return "", err + } + + _, found := k.bankKeeper.GetDenomMetaData(ctx, denom) + if found { + return "", types.ErrDenomExists + } + + return denom, nil +} + +func (k Keeper) chargeForCreateDenom(ctx context.Context, creatorAddr string, subdenom string) (err error) { + creationFee := k.GetParams(ctx).DenomCreationFee + accAddr, err := sdk.AccAddressFromBech32(creatorAddr) + if err != nil { + return err + } + if creationFee != nil { + if err := k.communityPoolKeeper.FundCommunityPool(ctx, creationFee, accAddr); err != nil { + return err + } + } + return nil +} + +func (k Keeper) addDenomFromCreator(ctx context.Context, creator, denom string) { + store := k.GetCreatorPrefixStore(ctx, creator) + store.Set([]byte(denom), []byte(denom)) +} + +func (k Keeper) GetDenomsFromCreator(ctx context.Context, creator string) []string { + store := k.GetCreatorPrefixStore(ctx, creator) + + iterator := store.Iterator(nil, nil) + defer iterator.Close() + + denoms := []string{} + for ; iterator.Valid(); iterator.Next() { + denoms = append(denoms, string(iterator.Key())) + } + return denoms +} + +func (k Keeper) GetAllDenomsIterator(ctx context.Context) storetypes.Iterator { + return k.GetCreatorsPrefixStore(ctx).Iterator(nil, nil) +} diff --git a/x/tokenfactory/keeper/genesis.go b/x/tokenfactory/keeper/genesis.go new file mode 100644 index 00000000..9cb29ae5 --- /dev/null +++ b/x/tokenfactory/keeper/genesis.go @@ -0,0 +1,56 @@ +package keeper + +import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" +) + +func (k Keeper) InitGenesis(ctx context.Context, genState types.GenesisState) { + k.CreateModuleAccount(ctx) + + if genState.Params.DenomCreationFee == nil { + genState.Params.DenomCreationFee = sdk.NewCoins() + } + k.SetParams(ctx, genState.Params) + + for _, genDenom := range genState.GetFactoryDenoms() { + creator, _, err := types.DeconstructDenom(genDenom.GetDenom()) + if err != nil { + panic(err) + } + err = k.createDenomAfterValidation(ctx, creator, genDenom.GetDenom()) + if err != nil { + panic(err) + } + err = k.setAuthorityMetadata(ctx, genDenom.GetDenom(), genDenom.GetAuthorityMetadata()) + if err != nil { + panic(err) + } + } +} + +func (k Keeper) ExportGenesis(ctx context.Context) *types.GenesisState { + genDenoms := []types.GenesisDenom{} + iterator := k.GetAllDenomsIterator(ctx) + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + denom := string(iterator.Value()) + + authorityMetadata, err := k.GetAuthorityMetadata(ctx, denom) + if err != nil { + panic(err) + } + + genDenoms = append(genDenoms, types.GenesisDenom{ + Denom: denom, + AuthorityMetadata: authorityMetadata, + }) + } + + return &types.GenesisState{ + FactoryDenoms: genDenoms, + Params: k.GetParams(ctx), + } +} diff --git a/x/tokenfactory/keeper/grpc_query.go b/x/tokenfactory/keeper/grpc_query.go new file mode 100644 index 00000000..f03e1c2d --- /dev/null +++ b/x/tokenfactory/keeper/grpc_query.go @@ -0,0 +1,28 @@ +package keeper + +import ( + "context" + + "github.com/palomachain/paloma/v2/x/tokenfactory/types" +) + +var _ types.QueryServer = Keeper{} + +func (k Keeper) Params(ctx context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) { + params := k.GetParams(ctx) + return &types.QueryParamsResponse{Params: params}, nil +} + +func (k Keeper) DenomAuthorityMetadata(ctx context.Context, req *types.QueryDenomAuthorityMetadataRequest) (*types.QueryDenomAuthorityMetadataResponse, error) { + authorityMetadata, err := k.GetAuthorityMetadata(ctx, req.GetDenom()) + if err != nil { + return nil, err + } + + return &types.QueryDenomAuthorityMetadataResponse{AuthorityMetadata: authorityMetadata}, nil +} + +func (k Keeper) DenomsFromCreator(ctx context.Context, req *types.QueryDenomsFromCreatorRequest) (*types.QueryDenomsFromCreatorResponse, error) { + denoms := k.GetDenomsFromCreator(ctx, req.GetCreator()) + return &types.QueryDenomsFromCreatorResponse{Denoms: denoms}, nil +} diff --git a/x/tokenfactory/keeper/keeper.go b/x/tokenfactory/keeper/keeper.go new file mode 100644 index 00000000..46ef6ebb --- /dev/null +++ b/x/tokenfactory/keeper/keeper.go @@ -0,0 +1,95 @@ +package keeper + +import ( + "context" + "fmt" + + "cosmossdk.io/log" + "cosmossdk.io/store/prefix" + storetypes "cosmossdk.io/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" + "github.com/palomachain/paloma/v2/util/liblog" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" +) + +type ( + Keeper struct { + storeKey storetypes.StoreKey + + paramSpace paramtypes.Subspace + + accountKeeper types.AccountKeeper + bankKeeper types.BankKeeper + communityPoolKeeper types.CommunityPoolKeeper + + authority string + } +) + +func NewKeeper( + storeKey storetypes.StoreKey, + paramSpace paramtypes.Subspace, + accountKeeper types.AccountKeeper, + bankKeeper types.BankKeeper, + communityPoolKeeper types.CommunityPoolKeeper, + authority string, +) Keeper { + if !paramSpace.HasKeyTable() { + paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable()) + } + + return Keeper{ + storeKey: storeKey, + paramSpace: paramSpace, + + accountKeeper: accountKeeper, + bankKeeper: bankKeeper, + communityPoolKeeper: communityPoolKeeper, + authority: authority, + } +} + +func (k Keeper) Logger(ctx context.Context) log.Logger { + sdkCtx := sdk.UnwrapSDKContext(ctx) + return liblog.FromSDKLogger(sdkCtx.Logger()).With("module", fmt.Sprintf("x/%s", types.ModuleName)) +} + +func (k Keeper) GetDenomPrefixStore(ctx context.Context, denom string) storetypes.KVStore { + sdkCtx := sdk.UnwrapSDKContext(ctx) + store := sdkCtx.KVStore(k.storeKey) + return prefix.NewStore(store, types.GetDenomPrefixStore(denom)) +} + +func (k Keeper) GetCreatorPrefixStore(ctx context.Context, creator string) storetypes.KVStore { + sdkCtx := sdk.UnwrapSDKContext(ctx) + store := sdkCtx.KVStore(k.storeKey) + return prefix.NewStore(store, types.GetCreatorPrefix(creator)) +} + +func (k Keeper) GetCreatorsPrefixStore(ctx context.Context) storetypes.KVStore { + sdkCtx := sdk.UnwrapSDKContext(ctx) + store := sdkCtx.KVStore(k.storeKey) + return prefix.NewStore(store, types.GetCreatorsPrefix()) +} + +// CreateModuleAccount creates a module account with minting and burning capabilities +// This account isn't intended to store any coins, +// it purely mints and burns them on behalf of the admin of respective denoms, +// and sends to the relevant address. +func (k Keeper) CreateModuleAccount(ctx context.Context) { + moduleAcc := authtypes.NewEmptyModuleAccount(types.ModuleName, authtypes.Minter, authtypes.Burner) + k.accountKeeper.SetModuleAccount(ctx, moduleAcc) +} + +func (k Keeper) GetParams(ctx context.Context) (params types.Params) { + sdkCtx := sdk.UnwrapSDKContext(ctx) + k.paramSpace.GetParamSet(sdkCtx, ¶ms) + return params +} + +func (k Keeper) SetParams(ctx context.Context, params types.Params) { + sdkCtx := sdk.UnwrapSDKContext(ctx) + k.paramSpace.SetParamSet(sdkCtx, ¶ms) +} diff --git a/x/tokenfactory/keeper/msg_server.go b/x/tokenfactory/keeper/msg_server.go new file mode 100644 index 00000000..5a516846 --- /dev/null +++ b/x/tokenfactory/keeper/msg_server.go @@ -0,0 +1,174 @@ +package keeper + +import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" +) + +type msgServer struct { + Keeper +} + +func NewMsgServerImpl(keeper Keeper) types.MsgServer { + return &msgServer{Keeper: keeper} +} + +var _ types.MsgServer = msgServer{} + +func (server msgServer) CreateDenom(ctx context.Context, msg *types.MsgCreateDenom) (*types.MsgCreateDenomResponse, error) { + denom, err := server.Keeper.CreateDenom(ctx, msg.Metadata.Creator, msg.Subdenom) + if err != nil { + return nil, err + } + + sdkCtx := sdk.UnwrapSDKContext(ctx) + sdkCtx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + types.TypeMsgCreateDenom, + sdk.NewAttribute(types.AttributeCreator, msg.Metadata.Creator), + sdk.NewAttribute(types.AttributeNewTokenDenom, denom), + ), + }) + + return &types.MsgCreateDenomResponse{ + NewTokenDenom: denom, + }, nil +} + +func (server msgServer) Mint(ctx context.Context, msg *types.MsgMint) (*types.MsgMintResponse, error) { + _, denomExists := server.bankKeeper.GetDenomMetaData(ctx, msg.Amount.Denom) + if !denomExists { + return nil, types.ErrDenomDoesNotExist.Wrapf("denom: %s", msg.Amount.Denom) + } + + authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.Amount.GetDenom()) + if err != nil { + return nil, err + } + + if msg.Metadata.Creator != authorityMetadata.GetAdmin() { + return nil, types.ErrUnauthorized + } + + err = server.Keeper.mintTo(ctx, msg.Amount, msg.Metadata.Creator) + if err != nil { + return nil, err + } + + sdkCtx := sdk.UnwrapSDKContext(ctx) + sdkCtx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + types.TypeMsgMint, + sdk.NewAttribute(types.AttributeMintToAddress, msg.Metadata.Creator), + sdk.NewAttribute(types.AttributeAmount, msg.Amount.String()), + ), + }) + + return &types.MsgMintResponse{}, nil +} + +func (server msgServer) Burn(ctx context.Context, msg *types.MsgBurn) (*types.MsgBurnResponse, error) { + authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.Amount.GetDenom()) + if err != nil { + return nil, err + } + + if msg.Metadata.Creator != authorityMetadata.GetAdmin() { + return nil, types.ErrUnauthorized + } + + err = server.Keeper.burnFrom(ctx, msg.Amount, msg.Metadata.Creator) + if err != nil { + return nil, err + } + + sdkCtx := sdk.UnwrapSDKContext(ctx) + sdkCtx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + types.TypeMsgBurn, + sdk.NewAttribute(types.AttributeBurnFromAddress, msg.Metadata.Creator), + sdk.NewAttribute(types.AttributeAmount, msg.Amount.String()), + ), + }) + + return &types.MsgBurnResponse{}, nil +} + +func (server msgServer) ChangeAdmin(ctx context.Context, msg *types.MsgChangeAdmin) (*types.MsgChangeAdminResponse, error) { + authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.Denom) + if err != nil { + return nil, err + } + + if msg.Metadata.Creator != authorityMetadata.GetAdmin() { + return nil, types.ErrUnauthorized + } + + err = server.Keeper.setAdmin(ctx, msg.Denom, msg.NewAdmin) + if err != nil { + return nil, err + } + + sdkCtx := sdk.UnwrapSDKContext(ctx) + sdkCtx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + types.TypeMsgChangeAdmin, + sdk.NewAttribute(types.AttributeDenom, msg.GetDenom()), + sdk.NewAttribute(types.AttributeNewAdmin, msg.NewAdmin), + ), + }) + + return &types.MsgChangeAdminResponse{}, nil +} + +func (server msgServer) SetDenomMetadata(ctx context.Context, msg *types.MsgSetDenomMetadata) (*types.MsgSetDenomMetadataResponse, error) { + err := msg.DenomMetadata.Validate() + if err != nil { + return nil, err + } + + authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.DenomMetadata.Base) + if err != nil { + return nil, err + } + + if msg.Metadata.Creator != authorityMetadata.GetAdmin() { + return nil, types.ErrUnauthorized + } + + server.Keeper.bankKeeper.SetDenomMetaData(ctx, msg.DenomMetadata) + + sdkCtx := sdk.UnwrapSDKContext(ctx) + sdkCtx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + types.TypeMsgSetDenomMetadata, + sdk.NewAttribute(types.AttributeDenom, msg.DenomMetadata.Base), + sdk.NewAttribute(types.AttributeDenomMetadata, msg.Metadata.String()), + ), + }) + + return &types.MsgSetDenomMetadataResponse{}, nil +} + +func (server msgServer) UpdateParams(ctx context.Context, msg *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { + if err := msg.ValidateBasic(); err != nil { + return nil, err + } + + if err := msg.Params.Validate(); err != nil { + return nil, types.ErrInvalidParams + } + + if msg.Authority != msg.Metadata.Creator { + return nil, types.ErrUnauthorized.Wrapf("authority mismatch: %s", msg.Authority) + } + + if msg.Authority != server.authority { + return nil, types.ErrUnauthorized.Wrapf("unexpected authority: %s", msg.Authority) + } + + server.SetParams(ctx, msg.Params) + return &types.MsgUpdateParamsResponse{}, nil +} diff --git a/x/tokenfactory/types/authorityMetadata.pb.go b/x/tokenfactory/types/authorityMetadata.pb.go index 335b5fce..8e321a3d 100644 --- a/x/tokenfactory/types/authorityMetadata.pb.go +++ b/x/tokenfactory/types/authorityMetadata.pb.go @@ -5,18 +5,22 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -28,7 +32,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // capabilities over a token factory denom. Right now there is only one Admin // permission, but is planned to be extended to the future. type DenomAuthorityMetadata struct { - // Can be empty for no admin, or a valid osmosis address + // Can be empty for no admin, or a valid paloma address Admin string `protobuf:"bytes,1,opt,name=admin,proto3" json:"admin,omitempty" yaml:"admin"` } @@ -38,9 +42,11 @@ func (*DenomAuthorityMetadata) ProtoMessage() {} func (*DenomAuthorityMetadata) Descriptor() ([]byte, []int) { return fileDescriptor_0e118f93d35eb685, []int{0} } + func (m *DenomAuthorityMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *DenomAuthorityMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DenomAuthorityMetadata.Marshal(b, m, deterministic) @@ -53,12 +59,15 @@ func (m *DenomAuthorityMetadata) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *DenomAuthorityMetadata) XXX_Merge(src proto.Message) { xxx_messageInfo_DenomAuthorityMetadata.Merge(m, src) } + func (m *DenomAuthorityMetadata) XXX_Size() int { return m.Size() } + func (m *DenomAuthorityMetadata) XXX_DiscardUnknown() { xxx_messageInfo_DenomAuthorityMetadata.DiscardUnknown(m) } @@ -81,7 +90,7 @@ func init() { } var fileDescriptor_0e118f93d35eb685 = []byte{ - // 239 bytes of a gzipped FileDescriptorProto + // 268 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2f, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x4b, 0xf2, 0xb3, 0x53, 0xf3, 0xd2, 0x12, 0x93, 0x4b, 0xf2, 0x8b, 0x2a, 0xf5, 0x13, 0x4b, 0x4b, 0x32, 0xf2, 0x8b, 0x32, 0x4b, @@ -89,14 +98,16 @@ var fileDescriptor_0e118f93d35eb685 = []byte{ 0xe4, 0x91, 0x34, 0xea, 0x41, 0xd8, 0x7a, 0xc8, 0x1a, 0xa5, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x6a, 0xf5, 0x41, 0x2c, 0x88, 0x36, 0x29, 0xb9, 0xe4, 0xfc, 0xe2, 0xdc, 0xfc, 0x62, 0xfd, 0xa4, 0xc4, 0xe2, 0x54, 0xfd, 0x32, 0xc3, 0xa4, 0xd4, 0x92, 0x44, 0x43, 0xfd, 0xe4, 0x7c, 0x90, 0x19, - 0x20, 0x79, 0x25, 0x37, 0x2e, 0x31, 0x97, 0xd4, 0xbc, 0xfc, 0x5c, 0x47, 0x74, 0x6b, 0x85, 0xd4, - 0xb8, 0x58, 0x13, 0x53, 0x72, 0x33, 0xf3, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x9d, 0x04, 0x3e, - 0xdd, 0x93, 0xe7, 0xa9, 0x4c, 0xcc, 0xcd, 0xb1, 0x52, 0x02, 0x0b, 0x2b, 0x05, 0x41, 0xa4, 0xad, - 0x58, 0x5e, 0x2c, 0x90, 0x67, 0x74, 0xf2, 0x3f, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, - 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, - 0x86, 0x28, 0xd3, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x2c, 0x9e, - 0x2f, 0x33, 0xd2, 0xaf, 0x40, 0x0d, 0x81, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0xfb, - 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x56, 0x0f, 0xe7, 0xf2, 0x31, 0x01, 0x00, 0x00, + 0x60, 0x79, 0x49, 0x88, 0x7c, 0x3c, 0x44, 0x23, 0x84, 0x03, 0x91, 0x52, 0x8a, 0xe3, 0x12, 0x73, + 0x49, 0xcd, 0xcb, 0xcf, 0x75, 0x44, 0x77, 0x91, 0x90, 0x1d, 0x17, 0x6b, 0x62, 0x4a, 0x6e, 0x66, + 0x9e, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xa7, 0x93, 0xc6, 0xa7, 0x7b, 0xf2, 0x3c, 0x95, 0x89, 0xb9, + 0x39, 0x56, 0x4a, 0x60, 0x61, 0xa5, 0x4b, 0x5b, 0x74, 0x45, 0xa0, 0x46, 0x39, 0xa6, 0xa4, 0x14, + 0xa5, 0x16, 0x17, 0x07, 0x97, 0x14, 0x65, 0xe6, 0xa5, 0x07, 0x41, 0xb4, 0x59, 0xb1, 0xbc, 0x58, + 0x20, 0xcf, 0xe8, 0xe4, 0x7f, 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, 0xa6, + 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x58, 0xc2, 0xab, 0xcc, 0x48, + 0xbf, 0x02, 0x35, 0xd0, 0x4a, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0xee, 0x36, 0x06, 0x04, + 0x00, 0x00, 0xff, 0xff, 0x68, 0xab, 0x20, 0x83, 0x64, 0x01, 0x00, 0x00, } func (this *DenomAuthorityMetadata) Equal(that interface{}) bool { @@ -123,6 +134,7 @@ func (this *DenomAuthorityMetadata) Equal(that interface{}) bool { } return true } + func (m *DenomAuthorityMetadata) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -164,6 +176,7 @@ func encodeVarintAuthorityMetadata(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *DenomAuthorityMetadata) Size() (n int) { if m == nil { return 0 @@ -180,9 +193,11 @@ func (m *DenomAuthorityMetadata) Size() (n int) { func sovAuthorityMetadata(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozAuthorityMetadata(x uint64) (n int) { return sovAuthorityMetadata(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *DenomAuthorityMetadata) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -265,6 +280,7 @@ func (m *DenomAuthorityMetadata) Unmarshal(dAtA []byte) error { } return nil } + func skipAuthorityMetadata(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/tokenfactory/types/codec.go b/x/tokenfactory/types/codec.go index c735a68c..d8acb280 100644 --- a/x/tokenfactory/types/codec.go +++ b/x/tokenfactory/types/codec.go @@ -27,6 +27,6 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { } var ( - amino = codec.NewLegacyAmino() + Amino = codec.NewLegacyAmino() ModuleCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry()) ) diff --git a/x/tokenfactory/types/errors.go b/x/tokenfactory/types/errors.go index 5f76a78e..f7ed8659 100644 --- a/x/tokenfactory/types/errors.go +++ b/x/tokenfactory/types/errors.go @@ -19,4 +19,5 @@ var ( ErrSubdenomTooLong = sdkerrors.Register(ModuleName, 8, fmt.Sprintf("subdenom too long, max length is %d bytes", MaxSubdenomLength)) ErrCreatorTooLong = sdkerrors.Register(ModuleName, 9, fmt.Sprintf("creator too long, max length is %d bytes", MaxCreatorLength)) ErrDenomDoesNotExist = sdkerrors.Register(ModuleName, 10, "denom does not exist") + ErrInvalidParams = sdkerrors.Register(ModuleName, 11, "invalid params") ) diff --git a/x/tokenfactory/types/expected_keepers.go b/x/tokenfactory/types/expected_keepers.go index b8543169..444f44ee 100644 --- a/x/tokenfactory/types/expected_keepers.go +++ b/x/tokenfactory/types/expected_keepers.go @@ -8,6 +8,7 @@ import ( banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" ) +//go:generate mockery --name=BankKeeper type BankKeeper interface { // Methods imported from bank should be defined here GetDenomMetaData(ctx context.Context, denom string) (banktypes.Metadata, bool) @@ -27,12 +28,13 @@ type BankKeeper interface { GetBalance(ctx context.Context, addr sdk.AccAddress, denom string) sdk.Coin } +//go:generate mockery --name=AccountKeeper type AccountKeeper interface { SetModuleAccount(ctx context.Context, macc sdktypes.ModuleAccountI) GetAccount(ctx context.Context, addr sdk.AccAddress) sdktypes.AccountI } -// CommunityPoolKeeper defines the contract needed to be fulfilled for community pool interactions. +//go:generate mockery --name=CommunityPoolKeeper type CommunityPoolKeeper interface { FundCommunityPool(ctx context.Context, amount sdk.Coins, sender sdk.AccAddress) error } diff --git a/x/tokenfactory/types/mocks/AccountKeeper.go b/x/tokenfactory/types/mocks/AccountKeeper.go new file mode 100644 index 00000000..ace60532 --- /dev/null +++ b/x/tokenfactory/types/mocks/AccountKeeper.go @@ -0,0 +1,56 @@ +// Code generated by mockery v2.43.2. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + types "github.com/cosmos/cosmos-sdk/types" +) + +// AccountKeeper is an autogenerated mock type for the AccountKeeper type +type AccountKeeper struct { + mock.Mock +} + +// GetAccount provides a mock function with given fields: ctx, addr +func (_m *AccountKeeper) GetAccount(ctx context.Context, addr types.AccAddress) types.AccountI { + ret := _m.Called(ctx, addr) + + if len(ret) == 0 { + panic("no return value specified for GetAccount") + } + + var r0 types.AccountI + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress) types.AccountI); ok { + r0 = rf(ctx, addr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(types.AccountI) + } + } + + return r0 +} + +// SetModuleAccount provides a mock function with given fields: ctx, macc +func (_m *AccountKeeper) SetModuleAccount(ctx context.Context, macc types.ModuleAccountI) { + _m.Called(ctx, macc) +} + +// NewAccountKeeper creates a new instance of AccountKeeper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAccountKeeper(t interface { + mock.TestingT + Cleanup(func()) +}, +) *AccountKeeper { + mock := &AccountKeeper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/x/tokenfactory/types/mocks/BankKeeper.go b/x/tokenfactory/types/mocks/BankKeeper.go new file mode 100644 index 00000000..9a3802f1 --- /dev/null +++ b/x/tokenfactory/types/mocks/BankKeeper.go @@ -0,0 +1,250 @@ +// Code generated by mockery v2.43.2. DO NOT EDIT. + +package mocks + +import ( + context "context" + + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + + mock "github.com/stretchr/testify/mock" + + types "github.com/cosmos/cosmos-sdk/types" +) + +// BankKeeper is an autogenerated mock type for the BankKeeper type +type BankKeeper struct { + mock.Mock +} + +// BurnCoins provides a mock function with given fields: ctx, moduleName, amt +func (_m *BankKeeper) BurnCoins(ctx context.Context, moduleName string, amt types.Coins) error { + ret := _m.Called(ctx, moduleName, amt) + + if len(ret) == 0 { + panic("no return value specified for BurnCoins") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.Coins) error); ok { + r0 = rf(ctx, moduleName, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// GetAllBalances provides a mock function with given fields: ctx, addr +func (_m *BankKeeper) GetAllBalances(ctx context.Context, addr types.AccAddress) types.Coins { + ret := _m.Called(ctx, addr) + + if len(ret) == 0 { + panic("no return value specified for GetAllBalances") + } + + var r0 types.Coins + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress) types.Coins); ok { + r0 = rf(ctx, addr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(types.Coins) + } + } + + return r0 +} + +// GetBalance provides a mock function with given fields: ctx, addr, denom +func (_m *BankKeeper) GetBalance(ctx context.Context, addr types.AccAddress, denom string) types.Coin { + ret := _m.Called(ctx, addr, denom) + + if len(ret) == 0 { + panic("no return value specified for GetBalance") + } + + var r0 types.Coin + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, string) types.Coin); ok { + r0 = rf(ctx, addr, denom) + } else { + r0 = ret.Get(0).(types.Coin) + } + + return r0 +} + +// GetDenomMetaData provides a mock function with given fields: ctx, denom +func (_m *BankKeeper) GetDenomMetaData(ctx context.Context, denom string) (banktypes.Metadata, bool) { + ret := _m.Called(ctx, denom) + + if len(ret) == 0 { + panic("no return value specified for GetDenomMetaData") + } + + var r0 banktypes.Metadata + var r1 bool + if rf, ok := ret.Get(0).(func(context.Context, string) (banktypes.Metadata, bool)); ok { + return rf(ctx, denom) + } + if rf, ok := ret.Get(0).(func(context.Context, string) banktypes.Metadata); ok { + r0 = rf(ctx, denom) + } else { + r0 = ret.Get(0).(banktypes.Metadata) + } + + if rf, ok := ret.Get(1).(func(context.Context, string) bool); ok { + r1 = rf(ctx, denom) + } else { + r1 = ret.Get(1).(bool) + } + + return r0, r1 +} + +// HasBalance provides a mock function with given fields: ctx, addr, amt +func (_m *BankKeeper) HasBalance(ctx context.Context, addr types.AccAddress, amt types.Coin) bool { + ret := _m.Called(ctx, addr, amt) + + if len(ret) == 0 { + panic("no return value specified for HasBalance") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, types.Coin) bool); ok { + r0 = rf(ctx, addr, amt) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// HasSupply provides a mock function with given fields: ctx, denom +func (_m *BankKeeper) HasSupply(ctx context.Context, denom string) bool { + ret := _m.Called(ctx, denom) + + if len(ret) == 0 { + panic("no return value specified for HasSupply") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(context.Context, string) bool); ok { + r0 = rf(ctx, denom) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MintCoins provides a mock function with given fields: ctx, moduleName, amt +func (_m *BankKeeper) MintCoins(ctx context.Context, moduleName string, amt types.Coins) error { + ret := _m.Called(ctx, moduleName, amt) + + if len(ret) == 0 { + panic("no return value specified for MintCoins") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.Coins) error); ok { + r0 = rf(ctx, moduleName, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SendCoins provides a mock function with given fields: ctx, fromAddr, toAddr, amt +func (_m *BankKeeper) SendCoins(ctx context.Context, fromAddr types.AccAddress, toAddr types.AccAddress, amt types.Coins) error { + ret := _m.Called(ctx, fromAddr, toAddr, amt) + + if len(ret) == 0 { + panic("no return value specified for SendCoins") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, types.AccAddress, types.Coins) error); ok { + r0 = rf(ctx, fromAddr, toAddr, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SendCoinsFromAccountToModule provides a mock function with given fields: ctx, senderAddr, recipientModule, amt +func (_m *BankKeeper) SendCoinsFromAccountToModule(ctx context.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins) error { + ret := _m.Called(ctx, senderAddr, recipientModule, amt) + + if len(ret) == 0 { + panic("no return value specified for SendCoinsFromAccountToModule") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, string, types.Coins) error); ok { + r0 = rf(ctx, senderAddr, recipientModule, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SendCoinsFromModuleToAccount provides a mock function with given fields: ctx, senderModule, recipientAddr, amt +func (_m *BankKeeper) SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error { + ret := _m.Called(ctx, senderModule, recipientAddr, amt) + + if len(ret) == 0 { + panic("no return value specified for SendCoinsFromModuleToAccount") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AccAddress, types.Coins) error); ok { + r0 = rf(ctx, senderModule, recipientAddr, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetDenomMetaData provides a mock function with given fields: ctx, denomMetaData +func (_m *BankKeeper) SetDenomMetaData(ctx context.Context, denomMetaData banktypes.Metadata) { + _m.Called(ctx, denomMetaData) +} + +// SpendableCoins provides a mock function with given fields: ctx, addr +func (_m *BankKeeper) SpendableCoins(ctx context.Context, addr types.AccAddress) types.Coins { + ret := _m.Called(ctx, addr) + + if len(ret) == 0 { + panic("no return value specified for SpendableCoins") + } + + var r0 types.Coins + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress) types.Coins); ok { + r0 = rf(ctx, addr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(types.Coins) + } + } + + return r0 +} + +// NewBankKeeper creates a new instance of BankKeeper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewBankKeeper(t interface { + mock.TestingT + Cleanup(func()) +}, +) *BankKeeper { + mock := &BankKeeper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/x/tokenfactory/types/mocks/CommunityPoolKeeper.go b/x/tokenfactory/types/mocks/CommunityPoolKeeper.go new file mode 100644 index 00000000..d036208e --- /dev/null +++ b/x/tokenfactory/types/mocks/CommunityPoolKeeper.go @@ -0,0 +1,49 @@ +// Code generated by mockery v2.43.2. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + types "github.com/cosmos/cosmos-sdk/types" +) + +// CommunityPoolKeeper is an autogenerated mock type for the CommunityPoolKeeper type +type CommunityPoolKeeper struct { + mock.Mock +} + +// FundCommunityPool provides a mock function with given fields: ctx, amount, sender +func (_m *CommunityPoolKeeper) FundCommunityPool(ctx context.Context, amount types.Coins, sender types.AccAddress) error { + ret := _m.Called(ctx, amount, sender) + + if len(ret) == 0 { + panic("no return value specified for FundCommunityPool") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, types.Coins, types.AccAddress) error); ok { + r0 = rf(ctx, amount, sender) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// NewCommunityPoolKeeper creates a new instance of CommunityPoolKeeper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewCommunityPoolKeeper(t interface { + mock.TestingT + Cleanup(func()) +}, +) *CommunityPoolKeeper { + mock := &CommunityPoolKeeper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/x/tokenfactory/types/msgs.go b/x/tokenfactory/types/msgs.go index 66519196..a5dc71a8 100644 --- a/x/tokenfactory/types/msgs.go +++ b/x/tokenfactory/types/msgs.go @@ -16,6 +16,7 @@ const ( TypeMsgBurn = "tf_burn" TypeMsgChangeAdmin = "change_admin" TypeMsgSetDenomMetadata = "set_denom_metadata" + TypeMsgUpdateParams = "update_params" ) var ( @@ -24,6 +25,7 @@ var ( _ sdk.Msg = &MsgBurn{} _ sdk.Msg = &MsgChangeAdmin{} _ sdk.Msg = &MsgSetDenomMetadata{} + _ sdk.Msg = &MsgUpdateParams{} ) func NewMsgCreateDenom(sender, subdenom string) *MsgCreateDenom { @@ -194,3 +196,25 @@ func (m MsgSetDenomMetadata) GetSignBytes() []byte { func (m MsgSetDenomMetadata) GetSigners() []sdk.AccAddress { return libmeta.GetSigners(&m) } + +func (m MsgUpdateParams) Route() string { return RouterKey } +func (m MsgUpdateParams) Type() string { return TypeMsgUpdateParams } +func (m MsgUpdateParams) ValidateBasic() error { + if err := libmeta.ValidateBasic(&m); err != nil { + return err + } + + if _, err := sdk.AccAddressFromBech32(m.Authority); err != nil { + return sdkerrors.Wrapf(sdktypeerrors.ErrInvalidAddress, "invalid authority address (%s)", err) + } + + return m.Params.Validate() +} + +func (m MsgUpdateParams) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +func (m MsgUpdateParams) GetSigners() []sdk.AccAddress { + return libmeta.GetSigners(&m) +} diff --git a/x/tokenfactory/types/msgs_test.go b/x/tokenfactory/types/msgs_test.go index 10a0141b..a8f02742 100644 --- a/x/tokenfactory/types/msgs_test.go +++ b/x/tokenfactory/types/msgs_test.go @@ -5,13 +5,12 @@ import ( "testing" sdkmath "cosmossdk.io/math" + "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" sdk "github.com/cosmos/cosmos-sdk/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" testutilcommmon "github.com/palomachain/paloma/v2/testutil/common" "github.com/palomachain/paloma/v2/x/tokenfactory/types" "github.com/stretchr/testify/require" - - "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" ) func TestMsgCreateDenom(t *testing.T) { diff --git a/x/tokenfactory/types/tx.pb.go b/x/tokenfactory/types/tx.pb.go index e1492a1d..3b9482b1 100644 --- a/x/tokenfactory/types/tx.pb.go +++ b/x/tokenfactory/types/tx.pb.go @@ -6,6 +6,11 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" types2 "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/cosmos-sdk/types/msgservice" types1 "github.com/cosmos/cosmos-sdk/x/bank/types" @@ -13,18 +18,18 @@ import ( grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" types "github.com/palomachain/paloma/v2/x/valset/types" + _ "google.golang.org/genproto/googleapis/api/annotations" 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -53,9 +58,11 @@ func (*MsgCreateDenom) ProtoMessage() {} func (*MsgCreateDenom) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{0} } + func (m *MsgCreateDenom) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgCreateDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgCreateDenom.Marshal(b, m, deterministic) @@ -68,12 +75,15 @@ func (m *MsgCreateDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return b[:n], nil } } + func (m *MsgCreateDenom) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgCreateDenom.Merge(m, src) } + func (m *MsgCreateDenom) XXX_Size() int { return m.Size() } + func (m *MsgCreateDenom) XXX_DiscardUnknown() { xxx_messageInfo_MsgCreateDenom.DiscardUnknown(m) } @@ -106,9 +116,11 @@ func (*MsgCreateDenomResponse) ProtoMessage() {} func (*MsgCreateDenomResponse) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{1} } + func (m *MsgCreateDenomResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgCreateDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgCreateDenomResponse.Marshal(b, m, deterministic) @@ -121,12 +133,15 @@ func (m *MsgCreateDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *MsgCreateDenomResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgCreateDenomResponse.Merge(m, src) } + func (m *MsgCreateDenomResponse) XXX_Size() int { return m.Size() } + func (m *MsgCreateDenomResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgCreateDenomResponse.DiscardUnknown(m) } @@ -153,9 +168,11 @@ func (*MsgSetDenomMetadata) ProtoMessage() {} func (*MsgSetDenomMetadata) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{2} } + func (m *MsgSetDenomMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSetDenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSetDenomMetadata.Marshal(b, m, deterministic) @@ -168,12 +185,15 @@ func (m *MsgSetDenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *MsgSetDenomMetadata) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSetDenomMetadata.Merge(m, src) } + func (m *MsgSetDenomMetadata) XXX_Size() int { return m.Size() } + func (m *MsgSetDenomMetadata) XXX_DiscardUnknown() { xxx_messageInfo_MsgSetDenomMetadata.DiscardUnknown(m) } @@ -196,8 +216,7 @@ func (m *MsgSetDenomMetadata) GetMetadata() types.MsgMetadata { // MsgSetDenomMetadataResponse defines the response structure for an executed // MsgSetDenomMetadata message. -type MsgSetDenomMetadataResponse struct { -} +type MsgSetDenomMetadataResponse struct{} func (m *MsgSetDenomMetadataResponse) Reset() { *m = MsgSetDenomMetadataResponse{} } func (m *MsgSetDenomMetadataResponse) String() string { return proto.CompactTextString(m) } @@ -205,9 +224,11 @@ func (*MsgSetDenomMetadataResponse) ProtoMessage() {} func (*MsgSetDenomMetadataResponse) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{3} } + func (m *MsgSetDenomMetadataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSetDenomMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSetDenomMetadataResponse.Marshal(b, m, deterministic) @@ -220,12 +241,15 @@ func (m *MsgSetDenomMetadataResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *MsgSetDenomMetadataResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSetDenomMetadataResponse.Merge(m, src) } + func (m *MsgSetDenomMetadataResponse) XXX_Size() int { return m.Size() } + func (m *MsgSetDenomMetadataResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgSetDenomMetadataResponse.DiscardUnknown(m) } @@ -245,9 +269,11 @@ func (*MsgMint) ProtoMessage() {} func (*MsgMint) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{4} } + func (m *MsgMint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgMint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgMint.Marshal(b, m, deterministic) @@ -260,12 +286,15 @@ func (m *MsgMint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *MsgMint) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgMint.Merge(m, src) } + func (m *MsgMint) XXX_Size() int { return m.Size() } + func (m *MsgMint) XXX_DiscardUnknown() { xxx_messageInfo_MsgMint.DiscardUnknown(m) } @@ -286,8 +315,7 @@ func (m *MsgMint) GetMetadata() types.MsgMetadata { return types.MsgMetadata{} } -type MsgMintResponse struct { -} +type MsgMintResponse struct{} func (m *MsgMintResponse) Reset() { *m = MsgMintResponse{} } func (m *MsgMintResponse) String() string { return proto.CompactTextString(m) } @@ -295,9 +323,11 @@ func (*MsgMintResponse) ProtoMessage() {} func (*MsgMintResponse) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{5} } + func (m *MsgMintResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgMintResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgMintResponse.Marshal(b, m, deterministic) @@ -310,12 +340,15 @@ func (m *MsgMintResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } + func (m *MsgMintResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgMintResponse.Merge(m, src) } + func (m *MsgMintResponse) XXX_Size() int { return m.Size() } + func (m *MsgMintResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgMintResponse.DiscardUnknown(m) } @@ -335,9 +368,11 @@ func (*MsgBurn) ProtoMessage() {} func (*MsgBurn) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{6} } + func (m *MsgBurn) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgBurn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgBurn.Marshal(b, m, deterministic) @@ -350,12 +385,15 @@ func (m *MsgBurn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *MsgBurn) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgBurn.Merge(m, src) } + func (m *MsgBurn) XXX_Size() int { return m.Size() } + func (m *MsgBurn) XXX_DiscardUnknown() { xxx_messageInfo_MsgBurn.DiscardUnknown(m) } @@ -376,8 +414,7 @@ func (m *MsgBurn) GetMetadata() types.MsgMetadata { return types.MsgMetadata{} } -type MsgBurnResponse struct { -} +type MsgBurnResponse struct{} func (m *MsgBurnResponse) Reset() { *m = MsgBurnResponse{} } func (m *MsgBurnResponse) String() string { return proto.CompactTextString(m) } @@ -385,9 +422,11 @@ func (*MsgBurnResponse) ProtoMessage() {} func (*MsgBurnResponse) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{7} } + func (m *MsgBurnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgBurnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgBurnResponse.Marshal(b, m, deterministic) @@ -400,12 +439,15 @@ func (m *MsgBurnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } + func (m *MsgBurnResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgBurnResponse.Merge(m, src) } + func (m *MsgBurnResponse) XXX_Size() int { return m.Size() } + func (m *MsgBurnResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgBurnResponse.DiscardUnknown(m) } @@ -426,9 +468,11 @@ func (*MsgChangeAdmin) ProtoMessage() {} func (*MsgChangeAdmin) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{8} } + func (m *MsgChangeAdmin) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgChangeAdmin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgChangeAdmin.Marshal(b, m, deterministic) @@ -441,12 +485,15 @@ func (m *MsgChangeAdmin) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return b[:n], nil } } + func (m *MsgChangeAdmin) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgChangeAdmin.Merge(m, src) } + func (m *MsgChangeAdmin) XXX_Size() int { return m.Size() } + func (m *MsgChangeAdmin) XXX_DiscardUnknown() { xxx_messageInfo_MsgChangeAdmin.DiscardUnknown(m) } @@ -476,8 +523,7 @@ func (m *MsgChangeAdmin) GetMetadata() types.MsgMetadata { // MsgChangeAdminResponse defines the response structure for an executed // MsgChangeAdmin message. -type MsgChangeAdminResponse struct { -} +type MsgChangeAdminResponse struct{} func (m *MsgChangeAdminResponse) Reset() { *m = MsgChangeAdminResponse{} } func (m *MsgChangeAdminResponse) String() string { return proto.CompactTextString(m) } @@ -485,9 +531,11 @@ func (*MsgChangeAdminResponse) ProtoMessage() {} func (*MsgChangeAdminResponse) Descriptor() ([]byte, []int) { return fileDescriptor_a83d7259c91f1067, []int{9} } + func (m *MsgChangeAdminResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgChangeAdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgChangeAdminResponse.Marshal(b, m, deterministic) @@ -500,18 +548,133 @@ func (m *MsgChangeAdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *MsgChangeAdminResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgChangeAdminResponse.Merge(m, src) } + func (m *MsgChangeAdminResponse) XXX_Size() int { return m.Size() } + func (m *MsgChangeAdminResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgChangeAdminResponse.DiscardUnknown(m) } var xxx_messageInfo_MsgChangeAdminResponse proto.InternalMessageInfo +type MsgUpdateParams struct { + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // params defines the x/tokenfactory parameters to update. + // + // NOTE: All parameters must be supplied. + Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"` + Metadata types.MsgMetadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata"` +} + +func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } +func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParams) ProtoMessage() {} +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{10} +} + +func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParams.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 *MsgUpdateParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParams.Merge(m, src) +} + +func (m *MsgUpdateParams) XXX_Size() int { + return m.Size() +} + +func (m *MsgUpdateParams) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo + +func (m *MsgUpdateParams) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateParams) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func (m *MsgUpdateParams) GetMetadata() types.MsgMetadata { + if m != nil { + return m.Metadata + } + return types.MsgMetadata{} +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +type MsgUpdateParamsResponse struct{} + +func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse{} } +func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParamsResponse) ProtoMessage() {} +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a83d7259c91f1067, []int{11} +} + +func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParamsResponse.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 *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src) +} + +func (m *MsgUpdateParamsResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgCreateDenom)(nil), "palomachain.paloma.tokenfactory.MsgCreateDenom") proto.RegisterType((*MsgCreateDenomResponse)(nil), "palomachain.paloma.tokenfactory.MsgCreateDenomResponse") @@ -523,6 +686,8 @@ func init() { proto.RegisterType((*MsgBurnResponse)(nil), "palomachain.paloma.tokenfactory.MsgBurnResponse") proto.RegisterType((*MsgChangeAdmin)(nil), "palomachain.paloma.tokenfactory.MsgChangeAdmin") proto.RegisterType((*MsgChangeAdminResponse)(nil), "palomachain.paloma.tokenfactory.MsgChangeAdminResponse") + proto.RegisterType((*MsgUpdateParams)(nil), "palomachain.paloma.tokenfactory.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "palomachain.paloma.tokenfactory.MsgUpdateParamsResponse") } func init() { @@ -530,53 +695,68 @@ func init() { } var fileDescriptor_a83d7259c91f1067 = []byte{ - // 648 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x3d, 0x6f, 0xd3, 0x4e, - 0x18, 0x8f, 0xff, 0xed, 0xbf, 0xb4, 0x57, 0xd2, 0x16, 0xf7, 0x15, 0xa3, 0xda, 0xd5, 0x0d, 0x55, - 0xc4, 0xe0, 0x23, 0x05, 0x84, 0x54, 0xb1, 0xe0, 0x32, 0xb0, 0x44, 0x48, 0x86, 0x09, 0x90, 0xaa, - 0xb3, 0x73, 0xb8, 0x51, 0xeb, 0xbb, 0x28, 0x77, 0x69, 0xda, 0x95, 0x81, 0x99, 0x2f, 0x82, 0xc4, - 0x37, 0x60, 0xed, 0xd8, 0x0d, 0xa6, 0x08, 0x25, 0x12, 0xec, 0xf9, 0x04, 0xe8, 0x5e, 0xe2, 0x38, - 0x69, 0x24, 0x0c, 0x12, 0x95, 0x98, 0x72, 0x97, 0xe7, 0xe5, 0xf7, 0xfc, 0x9e, 0xb7, 0x33, 0xa8, - 0x34, 0xf1, 0x09, 0x4b, 0x71, 0x7c, 0x84, 0x1b, 0x14, 0xe9, 0x33, 0x12, 0xec, 0x98, 0xd0, 0xb7, - 0x38, 0x16, 0xac, 0x75, 0x8e, 0xc4, 0x99, 0xdf, 0x6c, 0x31, 0xc1, 0x6c, 0x2f, 0xa7, 0xe9, 0xeb, - 0xb3, 0x9f, 0xd7, 0x74, 0xd6, 0x12, 0x96, 0x30, 0xa5, 0x8b, 0xe4, 0x49, 0x9b, 0x39, 0x6e, 0xcc, - 0x78, 0xca, 0x38, 0x8a, 0x30, 0x27, 0xe8, 0xb4, 0x1a, 0x11, 0x81, 0xab, 0x28, 0x66, 0xd2, 0xc7, - 0x84, 0x9c, 0x1e, 0x67, 0x72, 0x79, 0x31, 0xf2, 0x4d, 0x23, 0x4f, 0x79, 0x82, 0x4e, 0xab, 0xf2, - 0xc7, 0x08, 0x76, 0xa7, 0x44, 0x7e, 0x8a, 0x4f, 0x38, 0x11, 0x28, 0x66, 0x69, 0xca, 0x0c, 0x00, - 0xfc, 0x68, 0x81, 0xa5, 0x1a, 0x4f, 0x0e, 0x5a, 0x04, 0x0b, 0xf2, 0x94, 0x50, 0x96, 0xda, 0x08, - 0xcc, 0xf3, 0x76, 0x54, 0x97, 0xe7, 0x2d, 0x6b, 0xc7, 0xaa, 0x2c, 0x04, 0xab, 0x83, 0xae, 0xb7, - 0x7c, 0x8e, 0xd3, 0x93, 0x7d, 0x38, 0x94, 0xc0, 0x30, 0x53, 0xb2, 0x5f, 0x83, 0xf9, 0x94, 0x08, - 0x5c, 0xc7, 0x02, 0x6f, 0xfd, 0xb7, 0x63, 0x55, 0x16, 0xf7, 0x76, 0xfd, 0x29, 0xe9, 0xd0, 0xf0, - 0x7e, 0x8d, 0x27, 0x35, 0xa3, 0x1d, 0x6c, 0x5e, 0x74, 0xbd, 0xd2, 0xc8, 0xf9, 0xd0, 0x0b, 0x0c, - 0x33, 0x87, 0xfb, 0xe5, 0x77, 0x3f, 0x3e, 0xdd, 0xcd, 0xae, 0xf0, 0x0d, 0xd8, 0x18, 0x0f, 0x37, - 0x24, 0xbc, 0xc9, 0x28, 0x27, 0x76, 0x00, 0x96, 0x29, 0xe9, 0x1c, 0xaa, 0xa4, 0x1f, 0xe6, 0xa3, - 0x77, 0x06, 0x5d, 0x6f, 0x43, 0x03, 0x4c, 0x28, 0xc0, 0xb0, 0x4c, 0x49, 0xe7, 0xa5, 0xfc, 0x43, - 0xf9, 0x82, 0xdf, 0x2d, 0xb0, 0x5a, 0xe3, 0xc9, 0x0b, 0x22, 0xd4, 0x7d, 0x18, 0xa7, 0x1d, 0x83, - 0x25, 0x65, 0x70, 0x98, 0xf1, 0xb4, 0x14, 0xcf, 0x6d, 0x5f, 0xe7, 0xdf, 0x57, 0x25, 0x31, 0xf5, - 0xf1, 0x33, 0x7a, 0xdb, 0x86, 0xde, 0xba, 0x46, 0x1f, 0x77, 0x01, 0xc3, 0x72, 0x7d, 0x0c, 0xe4, - 0x3a, 0xd3, 0xb8, 0x0d, 0xee, 0x4c, 0xe1, 0x39, 0xcc, 0x25, 0xfc, 0x6c, 0x81, 0x1b, 0x12, 0xa0, - 0x41, 0x85, 0xfd, 0x0c, 0xcc, 0xe1, 0x94, 0xb5, 0xa9, 0x30, 0x9c, 0x6f, 0x8f, 0x38, 0x73, 0x92, - 0x71, 0x3e, 0x60, 0x0d, 0x1a, 0xac, 0x9b, 0x38, 0xca, 0x3a, 0x0e, 0x6d, 0x06, 0x43, 0x63, 0x7f, - 0xad, 0x04, 0x6f, 0x81, 0x65, 0x43, 0x60, 0x92, 0x54, 0xd0, 0x6e, 0xd1, 0x7f, 0x9a, 0x94, 0x24, - 0x90, 0x91, 0xfa, 0x62, 0xe6, 0xf7, 0x08, 0xd3, 0x84, 0x3c, 0xa9, 0xa7, 0x0d, 0x6a, 0xef, 0x82, - 0xff, 0xf3, 0xed, 0xbf, 0x32, 0xe8, 0x7a, 0x37, 0x73, 0x0d, 0x08, 0x43, 0x2d, 0xb6, 0xab, 0x60, - 0x41, 0xce, 0x03, 0x96, 0x46, 0x2a, 0xf4, 0x85, 0x60, 0x6d, 0xd0, 0xf5, 0x56, 0x46, 0xa3, 0xa2, - 0x44, 0x30, 0x9c, 0xa7, 0xa4, 0xa3, 0x5d, 0xe7, 0xc9, 0xce, 0xfc, 0x65, 0xb2, 0x5b, 0x7a, 0xd2, - 0x47, 0xc4, 0x86, 0x9c, 0xf7, 0x2e, 0x66, 0xc1, 0x4c, 0x8d, 0x27, 0x76, 0x07, 0x2c, 0x8e, 0xed, - 0x2d, 0xff, 0x17, 0x3b, 0xd8, 0x1f, 0xdf, 0x1c, 0xce, 0xa3, 0xdf, 0x34, 0xc8, 0x56, 0xcd, 0x7b, - 0x0b, 0xac, 0x5c, 0xd9, 0x11, 0x0f, 0x8a, 0x78, 0x9b, 0xb4, 0x72, 0x1e, 0xff, 0x89, 0x55, 0x16, - 0x48, 0x04, 0x66, 0xd5, 0x8c, 0x56, 0x8a, 0x78, 0x91, 0x9a, 0xce, 0xbd, 0xa2, 0x9a, 0x79, 0x0c, - 0x35, 0x32, 0x85, 0x30, 0xa4, 0x66, 0x31, 0x8c, 0x7c, 0x17, 0xab, 0x4a, 0xe6, 0x3a, 0xb8, 0x58, - 0x25, 0x47, 0x06, 0x05, 0x2b, 0x79, 0xb5, 0x95, 0x82, 0xe7, 0x17, 0x3d, 0xd7, 0xba, 0xec, 0xb9, - 0xd6, 0xb7, 0x9e, 0x6b, 0x7d, 0xe8, 0xbb, 0xa5, 0xcb, 0xbe, 0x5b, 0xfa, 0xda, 0x77, 0x4b, 0xaf, - 0x1e, 0x26, 0x0d, 0x71, 0xd4, 0x8e, 0xfc, 0x98, 0xa5, 0x68, 0xda, 0x5b, 0xba, 0x87, 0xce, 0x26, - 0x3e, 0x05, 0xce, 0x9b, 0x84, 0x47, 0x73, 0xea, 0x59, 0xbd, 0xff, 0x33, 0x00, 0x00, 0xff, 0xff, - 0x5b, 0xda, 0xcd, 0x46, 0x3a, 0x08, 0x00, 0x00, + // 862 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4d, 0x6f, 0x1b, 0x45, + 0x18, 0xf6, 0xb6, 0x25, 0x8d, 0xa7, 0x75, 0x12, 0xb6, 0x69, 0xe3, 0x2c, 0xc4, 0xae, 0x46, 0xc2, + 0x31, 0x88, 0xec, 0xe0, 0xf0, 0x51, 0x54, 0x71, 0xe9, 0x16, 0xa4, 0x5e, 0x2c, 0xd0, 0x16, 0x2e, + 0x80, 0x64, 0x8d, 0xed, 0x61, 0xbd, 0xaa, 0x77, 0xc6, 0xda, 0x19, 0x3b, 0xf5, 0xb5, 0xbf, 0x00, + 0xc4, 0x8f, 0xe0, 0x80, 0x90, 0x38, 0x70, 0xef, 0xb5, 0xc7, 0x0a, 0x0e, 0x70, 0xb2, 0x50, 0x82, + 0x40, 0xe2, 0x86, 0x7f, 0x01, 0x9a, 0x8f, 0xfd, 0xb0, 0xb1, 0xe4, 0x6d, 0x25, 0x22, 0xf5, 0xe4, + 0x19, 0xbf, 0x5f, 0xcf, 0xf3, 0xce, 0x3b, 0xcf, 0x0e, 0x68, 0x8e, 0xf0, 0x90, 0x45, 0xb8, 0x37, + 0xc0, 0x21, 0x45, 0x7a, 0x8d, 0x04, 0x7b, 0x40, 0xe8, 0x57, 0xb8, 0x27, 0x58, 0x3c, 0x45, 0xe2, + 0xa1, 0x3b, 0x8a, 0x99, 0x60, 0x76, 0x3d, 0xe7, 0xe9, 0xea, 0xb5, 0x9b, 0xf7, 0x74, 0xf6, 0x7b, + 0x8c, 0x47, 0x8c, 0x77, 0x94, 0x3b, 0xd2, 0x1b, 0x1d, 0xeb, 0xd4, 0xf4, 0x0e, 0x75, 0x31, 0x27, + 0x68, 0xd2, 0xea, 0x12, 0x81, 0x5b, 0xa8, 0xc7, 0x64, 0xa2, 0x25, 0x3b, 0x7d, 0x90, 0xda, 0xe5, + 0xc6, 0xd8, 0xf7, 0x8c, 0x3d, 0xe2, 0x01, 0x9a, 0xb4, 0xe4, 0x8f, 0x31, 0xec, 0x06, 0x2c, 0x60, + 0xba, 0xa0, 0x5c, 0x99, 0x7f, 0x5f, 0x0d, 0x18, 0x0b, 0x86, 0x04, 0xe1, 0x51, 0x88, 0x30, 0xa5, + 0x4c, 0x60, 0x11, 0x32, 0x9a, 0x80, 0x79, 0x73, 0x1d, 0xe5, 0x11, 0x8e, 0x71, 0x94, 0x78, 0x37, + 0x56, 0x78, 0x4f, 0xf0, 0x90, 0x13, 0x81, 0x7a, 0x2c, 0x8a, 0x98, 0xa1, 0x00, 0x7f, 0xb0, 0xc0, + 0x56, 0x9b, 0x07, 0x77, 0x63, 0x82, 0x05, 0xf9, 0x90, 0x50, 0x16, 0xd9, 0x08, 0x6c, 0xf2, 0x71, + 0xb7, 0x2f, 0xd7, 0x55, 0xeb, 0xa6, 0xd5, 0x2c, 0x7b, 0xd7, 0xe6, 0xb3, 0xfa, 0xf6, 0x14, 0x47, + 0xc3, 0xdb, 0x30, 0xb1, 0x40, 0x3f, 0x75, 0xb2, 0xbf, 0x00, 0x9b, 0x11, 0x11, 0xb8, 0x8f, 0x05, + 0xae, 0x5e, 0xb8, 0x69, 0x35, 0xaf, 0x1c, 0x37, 0xdc, 0x15, 0x5d, 0xd7, 0xe5, 0xdd, 0x36, 0x0f, + 0xda, 0xc6, 0xdb, 0xdb, 0x7b, 0x32, 0xab, 0x97, 0xb2, 0xe4, 0x49, 0x16, 0xe8, 0xa7, 0x09, 0x6f, + 0x57, 0x1e, 0xfd, 0xf5, 0xe3, 0x1b, 0xe9, 0x16, 0x7e, 0x09, 0x6e, 0x2c, 0xc2, 0xf5, 0x09, 0x1f, + 0x31, 0xca, 0x89, 0xed, 0x81, 0x6d, 0x4a, 0x4e, 0x3a, 0xaa, 0x25, 0x9d, 0x3c, 0x7a, 0x67, 0x3e, + 0xab, 0xdf, 0xd0, 0x05, 0x96, 0x1c, 0xa0, 0x5f, 0xa1, 0xe4, 0xe4, 0x53, 0xf9, 0x87, 0xca, 0x05, + 0xff, 0xb4, 0xc0, 0xb5, 0x36, 0x0f, 0xee, 0x13, 0xa1, 0xf6, 0x09, 0x4e, 0xbb, 0x07, 0xb6, 0x54, + 0x40, 0x27, 0xe5, 0x69, 0x29, 0x9e, 0x07, 0xae, 0x99, 0x17, 0x75, 0xe8, 0x66, 0x02, 0xdc, 0x94, + 0xde, 0x81, 0xa1, 0x77, 0x5d, 0x57, 0x5f, 0x4c, 0x01, 0xfd, 0x4a, 0x7f, 0xa1, 0xc8, 0x79, 0xb6, + 0xf1, 0x00, 0xbc, 0xb2, 0x82, 0x67, 0xd2, 0x4b, 0xf8, 0xd8, 0x02, 0x97, 0x65, 0x81, 0x90, 0x0a, + 0xfb, 0x1e, 0xd8, 0xc0, 0x11, 0x1b, 0x53, 0x61, 0x38, 0xef, 0x67, 0x9c, 0x39, 0x49, 0x39, 0xdf, + 0x65, 0x21, 0xf5, 0xae, 0x1b, 0x1c, 0x15, 0x8d, 0x43, 0x87, 0x41, 0xdf, 0xc4, 0x9f, 0x2b, 0xc1, + 0x97, 0xc1, 0xb6, 0x21, 0xb0, 0x4c, 0xca, 0x1b, 0xc7, 0xf4, 0x85, 0x26, 0x25, 0x09, 0xa4, 0xa4, + 0x7e, 0x35, 0xf7, 0x77, 0x80, 0x69, 0x40, 0xee, 0xf4, 0xa3, 0x90, 0xda, 0x0d, 0xf0, 0x52, 0x7e, + 0xfc, 0x77, 0xe6, 0xb3, 0xfa, 0xd5, 0xdc, 0x00, 0x42, 0x5f, 0x9b, 0xed, 0x16, 0x28, 0xcb, 0xfb, + 0x80, 0x65, 0x90, 0x82, 0x5e, 0xf6, 0x76, 0xe7, 0xb3, 0xfa, 0x4e, 0x76, 0x55, 0x94, 0x09, 0xfa, + 0x9b, 0x94, 0x9c, 0xe8, 0xd4, 0x79, 0xb2, 0x17, 0xff, 0x67, 0xb2, 0x55, 0x7d, 0xd3, 0x33, 0x62, + 0x29, 0xe7, 0xbf, 0x2d, 0xd5, 0x87, 0xcf, 0x46, 0x7d, 0x2c, 0xc8, 0x27, 0x4a, 0xf5, 0xec, 0xf7, + 0x40, 0x19, 0x8f, 0xc5, 0x80, 0xc5, 0xa1, 0x98, 0x1a, 0xe2, 0xd5, 0x9f, 0x7f, 0x3a, 0xda, 0x35, + 0xc7, 0x7a, 0xa7, 0xdf, 0x8f, 0x09, 0xe7, 0xf7, 0x45, 0x1c, 0xd2, 0xc0, 0xcf, 0x5c, 0xed, 0x8f, + 0xc0, 0x86, 0xd6, 0x4d, 0x73, 0x78, 0x87, 0xee, 0x9a, 0xef, 0x85, 0xab, 0x0b, 0x7a, 0x97, 0x24, + 0x21, 0xdf, 0x04, 0xdb, 0xf7, 0x9e, 0xbb, 0x31, 0x3a, 0x4f, 0xd6, 0x85, 0x2d, 0xd9, 0x85, 0x0c, + 0x20, 0xdc, 0x07, 0x7b, 0x4b, 0x5c, 0x93, 0x3e, 0x1c, 0xff, 0x73, 0x19, 0x5c, 0x6c, 0xf3, 0xc0, + 0xfe, 0xce, 0x02, 0x57, 0x16, 0x04, 0x7c, 0x2d, 0x87, 0x45, 0x09, 0x75, 0x6e, 0x3d, 0x63, 0x40, + 0x7a, 0x12, 0xee, 0xa3, 0x5f, 0xfe, 0xf8, 0xf6, 0x42, 0x13, 0x36, 0xd0, 0xba, 0x8f, 0x93, 0x1e, + 0xb9, 0xc7, 0x16, 0xd8, 0xf9, 0x8f, 0xb8, 0xbe, 0x53, 0xa4, 0xfa, 0x72, 0x94, 0xf3, 0xc1, 0xf3, + 0x44, 0xa5, 0xc0, 0x6f, 0x29, 0xe0, 0x2d, 0x88, 0x8a, 0x01, 0x3f, 0x4a, 0x8e, 0xc7, 0xfe, 0xc6, + 0x02, 0x97, 0x94, 0x2c, 0x36, 0x8b, 0xd4, 0x97, 0x9e, 0xce, 0x5b, 0x45, 0x3d, 0x53, 0x74, 0x47, + 0x0a, 0xdd, 0x21, 0x7c, 0x6d, 0x2d, 0xba, 0x48, 0x42, 0x91, 0x98, 0x94, 0xaa, 0x15, 0xc2, 0x24, + 0x3d, 0x8b, 0x61, 0x5a, 0x10, 0x9a, 0xe2, 0x98, 0xba, 0x12, 0x8a, 0x9a, 0xc9, 0x9c, 0x28, 0x15, + 0x9b, 0xc9, 0x2c, 0xa0, 0xe0, 0x4c, 0xae, 0x50, 0x07, 0x33, 0x93, 0xce, 0xfa, 0x99, 0x54, 0xf2, + 0x66, 0x7f, 0x6f, 0x81, 0xab, 0x0b, 0x52, 0x52, 0xa8, 0x37, 0xf9, 0x08, 0xe7, 0xfd, 0x67, 0x8d, + 0x48, 0xc1, 0x22, 0x05, 0xf6, 0x75, 0xe7, 0x10, 0x15, 0x7b, 0xdd, 0x79, 0x1f, 0x3f, 0x39, 0xad, + 0x59, 0x4f, 0x4f, 0x6b, 0xd6, 0xef, 0xa7, 0x35, 0xeb, 0xeb, 0xb3, 0x5a, 0xe9, 0xe9, 0x59, 0xad, + 0xf4, 0xdb, 0x59, 0xad, 0xf4, 0xf9, 0xbb, 0x41, 0x28, 0x06, 0xe3, 0xae, 0xdb, 0x63, 0xd1, 0xaa, + 0x64, 0x93, 0x63, 0xf4, 0x70, 0xe9, 0x89, 0x3c, 0x1d, 0x11, 0xde, 0xdd, 0x50, 0xef, 0xc0, 0xb7, + 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x1c, 0xd6, 0x62, 0xd7, 0x52, 0x0b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -591,6 +771,7 @@ type MsgClient interface { Mint(ctx context.Context, in *MsgMint, opts ...grpc.CallOption) (*MsgMintResponse, error) Burn(ctx context.Context, in *MsgBurn, opts ...grpc.CallOption) (*MsgBurnResponse, error) ChangeAdmin(ctx context.Context, in *MsgChangeAdmin, opts ...grpc.CallOption) (*MsgChangeAdminResponse, error) + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) } type msgClient struct { @@ -646,6 +827,15 @@ func (c *msgClient) ChangeAdmin(ctx context.Context, in *MsgChangeAdmin, opts .. return out, nil } +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/palomachain.paloma.tokenfactory.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { CreateDenom(context.Context, *MsgCreateDenom) (*MsgCreateDenomResponse, error) @@ -653,28 +843,36 @@ type MsgServer interface { Mint(context.Context, *MsgMint) (*MsgMintResponse, error) Burn(context.Context, *MsgBurn) (*MsgBurnResponse, error) ChangeAdmin(context.Context, *MsgChangeAdmin) (*MsgChangeAdminResponse, error) + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func (*UnimplementedMsgServer) CreateDenom(ctx context.Context, req *MsgCreateDenom) (*MsgCreateDenomResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CreateDenom not implemented") } + func (*UnimplementedMsgServer) SetDenomMetadata(ctx context.Context, req *MsgSetDenomMetadata) (*MsgSetDenomMetadataResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetDenomMetadata not implemented") } + func (*UnimplementedMsgServer) Mint(ctx context.Context, req *MsgMint) (*MsgMintResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Mint not implemented") } + func (*UnimplementedMsgServer) Burn(ctx context.Context, req *MsgBurn) (*MsgBurnResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Burn not implemented") } + func (*UnimplementedMsgServer) ChangeAdmin(ctx context.Context, req *MsgChangeAdmin) (*MsgChangeAdminResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ChangeAdmin not implemented") } +func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} + func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) } @@ -769,6 +967,24 @@ func _Msg_ChangeAdmin_Handler(srv interface{}, ctx context.Context, dec func(int return interceptor(ctx, in, info, handler) } +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.tokenfactory.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "palomachain.paloma.tokenfactory.Msg", HandlerType: (*MsgServer)(nil), @@ -793,6 +1009,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "ChangeAdmin", Handler: _Msg_ChangeAdmin_Handler, }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "palomachain/paloma/tokenfactory/tx.proto", @@ -1136,6 +1356,79 @@ func (m *MsgChangeAdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *MsgUpdateParams) 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 *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateParamsResponse) 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 *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParamsResponse) 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 @@ -1147,6 +1440,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgCreateDenom) Size() (n int) { if m == nil { return 0 @@ -1269,12 +1563,40 @@ func (m *MsgChangeAdminResponse) Size() (n int) { return n } +func (m *MsgUpdateParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Params.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.Metadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateParamsResponse) 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 *MsgCreateDenom) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1390,6 +1712,7 @@ func (m *MsgCreateDenom) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgCreateDenomResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1472,6 +1795,7 @@ func (m *MsgCreateDenomResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSetDenomMetadata) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1588,6 +1912,7 @@ func (m *MsgSetDenomMetadata) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSetDenomMetadataResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1638,6 +1963,7 @@ func (m *MsgSetDenomMetadataResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgMint) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1754,6 +2080,7 @@ func (m *MsgMint) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgMintResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1804,6 +2131,7 @@ func (m *MsgMintResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgBurn) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1920,6 +2248,7 @@ func (m *MsgBurn) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgBurnResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1970,6 +2299,7 @@ func (m *MsgBurnResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgChangeAdmin) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2117,6 +2447,7 @@ func (m *MsgChangeAdmin) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgChangeAdminResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2167,6 +2498,207 @@ func (m *MsgChangeAdminResponse) Unmarshal(dAtA []byte) error { } return nil } + +func (m *MsgUpdateParams) 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: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", 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.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + 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 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 + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 + } + if err := m.Metadata.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 *MsgUpdateParamsResponse) 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: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: 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 diff --git a/x/tokenfactory/types/tx.pb.gw.go b/x/tokenfactory/types/tx.pb.gw.go new file mode 100644 index 00000000..a63b9135 --- /dev/null +++ b/x/tokenfactory/types/tx.pb.gw.go @@ -0,0 +1,550 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: palomachain/paloma/tokenfactory/tx.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 + _ io.Reader + _ status.Status + _ = runtime.String + _ = utilities.NewDoubleArray + _ = descriptor.ForMessage + _ = metadata.Join +) + +var filter_Msg_CreateDenom_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_CreateDenom_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgCreateDenom + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_CreateDenom_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.CreateDenom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_CreateDenom_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgCreateDenom + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_CreateDenom_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.CreateDenom(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Msg_SetDenomMetadata_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_SetDenomMetadata_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgSetDenomMetadata + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_SetDenomMetadata_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.SetDenomMetadata(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_SetDenomMetadata_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgSetDenomMetadata + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_SetDenomMetadata_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.SetDenomMetadata(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Msg_Mint_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_Mint_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgMint + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_Mint_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Mint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_Mint_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgMint + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_Mint_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.Mint(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Msg_Burn_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_Burn_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgBurn + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_Burn_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Burn(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_Burn_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgBurn + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_Burn_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.Burn(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Msg_ChangeAdmin_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_ChangeAdmin_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgChangeAdmin + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_ChangeAdmin_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ChangeAdmin(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_ChangeAdmin_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgChangeAdmin + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_ChangeAdmin_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ChangeAdmin(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Msg_UpdateParams_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_UpdateParams_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgUpdateParams + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_UpdateParams_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UpdateParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_UpdateParams_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgUpdateParams + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_UpdateParams_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.UpdateParams(ctx, &protoReq) + return msg, metadata, err +} + +// RegisterMsgHandlerServer registers the http handlers for service Msg to "mux". +// UnaryRPC :call MsgServer 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 RegisterMsgHandlerFromEndpoint instead. +func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MsgServer) error { + mux.Handle("POST", pattern_Msg_CreateDenom_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_Msg_CreateDenom_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_Msg_CreateDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_SetDenomMetadata_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_Msg_SetDenomMetadata_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_Msg_SetDenomMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_Mint_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_Msg_Mint_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_Msg_Mint_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_Burn_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_Msg_Burn_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_Msg_Burn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("PUT", pattern_Msg_ChangeAdmin_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_Msg_ChangeAdmin_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_Msg_ChangeAdmin_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("PUT", pattern_Msg_UpdateParams_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_Msg_UpdateParams_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_Msg_UpdateParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + return nil +} + +// RegisterMsgHandlerFromEndpoint is same as RegisterMsgHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterMsgHandlerFromEndpoint(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 RegisterMsgHandler(ctx, mux, conn) +} + +// RegisterMsgHandler registers the http handlers for service Msg to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterMsgHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterMsgHandlerClient(ctx, mux, NewMsgClient(conn)) +} + +// RegisterMsgHandlerClient registers the http handlers for service Msg +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MsgClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MsgClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "MsgClient" to call the correct interceptors. +func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MsgClient) error { + mux.Handle("POST", pattern_Msg_CreateDenom_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_Msg_CreateDenom_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_CreateDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_SetDenomMetadata_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_Msg_SetDenomMetadata_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_SetDenomMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_Mint_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_Msg_Mint_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_Mint_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_Burn_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_Msg_Burn_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_Burn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("PUT", pattern_Msg_ChangeAdmin_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_Msg_ChangeAdmin_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_ChangeAdmin_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("PUT", pattern_Msg_UpdateParams_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_Msg_UpdateParams_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_UpdateParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + return nil +} + +var ( + pattern_Msg_CreateDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "tokenfactory", "denom"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Msg_SetDenomMetadata_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "tokenfactory", "denom-metadata"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Msg_Mint_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "tokenfactory", "mint"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Msg_Burn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "tokenfactory", "burn"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Msg_ChangeAdmin_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "tokenfactory", "admin"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Msg_UpdateParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "tokenfactory", "params"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Msg_CreateDenom_0 = runtime.ForwardResponseMessage + + forward_Msg_SetDenomMetadata_0 = runtime.ForwardResponseMessage + + forward_Msg_Mint_0 = runtime.ForwardResponseMessage + + forward_Msg_Burn_0 = runtime.ForwardResponseMessage + + forward_Msg_ChangeAdmin_0 = runtime.ForwardResponseMessage + + forward_Msg_UpdateParams_0 = runtime.ForwardResponseMessage +) From 2dea1a66fa045cfa31d8fd41879263152b627555 Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Thu, 12 Dec 2024 21:50:18 +0100 Subject: [PATCH 4/9] Add client --- x/tokenfactory/client/cli/query.go | 110 ++++++++++++++++++++ x/tokenfactory/client/cli/tx.go | 162 +++++++++++++++++++++++++++++ 2 files changed, 272 insertions(+) create mode 100644 x/tokenfactory/client/cli/query.go create mode 100644 x/tokenfactory/client/cli/tx.go diff --git a/x/tokenfactory/client/cli/query.go b/x/tokenfactory/client/cli/query.go new file mode 100644 index 00000000..642a6690 --- /dev/null +++ b/x/tokenfactory/client/cli/query.go @@ -0,0 +1,110 @@ +package cli + +import ( + "fmt" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" + "github.com/spf13/cobra" +) + +func GetQueryCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: fmt.Sprintf("Querying commands for the %s module", types.ModuleName), + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + cmd.AddCommand( + GetParams(), + GetCmdDenomAuthorityMetadata(), + GetCmdDenomsFromCreator(), + ) + + return cmd +} + +func GetParams() *cobra.Command { + cmd := &cobra.Command{ + Use: "params [flags]", + Short: "Get the params for the x/tokenfactory module", + Args: cobra.ExactArgs(0), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{}) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + +func GetCmdDenomAuthorityMetadata() *cobra.Command { + cmd := &cobra.Command{ + Use: "denom-authority-metadata [denom] [flags]", + Short: "Get the authority metadata for a specific denom", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.DenomAuthorityMetadata(cmd.Context(), &types.QueryDenomAuthorityMetadataRequest{ + Denom: args[0], + }) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + +func GetCmdDenomsFromCreator() *cobra.Command { + cmd := &cobra.Command{ + Use: "denoms-from-creator [creator address] [flags]", + Short: "Returns a list of all tokens created by a specific creator address", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.DenomsFromCreator(cmd.Context(), &types.QueryDenomsFromCreatorRequest{ + Creator: args[0], + }) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/tokenfactory/client/cli/tx.go b/x/tokenfactory/client/cli/tx.go new file mode 100644 index 00000000..fc0608c3 --- /dev/null +++ b/x/tokenfactory/client/cli/tx.go @@ -0,0 +1,162 @@ +package cli + +import ( + "fmt" + + "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/palomachain/paloma/v2/x/tokenfactory/types" + "github.com/spf13/cobra" +) + +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( + NewCreateDenomCmd(), + NewMintCmd(), + NewBurnCmd(), + NewChangeAdminCmd(), + ) + + return cmd +} + +func NewCreateDenomCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "create-denom [subdenom] [flags]", + Short: "create a new denom from an account", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + txf, err := tx.NewFactoryCLI(clientCtx, cmd.Flags()) + if err != nil { + return err + } + txf = txf.WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever) + + msg := types.NewMsgCreateDenom( + clientCtx.GetFromAddress().String(), + args[0], + ) + + return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} + +func NewMintCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "mint [amount] [flags]", + Short: "Mint a denom to an address. Must have admin authority to do so.", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + txf, err := tx.NewFactoryCLI(clientCtx, cmd.Flags()) + if err != nil { + return err + } + txf = txf.WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever) + + amount, err := sdk.ParseCoinNormalized(args[0]) + if err != nil { + return err + } + + msg := types.NewMsgMint( + clientCtx.GetFromAddress().String(), + amount, + ) + + return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} + +func NewBurnCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "burn [amount] [flags]", + Short: "Burn tokens from an address. Must have admin authority to do so.", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + txf, err := tx.NewFactoryCLI(clientCtx, cmd.Flags()) + if err != nil { + return err + } + txf = txf.WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever) + + amount, err := sdk.ParseCoinNormalized(args[0]) + if err != nil { + return err + } + + msg := types.NewMsgBurn( + clientCtx.GetFromAddress().String(), + amount, + ) + + return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} + +func NewChangeAdminCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "change-admin [denom] [new-admin-address] [flags]", + Short: "Changes the admin address for a factory-created denom. Must have admin authority to do so.", + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + txf, err := tx.NewFactoryCLI(clientCtx, cmd.Flags()) + if err != nil { + return err + } + txf = txf.WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever) + + msg := types.NewMsgChangeAdmin( + clientCtx.GetFromAddress().String(), + args[0], + args[1], + ) + + return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} From fbfa6eb5e108a3166c0bebf62afd5bd84204013c Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Thu, 12 Dec 2024 22:23:58 +0100 Subject: [PATCH 5/9] Add module --- app/app.go | 64 ++++++++----- app/upgrades.go | 12 +++ x/tokenfactory/module.go | 199 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 253 insertions(+), 22 deletions(-) create mode 100644 x/tokenfactory/module.go diff --git a/app/app.go b/app/app.go index 9009e237..b3bbc85c 100644 --- a/app/app.go +++ b/app/app.go @@ -145,6 +145,9 @@ import ( skywayclient "github.com/palomachain/paloma/v2/x/skyway/client" skywaymodulekeeper "github.com/palomachain/paloma/v2/x/skyway/keeper" skywaymoduletypes "github.com/palomachain/paloma/v2/x/skyway/types" + "github.com/palomachain/paloma/v2/x/tokenfactory" + tokenfactorymodulekeeper "github.com/palomachain/paloma/v2/x/tokenfactory/keeper" + tokenfactorymoduletypes "github.com/palomachain/paloma/v2/x/tokenfactory/types" treasurymodule "github.com/palomachain/paloma/v2/x/treasury" treasuryclient "github.com/palomachain/paloma/v2/x/treasury/client" treasurymodulekeeper "github.com/palomachain/paloma/v2/x/treasury/keeper" @@ -178,19 +181,20 @@ var ( // module account permissions maccPerms = map[string][]string{ - authtypes.FeeCollectorName: nil, - distrtypes.ModuleName: nil, - minttypes.ModuleName: {authtypes.Minter}, - stakingtypes.BondedPoolName: {authtypes.Burner, authtypes.Staking}, - stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking}, - govtypes.ModuleName: {authtypes.Burner}, - skywaymoduletypes.ModuleName: {authtypes.Minter, authtypes.Burner}, - ibctransfertypes.ModuleName: {authtypes.Minter, authtypes.Burner}, - ibcfeetypes.ModuleName: nil, - icatypes.ModuleName: nil, - wasmtypes.ModuleName: {authtypes.Burner}, - treasurymoduletypes.ModuleName: {authtypes.Burner, authtypes.Minter}, - palomamoduletypes.ModuleName: nil, + authtypes.FeeCollectorName: nil, + distrtypes.ModuleName: nil, + minttypes.ModuleName: {authtypes.Minter}, + stakingtypes.BondedPoolName: {authtypes.Burner, authtypes.Staking}, + stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking}, + govtypes.ModuleName: {authtypes.Burner}, + skywaymoduletypes.ModuleName: {authtypes.Minter, authtypes.Burner}, + ibctransfertypes.ModuleName: {authtypes.Minter, authtypes.Burner}, + ibcfeetypes.ModuleName: nil, + icatypes.ModuleName: nil, + wasmtypes.ModuleName: {authtypes.Burner}, + treasurymoduletypes.ModuleName: {authtypes.Burner, authtypes.Minter}, + palomamoduletypes.ModuleName: nil, + tokenfactorymoduletypes.ModuleName: {authtypes.Minter, authtypes.Burner}, } ) @@ -250,15 +254,16 @@ type App struct { ICAHostKeeper icahostkeeper.Keeper TransferKeeper ibctransferkeeper.Keeper - SchedulerKeeper schedulermodulekeeper.Keeper - ConsensusKeeper consensusmodulekeeper.Keeper - ValsetKeeper valsetmodulekeeper.Keeper - PalomaKeeper palomamodulekeeper.Keeper - TreasuryKeeper treasurymodulekeeper.Keeper - EvmKeeper evmmodulekeeper.Keeper - SkywayKeeper skywaymodulekeeper.Keeper - wasmKeeper wasmkeeper.Keeper - MetrixKeeper metrixmodulekeeper.Keeper + SchedulerKeeper schedulermodulekeeper.Keeper + ConsensusKeeper consensusmodulekeeper.Keeper + ValsetKeeper valsetmodulekeeper.Keeper + PalomaKeeper palomamodulekeeper.Keeper + TreasuryKeeper treasurymodulekeeper.Keeper + EvmKeeper evmmodulekeeper.Keeper + SkywayKeeper skywaymodulekeeper.Keeper + wasmKeeper wasmkeeper.Keeper + MetrixKeeper metrixmodulekeeper.Keeper + TokenFactoryKeeper tokenfactorymodulekeeper.Keeper // ModuleManager is the module manager ModuleManager *module.Manager @@ -342,6 +347,7 @@ func New( wasmtypes.StoreKey, palomamoduletypes.StoreKey, authzkeeper.StoreKey, + tokenfactorymoduletypes.StoreKey, ) tkeys := storetypes.NewTransientStoreKeys(paramstypes.TStoreKey) memKeys := storetypes.NewMemoryStoreKeys( @@ -353,6 +359,7 @@ func New( treasurymoduletypes.MemStoreKey, palomamoduletypes.MemStoreKey, metrixmoduletypes.MemStoreKey, + tokenfactorymoduletypes.MemStoreKey, ) app := &App{ @@ -671,6 +678,14 @@ func New( app.EvmKeeper, ) + app.TokenFactoryKeeper = tokenfactorymodulekeeper.NewKeeper( + keys[tokenfactorymoduletypes.StoreKey], + app.GetSubspace(tokenfactorymoduletypes.ModuleName), + app.AccountKeeper, + app.BankKeeper, + app.DistrKeeper, + authorityAddress) + app.ScopedConsensusKeeper = scopedConsensusKeeper govRouter := govv1beta1.NewRouter() @@ -804,6 +819,7 @@ func New( skywayModule := skywaymodule.NewAppModule(appCodec, app.SkywayKeeper, app.BankKeeper, app.GetSubspace(skywaymoduletypes.ModuleName), libcons.New(app.ValsetKeeper.GetCurrentSnapshot, appCodec)) treasuryModule := treasurymodule.NewAppModule(appCodec, app.TreasuryKeeper, app.AccountKeeper, app.BankKeeper) metrixModule := metrix.NewAppModule(appCodec, app.MetrixKeeper) + tokenfactorymodule := tokenfactory.NewAppModule(app.TokenFactoryKeeper, app.AccountKeeper, app.BankKeeper) stakingAppModule := staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper, app.GetSubspace(stakingtypes.ModuleName)) @@ -836,6 +852,7 @@ func New( palomaModule, treasuryModule, metrixModule, + tokenfactorymodule, wasm.NewAppModule(appCodec, &app.wasmKeeper, app.StakingKeeper, app.AccountKeeper, app.BankKeeper, app.MsgServiceRouter(), app.GetSubspace(wasmtypes.ModuleName)), ibc.NewAppModule(app.IBCKeeper), transfer.NewAppModule(app.TransferKeeper), @@ -894,6 +911,7 @@ func New( ibcfeetypes.ModuleName, consensusparamtypes.ModuleName, metrixmoduletypes.ModuleName, + tokenfactorymoduletypes.ModuleName, ) app.ModuleManager.SetOrderEndBlockers( @@ -927,6 +945,7 @@ func New( treasurymoduletypes.ModuleName, consensusparamtypes.ModuleName, metrixmoduletypes.ModuleName, + tokenfactorymoduletypes.ModuleName, ) // NOTE: The genutils module must occur after staking so that pools are @@ -966,6 +985,7 @@ func New( treasurymoduletypes.ModuleName, consensusparamtypes.ModuleName, metrixmoduletypes.ModuleName, + tokenfactorymoduletypes.ModuleName, ) app.configurator = module.NewConfigurator(appCodec, app.MsgServiceRouter(), app.GRPCQueryRouter()) diff --git a/app/upgrades.go b/app/upgrades.go index 0e01f8eb..6bf947ab 100644 --- a/app/upgrades.go +++ b/app/upgrades.go @@ -22,6 +22,7 @@ import ( metrixmoduletypes "github.com/palomachain/paloma/v2/x/metrix/types" palomamoduletypes "github.com/palomachain/paloma/v2/x/paloma/types" skywaymoduletypes "github.com/palomachain/paloma/v2/x/skyway/types" + tokenfactorymoduletypes "github.com/palomachain/paloma/v2/x/tokenfactory/types" ) var minCommissionRate = math.LegacyMustNewDecFromStr("0.05") @@ -172,6 +173,17 @@ func (app *App) RegisterUpgradeHandlers(semverVersion string) { app.SetStoreLoader(upgradetypes.UpgradeStoreLoader(upgradeInfo.Height, &storeUpgrades)) } + if upgradeInfo.Name == "v2.4.0" && !app.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height) { + storeUpgrades := storetypes.StoreUpgrades{ + Added: []string{ + tokenfactorymoduletypes.StoreKey, + }, + } + + // configure store loader that checks if version == upgradeHeight and applies store upgrades + app.SetStoreLoader(upgradetypes.UpgradeStoreLoader(upgradeInfo.Height, &storeUpgrades)) + } + app.UpgradeKeeper.SetUpgradeHandler(semverVersion, func(ctx context.Context, plan upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) { return app.ModuleManager.RunMigrations(ctx, app.configurator, fromVM) }) diff --git a/x/tokenfactory/module.go b/x/tokenfactory/module.go new file mode 100644 index 00000000..f6476121 --- /dev/null +++ b/x/tokenfactory/module.go @@ -0,0 +1,199 @@ +package tokenfactory + +import ( + "context" + "encoding/json" + "fmt" + + abci "github.com/cometbft/cometbft/abci/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/codec" + cdctypes "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/palomachain/paloma/v2/x/tokenfactory/client/cli" + "github.com/palomachain/paloma/v2/x/tokenfactory/keeper" + "github.com/palomachain/paloma/v2/x/tokenfactory/types" + "github.com/spf13/cobra" +) + +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} +) + +// ---------------------------------------------------------------------------- +// AppModuleBasic +// ---------------------------------------------------------------------------- + +// AppModuleBasic implements the AppModuleBasic interface for the capability module. +type AppModuleBasic struct{} + +func NewAppModuleBasic() AppModuleBasic { + return AppModuleBasic{} +} + +// Name returns the x/tokenfactory module's name. +func (AppModuleBasic) Name() string { + return types.ModuleName +} + +func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + types.RegisterCodec(cdc) +} + +// RegisterInterfaces registers the module's interface types +func (a AppModuleBasic) RegisterInterfaces(reg cdctypes.InterfaceRegistry) { + types.RegisterInterfaces(reg) +} + +// DefaultGenesis returns the x/tokenfactory module's default genesis state. +func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { + return cdc.MustMarshalJSON(types.DefaultGenesis()) +} + +// ValidateGenesis performs genesis state validation for the x/tokenfactory module. +func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error { + var genState types.GenesisState + if err := cdc.UnmarshalJSON(bz, &genState); err != nil { + return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) + } + + return genState.Validate() +} + +// RegisterRESTRoutes registers the capability module's REST service handlers. +func (AppModuleBasic) RegisterRESTRoutes(clientCtx client.Context, rtr *mux.Router) { +} + +// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the module. +func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) { + types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx)) //nolint:errcheck +} + +// GetTxCmd returns the x/tokenfactory module's root tx command. +func (a AppModuleBasic) GetTxCmd() *cobra.Command { + return cli.GetTxCmd() +} + +// GetQueryCmd returns the x/tokenfactory module's root query command. +func (AppModuleBasic) GetQueryCmd() *cobra.Command { + return cli.GetQueryCmd() +} + +// ---------------------------------------------------------------------------- +// AppModule +// ---------------------------------------------------------------------------- + +// AppModule implements the AppModule interface for the capability module. +type AppModule struct { + AppModuleBasic + + keeper keeper.Keeper + accountKeeper types.AccountKeeper + bankKeeper types.BankKeeper +} + +func (am AppModule) IsAppModule() {} +func (am AppModule) IsOnePerModuleType() {} + +func (am AppModule) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) { + if err := types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx)); err != nil { + panic(err) + } +} + +func (am AppModule) RegisterInterfaces(reg cdctypes.InterfaceRegistry) { + types.RegisterInterfaces(reg) +} + +func (am AppModule) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + types.RegisterCodec(cdc) +} + +func NewAppModule( + keeper keeper.Keeper, + accountKeeper types.AccountKeeper, + bankKeeper types.BankKeeper, +) AppModule { + return AppModule{ + AppModuleBasic: NewAppModuleBasic(), + keeper: keeper, + accountKeeper: accountKeeper, + bankKeeper: bankKeeper, + } +} + +// Name returns the x/tokenfactory module's name. +func (am AppModule) Name() string { + return am.AppModuleBasic.Name() +} + +// QuerierRoute returns the capability module's query routing key. +func (AppModule) QuerierRoute() string { return types.QuerierRoute } + +// 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(), keeper.NewMsgServerImpl(am.keeper)) + types.RegisterQueryServer(cfg.QueryServer(), am.keeper) +} + +// RegisterInvariants registers the x/tokenfactory module's invariants. +func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {} + +// InitGenesis performs the x/tokenfactory module's genesis initialization. It +// returns no validator updates. +func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, gs json.RawMessage) []abci.ValidatorUpdate { + var genState types.GenesisState + cdc.MustUnmarshalJSON(gs, &genState) + + am.keeper.InitGenesis(ctx, genState) + + return []abci.ValidatorUpdate{} +} + +// ExportGenesis returns the x/tokenfactory module's exported genesis state as raw +// JSON bytes. +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + genState := am.keeper.ExportGenesis(ctx) + return cdc.MustMarshalJSON(genState) +} + +// ConsensusVersion implements ConsensusVersion. +func (AppModule) ConsensusVersion() uint64 { return 1 } + +// BeginBlock executes all ABCI BeginBlock logic respective to the tokenfactory module. +func (am AppModule) BeginBlock(ctx context.Context) error { return nil } + +// EndBlock executes all ABCI EndBlock logic respective to the tokenfactory module. It +// returns no validator updates. +func (am AppModule) EndBlock(ctx context.Context) error { + return nil +} + +// GenerateGenesisState creates a randomized GenState of the distribution module. +func (AppModule) GenerateGenesisState(simState *module.SimulationState) { + // TODO: implement +} + +// ProposalContents returns all the distribution content functions used to +// simulate governance proposals. +func (am AppModule) ProposalContents(simState module.SimulationState) []simtypes.WeightedProposalContent { + // TODO: implement + return nil +} + +// RegisterStoreDecoder registers a decoder for distribution module's types +func (am AppModule) RegisterStoreDecoder(sdr simtypes.StoreDecoderRegistry) { + // TODO: implement +} + +// WeightedOperations returns the all the gov module operations with their respective weights. +func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation { + // TODO: implement + return nil +} From 461ee9983cd6729c96ef532768899a3e2c8039d0 Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Thu, 12 Dec 2024 22:47:54 +0100 Subject: [PATCH 6/9] Register in params keeper --- app/app.go | 1 + 1 file changed, 1 insertion(+) diff --git a/app/app.go b/app/app.go index b3bbc85c..7b632456 100644 --- a/app/app.go +++ b/app/app.go @@ -1258,6 +1258,7 @@ func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino paramsKeeper.Subspace(evmmoduletypes.ModuleName) paramsKeeper.Subspace(skywaymoduletypes.ModuleName).WithKeyTable(skywaymoduletypes.ParamKeyTable()) paramsKeeper.Subspace(metrixmoduletypes.ModuleName) + paramsKeeper.Subspace(tokenfactorymoduletypes.ModuleName) paramsKeeper.Subspace(ibcexported.ModuleName).WithKeyTable(keyTable) paramsKeeper.Subspace(ibctransfertypes.ModuleName).WithKeyTable(ibctransfertypes.ParamKeyTable()) From 842747d801ef4df1c1ad80295d1318768f2e99f4 Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Thu, 12 Dec 2024 22:53:47 +0100 Subject: [PATCH 7/9] Remove legacy module account creation --- x/tokenfactory/keeper/genesis.go | 2 -- x/tokenfactory/keeper/keeper.go | 10 ---------- 2 files changed, 12 deletions(-) diff --git a/x/tokenfactory/keeper/genesis.go b/x/tokenfactory/keeper/genesis.go index 9cb29ae5..c660fb49 100644 --- a/x/tokenfactory/keeper/genesis.go +++ b/x/tokenfactory/keeper/genesis.go @@ -8,8 +8,6 @@ import ( ) func (k Keeper) InitGenesis(ctx context.Context, genState types.GenesisState) { - k.CreateModuleAccount(ctx) - if genState.Params.DenomCreationFee == nil { genState.Params.DenomCreationFee = sdk.NewCoins() } diff --git a/x/tokenfactory/keeper/keeper.go b/x/tokenfactory/keeper/keeper.go index 46ef6ebb..e1adfe26 100644 --- a/x/tokenfactory/keeper/keeper.go +++ b/x/tokenfactory/keeper/keeper.go @@ -8,7 +8,6 @@ import ( "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" sdk "github.com/cosmos/cosmos-sdk/types" - authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/palomachain/paloma/v2/util/liblog" "github.com/palomachain/paloma/v2/x/tokenfactory/types" @@ -74,15 +73,6 @@ func (k Keeper) GetCreatorsPrefixStore(ctx context.Context) storetypes.KVStore { return prefix.NewStore(store, types.GetCreatorsPrefix()) } -// CreateModuleAccount creates a module account with minting and burning capabilities -// This account isn't intended to store any coins, -// it purely mints and burns them on behalf of the admin of respective denoms, -// and sends to the relevant address. -func (k Keeper) CreateModuleAccount(ctx context.Context) { - moduleAcc := authtypes.NewEmptyModuleAccount(types.ModuleName, authtypes.Minter, authtypes.Burner) - k.accountKeeper.SetModuleAccount(ctx, moduleAcc) -} - func (k Keeper) GetParams(ctx context.Context) (params types.Params) { sdkCtx := sdk.UnwrapSDKContext(ctx) k.paramSpace.GetParamSet(sdkCtx, ¶ms) From c3600620d5c61ef701a8038f2378f2cfccaf797f Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Fri, 13 Dec 2024 14:42:57 +0100 Subject: [PATCH 8/9] Add user token mapping feature --- app/app.go | 17 +- proto/palomachain/paloma/skyway/msgs.proto | 22 + x/consensus/types/consensus_queue.pb.go | 174 +++-- x/consensus/types/genesis.pb.go | 32 +- x/consensus/types/packet.pb.go | 43 +- x/consensus/types/params.pb.go | 35 +- x/consensus/types/query.pb.go | 158 ++--- x/consensus/types/simple_test_message.pb.go | 36 +- x/consensus/types/tx.pb.go | 203 ++++-- x/evm/types/add_chain_proposal.pb.go | 58 +- x/evm/types/chain_info.pb.go | 100 +-- ...change_min_on_chain_balance_proposal.pb.go | 32 +- .../deploy_new_smart_contract_proposal.pb.go | 32 +- .../evm_reference_block_attestation.pb.go | 73 ++- x/evm/types/evm_state_attestation.pb.go | 83 ++- x/evm/types/genesis.pb.go | 52 +- x/evm/types/job.pb.go | 40 +- x/evm/types/params.pb.go | 36 +- x/evm/types/query.pb.go | 210 ++++-- x/evm/types/relay_weights.pb.go | 34 +- x/evm/types/relay_weights_proposal.pb.go | 66 +- x/evm/types/remove_chain_proposal.pb.go | 32 +- x/evm/types/set_fee_mgr_proposal.pb.go | 10 +- ...et_smart_contract_deployers_proposal.pb.go | 70 +- x/evm/types/treasury.pb.go | 66 +- x/evm/types/turnstone.pb.go | 139 ++-- x/evm/types/tx.pb.go | 158 +++-- x/evm/types/user_smart_contract.pb.go | 96 +-- x/metrix/types/genesis.pb.go | 34 +- x/metrix/types/metrix.pb.go | 116 ++-- x/metrix/types/params.pb.go | 37 +- x/metrix/types/query.pb.go | 158 +++-- x/metrix/types/tx.pb.go | 36 +- .../types/light_node_client_feegranter.pb.go | 34 +- ...ight_node_client_feegranter_proposal.pb.go | 30 +- .../types/light_node_client_funders.pb.go | 34 +- .../light_node_client_funders_proposal.pb.go | 30 +- .../types/light_node_client_license.pb.go | 64 +- x/scheduler/types/genesis.pb.go | 32 +- x/scheduler/types/job.pb.go | 140 ++-- x/scheduler/types/packet.pb.go | 43 +- x/scheduler/types/params.pb.go | 35 +- x/scheduler/types/query.pb.go | 107 +-- x/scheduler/types/tx.pb.go | 111 ++-- x/skyway/client/cli/tx.go | 42 ++ x/skyway/keeper/keeper.go | 27 +- x/skyway/keeper/msg_server.go | 43 ++ x/skyway/keeper/test_common.go | 1 + x/skyway/types/attestation.pb.go | 140 ++-- x/skyway/types/batch.pb.go | 126 ++-- x/skyway/types/bridge_tax.pb.go | 34 +- x/skyway/types/bridge_tax_proposal.pb.go | 62 +- x/skyway/types/bridge_transfer_limit.pb.go | 90 +-- .../bridge_transfer_limit_proposal.pb.go | 68 +- x/skyway/types/codec.go | 2 + x/skyway/types/erc20_to_denom_proposal.pb.go | 59 +- x/skyway/types/errors.go | 1 + x/skyway/types/ethereum_signer.pb.go | 23 +- x/skyway/types/events.go | 5 + x/skyway/types/expected_keepers.go | 5 + x/skyway/types/genesis.pb.go | 120 ++-- .../types/gravity/bridge_tax_proposal.pb.go | 63 +- .../bridge_transfer_limit_proposal.pb.go | 74 ++- .../gravity/erc20_to_denom_proposal.pb.go | 58 +- x/skyway/types/legacy_msgs.pb.go | 74 ++- x/skyway/types/light_node_sale_contract.pb.go | 30 +- .../light_node_sale_contracts_proposal.pb.go | 30 +- x/skyway/types/msgs.go | 35 + x/skyway/types/msgs.pb.go | 611 ++++++++++++++---- x/skyway/types/msgs.pb.gw.go | 159 +++-- x/skyway/types/params.pb.go | 69 +- x/skyway/types/pool.pb.go | 78 ++- x/skyway/types/query.pb.go | 480 ++++++++++---- x/skyway/types/types.pb.go | 84 ++- x/tokenfactory/types/params.go | 6 +- .../types/community_fund_fee_proposal.pb.go | 34 +- x/treasury/types/fees.pb.go | 113 ++-- x/treasury/types/genesis.pb.go | 58 +- x/treasury/types/params.pb.go | 35 +- x/treasury/types/query.pb.go | 140 ++-- x/treasury/types/security_fee_proposal.pb.go | 32 +- x/treasury/types/tx.pb.go | 44 +- x/valset/types/common.pb.go | 34 +- x/valset/types/genesis.pb.go | 33 +- x/valset/types/jail.pb.go | 66 +- x/valset/types/params.pb.go | 37 +- x/valset/types/pigeon_requirements.pb.go | 37 +- x/valset/types/query.pb.go | 281 +++++--- .../set_pigeon_requirements_proposal.pb.go | 54 +- x/valset/types/snapshot.pb.go | 126 ++-- x/valset/types/tx.pb.go | 70 +- 91 files changed, 4678 insertions(+), 2363 deletions(-) diff --git a/app/app.go b/app/app.go index 7b632456..725191dc 100644 --- a/app/app.go +++ b/app/app.go @@ -625,6 +625,14 @@ func New( app.EvmKeeper, } + app.TokenFactoryKeeper = tokenfactorymodulekeeper.NewKeeper( + keys[tokenfactorymoduletypes.StoreKey], + app.GetSubspace(tokenfactorymoduletypes.ModuleName), + app.AccountKeeper, + app.BankKeeper, + app.DistrKeeper, + authorityAddress) + app.SkywayKeeper = skywaymodulekeeper.NewKeeper( appCodec, app.AccountKeeper, @@ -636,6 +644,7 @@ func New( app.EvmKeeper, app.ConsensusKeeper, app.PalomaKeeper, + app.TokenFactoryKeeper, skywaymodulekeeper.NewSkywayStoreGetter(keys[skywaymoduletypes.StoreKey]), authorityAddress, authcodec.NewBech32Codec(chainparams.ValidatorAddressPrefix), @@ -678,14 +687,6 @@ func New( app.EvmKeeper, ) - app.TokenFactoryKeeper = tokenfactorymodulekeeper.NewKeeper( - keys[tokenfactorymoduletypes.StoreKey], - app.GetSubspace(tokenfactorymoduletypes.ModuleName), - app.AccountKeeper, - app.BankKeeper, - app.DistrKeeper, - authorityAddress) - app.ScopedConsensusKeeper = scopedConsensusKeeper govRouter := govv1beta1.NewRouter() diff --git a/proto/palomachain/paloma/skyway/msgs.proto b/proto/palomachain/paloma/skyway/msgs.proto index 2513b35f..f40fa9da 100644 --- a/proto/palomachain/paloma/skyway/msgs.proto +++ b/proto/palomachain/paloma/skyway/msgs.proto @@ -66,6 +66,12 @@ service Msg { "/palomachain/paloma/skyway/light-node-sale-claim"; } + rpc SetERC20ToTokenDenom(MsgSetERC20ToTokenDenom) + returns (google.protobuf.Empty) { + option (google.api.http).post = + "/palomachain/paloma/skyway/erc20-to-token-denom"; + } + rpc OverrideNonceProposal(MsgNonceOverrideProposal) returns (google.protobuf.Empty); } @@ -303,3 +309,19 @@ message MsgEstimateBatchGas { string eth_signer = 4; uint64 estimate = 5; } + +// MsgSetERC20ToTokenDenom is a message to set the mapping between an ERC20 token +// and a denom created by the token factory. +// Needs admin rights on the token to set the mapping. +message MsgSetERC20ToTokenDenom { + option (cosmos.msg.v1.signer) = "metadata"; + + palomachain.paloma.valset.MsgMetadata metadata = 1 + [ + (gogoproto.moretags) = "yaml:\"metadata\"", + (gogoproto.nullable) = false + ]; + string denom = 2 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; + string chain_reference_id = 3 [ (gogoproto.moretags) = "yaml:\"chain_reference_id\"" ]; + string erc20 = 4 [ (gogoproto.moretags) = "yaml:\"erc20\"" ]; +} diff --git a/x/consensus/types/consensus_queue.pb.go b/x/consensus/types/consensus_queue.pb.go index b80db95d..4f177e73 100644 --- a/x/consensus/types/consensus_queue.pb.go +++ b/x/consensus/types/consensus_queue.pb.go @@ -4,8 +4,13 @@ package types import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + time "time" + + cosmossdk_io_math "cosmossdk.io/math" _ "github.com/cosmos/cosmos-proto" types "github.com/cosmos/cosmos-sdk/codec/types" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" @@ -14,17 +19,15 @@ import ( proto "github.com/cosmos/gogoproto/proto" github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "google.golang.org/protobuf/types/known/timestamppb" - io "io" - math "math" - math_bits "math/bits" - time "time" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf -var _ = time.Kitchen +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = math.Inf + _ = time.Kitchen +) // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -58,9 +61,11 @@ func (*QueuedSignedMessage) ProtoMessage() {} func (*QueuedSignedMessage) Descriptor() ([]byte, []int) { return fileDescriptor_3a5520bff1a7c91d, []int{0} } + func (m *QueuedSignedMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueuedSignedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueuedSignedMessage.Marshal(b, m, deterministic) @@ -73,12 +78,15 @@ func (m *QueuedSignedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueuedSignedMessage) XXX_Merge(src proto.Message) { xxx_messageInfo_QueuedSignedMessage.Merge(m, src) } + func (m *QueuedSignedMessage) XXX_Size() int { return m.Size() } + func (m *QueuedSignedMessage) XXX_DiscardUnknown() { xxx_messageInfo_QueuedSignedMessage.DiscardUnknown(m) } @@ -179,9 +187,11 @@ func (*BatchOfConsensusMessages) ProtoMessage() {} func (*BatchOfConsensusMessages) Descriptor() ([]byte, []int) { return fileDescriptor_3a5520bff1a7c91d, []int{1} } + func (m *BatchOfConsensusMessages) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *BatchOfConsensusMessages) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchOfConsensusMessages.Marshal(b, m, deterministic) @@ -194,12 +204,15 @@ func (m *BatchOfConsensusMessages) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *BatchOfConsensusMessages) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchOfConsensusMessages.Merge(m, src) } + func (m *BatchOfConsensusMessages) XXX_Size() int { return m.Size() } + func (m *BatchOfConsensusMessages) XXX_DiscardUnknown() { xxx_messageInfo_BatchOfConsensusMessages.DiscardUnknown(m) } @@ -224,9 +237,11 @@ func (*Batch) ProtoMessage() {} func (*Batch) Descriptor() ([]byte, []int) { return fileDescriptor_3a5520bff1a7c91d, []int{2} } + func (m *Batch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Batch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Batch.Marshal(b, m, deterministic) @@ -239,12 +254,15 @@ func (m *Batch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Batch) XXX_Merge(src proto.Message) { xxx_messageInfo_Batch.Merge(m, src) } + func (m *Batch) XXX_Size() int { return m.Size() } + func (m *Batch) XXX_DiscardUnknown() { xxx_messageInfo_Batch.DiscardUnknown(m) } @@ -279,9 +297,11 @@ func (*SignData) ProtoMessage() {} func (*SignData) Descriptor() ([]byte, []int) { return fileDescriptor_3a5520bff1a7c91d, []int{3} } + func (m *SignData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SignData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SignData.Marshal(b, m, deterministic) @@ -294,12 +314,15 @@ func (m *SignData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *SignData) XXX_Merge(src proto.Message) { xxx_messageInfo_SignData.Merge(m, src) } + func (m *SignData) XXX_Size() int { return m.Size() } + func (m *SignData) XXX_DiscardUnknown() { xxx_messageInfo_SignData.DiscardUnknown(m) } @@ -352,9 +375,11 @@ func (*Evidence) ProtoMessage() {} func (*Evidence) Descriptor() ([]byte, []int) { return fileDescriptor_3a5520bff1a7c91d, []int{4} } + func (m *Evidence) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Evidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Evidence.Marshal(b, m, deterministic) @@ -367,12 +392,15 @@ func (m *Evidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Evidence) XXX_Merge(src proto.Message) { xxx_messageInfo_Evidence.Merge(m, src) } + func (m *Evidence) XXX_Size() int { return m.Size() } + func (m *Evidence) XXX_DiscardUnknown() { xxx_messageInfo_Evidence.DiscardUnknown(m) } @@ -404,9 +432,11 @@ func (*GasEstimate) ProtoMessage() {} func (*GasEstimate) Descriptor() ([]byte, []int) { return fileDescriptor_3a5520bff1a7c91d, []int{5} } + func (m *GasEstimate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *GasEstimate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GasEstimate.Marshal(b, m, deterministic) @@ -419,12 +449,15 @@ func (m *GasEstimate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *GasEstimate) XXX_Merge(src proto.Message) { xxx_messageInfo_GasEstimate.Merge(m, src) } + func (m *GasEstimate) XXX_Size() int { return m.Size() } + func (m *GasEstimate) XXX_DiscardUnknown() { xxx_messageInfo_GasEstimate.DiscardUnknown(m) } @@ -457,9 +490,11 @@ func (*PublicAccessData) ProtoMessage() {} func (*PublicAccessData) Descriptor() ([]byte, []int) { return fileDescriptor_3a5520bff1a7c91d, []int{6} } + func (m *PublicAccessData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *PublicAccessData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PublicAccessData.Marshal(b, m, deterministic) @@ -472,12 +507,15 @@ func (m *PublicAccessData) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *PublicAccessData) XXX_Merge(src proto.Message) { xxx_messageInfo_PublicAccessData.Merge(m, src) } + func (m *PublicAccessData) XXX_Size() int { return m.Size() } + func (m *PublicAccessData) XXX_DiscardUnknown() { xxx_messageInfo_PublicAccessData.DiscardUnknown(m) } @@ -516,9 +554,11 @@ func (*ErrorData) ProtoMessage() {} func (*ErrorData) Descriptor() ([]byte, []int) { return fileDescriptor_3a5520bff1a7c91d, []int{7} } + func (m *ErrorData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ErrorData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ErrorData.Marshal(b, m, deterministic) @@ -531,12 +571,15 @@ func (m *ErrorData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *ErrorData) XXX_Merge(src proto.Message) { xxx_messageInfo_ErrorData.Merge(m, src) } + func (m *ErrorData) XXX_Size() int { return m.Size() } + func (m *ErrorData) XXX_DiscardUnknown() { xxx_messageInfo_ErrorData.DiscardUnknown(m) } @@ -573,60 +616,60 @@ func init() { } var fileDescriptor_3a5520bff1a7c91d = []byte{ - // 835 bytes of a gzipped FileDescriptorProto + // 838 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xbf, 0x8f, 0xe3, 0x44, 0x14, 0xce, 0x6c, 0x9c, 0x3d, 0x67, 0xb2, 0x77, 0xda, 0x1b, 0x16, 0xf0, 0xad, 0x4e, 0x89, 0x95, - 0xe2, 0x30, 0x27, 0xd6, 0x86, 0x45, 0xa2, 0xa0, 0x40, 0x8a, 0xb9, 0x15, 0x04, 0xb4, 0x82, 0x9b, - 0x3d, 0x51, 0x5c, 0x13, 0x4d, 0xec, 0x89, 0x63, 0xc5, 0xf6, 0xe4, 0x3c, 0xe3, 0x68, 0xf3, 0x27, - 0xd0, 0x5d, 0x83, 0x44, 0x49, 0x83, 0x44, 0x49, 0xc1, 0x1f, 0xb1, 0xe5, 0x89, 0x0a, 0x51, 0x04, - 0xb4, 0x5b, 0x50, 0xd2, 0x53, 0x21, 0xcf, 0xd8, 0x8e, 0xf7, 0xc7, 0xed, 0xd2, 0x2c, 0x4d, 0xf2, - 0xe6, 0xbd, 0xf7, 0xbd, 0xf9, 0x66, 0xde, 0xf7, 0xc6, 0x70, 0x7f, 0x4e, 0x22, 0x16, 0x13, 0x6f, - 0x4a, 0xc2, 0xc4, 0x51, 0xb6, 0xe3, 0xb1, 0x84, 0xd3, 0x84, 0x67, 0x7c, 0x6d, 0x8d, 0x5e, 0x64, - 0x34, 0xa3, 0xf6, 0x3c, 0x65, 0x82, 0xa1, 0x87, 0x35, 0x8c, 0xad, 0x6c, 0xbb, 0xca, 0xdc, 0x7d, - 0x10, 0x30, 0x16, 0x44, 0xd4, 0x91, 0xb9, 0xe3, 0x6c, 0xe2, 0x90, 0x64, 0xa9, 0x80, 0xbb, 0x3b, + 0xe2, 0x30, 0x27, 0xd6, 0x86, 0x20, 0x51, 0x50, 0x20, 0xc5, 0xdc, 0x0a, 0x16, 0x58, 0xc1, 0xcd, + 0x9e, 0x28, 0xae, 0x89, 0x26, 0xf6, 0xc4, 0xb1, 0x62, 0x7b, 0x72, 0x9e, 0x71, 0xb4, 0xf9, 0x13, + 0xe8, 0xae, 0x41, 0xa2, 0xa4, 0x41, 0xa2, 0xa4, 0xe0, 0x8f, 0xd8, 0xf2, 0x44, 0x85, 0x28, 0x02, + 0xda, 0x2d, 0x28, 0xe9, 0xa9, 0x90, 0x67, 0x6c, 0xc7, 0xfb, 0xe3, 0xf6, 0x68, 0xf6, 0x9a, 0xe4, + 0xcd, 0x7b, 0xef, 0x7b, 0xf3, 0xcd, 0xbc, 0xef, 0x8d, 0xe1, 0x60, 0x4e, 0x22, 0x16, 0x13, 0x6f, + 0x4a, 0xc2, 0xc4, 0x51, 0xb6, 0xe3, 0xb1, 0x84, 0xd3, 0x84, 0x67, 0x7c, 0x6d, 0x8d, 0x9e, 0x65, + 0x34, 0xa3, 0xf6, 0x3c, 0x65, 0x82, 0xa1, 0xfb, 0x35, 0x8c, 0xad, 0x6c, 0xbb, 0xca, 0xdc, 0xbd, + 0x17, 0x30, 0x16, 0x44, 0xd4, 0x91, 0xb9, 0xe3, 0x6c, 0xe2, 0x90, 0x64, 0xa9, 0x80, 0xbb, 0x3b, 0x01, 0x0b, 0x98, 0x34, 0x9d, 0xdc, 0x2a, 0xbc, 0xbd, 0x8b, 0x00, 0x11, 0xc6, 0x94, 0x0b, 0x12, - 0xcf, 0x8b, 0x84, 0x07, 0x1e, 0xe3, 0x31, 0xe3, 0x23, 0x85, 0x54, 0x8b, 0x22, 0x74, 0x9f, 0xc4, - 0x61, 0xc2, 0x1c, 0xf9, 0xab, 0x5c, 0xfd, 0x1f, 0x37, 0xe1, 0x1b, 0x4f, 0x73, 0xb6, 0xfe, 0x51, - 0x18, 0x24, 0xd4, 0x3f, 0xa4, 0x9c, 0x93, 0x80, 0xa2, 0x7b, 0x70, 0x23, 0xf4, 0x0d, 0x60, 0x02, - 0x4b, 0xc3, 0x1b, 0xa1, 0x8f, 0x6c, 0x88, 0x88, 0xef, 0x53, 0x7f, 0x20, 0xdc, 0x88, 0x79, 0xb3, - 0xcf, 0x69, 0x18, 0x4c, 0x85, 0xb1, 0x61, 0x02, 0xab, 0x89, 0xaf, 0x88, 0xa0, 0x4f, 0xe0, 0x9d, - 0xc2, 0x6b, 0x34, 0x4d, 0x60, 0x75, 0xf6, 0x77, 0x6d, 0x45, 0xdc, 0x2e, 0x89, 0xdb, 0xcf, 0x4a, - 0xe2, 0xae, 0x7e, 0xb2, 0xea, 0x35, 0x5e, 0xfe, 0xd1, 0x03, 0xb8, 0x04, 0xa1, 0x47, 0xb0, 0x19, - 0xf3, 0xc0, 0xd0, 0x24, 0x76, 0xe7, 0x12, 0x76, 0x90, 0x2c, 0x71, 0x9e, 0x80, 0x5c, 0xa8, 0xf3, - 0x30, 0x48, 0x9e, 0x10, 0x41, 0x8c, 0x4d, 0xb3, 0x69, 0x75, 0xf6, 0x1f, 0xd9, 0xd7, 0x5d, 0xb8, - 0x7d, 0x54, 0x64, 0xe3, 0x0a, 0x97, 0xd7, 0xa0, 0x8b, 0xd0, 0xa7, 0x89, 0x47, 0x8d, 0x3b, 0xff, - 0xa5, 0xc6, 0x41, 0x91, 0x8d, 0x2b, 0x1c, 0x7a, 0x0e, 0xb7, 0xe7, 0xd9, 0x38, 0x0a, 0xbd, 0x81, - 0xe7, 0x51, 0xce, 0x25, 0x1f, 0x5d, 0x92, 0xb7, 0xaf, 0xaf, 0xf5, 0xf5, 0x05, 0x14, 0xbe, 0x54, - 0x07, 0xbd, 0x07, 0xef, 0xa7, 0xf4, 0x45, 0x16, 0xa6, 0x34, 0x27, 0x4f, 0x44, 0x96, 0x52, 0x6e, - 0xb4, 0x4d, 0x60, 0xe9, 0xf8, 0x72, 0x00, 0x1d, 0xc0, 0x36, 0x4d, 0x53, 0x96, 0x4a, 0x0a, 0x50, - 0x52, 0x78, 0xe7, 0x86, 0xe3, 0x94, 0xe9, 0x78, 0x8d, 0x44, 0x01, 0x7c, 0x7b, 0x4a, 0x12, 0x3f, - 0xa2, 0xfe, 0x88, 0x88, 0xd1, 0x38, 0x6f, 0xed, 0x68, 0xaa, 0xba, 0xde, 0x31, 0x81, 0xd5, 0x76, - 0xdf, 0x3f, 0x59, 0xf5, 0xc0, 0xef, 0xab, 0xde, 0x9b, 0x4a, 0x62, 0xdc, 0x9f, 0xd9, 0x21, 0x73, - 0x62, 0x22, 0xa6, 0xf6, 0x30, 0x11, 0xbf, 0xfe, 0xb2, 0x07, 0x0b, 0xed, 0x0d, 0x13, 0xf1, 0xd3, - 0x5f, 0x3f, 0x3f, 0x06, 0x78, 0xa7, 0x28, 0x78, 0x5e, 0x29, 0x87, 0x70, 0x2b, 0x20, 0xfc, 0x80, - 0x8b, 0x30, 0x26, 0x82, 0x72, 0x63, 0x4b, 0x76, 0xe0, 0xdd, 0xeb, 0x29, 0x7f, 0xb6, 0x46, 0xe0, - 0x73, 0x70, 0xb4, 0x0b, 0xf5, 0x49, 0x44, 0x82, 0x43, 0xc2, 0x67, 0xc6, 0x5d, 0x13, 0x58, 0x77, - 0x71, 0xb5, 0x46, 0x26, 0xec, 0xd4, 0x72, 0x8d, 0x7b, 0x52, 0xdd, 0x75, 0xd7, 0xc7, 0xda, 0xf7, - 0x3f, 0xf4, 0x1a, 0x5f, 0x68, 0x7a, 0x6b, 0x7b, 0x13, 0x77, 0xc6, 0x4b, 0x41, 0xf9, 0x33, 0x96, - 0xdf, 0x6d, 0xdf, 0x85, 0x86, 0x4b, 0x84, 0x37, 0xfd, 0x6a, 0xf2, 0x69, 0x49, 0xa2, 0x18, 0x15, - 0x5e, 0x6a, 0x15, 0xdc, 0xa0, 0xd5, 0xfe, 0x11, 0x6c, 0xc9, 0x1a, 0xc8, 0x82, 0x5a, 0xcc, 0x03, - 0x6e, 0x00, 0x79, 0xd4, 0xab, 0x11, 0x32, 0x23, 0x67, 0x5c, 0x63, 0x21, 0xe7, 0x6d, 0xeb, 0x3c, - 0xb1, 0xbf, 0x01, 0xd4, 0x4b, 0x4d, 0xa3, 0xa7, 0x10, 0x2e, 0x48, 0x34, 0xf0, 0xfd, 0x94, 0x72, - 0x2e, 0x09, 0x6d, 0xb9, 0x1f, 0xfc, 0xb3, 0xea, 0xed, 0x05, 0xa1, 0x98, 0x66, 0x63, 0xdb, 0x63, - 0x71, 0xf1, 0x22, 0x14, 0x7f, 0x7b, 0xdc, 0x9f, 0x39, 0x62, 0x39, 0xa7, 0xdc, 0xfe, 0xa6, 0x02, - 0xe2, 0x5a, 0x11, 0xf4, 0x10, 0xb6, 0x79, 0x29, 0xae, 0x62, 0xff, 0xb5, 0x23, 0x8f, 0xd2, 0x63, - 0x91, 0x12, 0x29, 0xb6, 0xa6, 0x8a, 0x56, 0x0e, 0xf4, 0x11, 0x7c, 0x8b, 0x1e, 0x0b, 0x9a, 0x26, - 0x24, 0x1a, 0x78, 0x1e, 0xcb, 0x12, 0x51, 0x52, 0xcb, 0xe7, 0xba, 0x8d, 0x5f, 0x13, 0xcd, 0xab, - 0xaa, 0x21, 0xf8, 0x92, 0x2e, 0x8d, 0x96, 0xaa, 0x5a, 0x39, 0xfa, 0xdf, 0x02, 0xa8, 0x97, 0x13, - 0x78, 0x1b, 0x27, 0x7e, 0x0c, 0x5b, 0xf3, 0x94, 0xb1, 0x89, 0x3c, 0xed, 0xeb, 0xda, 0xa3, 0x52, - 0xfa, 0x0b, 0xd8, 0xa9, 0x49, 0xf1, 0x36, 0xd8, 0xec, 0xc0, 0xd6, 0x82, 0x44, 0x99, 0xba, 0x7b, - 0x0d, 0xab, 0x45, 0xff, 0x3b, 0x00, 0xb7, 0x2f, 0xbe, 0x1c, 0xb7, 0xb1, 0x3b, 0x82, 0x9a, 0x9f, - 0xb7, 0x56, 0x35, 0x5e, 0xda, 0xf9, 0x84, 0x2d, 0x48, 0xc4, 0xa9, 0x18, 0x3e, 0x91, 0x2d, 0xd7, - 0x70, 0xb5, 0xee, 0xa7, 0xb0, 0x5d, 0xbd, 0x26, 0xff, 0x13, 0x1f, 0x77, 0x78, 0x72, 0xda, 0x05, - 0xaf, 0x4e, 0xbb, 0xe0, 0xcf, 0xd3, 0x2e, 0x78, 0x79, 0xd6, 0x6d, 0xbc, 0x3a, 0xeb, 0x36, 0x7e, - 0x3b, 0xeb, 0x36, 0x9e, 0x3b, 0xb5, 0x8d, 0xae, 0xf8, 0x72, 0x1f, 0xd7, 0xbe, 0xdd, 0x72, 0xd7, - 0xf1, 0xa6, 0xec, 0xf1, 0x87, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x07, 0x2a, 0x30, 0xe8, - 0x07, 0x00, 0x00, + 0xcf, 0x8b, 0x84, 0x7b, 0x1e, 0xe3, 0x31, 0xe3, 0x23, 0x85, 0x54, 0x8b, 0x22, 0x74, 0x97, 0xc4, + 0x61, 0xc2, 0x1c, 0xf9, 0xab, 0x5c, 0xfd, 0x9f, 0x36, 0xe1, 0x1b, 0x8f, 0x73, 0xb6, 0xfe, 0x51, + 0x18, 0x24, 0xd4, 0x3f, 0xa4, 0x9c, 0x93, 0x80, 0xa2, 0x3b, 0x70, 0x23, 0xf4, 0x0d, 0x60, 0x02, + 0x4b, 0xc3, 0x1b, 0xa1, 0x8f, 0x6c, 0x88, 0x88, 0xef, 0x53, 0x7f, 0x28, 0xdc, 0x88, 0x79, 0xb3, + 0xcf, 0x69, 0x18, 0x4c, 0x85, 0xb1, 0x61, 0x02, 0xab, 0x89, 0xaf, 0x88, 0xa0, 0x4f, 0xe0, 0xad, + 0xc2, 0x6b, 0x34, 0x4d, 0x60, 0x75, 0x06, 0xbb, 0xb6, 0x22, 0x6e, 0x97, 0xc4, 0xed, 0x27, 0x25, + 0x71, 0x57, 0x3f, 0x59, 0xf5, 0x1a, 0xcf, 0xff, 0xec, 0x01, 0x5c, 0x82, 0xd0, 0x03, 0xd8, 0x8c, + 0x79, 0x60, 0x68, 0x12, 0xbb, 0x73, 0x09, 0x3b, 0x4c, 0x96, 0x38, 0x4f, 0x40, 0x2e, 0xd4, 0x79, + 0x18, 0x24, 0x8f, 0x88, 0x20, 0xc6, 0xa6, 0xd9, 0xb4, 0x3a, 0x83, 0x07, 0xf6, 0x75, 0x17, 0x6e, + 0x1f, 0x15, 0xd9, 0xb8, 0xc2, 0xe5, 0x35, 0xe8, 0x22, 0xf4, 0x69, 0xe2, 0x51, 0xe3, 0xd6, 0xff, + 0xa9, 0xb1, 0x5f, 0x64, 0xe3, 0x0a, 0x87, 0x9e, 0xc2, 0xed, 0x79, 0x36, 0x8e, 0x42, 0x6f, 0xe8, + 0x79, 0x94, 0x73, 0xc9, 0x47, 0x97, 0xe4, 0xed, 0xeb, 0x6b, 0x7d, 0x73, 0x01, 0x85, 0x2f, 0xd5, + 0x41, 0xef, 0xc1, 0xbb, 0x29, 0x7d, 0x96, 0x85, 0x29, 0xcd, 0xc9, 0x13, 0x91, 0xa5, 0x94, 0x1b, + 0x6d, 0x13, 0x58, 0x3a, 0xbe, 0x1c, 0x40, 0xfb, 0xb0, 0x4d, 0xd3, 0x94, 0xa5, 0x92, 0x02, 0x94, + 0x14, 0xde, 0x79, 0xc5, 0x71, 0xca, 0x74, 0xbc, 0x46, 0xa2, 0x00, 0xbe, 0x3d, 0x25, 0x89, 0x1f, + 0x51, 0x7f, 0x44, 0xc4, 0x68, 0x9c, 0xb7, 0x76, 0x34, 0x55, 0x5d, 0xef, 0x98, 0xc0, 0x6a, 0xbb, + 0xef, 0x9f, 0xac, 0x7a, 0xe0, 0x8f, 0x55, 0xef, 0x4d, 0x25, 0x31, 0xee, 0xcf, 0xec, 0x90, 0x39, + 0x31, 0x11, 0x53, 0xfb, 0x20, 0x11, 0xbf, 0xfd, 0xba, 0x07, 0x0b, 0xed, 0x1d, 0x24, 0xe2, 0xe7, + 0xbf, 0x7f, 0x79, 0x08, 0xf0, 0x4e, 0x51, 0xf0, 0xbc, 0x52, 0x0e, 0xe1, 0x56, 0x40, 0xf8, 0x3e, + 0x17, 0x61, 0x4c, 0x04, 0xe5, 0xc6, 0x96, 0xec, 0xc0, 0xbb, 0xd7, 0x53, 0xfe, 0x6c, 0x8d, 0xc0, + 0xe7, 0xe0, 0x68, 0x17, 0xea, 0x93, 0x88, 0x04, 0x87, 0x84, 0xcf, 0x8c, 0xdb, 0x26, 0xb0, 0x6e, + 0xe3, 0x6a, 0x8d, 0x4c, 0xd8, 0xa9, 0xe5, 0x1a, 0x77, 0xa4, 0xba, 0xeb, 0xae, 0x8f, 0xb5, 0x1f, + 0x7e, 0xec, 0x35, 0xbe, 0xd0, 0xf4, 0xd6, 0xf6, 0x26, 0xee, 0x8c, 0x97, 0x82, 0xf2, 0x27, 0x2c, + 0xbf, 0xdb, 0xbe, 0x0b, 0x0d, 0x97, 0x08, 0x6f, 0xfa, 0xf5, 0xe4, 0xd3, 0x92, 0x44, 0x31, 0x2a, + 0xbc, 0xd4, 0x2a, 0x78, 0x85, 0x56, 0xfb, 0x47, 0xb0, 0x25, 0x6b, 0x20, 0x0b, 0x6a, 0x31, 0x0f, + 0xb8, 0x01, 0xe4, 0x51, 0xaf, 0x46, 0xc8, 0x8c, 0x9c, 0x71, 0x8d, 0x85, 0x9c, 0xb7, 0xad, 0xf3, + 0xc4, 0xfe, 0x01, 0x50, 0x2f, 0x35, 0x8d, 0x1e, 0x43, 0xb8, 0x20, 0xd1, 0xd0, 0xf7, 0x53, 0xca, + 0xb9, 0x24, 0xb4, 0xe5, 0x7e, 0xf0, 0xef, 0xaa, 0xb7, 0x17, 0x84, 0x62, 0x9a, 0x8d, 0x6d, 0x8f, + 0xc5, 0xc5, 0x8b, 0x50, 0xfc, 0xed, 0x71, 0x7f, 0xe6, 0x88, 0xe5, 0x9c, 0x72, 0xfb, 0xdb, 0x0a, + 0x88, 0x6b, 0x45, 0xd0, 0x7d, 0xd8, 0xe6, 0xa5, 0xb8, 0x8a, 0xfd, 0xd7, 0x8e, 0x3c, 0x4a, 0x8f, + 0x45, 0x4a, 0xa4, 0xd8, 0x9a, 0x2a, 0x5a, 0x39, 0xd0, 0x47, 0xf0, 0x2d, 0x7a, 0x2c, 0x68, 0x9a, + 0x90, 0x68, 0xe8, 0x79, 0x2c, 0x4b, 0x44, 0x49, 0x2d, 0x9f, 0xeb, 0x36, 0x7e, 0x49, 0x34, 0xaf, + 0xaa, 0x86, 0xe0, 0x4b, 0xba, 0x34, 0x5a, 0xaa, 0x6a, 0xe5, 0xe8, 0x7f, 0x07, 0xa0, 0x5e, 0x4e, + 0xe0, 0x4d, 0x9c, 0xf8, 0x21, 0x6c, 0xcd, 0x53, 0xc6, 0x26, 0xf2, 0xb4, 0x2f, 0x6b, 0x8f, 0x4a, + 0xe9, 0x2f, 0x60, 0xa7, 0x26, 0xc5, 0x9b, 0x60, 0xb3, 0x03, 0x5b, 0x0b, 0x12, 0x65, 0xea, 0xee, + 0x35, 0xac, 0x16, 0xfd, 0xef, 0x01, 0xdc, 0xbe, 0xf8, 0x72, 0xdc, 0xc4, 0xee, 0x08, 0x6a, 0x7e, + 0xde, 0x5a, 0xd5, 0x78, 0x69, 0xe7, 0x13, 0xb6, 0x20, 0x11, 0xa7, 0xe2, 0xe0, 0x91, 0x6c, 0xb9, + 0x86, 0xab, 0x75, 0x3f, 0x85, 0xed, 0xea, 0x35, 0x79, 0x4d, 0x7c, 0xdc, 0xaf, 0x4e, 0x4e, 0xbb, + 0xe0, 0xc5, 0x69, 0x17, 0xfc, 0x75, 0xda, 0x05, 0xcf, 0xcf, 0xba, 0x8d, 0x17, 0x67, 0xdd, 0xc6, + 0xef, 0x67, 0xdd, 0xc6, 0xd3, 0x41, 0x6d, 0xa3, 0x2b, 0xbe, 0xdc, 0x8b, 0x81, 0x73, 0x5c, 0xfb, + 0x7c, 0xcb, 0x8d, 0xc7, 0x9b, 0xb2, 0xcd, 0x1f, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xe3, + 0xc4, 0x6e, 0xeb, 0x07, 0x00, 0x00, } func (m *QueuedSignedMessage) Marshal() (dAtA []byte, err error) { @@ -1084,6 +1127,7 @@ func encodeVarintConsensusQueue(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QueuedSignedMessage) Size() (n int) { if m == nil { return 0 @@ -1278,9 +1322,11 @@ func (m *ErrorData) Size() (n int) { func sovConsensusQueue(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozConsensusQueue(x uint64) (n int) { return sovConsensusQueue(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *QueuedSignedMessage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1706,6 +1752,7 @@ func (m *QueuedSignedMessage) Unmarshal(dAtA []byte) error { } return nil } + func (m *BatchOfConsensusMessages) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1792,6 +1839,7 @@ func (m *BatchOfConsensusMessages) Unmarshal(dAtA []byte) error { } return nil } + func (m *Batch) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1910,6 +1958,7 @@ func (m *Batch) Unmarshal(dAtA []byte) error { } return nil } + func (m *SignData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2128,6 +2177,7 @@ func (m *SignData) Unmarshal(dAtA []byte) error { } return nil } + func (m *Evidence) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2248,6 +2298,7 @@ func (m *Evidence) Unmarshal(dAtA []byte) error { } return nil } + func (m *GasEstimate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2351,6 +2402,7 @@ func (m *GasEstimate) Unmarshal(dAtA []byte) error { } return nil } + func (m *PublicAccessData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2488,6 +2540,7 @@ func (m *PublicAccessData) Unmarshal(dAtA []byte) error { } return nil } + func (m *ErrorData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2606,6 +2659,7 @@ func (m *ErrorData) Unmarshal(dAtA []byte) error { } return nil } + func skipConsensusQueue(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/consensus/types/genesis.pb.go b/x/consensus/types/genesis.pb.go index 3fe80ff7..2855e565 100644 --- a/x/consensus/types/genesis.pb.go +++ b/x/consensus/types/genesis.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_a893fc353f9fbf66, []int{0} } + 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) @@ -50,12 +55,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) 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) } @@ -85,7 +93,7 @@ func init() { } var fileDescriptor_a893fc353f9fbf66 = []byte{ - // 220 bytes of a gzipped FileDescriptorProto + // 223 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x93, 0xf3, 0xf3, 0x8a, 0x53, 0xf3, 0x8a, 0x4b, 0x8b, 0xf5, 0xd3, 0x53, 0xf3, 0x52, 0x8b, 0x33, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, @@ -95,11 +103,11 @@ var fileDescriptor_a893fc353f9fbf66 = []byte{ 0x15, 0x72, 0xe2, 0x62, 0x83, 0xc8, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0xa9, 0xe8, 0xe1, 0xb3, 0x5f, 0x2f, 0x00, 0xac, 0xd6, 0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0xa8, 0x4e, 0x21, 0x71, 0x2e, 0xf6, 0x82, 0xfc, 0xa2, 0x92, 0xf8, 0xcc, 0x14, 0x09, 0x26, 0x05, 0x46, 0x0d, 0xce, - 0x20, 0x36, 0x10, 0xd7, 0x33, 0xc5, 0xc9, 0xf3, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, + 0x20, 0x36, 0x10, 0xd7, 0x33, 0xc5, 0xc9, 0xe7, 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, 0xf4, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0x38, - 0xbe, 0x02, 0xc9, 0xf9, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0xe7, 0x1b, 0x03, 0x02, - 0x00, 0x00, 0xff, 0xff, 0x80, 0xc7, 0x8f, 0x77, 0x4b, 0x01, 0x00, 0x00, + 0x18, 0xa2, 0x8c, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0x38, + 0xbe, 0xcc, 0x48, 0xbf, 0x02, 0xc9, 0x07, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0x1f, + 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x48, 0x57, 0x1a, 0xbd, 0x4e, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -153,6 +161,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -171,9 +180,11 @@ func (m *GenesisState) Size() (n int) { 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 *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -289,6 +300,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/consensus/types/packet.pb.go b/x/consensus/types/packet.pb.go index b41a33a8..bbccfdf1 100644 --- a/x/consensus/types/packet.pb.go +++ b/x/consensus/types/packet.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*ConsensusPacketData) ProtoMessage() {} func (*ConsensusPacketData) Descriptor() ([]byte, []int) { return fileDescriptor_fa5d9a8bb2b263d1, []int{0} } + func (m *ConsensusPacketData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ConsensusPacketData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ConsensusPacketData.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *ConsensusPacketData) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *ConsensusPacketData) XXX_Merge(src proto.Message) { xxx_messageInfo_ConsensusPacketData.Merge(m, src) } + func (m *ConsensusPacketData) XXX_Size() int { return m.Size() } + func (m *ConsensusPacketData) XXX_DiscardUnknown() { xxx_messageInfo_ConsensusPacketData.DiscardUnknown(m) } @@ -95,8 +103,7 @@ func (*ConsensusPacketData) XXX_OneofWrappers() []interface{} { } } -type NoData struct { -} +type NoData struct{} func (m *NoData) Reset() { *m = NoData{} } func (m *NoData) String() string { return proto.CompactTextString(m) } @@ -104,9 +111,11 @@ func (*NoData) ProtoMessage() {} func (*NoData) Descriptor() ([]byte, []int) { return fileDescriptor_fa5d9a8bb2b263d1, []int{1} } + func (m *NoData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *NoData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NoData.Marshal(b, m, deterministic) @@ -119,12 +128,15 @@ func (m *NoData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *NoData) XXX_Merge(src proto.Message) { xxx_messageInfo_NoData.Merge(m, src) } + func (m *NoData) XXX_Size() int { return m.Size() } + func (m *NoData) XXX_DiscardUnknown() { xxx_messageInfo_NoData.DiscardUnknown(m) } @@ -141,7 +153,7 @@ func init() { } var fileDescriptor_fa5d9a8bb2b263d1 = []byte{ - // 183 bytes of a gzipped FileDescriptorProto + // 186 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2c, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x93, 0xf3, 0xf3, 0x8a, 0x53, 0xf3, 0x8a, 0x4b, 0x8b, 0xf5, 0x0b, 0x12, 0x93, 0xb3, 0x53, 0x4b, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, @@ -149,11 +161,11 @@ var fileDescriptor_fa5d9a8bb2b263d1 = []byte{ 0x30, 0x4e, 0x00, 0x58, 0x9b, 0x4b, 0x62, 0x49, 0xa2, 0x90, 0x1d, 0x17, 0x5b, 0x5e, 0x3e, 0x88, 0x25, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0xa4, 0xa2, 0x87, 0xcf, 0x14, 0x3d, 0x3f, 0xb0, 0x5a, 0x0f, 0x86, 0x20, 0xa8, 0x2e, 0x27, 0x0e, 0x2e, 0x36, 0x88, 0x23, 0x94, 0x38, 0xb8, 0xd8, 0x20, - 0xb2, 0x4e, 0x9e, 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, 0x9f, 0x9e, - 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0xc5, 0x63, 0x15, 0x48, 0x5e, 0x2b, - 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x7b, 0xcd, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x0d, - 0x53, 0x29, 0xed, 0x07, 0x01, 0x00, 0x00, + 0xb2, 0x4e, 0x3e, 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, 0x65, 0x94, 0x9e, + 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0xc5, 0x63, 0x65, 0x46, 0xfa, 0x15, + 0x48, 0xbe, 0x2b, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0xfb, 0xce, 0x18, 0x10, 0x00, 0x00, + 0xff, 0xff, 0xc2, 0x96, 0x6f, 0x7e, 0x0a, 0x01, 0x00, 0x00, } func (m *ConsensusPacketData) Marshal() (dAtA []byte, err error) { @@ -209,6 +221,7 @@ func (m *ConsensusPacketData_NoData) MarshalToSizedBuffer(dAtA []byte) (int, err } return len(dAtA) - i, nil } + func (m *NoData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -243,6 +256,7 @@ func encodeVarintPacket(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *ConsensusPacketData) Size() (n int) { if m == nil { return 0 @@ -267,6 +281,7 @@ func (m *ConsensusPacketData_NoData) Size() (n int) { } return n } + func (m *NoData) Size() (n int) { if m == nil { return 0 @@ -279,9 +294,11 @@ func (m *NoData) Size() (n int) { func sovPacket(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozPacket(x uint64) (n int) { return sovPacket(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *ConsensusPacketData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -367,6 +384,7 @@ func (m *ConsensusPacketData) Unmarshal(dAtA []byte) error { } return nil } + func (m *NoData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -417,6 +435,7 @@ func (m *NoData) Unmarshal(dAtA []byte) error { } return nil } + func skipPacket(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/consensus/types/params.pb.go b/x/consensus/types/params.pb.go index 085f75b4..be8af1d2 100644 --- a/x/consensus/types/params.pb.go +++ b/x/consensus/types/params.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -24,17 +27,18 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Params defines the parameters for the module. -type Params struct { -} +type Params struct{} func (m *Params) Reset() { *m = Params{} } func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_1b92ec47918814c4, []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) @@ -47,12 +51,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 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) } @@ -68,17 +75,17 @@ func init() { } var fileDescriptor_1b92ec47918814c4 = []byte{ - // 155 bytes of a gzipped FileDescriptorProto + // 158 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2c, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x93, 0xf3, 0xf3, 0x8a, 0x53, 0xf3, 0x8a, 0x4b, 0x8b, 0xf5, 0x0b, 0x12, 0x8b, 0x12, 0x73, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x64, 0x90, 0x94, 0xea, 0x41, 0xd8, 0x7a, 0x70, 0xa5, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x85, 0xfa, 0x20, 0x16, 0x44, 0x8f, 0x12, 0x1f, 0x17, 0x5b, 0x00, 0xd8, 0x0c, 0x2b, - 0x96, 0x19, 0x0b, 0xe4, 0x19, 0x9c, 0x3c, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, + 0x96, 0x19, 0x0b, 0xe4, 0x19, 0x9c, 0x7c, 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, 0x3f, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x8b, 0x9b, - 0x2a, 0x90, 0x5c, 0x55, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xb6, 0xc1, 0x18, 0x10, 0x00, - 0x00, 0xff, 0xff, 0xad, 0x8b, 0x09, 0xe6, 0xc2, 0x00, 0x00, 0x00, + 0x21, 0xca, 0x28, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x8b, 0x9b, + 0xca, 0x8c, 0xf4, 0x2b, 0x90, 0x1c, 0x56, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xb6, 0xc4, + 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x76, 0xa4, 0x98, 0xd5, 0xc5, 0x00, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -115,6 +122,7 @@ func encodeVarintParams(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -127,9 +135,11 @@ func (m *Params) Size() (n int) { func sovParams(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozParams(x uint64) (n int) { return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -180,6 +190,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func skipParams(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/consensus/types/query.pb.go b/x/consensus/types/query.pb.go index 0d25deb5..d6dae529 100644 --- a/x/consensus/types/query.pb.go +++ b/x/consensus/types/query.pb.go @@ -1177,85 +1177,85 @@ func init() { } var fileDescriptor_186b66ae011355e3 = []byte{ - // 1235 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x98, 0xcf, 0x6f, 0x1b, 0x45, - 0x14, 0xc7, 0x33, 0x8e, 0x93, 0x3a, 0x2f, 0x0d, 0x54, 0x43, 0x28, 0xee, 0x12, 0xdc, 0x68, 0x15, - 0x42, 0xda, 0x52, 0x6f, 0x93, 0x08, 0x50, 0x1a, 0x10, 0xd8, 0x4d, 0x48, 0x03, 0x04, 0x9a, 0x25, - 0x14, 0xc1, 0xc5, 0x9a, 0xd8, 0xd3, 0xcd, 0xaa, 0xeb, 0x5d, 0x67, 0x67, 0x36, 0x8a, 0xa9, 0xa2, - 0x22, 0xfe, 0x02, 0x24, 0x2e, 0x48, 0x1c, 0x80, 0x03, 0xff, 0x04, 0x47, 0x0e, 0x28, 0xc7, 0x22, - 0x2e, 0x9c, 0x2a, 0x94, 0x20, 0x0e, 0x48, 0x70, 0x44, 0x82, 0x0b, 0x68, 0x67, 0x67, 0xd7, 0x6b, - 0xc7, 0x3f, 0x36, 0x4e, 0x23, 0x38, 0x65, 0x76, 0x66, 0xde, 0x77, 0xde, 0xe7, 0xbd, 0x99, 0x37, - 0xe3, 0xc0, 0x4c, 0x8d, 0x58, 0x4e, 0x95, 0x94, 0xb7, 0x88, 0x69, 0x6b, 0x41, 0x5b, 0x2b, 0x3b, - 0x36, 0xa3, 0x36, 0xf3, 0x98, 0xb6, 0xed, 0x51, 0xb7, 0x9e, 0xaf, 0xb9, 0x0e, 0x77, 0xf0, 0x44, - 0x6c, 0x66, 0x3e, 0x68, 0xe7, 0xa3, 0x99, 0xca, 0xb8, 0xe1, 0x18, 0x8e, 0x98, 0xa8, 0xf9, 0xad, - 0xc0, 0x46, 0x99, 0x30, 0x1c, 0xc7, 0xb0, 0xa8, 0x46, 0x6a, 0xa6, 0x46, 0x6c, 0xdb, 0xe1, 0x84, - 0x9b, 0x8e, 0xcd, 0xe4, 0xe8, 0x5c, 0xd7, 0xb5, 0xa3, 0x56, 0x69, 0xdb, 0xa3, 0x1e, 0x95, 0x36, - 0x97, 0xba, 0xda, 0xd4, 0x88, 0x4b, 0xaa, 0xa1, 0xfc, 0x05, 0xb9, 0xb8, 0xf8, 0xda, 0xf4, 0xee, - 0x68, 0xc4, 0x96, 0x2c, 0xea, 0x38, 0xe0, 0x75, 0x1f, 0xed, 0x96, 0x98, 0xaf, 0xd3, 0x6d, 0x8f, - 0x32, 0xae, 0x7e, 0x00, 0x4f, 0x34, 0xf5, 0xb2, 0x9a, 0x2f, 0x8c, 0x8b, 0x30, 0x1c, 0xe8, 0x66, - 0xd1, 0x24, 0x9a, 0x19, 0x9d, 0x9b, 0xca, 0x77, 0x8b, 0x44, 0x3e, 0xb0, 0x2e, 0xa6, 0xf7, 0x1f, - 0x5e, 0x1c, 0xd0, 0xa5, 0xa5, 0xfa, 0x25, 0x82, 0x29, 0xa1, 0xbd, 0xee, 0xb3, 0x54, 0xd6, 0x28, - 0x63, 0xc4, 0xa0, 0xec, 0x75, 0xc7, 0x7d, 0xd7, 0x34, 0x6c, 0xd3, 0x36, 0xa4, 0x0f, 0x78, 0x1d, - 0x60, 0x87, 0x58, 0x85, 0x4a, 0xc5, 0xa5, 0x2c, 0x58, 0xf0, 0x6c, 0x71, 0xf6, 0xef, 0x87, 0x17, - 0xaf, 0x1a, 0x26, 0xdf, 0xf2, 0x36, 0xf3, 0x65, 0xa7, 0xaa, 0x95, 0x1d, 0x56, 0x75, 0x98, 0xfc, - 0x73, 0x95, 0x55, 0xee, 0x6a, 0xbc, 0x5e, 0xa3, 0x2c, 0x7f, 0x3b, 0x32, 0xd4, 0x63, 0x22, 0x78, - 0x0a, 0xc6, 0x44, 0x04, 0x37, 0xea, 0x35, 0xfa, 0x36, 0xa9, 0xd2, 0x6c, 0x6a, 0x12, 0xcd, 0x8c, - 0xe8, 0xcd, 0x9d, 0xea, 0x47, 0xf0, 0x6c, 0x0f, 0x07, 0x65, 0x38, 0xd6, 0x61, 0xac, 0x1a, 0x8c, - 0x6e, 0x38, 0xfe, 0x58, 0x16, 0x4d, 0x0e, 0xce, 0x8c, 0xce, 0x5d, 0xe9, 0x1e, 0x95, 0xb5, 0xb8, - 0x89, 0xde, 0xac, 0xa0, 0xde, 0x87, 0xb1, 0xa6, 0x71, 0x3c, 0x0e, 0x43, 0xb6, 0x63, 0x97, 0x69, - 0x10, 0x00, 0x3d, 0xf8, 0xc0, 0x8f, 0x41, 0xca, 0xac, 0x08, 0xef, 0xd3, 0x7a, 0xca, 0xac, 0xe0, - 0x49, 0x18, 0xdd, 0xac, 0x73, 0xca, 0xa4, 0x1f, 0x83, 0x62, 0x6e, 0xbc, 0x0b, 0x4f, 0xc3, 0x60, - 0x95, 0x19, 0xd9, 0xb4, 0xc8, 0xdb, 0x78, 0x3e, 0xd8, 0x10, 0xf9, 0x70, 0x43, 0xe4, 0x0b, 0x76, - 0x5d, 0xf7, 0x27, 0xa8, 0x7f, 0x21, 0xc0, 0xb7, 0x89, 0x65, 0x56, 0x08, 0x0f, 0x80, 0x09, 0xf7, - 0x5c, 0x7a, 0x1a, 0xc9, 0x98, 0x80, 0x11, 0x16, 0xea, 0x0b, 0x94, 0xb3, 0x7a, 0xa3, 0xc3, 0x1f, - 0xa5, 0xbb, 0xdc, 0x25, 0x4b, 0x84, 0x13, 0xc9, 0xd3, 0xe8, 0xc0, 0x2f, 0xc2, 0x79, 0xba, 0xcb, - 0xa9, 0x6b, 0x13, 0xab, 0x50, 0x2e, 0x3b, 0x9e, 0xcd, 0x43, 0xd7, 0xd2, 0x22, 0xa3, 0x1d, 0x46, - 0x7d, 0xd5, 0x9a, 0xb7, 0x69, 0x99, 0xe5, 0x37, 0x69, 0x3d, 0x3b, 0x14, 0xa8, 0x46, 0x1d, 0xea, - 0xef, 0x29, 0x78, 0x52, 0x46, 0xff, 0x7d, 0x93, 0x6f, 0x45, 0xf4, 0x2c, 0x61, 0x16, 0x64, 0x8c, - 0x07, 0x7b, 0xc4, 0x18, 0xbf, 0x05, 0x19, 0x1f, 0x54, 0xa0, 0xa5, 0xc5, 0x96, 0xb9, 0xd6, 0x7d, - 0xcb, 0x1c, 0x4d, 0x88, 0x1e, 0x29, 0xb4, 0xe6, 0x7e, 0xe8, 0x68, 0xee, 0x2f, 0xc3, 0xb9, 0x00, - 0xb2, 0x50, 0x2e, 0x53, 0xc6, 0xc4, 0xba, 0xc3, 0x62, 0xda, 0x91, 0x7e, 0x11, 0x77, 0xd7, 0x75, - 0x5c, 0x31, 0xe9, 0x8c, 0x8c, 0x7b, 0xd8, 0x81, 0x15, 0xc8, 0xec, 0x10, 0x8b, 0x51, 0xbe, 0xba, - 0x94, 0x1d, 0x11, 0xdc, 0xd1, 0xb7, 0xef, 0x87, 0x41, 0xd8, 0x32, 0xe3, 0x66, 0x95, 0x70, 0x9a, - 0x05, 0x31, 0x1c, 0xef, 0x7a, 0x23, 0x9d, 0xc9, 0x9c, 0x1b, 0xd1, 0x33, 0x74, 0xc7, 0xac, 0x50, - 0xbb, 0x4c, 0xd5, 0x3f, 0x11, 0x60, 0x19, 0x6f, 0x71, 0xe0, 0x74, 0xca, 0x3c, 0x8b, 0xe3, 0x35, - 0x38, 0x23, 0x0f, 0x85, 0x2c, 0x33, 0xf3, 0x89, 0x0e, 0x54, 0x73, 0xca, 0xf4, 0x50, 0x03, 0x17, - 0x21, 0x5a, 0x31, 0x9b, 0x12, 0xd1, 0x9e, 0xee, 0xae, 0xb7, 0x2c, 0x67, 0x37, 0x3c, 0xc5, 0x6b, - 0x70, 0x36, 0x06, 0xc2, 0xb2, 0x83, 0x42, 0xe7, 0x52, 0x77, 0x9d, 0x95, 0x86, 0x85, 0xde, 0x64, - 0xae, 0xbe, 0x03, 0x4f, 0x09, 0x60, 0xe9, 0x79, 0xb1, 0xbe, 0xba, 0x14, 0x56, 0xbd, 0x23, 0x25, - 0x0a, 0xb5, 0x29, 0x51, 0xad, 0x3b, 0x4f, 0xfd, 0x0e, 0xc1, 0xd3, 0x71, 0x45, 0xb6, 0x6a, 0x8b, - 0xea, 0x75, 0x3c, 0xd5, 0x3d, 0x98, 0x64, 0x77, 0xcd, 0x5a, 0xc8, 0x7f, 0xcb, 0x75, 0xfc, 0x56, - 0xa5, 0x58, 0x6f, 0x9c, 0xe0, 0xe0, 0xa0, 0xf6, 0x73, 0xf4, 0x7b, 0x4a, 0xab, 0x1e, 0x4c, 0xb4, - 0x67, 0x90, 0xe5, 0xf6, 0x3d, 0xc8, 0xc8, 0x9c, 0x32, 0x59, 0x69, 0xfb, 0xd9, 0x18, 0xf2, 0x3a, - 0x8a, 0xa4, 0xd4, 0xaf, 0x50, 0xa7, 0x7a, 0xaf, 0x53, 0x8b, 0xd4, 0x63, 0x37, 0x52, 0xb2, 0x28, - 0x36, 0x97, 0xca, 0xd4, 0x23, 0x28, 0x95, 0xea, 0x7d, 0x98, 0xee, 0xe5, 0xe1, 0xe9, 0xc6, 0xe8, - 0x6b, 0xd4, 0xc9, 0x83, 0x02, 0xe7, 0x94, 0xf1, 0xff, 0x43, 0x90, 0x3e, 0x46, 0xf0, 0x5c, 0x4f, - 0x1f, 0x4f, 0x37, 0x4c, 0x39, 0xb9, 0x83, 0x57, 0x28, 0x2f, 0x58, 0x96, 0xf0, 0xc3, 0xa7, 0x8d, - 0x9e, 0x55, 0x2f, 0xc1, 0x33, 0x1d, 0xc6, 0xa5, 0x5f, 0xe7, 0x61, 0x58, 0xc4, 0x29, 0xf0, 0x6a, - 0x44, 0x97, 0x5f, 0xea, 0x37, 0x08, 0x2e, 0xb7, 0x67, 0x6b, 0x14, 0x19, 0xd3, 0xb1, 0xff, 0xf3, - 0x1c, 0x7c, 0x8e, 0xe0, 0x4a, 0x22, 0x3f, 0x25, 0xaf, 0x09, 0x38, 0x0c, 0xde, 0x86, 0x13, 0x5d, - 0x1d, 0x27, 0xce, 0x48, 0x1b, 0xd1, 0xb9, 0xfd, 0x31, 0x18, 0x12, 0xae, 0xe1, 0x2f, 0x10, 0x0c, - 0x07, 0x4f, 0x53, 0xdc, 0xe3, 0xde, 0x3d, 0xfa, 0x32, 0x56, 0x66, 0x8f, 0x61, 0x11, 0x40, 0xaa, - 0xcf, 0x7f, 0xf2, 0xe3, 0x2f, 0x9f, 0xa5, 0xa6, 0xf1, 0x94, 0x96, 0xe0, 0xc5, 0x8e, 0x7f, 0x45, - 0x90, 0xed, 0xf4, 0xf2, 0xc4, 0xc5, 0x04, 0xab, 0xf7, 0x78, 0x57, 0x2b, 0x37, 0x4e, 0xa4, 0x21, - 0x99, 0x0a, 0x82, 0x69, 0x11, 0x2f, 0x68, 0xbd, 0x7e, 0x35, 0x79, 0xb4, 0x52, 0x0a, 0xd3, 0x51, - 0xba, 0xe3, 0xb8, 0x25, 0x26, 0x59, 0x7e, 0x43, 0x70, 0xa1, 0x63, 0x41, 0xc3, 0x7d, 0x79, 0xd9, - 0x52, 0xb0, 0x95, 0xa5, 0x93, 0x89, 0x48, 0xd6, 0xa2, 0x60, 0x7d, 0x19, 0x5f, 0x3f, 0x3e, 0xab, - 0x1b, 0xe2, 0xfc, 0x83, 0x20, 0xd7, 0xfd, 0x4c, 0xe0, 0x9b, 0xfd, 0x38, 0xdb, 0xee, 0xf8, 0x2b, - 0xab, 0x8f, 0x40, 0x49, 0xb2, 0xdf, 0x14, 0xec, 0x45, 0xfc, 0xda, 0xf1, 0xd9, 0x0d, 0xc2, 0x4a, - 0xb4, 0x81, 0xf7, 0x07, 0x02, 0xa5, 0x73, 0x65, 0xc6, 0x7d, 0xa5, 0xaa, 0xf5, 0xf2, 0x51, 0x96, - 0x4f, 0xa8, 0x22, 0xa9, 0x6f, 0x08, 0xea, 0x57, 0xf0, 0xe2, 0xf1, 0xa9, 0x49, 0x44, 0xf4, 0x03, - 0x82, 0xc7, 0x5b, 0x9e, 0x32, 0x78, 0x21, 0x81, 0x7f, 0xed, 0x9f, 0x70, 0xca, 0xf5, 0x7e, 0x4c, - 0x25, 0xcf, 0x8a, 0xe0, 0x29, 0xe0, 0x57, 0xbb, 0xf3, 0x44, 0x20, 0xa6, 0x1d, 0xfc, 0xa7, 0x41, - 0xbb, 0xd7, 0x74, 0x63, 0xec, 0xe1, 0x6f, 0x11, 0x8c, 0xc6, 0x1e, 0xad, 0xf8, 0x85, 0xe4, 0x4e, - 0xc5, 0x1e, 0xb9, 0xca, 0xb5, 0x44, 0xa5, 0x3d, 0xf6, 0x9b, 0x20, 0xe9, 0x19, 0x6c, 0xf1, 0x37, - 0x24, 0xd2, 0xee, 0x99, 0x95, 0x3d, 0xfc, 0x3d, 0x82, 0x73, 0xad, 0x37, 0x2f, 0x4e, 0x12, 0xd6, - 0x0e, 0xd7, 0xb9, 0xb2, 0xd8, 0x97, 0xad, 0xcc, 0xc9, 0x82, 0x20, 0x9a, 0xc7, 0xb3, 0xdd, 0x89, - 0x0c, 0xca, 0x4b, 0xc4, 0xb2, 0x82, 0x7c, 0x94, 0x6c, 0x5f, 0xa2, 0xb8, 0xba, 0x7f, 0x90, 0x43, - 0x0f, 0x0e, 0x72, 0xe8, 0xe7, 0x83, 0x1c, 0xfa, 0xf4, 0x30, 0x37, 0xf0, 0xe0, 0x30, 0x37, 0xf0, - 0xd3, 0x61, 0x6e, 0xe0, 0x43, 0x2d, 0x76, 0x75, 0xb7, 0x91, 0xdd, 0x8d, 0x09, 0x8b, 0x7b, 0x7c, - 0x73, 0x58, 0xfc, 0x3a, 0x9d, 0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0x5e, 0x96, 0xd0, 0xdb, 0xfd, - 0x12, 0x00, 0x00, + // 1240 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x98, 0x4f, 0x6f, 0x1b, 0xc5, + 0x1b, 0xc7, 0x33, 0x8e, 0x93, 0x3a, 0x4f, 0x92, 0xdf, 0x2f, 0x1a, 0x42, 0x71, 0x97, 0xe0, 0x46, + 0xab, 0x10, 0xd2, 0x96, 0x7a, 0x1b, 0x47, 0x80, 0xd2, 0x80, 0xc0, 0x6e, 0x42, 0x1a, 0x68, 0xa0, + 0x59, 0x42, 0x11, 0x5c, 0xac, 0x89, 0x3d, 0xdd, 0xac, 0xba, 0xde, 0x75, 0x76, 0x66, 0xa3, 0x98, + 0x2a, 0x2a, 0xe2, 0x15, 0x20, 0x71, 0x41, 0xe2, 0x00, 0x1c, 0x78, 0x13, 0x1c, 0x39, 0xa0, 0x1c, + 0x8b, 0xb8, 0x70, 0xaa, 0x50, 0x82, 0x38, 0x20, 0xc1, 0x11, 0x09, 0x2e, 0xa0, 0x9d, 0x9d, 0x5d, + 0xaf, 0x1d, 0xff, 0x8b, 0xd3, 0x08, 0x4e, 0x99, 0x9d, 0x99, 0xe7, 0x3b, 0xcf, 0xe7, 0x79, 0x66, + 0x9e, 0x19, 0x07, 0xe6, 0xaa, 0xc4, 0x72, 0x2a, 0xa4, 0xb4, 0x4d, 0x4c, 0x5b, 0x0b, 0xda, 0x5a, + 0xc9, 0xb1, 0x19, 0xb5, 0x99, 0xc7, 0xb4, 0x1d, 0x8f, 0xba, 0xb5, 0x6c, 0xd5, 0x75, 0xb8, 0x83, + 0xa7, 0x62, 0x33, 0xb3, 0x41, 0x3b, 0x1b, 0xcd, 0x54, 0x26, 0x0d, 0xc7, 0x70, 0xc4, 0x44, 0xcd, + 0x6f, 0x05, 0x36, 0xca, 0x94, 0xe1, 0x38, 0x86, 0x45, 0x35, 0x52, 0x35, 0x35, 0x62, 0xdb, 0x0e, + 0x27, 0xdc, 0x74, 0x6c, 0x26, 0x47, 0x73, 0x1d, 0xd7, 0x8e, 0x5a, 0xc5, 0x1d, 0x8f, 0x7a, 0x54, + 0xda, 0x5c, 0xea, 0x68, 0x53, 0x25, 0x2e, 0xa9, 0x84, 0xf2, 0x17, 0xe4, 0xe2, 0xe2, 0x6b, 0xcb, + 0xbb, 0xab, 0x11, 0x5b, 0xb2, 0xa8, 0x93, 0x80, 0x37, 0x7c, 0xb4, 0xdb, 0x62, 0xbe, 0x4e, 0x77, + 0x3c, 0xca, 0xb8, 0xfa, 0x3e, 0x3c, 0xd1, 0xd0, 0xcb, 0xaa, 0xbe, 0x30, 0x2e, 0xc0, 0x70, 0xa0, + 0x9b, 0x46, 0xd3, 0x68, 0x6e, 0x34, 0x37, 0x93, 0xed, 0x14, 0x89, 0x6c, 0x60, 0x5d, 0x48, 0x1e, + 0x3c, 0xba, 0x38, 0xa0, 0x4b, 0x4b, 0xf5, 0x0b, 0x04, 0x33, 0x42, 0x7b, 0xc3, 0x67, 0x29, 0xaf, + 0x53, 0xc6, 0x88, 0x41, 0xd9, 0xeb, 0x8e, 0xfb, 0x8e, 0x69, 0xd8, 0xa6, 0x6d, 0x48, 0x1f, 0xf0, + 0x06, 0xc0, 0x2e, 0xb1, 0xf2, 0xe5, 0xb2, 0x4b, 0x59, 0xb0, 0xe0, 0x58, 0x61, 0xfe, 0xaf, 0x47, + 0x17, 0xaf, 0x1a, 0x26, 0xdf, 0xf6, 0xb6, 0xb2, 0x25, 0xa7, 0xa2, 0x95, 0x1c, 0x56, 0x71, 0x98, + 0xfc, 0x73, 0x95, 0x95, 0xef, 0x69, 0xbc, 0x56, 0xa5, 0x2c, 0x7b, 0x27, 0x32, 0xd4, 0x63, 0x22, + 0x78, 0x06, 0xc6, 0x45, 0x04, 0x37, 0x6b, 0x55, 0xfa, 0x16, 0xa9, 0xd0, 0x74, 0x62, 0x1a, 0xcd, + 0x8d, 0xe8, 0x8d, 0x9d, 0xea, 0x87, 0xf0, 0x6c, 0x17, 0x07, 0x65, 0x38, 0x36, 0x60, 0xbc, 0x12, + 0x8c, 0x6e, 0x3a, 0xfe, 0x58, 0x1a, 0x4d, 0x0f, 0xce, 0x8d, 0xe6, 0xae, 0x74, 0x8e, 0xca, 0x7a, + 0xdc, 0x44, 0x6f, 0x54, 0x50, 0x1f, 0xc0, 0x78, 0xc3, 0x38, 0x9e, 0x84, 0x21, 0xdb, 0xb1, 0x4b, + 0x34, 0x08, 0x80, 0x1e, 0x7c, 0xe0, 0xff, 0x41, 0xc2, 0x2c, 0x0b, 0xef, 0x93, 0x7a, 0xc2, 0x2c, + 0xe3, 0x69, 0x18, 0xdd, 0xaa, 0x71, 0xca, 0xa4, 0x1f, 0x83, 0x62, 0x6e, 0xbc, 0x0b, 0xcf, 0xc2, + 0x60, 0x85, 0x19, 0xe9, 0xa4, 0xc8, 0xdb, 0x64, 0x36, 0xd8, 0x10, 0xd9, 0x70, 0x43, 0x64, 0xf3, + 0x76, 0x4d, 0xf7, 0x27, 0xa8, 0x7f, 0x22, 0xc0, 0x77, 0x88, 0x65, 0x96, 0x09, 0x0f, 0x80, 0x09, + 0xf7, 0x5c, 0x7a, 0x16, 0xc9, 0x98, 0x82, 0x11, 0x16, 0xea, 0x0b, 0x94, 0x31, 0xbd, 0xde, 0xe1, + 0x8f, 0xd2, 0x3d, 0xee, 0x92, 0x65, 0xc2, 0x89, 0xe4, 0xa9, 0x77, 0xe0, 0x17, 0xe1, 0x3c, 0xdd, + 0xe3, 0xd4, 0xb5, 0x89, 0x95, 0x2f, 0x95, 0x1c, 0xcf, 0xe6, 0xa1, 0x6b, 0x49, 0x91, 0xd1, 0x36, + 0xa3, 0xbe, 0x6a, 0xd5, 0xdb, 0xb2, 0xcc, 0xd2, 0x9b, 0xb4, 0x96, 0x1e, 0x0a, 0x54, 0xa3, 0x0e, + 0xf5, 0xb7, 0x04, 0x3c, 0x29, 0xa3, 0xff, 0x9e, 0xc9, 0xb7, 0x23, 0x7a, 0xd6, 0x63, 0x16, 0x64, + 0x8c, 0x07, 0xbb, 0xc4, 0x18, 0xdf, 0x82, 0x94, 0x0f, 0x2a, 0xd0, 0x92, 0x62, 0xcb, 0x5c, 0xeb, + 0xbc, 0x65, 0x8e, 0x27, 0x44, 0x8f, 0x14, 0x9a, 0x73, 0x3f, 0x74, 0x3c, 0xf7, 0x97, 0x61, 0x22, + 0x80, 0xcc, 0x97, 0x4a, 0x94, 0x31, 0xb1, 0xee, 0xb0, 0x98, 0x76, 0xac, 0x5f, 0xc4, 0xdd, 0x75, + 0x1d, 0x57, 0x4c, 0x3a, 0x27, 0xe3, 0x1e, 0x76, 0x60, 0x05, 0x52, 0xbb, 0xc4, 0x62, 0x94, 0xaf, + 0x2d, 0xa7, 0x47, 0x04, 0x77, 0xf4, 0xed, 0xfb, 0x61, 0x10, 0xb6, 0xc2, 0xb8, 0x59, 0x21, 0x9c, + 0xa6, 0x41, 0x0c, 0xc7, 0xbb, 0xde, 0x48, 0xa6, 0x52, 0x13, 0x23, 0x7a, 0x8a, 0xee, 0x9a, 0x65, + 0x6a, 0x97, 0xa8, 0xfa, 0x07, 0x02, 0x2c, 0xe3, 0x2d, 0x0e, 0x9c, 0x4e, 0x99, 0x67, 0x71, 0xbc, + 0x0e, 0xe7, 0xe4, 0xa1, 0x90, 0x65, 0x66, 0xa1, 0xa7, 0x03, 0xd5, 0x98, 0x32, 0x3d, 0xd4, 0xc0, + 0x05, 0x88, 0x56, 0x4c, 0x27, 0x44, 0xb4, 0x67, 0x3b, 0xeb, 0xad, 0xc8, 0xd9, 0x75, 0x4f, 0xf1, + 0x3a, 0x8c, 0xc5, 0x40, 0x58, 0x7a, 0x50, 0xe8, 0x5c, 0xea, 0xac, 0xb3, 0x5a, 0xb7, 0xd0, 0x1b, + 0xcc, 0xd5, 0xb7, 0xe1, 0x29, 0x01, 0x2c, 0x3d, 0x2f, 0xd4, 0xd6, 0x96, 0xc3, 0xaa, 0x77, 0xac, + 0x44, 0xa1, 0x16, 0x25, 0xaa, 0x79, 0xe7, 0xa9, 0xdf, 0x22, 0x78, 0x3a, 0xae, 0xc8, 0xd6, 0x6c, + 0x51, 0xbd, 0x4e, 0xa6, 0xba, 0x0f, 0xd3, 0xec, 0x9e, 0x59, 0x0d, 0xf9, 0x6f, 0xbb, 0x8e, 0xdf, + 0x2a, 0x17, 0x6a, 0xf5, 0x13, 0x1c, 0x1c, 0xd4, 0x7e, 0x8e, 0x7e, 0x57, 0x69, 0xd5, 0x83, 0xa9, + 0xd6, 0x0c, 0xb2, 0xdc, 0xbe, 0x0b, 0x29, 0x99, 0x53, 0x26, 0x2b, 0x6d, 0x3f, 0x1b, 0x43, 0x5e, + 0x47, 0x91, 0x94, 0xfa, 0x25, 0x6a, 0x57, 0xef, 0x75, 0x6a, 0x91, 0x5a, 0xec, 0x46, 0xea, 0x2d, + 0x8a, 0x8d, 0xa5, 0x32, 0xf1, 0x18, 0x4a, 0xa5, 0xfa, 0x00, 0x66, 0xbb, 0x79, 0x78, 0xb6, 0x31, + 0xfa, 0x0a, 0xb5, 0xf3, 0x20, 0xcf, 0x39, 0x65, 0xfc, 0xbf, 0x10, 0xa4, 0x8f, 0x10, 0x3c, 0xd7, + 0xd5, 0xc7, 0xb3, 0x0d, 0x53, 0x46, 0xee, 0xe0, 0x55, 0xca, 0xf3, 0x96, 0x25, 0xfc, 0xf0, 0x69, + 0xa3, 0x67, 0xd5, 0x4b, 0xf0, 0x4c, 0x9b, 0x71, 0xe9, 0xd7, 0x79, 0x18, 0x16, 0x71, 0x0a, 0xbc, + 0x1a, 0xd1, 0xe5, 0x97, 0xfa, 0x35, 0x82, 0xcb, 0xad, 0xd9, 0xea, 0x45, 0xc6, 0x74, 0xec, 0x7f, + 0x3d, 0x07, 0x9f, 0x21, 0xb8, 0xd2, 0x93, 0x9f, 0x92, 0xd7, 0x04, 0x1c, 0x06, 0x6f, 0xd3, 0x89, + 0xae, 0x8e, 0x53, 0x67, 0xa4, 0x85, 0x68, 0xee, 0x60, 0x1c, 0x86, 0x84, 0x6b, 0xf8, 0x73, 0x04, + 0xc3, 0xc1, 0xd3, 0x14, 0x77, 0xb9, 0x77, 0x8f, 0xbf, 0x8c, 0x95, 0xf9, 0x13, 0x58, 0x04, 0x90, + 0xea, 0xf3, 0x1f, 0xff, 0xf0, 0xf3, 0xa7, 0x89, 0x59, 0x3c, 0xa3, 0xf5, 0xf0, 0x62, 0xc7, 0xbf, + 0x20, 0x48, 0xb7, 0x7b, 0x79, 0xe2, 0x42, 0x0f, 0xab, 0x77, 0x79, 0x57, 0x2b, 0x37, 0x4e, 0xa5, + 0x21, 0x99, 0xf2, 0x82, 0x69, 0x09, 0x2f, 0x6a, 0xdd, 0x7e, 0x35, 0x79, 0xb4, 0x5c, 0x0c, 0xd3, + 0x51, 0xbc, 0xeb, 0xb8, 0x45, 0x26, 0x59, 0x7e, 0x45, 0x70, 0xa1, 0x6d, 0x41, 0xc3, 0x7d, 0x79, + 0xd9, 0x54, 0xb0, 0x95, 0xe5, 0xd3, 0x89, 0x48, 0xd6, 0x82, 0x60, 0x7d, 0x19, 0x5f, 0x3f, 0x39, + 0xab, 0x1b, 0xe2, 0xfc, 0x8d, 0x20, 0xd3, 0xf9, 0x4c, 0xe0, 0x9b, 0xfd, 0x38, 0xdb, 0xea, 0xf8, + 0x2b, 0x6b, 0x8f, 0x41, 0x49, 0xb2, 0xdf, 0x14, 0xec, 0x05, 0xfc, 0xda, 0xc9, 0xd9, 0x0d, 0xc2, + 0x8a, 0xb4, 0x8e, 0xf7, 0x3b, 0x02, 0xa5, 0x7d, 0x65, 0xc6, 0x7d, 0xa5, 0xaa, 0xf9, 0xf2, 0x51, + 0x56, 0x4e, 0xa9, 0x22, 0xa9, 0x6f, 0x08, 0xea, 0x57, 0xf0, 0xd2, 0xc9, 0xa9, 0x49, 0x44, 0xf4, + 0x3d, 0x82, 0xff, 0x37, 0x3d, 0x65, 0xf0, 0x62, 0x0f, 0xfe, 0xb5, 0x7e, 0xc2, 0x29, 0xd7, 0xfb, + 0x31, 0x95, 0x3c, 0xab, 0x82, 0x27, 0x8f, 0x5f, 0xed, 0xcc, 0x13, 0x81, 0x98, 0x76, 0xf0, 0x9f, + 0x06, 0xed, 0x7e, 0xc3, 0x8d, 0xb1, 0x8f, 0xbf, 0x41, 0x30, 0x1a, 0x7b, 0xb4, 0xe2, 0x17, 0x7a, + 0x77, 0x2a, 0xf6, 0xc8, 0x55, 0xae, 0xf5, 0x54, 0xda, 0x63, 0xbf, 0x09, 0x7a, 0x3d, 0x83, 0x4d, + 0xfe, 0x86, 0x44, 0xda, 0x7d, 0xb3, 0xbc, 0x8f, 0xbf, 0x43, 0x30, 0xd1, 0x7c, 0xf3, 0xe2, 0x5e, + 0xc2, 0xda, 0xe6, 0x3a, 0x57, 0x96, 0xfa, 0xb2, 0x95, 0x39, 0x59, 0x14, 0x44, 0x0b, 0x78, 0xbe, + 0x33, 0x91, 0x41, 0x79, 0x91, 0x58, 0x56, 0x90, 0x8f, 0xa2, 0xed, 0x4b, 0x14, 0x6e, 0x1d, 0x1c, + 0x66, 0xd0, 0xc3, 0xc3, 0x0c, 0xfa, 0xe9, 0x30, 0x83, 0x3e, 0x39, 0xca, 0x0c, 0x3c, 0x3c, 0xca, + 0x0c, 0xfc, 0x78, 0x94, 0x19, 0xf8, 0x20, 0x17, 0xbb, 0xba, 0x5b, 0xc8, 0xee, 0xe6, 0xb4, 0xbd, + 0x98, 0xb6, 0xb8, 0xca, 0xb7, 0x86, 0xc5, 0x0f, 0xd4, 0x85, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, + 0xae, 0x6f, 0x79, 0x62, 0x00, 0x13, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/consensus/types/simple_test_message.pb.go b/x/consensus/types/simple_test_message.pb.go index a283141c..f148c2a6 100644 --- a/x/consensus/types/simple_test_message.pb.go +++ b/x/consensus/types/simple_test_message.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -34,9 +37,11 @@ func (*SimpleMessage) ProtoMessage() {} func (*SimpleMessage) Descriptor() ([]byte, []int) { return fileDescriptor_552b11b5e7ba7b89, []int{0} } + func (m *SimpleMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SimpleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SimpleMessage.Marshal(b, m, deterministic) @@ -49,12 +54,15 @@ func (m *SimpleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error return b[:n], nil } } + func (m *SimpleMessage) XXX_Merge(src proto.Message) { xxx_messageInfo_SimpleMessage.Merge(m, src) } + func (m *SimpleMessage) XXX_Size() int { return m.Size() } + func (m *SimpleMessage) XXX_DiscardUnknown() { xxx_messageInfo_SimpleMessage.DiscardUnknown(m) } @@ -93,9 +101,11 @@ func (*EvenSimplerMessage) ProtoMessage() {} func (*EvenSimplerMessage) Descriptor() ([]byte, []int) { return fileDescriptor_552b11b5e7ba7b89, []int{1} } + func (m *EvenSimplerMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EvenSimplerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EvenSimplerMessage.Marshal(b, m, deterministic) @@ -108,12 +118,15 @@ func (m *EvenSimplerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *EvenSimplerMessage) XXX_Merge(src proto.Message) { xxx_messageInfo_EvenSimplerMessage.Merge(m, src) } + func (m *EvenSimplerMessage) XXX_Size() int { return m.Size() } + func (m *EvenSimplerMessage) XXX_DiscardUnknown() { xxx_messageInfo_EvenSimplerMessage.DiscardUnknown(m) } @@ -144,7 +157,7 @@ func init() { } var fileDescriptor_552b11b5e7ba7b89 = []byte{ - // 221 bytes of a gzipped FileDescriptorProto + // 224 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2b, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x93, 0xf3, 0xf3, 0x8a, 0x53, 0xf3, 0x8a, 0x4b, 0x8b, 0xf5, 0x8b, 0x33, 0x73, 0x0b, 0x72, 0x52, 0xe3, 0x4b, 0x52, 0x8b, 0x4b, @@ -154,11 +167,11 @@ var fileDescriptor_552b11b5e7ba7b89 = []byte{ 0x1a, 0x9c, 0x41, 0x50, 0x9e, 0x90, 0x08, 0x17, 0x6b, 0x46, 0x6a, 0x4e, 0x4e, 0xbe, 0x04, 0x13, 0x58, 0x18, 0xc2, 0x01, 0x89, 0x96, 0xe7, 0x17, 0xe5, 0xa4, 0x48, 0x30, 0x43, 0x44, 0xc1, 0x1c, 0x25, 0x3b, 0x2e, 0x21, 0xd7, 0xb2, 0xd4, 0x3c, 0x88, 0xc1, 0x45, 0x84, 0x4c, 0x16, 0xe0, 0x62, - 0x4e, 0xca, 0x87, 0x99, 0x0b, 0x62, 0x3a, 0x79, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, + 0x4e, 0xca, 0x87, 0x99, 0x0b, 0x62, 0x3a, 0xf9, 0x9c, 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, 0x7e, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x96, - 0xf0, 0xa8, 0x40, 0x0a, 0x91, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0x70, 0x20, 0x18, 0x03, - 0x02, 0x00, 0x00, 0xff, 0xff, 0x1e, 0x0d, 0xc4, 0xca, 0x3e, 0x01, 0x00, 0x00, + 0x1c, 0x43, 0x94, 0x51, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x96, + 0xf0, 0x28, 0x33, 0xd2, 0xaf, 0x40, 0x0a, 0x94, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0x70, + 0x38, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd3, 0x65, 0x8c, 0x9a, 0x41, 0x01, 0x00, 0x00, } func (m *SimpleMessage) Marshal() (dAtA []byte, err error) { @@ -253,6 +266,7 @@ func encodeVarintSimpleTestMessage(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *SimpleMessage) Size() (n int) { if m == nil { return 0 @@ -294,9 +308,11 @@ func (m *EvenSimplerMessage) Size() (n int) { func sovSimpleTestMessage(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozSimpleTestMessage(x uint64) (n int) { return sovSimpleTestMessage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SimpleMessage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -443,6 +459,7 @@ func (m *SimpleMessage) Unmarshal(dAtA []byte) error { } return nil } + func (m *EvenSimplerMessage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -557,6 +574,7 @@ func (m *EvenSimplerMessage) Unmarshal(dAtA []byte) error { } return nil } + func skipSimpleTestMessage(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/consensus/types/tx.pb.go b/x/consensus/types/tx.pb.go index efab28e9..eec3e37b 100644 --- a/x/consensus/types/tx.pb.go +++ b/x/consensus/types/tx.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + types1 "github.com/cosmos/cosmos-sdk/codec/types" _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/cosmos/gogoproto/gogoproto" @@ -16,15 +20,14 @@ import ( codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" emptypb "google.golang.org/protobuf/types/known/emptypb" - 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -43,9 +46,11 @@ func (*MsgAddMessagesSignatures) ProtoMessage() {} func (*MsgAddMessagesSignatures) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{0} } + func (m *MsgAddMessagesSignatures) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAddMessagesSignatures) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAddMessagesSignatures.Marshal(b, m, deterministic) @@ -58,12 +63,15 @@ func (m *MsgAddMessagesSignatures) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *MsgAddMessagesSignatures) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAddMessagesSignatures.Merge(m, src) } + func (m *MsgAddMessagesSignatures) XXX_Size() int { return m.Size() } + func (m *MsgAddMessagesSignatures) XXX_DiscardUnknown() { xxx_messageInfo_MsgAddMessagesSignatures.DiscardUnknown(m) } @@ -97,9 +105,11 @@ func (*ConsensusMessageSignature) ProtoMessage() {} func (*ConsensusMessageSignature) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{1} } + func (m *ConsensusMessageSignature) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ConsensusMessageSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ConsensusMessageSignature.Marshal(b, m, deterministic) @@ -112,12 +122,15 @@ func (m *ConsensusMessageSignature) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *ConsensusMessageSignature) XXX_Merge(src proto.Message) { xxx_messageInfo_ConsensusMessageSignature.Merge(m, src) } + func (m *ConsensusMessageSignature) XXX_Size() int { return m.Size() } + func (m *ConsensusMessageSignature) XXX_DiscardUnknown() { xxx_messageInfo_ConsensusMessageSignature.DiscardUnknown(m) } @@ -152,8 +165,7 @@ func (m *ConsensusMessageSignature) GetSignedByAddress() string { return "" } -type MsgAddMessagesSignaturesResponse struct { -} +type MsgAddMessagesSignaturesResponse struct{} func (m *MsgAddMessagesSignaturesResponse) Reset() { *m = MsgAddMessagesSignaturesResponse{} } func (m *MsgAddMessagesSignaturesResponse) String() string { return proto.CompactTextString(m) } @@ -161,9 +173,11 @@ func (*MsgAddMessagesSignaturesResponse) ProtoMessage() {} func (*MsgAddMessagesSignaturesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{2} } + func (m *MsgAddMessagesSignaturesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAddMessagesSignaturesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAddMessagesSignaturesResponse.Marshal(b, m, deterministic) @@ -176,12 +190,15 @@ func (m *MsgAddMessagesSignaturesResponse) XXX_Marshal(b []byte, deterministic b return b[:n], nil } } + func (m *MsgAddMessagesSignaturesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAddMessagesSignaturesResponse.Merge(m, src) } + func (m *MsgAddMessagesSignaturesResponse) XXX_Size() int { return m.Size() } + func (m *MsgAddMessagesSignaturesResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgAddMessagesSignaturesResponse.DiscardUnknown(m) } @@ -201,9 +218,11 @@ func (*MsgAddEvidence) ProtoMessage() {} func (*MsgAddEvidence) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{3} } + func (m *MsgAddEvidence) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAddEvidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAddEvidence.Marshal(b, m, deterministic) @@ -216,12 +235,15 @@ func (m *MsgAddEvidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return b[:n], nil } } + func (m *MsgAddEvidence) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAddEvidence.Merge(m, src) } + func (m *MsgAddEvidence) XXX_Size() int { return m.Size() } + func (m *MsgAddEvidence) XXX_DiscardUnknown() { xxx_messageInfo_MsgAddEvidence.DiscardUnknown(m) } @@ -256,8 +278,7 @@ func (m *MsgAddEvidence) GetMetadata() types.MsgMetadata { return types.MsgMetadata{} } -type MsgAddEvidenceResponse struct { -} +type MsgAddEvidenceResponse struct{} func (m *MsgAddEvidenceResponse) Reset() { *m = MsgAddEvidenceResponse{} } func (m *MsgAddEvidenceResponse) String() string { return proto.CompactTextString(m) } @@ -265,9 +286,11 @@ func (*MsgAddEvidenceResponse) ProtoMessage() {} func (*MsgAddEvidenceResponse) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{4} } + func (m *MsgAddEvidenceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAddEvidenceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAddEvidenceResponse.Marshal(b, m, deterministic) @@ -280,12 +303,15 @@ func (m *MsgAddEvidenceResponse) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *MsgAddEvidenceResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAddEvidenceResponse.Merge(m, src) } + func (m *MsgAddEvidenceResponse) XXX_Size() int { return m.Size() } + func (m *MsgAddEvidenceResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgAddEvidenceResponse.DiscardUnknown(m) } @@ -306,9 +332,11 @@ func (*MsgSetPublicAccessData) ProtoMessage() {} func (*MsgSetPublicAccessData) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{5} } + func (m *MsgSetPublicAccessData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSetPublicAccessData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSetPublicAccessData.Marshal(b, m, deterministic) @@ -321,12 +349,15 @@ func (m *MsgSetPublicAccessData) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *MsgSetPublicAccessData) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSetPublicAccessData.Merge(m, src) } + func (m *MsgSetPublicAccessData) XXX_Size() int { return m.Size() } + func (m *MsgSetPublicAccessData) XXX_DiscardUnknown() { xxx_messageInfo_MsgSetPublicAccessData.DiscardUnknown(m) } @@ -368,8 +399,7 @@ func (m *MsgSetPublicAccessData) GetValsetID() uint64 { return 0 } -type MsgSetPublicAccessDataResponse struct { -} +type MsgSetPublicAccessDataResponse struct{} func (m *MsgSetPublicAccessDataResponse) Reset() { *m = MsgSetPublicAccessDataResponse{} } func (m *MsgSetPublicAccessDataResponse) String() string { return proto.CompactTextString(m) } @@ -377,9 +407,11 @@ func (*MsgSetPublicAccessDataResponse) ProtoMessage() {} func (*MsgSetPublicAccessDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{6} } + func (m *MsgSetPublicAccessDataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSetPublicAccessDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSetPublicAccessDataResponse.Marshal(b, m, deterministic) @@ -392,12 +424,15 @@ func (m *MsgSetPublicAccessDataResponse) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *MsgSetPublicAccessDataResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSetPublicAccessDataResponse.Merge(m, src) } + func (m *MsgSetPublicAccessDataResponse) XXX_Size() int { return m.Size() } + func (m *MsgSetPublicAccessDataResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgSetPublicAccessDataResponse.DiscardUnknown(m) } @@ -417,9 +452,11 @@ func (*MsgSetErrorData) ProtoMessage() {} func (*MsgSetErrorData) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{7} } + func (m *MsgSetErrorData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSetErrorData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSetErrorData.Marshal(b, m, deterministic) @@ -432,12 +469,15 @@ func (m *MsgSetErrorData) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } + func (m *MsgSetErrorData) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSetErrorData.Merge(m, src) } + func (m *MsgSetErrorData) XXX_Size() int { return m.Size() } + func (m *MsgSetErrorData) XXX_DiscardUnknown() { xxx_messageInfo_MsgSetErrorData.DiscardUnknown(m) } @@ -472,8 +512,7 @@ func (m *MsgSetErrorData) GetMetadata() types.MsgMetadata { return types.MsgMetadata{} } -type MsgSetErrorDataResponse struct { -} +type MsgSetErrorDataResponse struct{} func (m *MsgSetErrorDataResponse) Reset() { *m = MsgSetErrorDataResponse{} } func (m *MsgSetErrorDataResponse) String() string { return proto.CompactTextString(m) } @@ -481,9 +520,11 @@ func (*MsgSetErrorDataResponse) ProtoMessage() {} func (*MsgSetErrorDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{8} } + func (m *MsgSetErrorDataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSetErrorDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSetErrorDataResponse.Marshal(b, m, deterministic) @@ -496,12 +537,15 @@ func (m *MsgSetErrorDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *MsgSetErrorDataResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSetErrorDataResponse.Merge(m, src) } + func (m *MsgSetErrorDataResponse) XXX_Size() int { return m.Size() } + func (m *MsgSetErrorDataResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgSetErrorDataResponse.DiscardUnknown(m) } @@ -519,9 +563,11 @@ func (*MsgAddMessageGasEstimates) ProtoMessage() {} func (*MsgAddMessageGasEstimates) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{9} } + func (m *MsgAddMessageGasEstimates) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAddMessageGasEstimates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAddMessageGasEstimates.Marshal(b, m, deterministic) @@ -534,12 +580,15 @@ func (m *MsgAddMessageGasEstimates) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *MsgAddMessageGasEstimates) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAddMessageGasEstimates.Merge(m, src) } + func (m *MsgAddMessageGasEstimates) XXX_Size() int { return m.Size() } + func (m *MsgAddMessageGasEstimates) XXX_DiscardUnknown() { xxx_messageInfo_MsgAddMessageGasEstimates.DiscardUnknown(m) } @@ -573,9 +622,11 @@ func (*MsgAddMessageGasEstimates_GasEstimate) ProtoMessage() {} func (*MsgAddMessageGasEstimates_GasEstimate) Descriptor() ([]byte, []int) { return fileDescriptor_9a053a9b8cda05fe, []int{9, 0} } + func (m *MsgAddMessageGasEstimates_GasEstimate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAddMessageGasEstimates_GasEstimate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAddMessageGasEstimates_GasEstimate.Marshal(b, m, deterministic) @@ -588,12 +639,15 @@ func (m *MsgAddMessageGasEstimates_GasEstimate) XXX_Marshal(b []byte, determinis return b[:n], nil } } + func (m *MsgAddMessageGasEstimates_GasEstimate) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAddMessageGasEstimates_GasEstimate.Merge(m, src) } + func (m *MsgAddMessageGasEstimates_GasEstimate) XXX_Size() int { return m.Size() } + func (m *MsgAddMessageGasEstimates_GasEstimate) XXX_DiscardUnknown() { xxx_messageInfo_MsgAddMessageGasEstimates_GasEstimate.DiscardUnknown(m) } @@ -647,60 +701,62 @@ func init() { } var fileDescriptor_9a053a9b8cda05fe = []byte{ - // 759 bytes of a gzipped FileDescriptorProto + // 760 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4b, 0x6f, 0xd3, 0x4a, 0x14, 0xce, 0x24, 0x4e, 0x6f, 0x7b, 0xd2, 0xc7, 0xd5, 0xf4, 0xe5, 0xf8, 0x56, 0xb9, 0x51, 0x74, - 0x6f, 0x15, 0x55, 0xf7, 0xda, 0x22, 0x3c, 0x2a, 0x21, 0x84, 0x94, 0xb6, 0x11, 0x04, 0x29, 0x08, - 0xb9, 0xac, 0xd8, 0x54, 0x13, 0x7b, 0xea, 0x5a, 0x8a, 0x3d, 0xa9, 0xc7, 0x8e, 0x9a, 0x2d, 0x3b, - 0x56, 0x74, 0xcb, 0xbf, 0xe0, 0x67, 0x74, 0x59, 0x76, 0xac, 0x10, 0x6a, 0x16, 0x20, 0xd6, 0xfd, - 0x01, 0x28, 0x7e, 0xe5, 0x51, 0xb7, 0x69, 0x0b, 0x2c, 0x58, 0x65, 0x66, 0xce, 0x77, 0x3e, 0x9f, - 0xef, 0x7c, 0xf1, 0xf1, 0xc0, 0xbf, 0x6d, 0xd2, 0x62, 0x16, 0xd1, 0x0e, 0x88, 0x69, 0x2b, 0xc1, - 0x5a, 0xd1, 0x98, 0xcd, 0xa9, 0xcd, 0x3d, 0xae, 0xb8, 0x47, 0x72, 0xdb, 0x61, 0x2e, 0xc3, 0x6b, - 0x43, 0x30, 0x39, 0x58, 0xcb, 0x31, 0x4c, 0x5a, 0x32, 0x98, 0xc1, 0x7c, 0xa0, 0xd2, 0x5f, 0x05, - 0x39, 0xd2, 0xaa, 0xc6, 0xb8, 0xc5, 0xb8, 0x62, 0x71, 0x43, 0xe9, 0xdc, 0xe9, 0xff, 0x84, 0x81, - 0xbc, 0xc1, 0x98, 0xd1, 0xa2, 0x8a, 0xbf, 0x6b, 0x7a, 0xfb, 0x0a, 0xb1, 0xbb, 0x61, 0x68, 0x3d, - 0xa1, 0x9c, 0x0e, 0x69, 0x71, 0xea, 0x2a, 0x1a, 0xb3, 0x2c, 0x66, 0x87, 0xb8, 0xbf, 0xc6, 0x29, - 0xa8, 0xd5, 0x76, 0x43, 0x92, 0x52, 0x0f, 0x81, 0xd8, 0xe0, 0x46, 0x55, 0xd7, 0x1b, 0x94, 0x73, - 0x62, 0x50, 0xbe, 0x6b, 0x1a, 0x36, 0x71, 0x3d, 0x87, 0x72, 0xbc, 0x07, 0xf3, 0xdc, 0x34, 0x6c, - 0x1a, 0xc7, 0xc4, 0x74, 0x31, 0x53, 0xce, 0x55, 0x36, 0xe5, 0xab, 0x24, 0xca, 0xdb, 0xd1, 0x2a, - 0x4c, 0x8b, 0x19, 0xd5, 0x31, 0x3a, 0xfc, 0x14, 0xa6, 0x2d, 0xea, 0x12, 0x9d, 0xb8, 0x44, 0xcc, - 0x14, 0x51, 0x39, 0x57, 0x59, 0x4f, 0xa2, 0x0e, 0x54, 0xc9, 0x0d, 0x6e, 0x34, 0x42, 0xf4, 0x96, - 0x70, 0xf2, 0xe9, 0xef, 0x94, 0x1a, 0x67, 0x3f, 0x9c, 0x7b, 0xfd, 0xe5, 0xfd, 0x46, 0xbc, 0x7d, - 0x26, 0x4c, 0xa3, 0x3f, 0xd3, 0xea, 0x1f, 0x9a, 0x43, 0x89, 0xcb, 0x9c, 0xd2, 0x3b, 0x04, 0xf9, - 0x4b, 0xab, 0xc2, 0xf3, 0x90, 0x36, 0x75, 0x11, 0x15, 0x51, 0x59, 0x50, 0xd3, 0xa6, 0x8e, 0xff, - 0x81, 0xb9, 0x43, 0x8f, 0x7a, 0xf4, 0x65, 0xb7, 0x4d, 0x9f, 0x13, 0x8b, 0x8a, 0xe9, 0x22, 0x2a, - 0xcf, 0xa8, 0xa3, 0x87, 0x78, 0x0d, 0x66, 0x78, 0x44, 0xe1, 0x17, 0x3f, 0xab, 0x0e, 0x0e, 0x70, - 0x19, 0x16, 0x02, 0xad, 0x5b, 0xdd, 0xaa, 0xae, 0x3b, 0x94, 0x73, 0x31, 0xeb, 0xb3, 0x8c, 0x1f, - 0x97, 0x4a, 0x50, 0xbc, 0xcc, 0x00, 0x95, 0xf2, 0x76, 0xbf, 0xea, 0xd2, 0x57, 0x04, 0xf3, 0x01, - 0xa8, 0xd6, 0x31, 0x75, 0x6a, 0x6b, 0x14, 0x6f, 0x40, 0xb6, 0xed, 0x30, 0xb6, 0xef, 0x17, 0x97, - 0xab, 0x2c, 0xc9, 0x81, 0xcb, 0x72, 0xe4, 0xb2, 0x5c, 0xb5, 0xbb, 0x6a, 0x00, 0xe9, 0x97, 0x6a, - 0x05, 0xe4, 0xf5, 0x1d, 0xbf, 0x54, 0x41, 0x1d, 0x1c, 0x5c, 0x94, 0x2b, 0x24, 0xc9, 0x1d, 0xb6, - 0x2a, 0xfb, 0x0b, 0xad, 0x12, 0x61, 0x65, 0x54, 0x69, 0xdc, 0x84, 0x73, 0xe4, 0x87, 0x76, 0xa9, - 0xfb, 0xc2, 0x6b, 0xb6, 0x4c, 0xad, 0xaa, 0x69, 0x94, 0xf3, 0x1d, 0xe2, 0x92, 0x51, 0x81, 0xe9, - 0x89, 0x02, 0x33, 0x49, 0x02, 0x31, 0x08, 0xbe, 0x38, 0xc1, 0xb7, 0xd2, 0x5f, 0xff, 0x3c, 0xd1, - 0x58, 0x82, 0xe9, 0x00, 0x55, 0xdf, 0x11, 0xa7, 0xfc, 0x02, 0xe3, 0xfd, 0x84, 0x86, 0x14, 0xa1, - 0x90, 0xac, 0x3a, 0x6e, 0xcc, 0x07, 0x04, 0x0b, 0x01, 0xa4, 0xe6, 0x38, 0xcc, 0xf9, 0x3d, 0x3a, - 0x32, 0x41, 0x75, 0x1e, 0x56, 0xc7, 0x24, 0xc5, 0x72, 0xbf, 0xa5, 0x21, 0x3f, 0xf2, 0xc6, 0x3c, - 0x21, 0xbc, 0xc6, 0x5d, 0xd3, 0x22, 0xee, 0xd8, 0x48, 0x41, 0x3f, 0x64, 0x19, 0x81, 0x19, 0x1a, - 0xd1, 0x86, 0x83, 0x6f, 0xfb, 0xea, 0xc1, 0x77, 0x69, 0x55, 0xf2, 0xd0, 0x46, 0x1d, 0xb0, 0x4a, - 0xc7, 0x08, 0x72, 0x43, 0x21, 0xbc, 0x0c, 0x53, 0x16, 0x37, 0xf6, 0xe2, 0x69, 0x94, 0xb5, 0xb8, - 0x51, 0xbf, 0xee, 0x40, 0x5a, 0x82, 0x6c, 0x87, 0xb4, 0x3c, 0x1a, 0xbe, 0xe1, 0xc1, 0x06, 0xcb, - 0x80, 0xa3, 0xe7, 0x5d, 0x98, 0x45, 0x09, 0x91, 0x31, 0x5b, 0x2a, 0xe7, 0x02, 0x64, 0x1a, 0xdc, - 0xc0, 0x6f, 0x11, 0x2c, 0x27, 0x7f, 0x24, 0x1e, 0xdc, 0xa0, 0x27, 0x43, 0x79, 0xd2, 0xe3, 0xdb, - 0xe5, 0x45, 0x7f, 0x03, 0xbc, 0x0f, 0x8b, 0x03, 0xc0, 0xc0, 0xff, 0xcd, 0x5b, 0x5a, 0x24, 0xad, - 0x5c, 0x98, 0xa0, 0xb5, 0xfe, 0x77, 0x12, 0x1f, 0x42, 0x6e, 0x78, 0xee, 0xfe, 0x77, 0x1d, 0xfe, - 0x08, 0x2d, 0xdd, 0xbb, 0x09, 0x3a, 0x96, 0xf6, 0x06, 0xc1, 0x62, 0xd2, 0x98, 0x9b, 0xcc, 0x96, - 0x90, 0x25, 0x3d, 0xba, 0x4d, 0x56, 0x5c, 0x8b, 0x0b, 0xb3, 0x23, 0x83, 0xe5, 0xff, 0xeb, 0xb0, - 0xc5, 0x70, 0xe9, 0xfe, 0x8d, 0xe0, 0xd1, 0x53, 0xb7, 0xea, 0x27, 0x67, 0x05, 0x74, 0x7a, 0x56, - 0x40, 0x9f, 0xcf, 0x0a, 0xe8, 0xb8, 0x57, 0x48, 0x9d, 0xf6, 0x0a, 0xa9, 0x8f, 0xbd, 0x42, 0xea, - 0x95, 0x62, 0x98, 0xee, 0x81, 0xd7, 0x94, 0x35, 0x66, 0x29, 0x09, 0x17, 0xa0, 0xa3, 0xe1, 0x1b, - 0x59, 0xb7, 0x4d, 0x79, 0x73, 0xca, 0xf7, 0xf3, 0xee, 0xf7, 0x00, 0x00, 0x00, 0xff, 0xff, 0x64, - 0x69, 0x8f, 0xf0, 0xbe, 0x09, 0x00, 0x00, + 0x6f, 0x15, 0x55, 0x60, 0x8b, 0xf0, 0xa8, 0x84, 0x10, 0x52, 0xda, 0x46, 0x50, 0x44, 0x10, 0x72, + 0x59, 0xb1, 0xa9, 0x26, 0xf6, 0xd4, 0xb5, 0x14, 0x7b, 0x52, 0x8f, 0x1d, 0x35, 0x5b, 0x76, 0xac, + 0xe8, 0x96, 0x7f, 0xc1, 0xcf, 0xe8, 0xb2, 0xec, 0x58, 0x21, 0xd4, 0x2c, 0x40, 0xac, 0xfb, 0x03, + 0x50, 0xfc, 0xca, 0xa3, 0x6e, 0xd3, 0x16, 0x58, 0xb0, 0xca, 0xcc, 0x9c, 0xef, 0x7c, 0x3e, 0xdf, + 0xf9, 0xe2, 0xe3, 0x81, 0xff, 0x5b, 0xa4, 0xc9, 0x2c, 0xa2, 0xed, 0x13, 0xd3, 0x56, 0x82, 0xb5, + 0xa2, 0x31, 0x9b, 0x53, 0x9b, 0x7b, 0x5c, 0x71, 0x0f, 0xe5, 0x96, 0xc3, 0x5c, 0x86, 0x57, 0x06, + 0x60, 0x72, 0xb0, 0x96, 0x63, 0x98, 0xb4, 0x60, 0x30, 0x83, 0xf9, 0x40, 0xa5, 0xb7, 0x0a, 0x72, + 0xa4, 0x65, 0x8d, 0x71, 0x8b, 0x71, 0xc5, 0xe2, 0x86, 0xd2, 0xbe, 0xd3, 0xfb, 0x09, 0x03, 0x79, + 0x83, 0x31, 0xa3, 0x49, 0x15, 0x7f, 0xd7, 0xf0, 0xf6, 0x14, 0x62, 0x77, 0xc2, 0xd0, 0x6a, 0x42, + 0x39, 0x6d, 0xd2, 0xe4, 0xd4, 0x55, 0x34, 0x66, 0x59, 0xcc, 0x0e, 0x71, 0xff, 0x8c, 0x52, 0x50, + 0xab, 0xe5, 0x86, 0x24, 0xa5, 0x2e, 0x02, 0xb1, 0xce, 0x8d, 0xaa, 0xae, 0xd7, 0x29, 0xe7, 0xc4, + 0xa0, 0x7c, 0xc7, 0x34, 0x6c, 0xe2, 0x7a, 0x0e, 0xe5, 0x78, 0x17, 0x66, 0xb9, 0x69, 0xd8, 0x34, + 0x8e, 0x89, 0xe9, 0x62, 0xa6, 0x9c, 0xab, 0xac, 0xcb, 0x97, 0x49, 0x94, 0x37, 0xa3, 0x55, 0x98, + 0x16, 0x33, 0xaa, 0x23, 0x74, 0xf8, 0x29, 0x4c, 0x5a, 0xd4, 0x25, 0x3a, 0x71, 0x89, 0x98, 0x29, + 0xa2, 0x72, 0xae, 0xb2, 0x9a, 0x44, 0x1d, 0xa8, 0x92, 0xeb, 0xdc, 0xa8, 0x87, 0xe8, 0x0d, 0xe1, + 0xf8, 0xf3, 0xbf, 0x29, 0x35, 0xce, 0x7e, 0x38, 0xf3, 0xe6, 0xeb, 0x87, 0xb5, 0x78, 0xfb, 0x4c, + 0x98, 0x44, 0x7f, 0xa7, 0xd5, 0xbf, 0x34, 0x87, 0x12, 0x97, 0x39, 0xa5, 0xf7, 0x08, 0xf2, 0x17, + 0x56, 0x85, 0x67, 0x21, 0x6d, 0xea, 0x22, 0x2a, 0xa2, 0xb2, 0xa0, 0xa6, 0x4d, 0x1d, 0xff, 0x07, + 0x33, 0x07, 0x1e, 0xf5, 0xe8, 0xab, 0x4e, 0x8b, 0xbe, 0x20, 0x16, 0x15, 0xd3, 0x45, 0x54, 0x9e, + 0x52, 0x87, 0x0f, 0xf1, 0x0a, 0x4c, 0xf1, 0x88, 0xc2, 0x2f, 0x7e, 0x5a, 0xed, 0x1f, 0xe0, 0x32, + 0xcc, 0x05, 0x5a, 0x37, 0x3a, 0x55, 0x5d, 0x77, 0x28, 0xe7, 0x62, 0xd6, 0x67, 0x19, 0x3d, 0x2e, + 0x95, 0xa0, 0x78, 0x91, 0x01, 0x2a, 0xe5, 0xad, 0x5e, 0xd5, 0xa5, 0x6f, 0x08, 0x66, 0x03, 0x50, + 0xad, 0x6d, 0xea, 0xd4, 0xd6, 0x28, 0x5e, 0x83, 0x6c, 0xcb, 0x61, 0x6c, 0xcf, 0x2f, 0x2e, 0x57, + 0x59, 0x90, 0x03, 0x97, 0xe5, 0xc8, 0x65, 0xb9, 0x6a, 0x77, 0xd4, 0x00, 0xd2, 0x2b, 0xd5, 0x0a, + 0xc8, 0xb7, 0xb7, 0xfc, 0x52, 0x05, 0xb5, 0x7f, 0x70, 0x5e, 0xae, 0x90, 0x24, 0x77, 0xd0, 0xaa, + 0xec, 0x6f, 0xb4, 0x4a, 0x84, 0xa5, 0x61, 0xa5, 0x71, 0x13, 0xce, 0x90, 0x1f, 0xda, 0xa1, 0xee, + 0x4b, 0xaf, 0xd1, 0x34, 0xb5, 0xaa, 0xa6, 0x51, 0xce, 0xb7, 0x88, 0x4b, 0x86, 0x05, 0xa6, 0xc7, + 0x0a, 0xcc, 0x24, 0x09, 0xc4, 0x20, 0xf8, 0xe2, 0x04, 0xdf, 0x4a, 0x7f, 0xfd, 0xeb, 0x44, 0x63, + 0x09, 0x26, 0x03, 0xd4, 0xf6, 0x96, 0x38, 0xe1, 0x17, 0x18, 0xef, 0xc7, 0x34, 0xa4, 0x08, 0x85, + 0x64, 0xd5, 0x71, 0x63, 0x3e, 0x22, 0x98, 0x0b, 0x20, 0x35, 0xc7, 0x61, 0xce, 0x9f, 0xd1, 0x91, + 0x31, 0xaa, 0xf3, 0xb0, 0x3c, 0x22, 0x29, 0x96, 0xfb, 0x3d, 0x0d, 0xf9, 0xa1, 0x37, 0xe6, 0x09, + 0xe1, 0x35, 0xee, 0x9a, 0x16, 0x71, 0x47, 0x46, 0x0a, 0xfa, 0x29, 0xcb, 0x08, 0x4c, 0xd1, 0x88, + 0x36, 0x1c, 0x7c, 0x9b, 0x97, 0x0f, 0xbe, 0x0b, 0xab, 0x92, 0x07, 0x36, 0x6a, 0x9f, 0x55, 0x3a, + 0x42, 0x90, 0x1b, 0x08, 0xe1, 0x45, 0x98, 0xb0, 0xb8, 0xb1, 0x1b, 0x4f, 0xa3, 0xac, 0xc5, 0x8d, + 0xed, 0xab, 0x0e, 0xa4, 0x05, 0xc8, 0xb6, 0x49, 0xd3, 0xa3, 0xe1, 0x1b, 0x1e, 0x6c, 0xb0, 0x0c, + 0x38, 0x7a, 0xde, 0xb9, 0x59, 0x94, 0x10, 0x19, 0xb1, 0xa5, 0x72, 0x26, 0x40, 0xa6, 0xce, 0x0d, + 0xfc, 0x0e, 0xc1, 0x62, 0xf2, 0x47, 0xe2, 0xc1, 0x35, 0x7a, 0x32, 0x90, 0x27, 0x3d, 0xbe, 0x59, + 0x5e, 0xf4, 0x37, 0xc0, 0x7b, 0x30, 0xdf, 0x07, 0xf4, 0xfd, 0x5f, 0xbf, 0xa1, 0x45, 0xd2, 0xd2, + 0xb9, 0x09, 0x5a, 0xeb, 0x7d, 0x27, 0xf1, 0x01, 0xe4, 0x06, 0xe7, 0xee, 0xad, 0xab, 0xf0, 0x47, + 0x68, 0xe9, 0xde, 0x75, 0xd0, 0xb1, 0xb4, 0xb7, 0x08, 0xe6, 0x93, 0xc6, 0xdc, 0x78, 0xb6, 0x84, + 0x2c, 0xe9, 0xd1, 0x4d, 0xb2, 0xe2, 0x5a, 0x5c, 0x98, 0x1e, 0x1a, 0x2c, 0xb7, 0xaf, 0xc2, 0x16, + 0xc3, 0xa5, 0xfb, 0xd7, 0x82, 0x47, 0x4f, 0xdd, 0x78, 0x7e, 0x7c, 0x5a, 0x40, 0x27, 0xa7, 0x05, + 0xf4, 0xe5, 0xb4, 0x80, 0x8e, 0xba, 0x85, 0xd4, 0x49, 0xb7, 0x90, 0xfa, 0xd4, 0x2d, 0xa4, 0x5e, + 0x57, 0x0c, 0xd3, 0xdd, 0xf7, 0x1a, 0xb2, 0xc6, 0x2c, 0x25, 0xe9, 0x02, 0x54, 0x51, 0x0e, 0x07, + 0x2f, 0x65, 0x9d, 0x16, 0xe5, 0x8d, 0x09, 0xdf, 0xd2, 0xbb, 0x3f, 0x02, 0x00, 0x00, 0xff, 0xff, + 0xd4, 0xbe, 0x75, 0x23, 0xc1, 0x09, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -780,21 +836,24 @@ type MsgServer interface { } // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func (*UnimplementedMsgServer) AddMessagesSignatures(ctx context.Context, req *MsgAddMessagesSignatures) (*MsgAddMessagesSignaturesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AddMessagesSignatures not implemented") } + func (*UnimplementedMsgServer) AddMessageEstimates(ctx context.Context, req *MsgAddMessageGasEstimates) (*emptypb.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method AddMessageEstimates not implemented") } + func (*UnimplementedMsgServer) AddEvidence(ctx context.Context, req *MsgAddEvidence) (*MsgAddEvidenceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AddEvidence not implemented") } + func (*UnimplementedMsgServer) SetPublicAccessData(ctx context.Context, req *MsgSetPublicAccessData) (*MsgSetPublicAccessDataResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetPublicAccessData not implemented") } + func (*UnimplementedMsgServer) SetErrorData(ctx context.Context, req *MsgSetErrorData) (*MsgSetErrorDataResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetErrorData not implemented") } @@ -1381,6 +1440,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgAddMessagesSignatures) Size() (n int) { if m == nil { return 0 @@ -1570,9 +1630,11 @@ func (m *MsgAddMessageGasEstimates_GasEstimate) Size() (n int) { 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 *MsgAddMessagesSignatures) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1690,6 +1752,7 @@ func (m *MsgAddMessagesSignatures) Unmarshal(dAtA []byte) error { } return nil } + func (m *ConsensusMessageSignature) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1857,6 +1920,7 @@ func (m *ConsensusMessageSignature) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAddMessagesSignaturesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1907,6 +1971,7 @@ func (m *MsgAddMessagesSignaturesResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAddEvidence) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2077,6 +2142,7 @@ func (m *MsgAddEvidence) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAddEvidenceResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2127,6 +2193,7 @@ func (m *MsgAddEvidenceResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSetPublicAccessData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2314,6 +2381,7 @@ func (m *MsgSetPublicAccessData) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSetPublicAccessDataResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2364,6 +2432,7 @@ func (m *MsgSetPublicAccessDataResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSetErrorData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2532,6 +2601,7 @@ func (m *MsgSetErrorData) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSetErrorDataResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2582,6 +2652,7 @@ func (m *MsgSetErrorDataResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAddMessageGasEstimates) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2699,6 +2770,7 @@ func (m *MsgAddMessageGasEstimates) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAddMessageGasEstimates_GasEstimate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2851,6 +2923,7 @@ func (m *MsgAddMessageGasEstimates_GasEstimate) Unmarshal(dAtA []byte) error { } return nil } + func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/add_chain_proposal.pb.go b/x/evm/types/add_chain_proposal.pb.go index c586887c..cfa3f4af 100644 --- a/x/evm/types/add_chain_proposal.pb.go +++ b/x/evm/types/add_chain_proposal.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -38,9 +41,11 @@ func (*AddChainProposal) ProtoMessage() {} func (*AddChainProposal) Descriptor() ([]byte, []int) { return fileDescriptor_a657bdb0fb93948a, []int{0} } + func (m *AddChainProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *AddChainProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AddChainProposal.Marshal(b, m, deterministic) @@ -53,12 +58,15 @@ func (m *AddChainProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *AddChainProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_AddChainProposal.Merge(m, src) } + func (m *AddChainProposal) XXX_Size() int { return m.Size() } + func (m *AddChainProposal) XXX_DiscardUnknown() { xxx_messageInfo_AddChainProposal.DiscardUnknown(m) } @@ -123,25 +131,25 @@ func init() { } var fileDescriptor_a657bdb0fb93948a = []byte{ - // 280 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xcd, 0x4a, 0xc4, 0x30, - 0x14, 0x85, 0x9b, 0x71, 0x7e, 0x30, 0x6e, 0xc6, 0x20, 0x92, 0x55, 0x28, 0xae, 0x46, 0x91, 0x76, - 0xe1, 0x13, 0xcc, 0xcf, 0xc2, 0x59, 0x29, 0x5d, 0xba, 0x19, 0xd2, 0xf4, 0x3a, 0x0d, 0xb6, 0x49, - 0x68, 0xe3, 0xa0, 0x2f, 0x21, 0x3e, 0x96, 0xcb, 0x59, 0xba, 0x94, 0xf6, 0x45, 0xa4, 0x69, 0x85, - 0x42, 0xdd, 0xdd, 0xf3, 0x9d, 0x73, 0x39, 0xe4, 0x06, 0x87, 0x86, 0x67, 0x3a, 0xe7, 0x22, 0xe5, - 0x52, 0x75, 0x73, 0x08, 0x87, 0x3c, 0xe4, 0x49, 0xb2, 0x73, 0x70, 0x67, 0x0a, 0x6d, 0x74, 0xc9, - 0xb3, 0xc0, 0x14, 0xda, 0x6a, 0x72, 0xd9, 0x5b, 0x08, 0xda, 0x39, 0x80, 0x43, 0x7e, 0xf5, 0x31, - 0xc2, 0xf3, 0x65, 0x92, 0xac, 0x1b, 0xfe, 0xd8, 0xad, 0x90, 0x0b, 0x3c, 0xb1, 0xd2, 0x66, 0x40, - 0x91, 0x8f, 0x16, 0xa7, 0x51, 0x2b, 0x88, 0x8f, 0xcf, 0x12, 0x28, 0x45, 0x21, 0x8d, 0x95, 0x5a, - 0xd1, 0x91, 0xf3, 0xfa, 0x88, 0xdc, 0xe0, 0xb9, 0x2b, 0x88, 0xe0, 0x19, 0x0a, 0x50, 0x02, 0xb6, - 0x1b, 0x7a, 0xe2, 0x62, 0x03, 0x4e, 0x28, 0x9e, 0x39, 0xb6, 0xdd, 0xd0, 0xb1, 0x8f, 0x16, 0xe3, - 0xe8, 0x4f, 0x36, 0x3d, 0x71, 0xa6, 0xc5, 0xcb, 0x3d, 0xc8, 0x7d, 0x6a, 0xe9, 0xc4, 0xb9, 0x7d, - 0x44, 0x6e, 0xf1, 0x79, 0x2b, 0x79, 0x99, 0x2e, 0x6d, 0x97, 0x9b, 0xba, 0xa2, 0xa1, 0xd1, 0xa4, - 0x73, 0xa9, 0x1e, 0x94, 0x7b, 0xe3, 0x8a, 0x67, 0x5c, 0x09, 0xa0, 0xb3, 0x36, 0x3d, 0x30, 0x56, - 0xeb, 0xaf, 0x8a, 0xa1, 0x63, 0xc5, 0xd0, 0x4f, 0xc5, 0xd0, 0x67, 0xcd, 0xbc, 0x63, 0xcd, 0xbc, - 0xef, 0x9a, 0x79, 0x4f, 0xd7, 0x7b, 0x69, 0xd3, 0xd7, 0x38, 0x10, 0x3a, 0xff, 0xef, 0xfc, 0x6f, - 0xee, 0x03, 0xec, 0xbb, 0x81, 0x32, 0x9e, 0xba, 0xa3, 0xdf, 0xfd, 0x06, 0x00, 0x00, 0xff, 0xff, - 0x44, 0x54, 0x92, 0x68, 0xa7, 0x01, 0x00, 0x00, + // 284 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xcf, 0x4a, 0xf4, 0x30, + 0x14, 0xc5, 0x27, 0xf3, 0xcd, 0x1f, 0xbe, 0xb8, 0x19, 0x83, 0x48, 0x56, 0xa1, 0xb8, 0x1a, 0x64, + 0x68, 0x41, 0x9f, 0x60, 0xc6, 0x41, 0x9c, 0x95, 0xd2, 0xa5, 0x9b, 0x21, 0x4d, 0xaf, 0xd3, 0x60, + 0x9b, 0x84, 0x36, 0x16, 0x7d, 0x09, 0xf1, 0xb1, 0x5c, 0xce, 0xd2, 0xa5, 0xb4, 0x2f, 0x22, 0x4d, + 0x2b, 0x14, 0xea, 0xee, 0x9e, 0xdf, 0x39, 0x97, 0x43, 0x6e, 0x70, 0x60, 0x78, 0xaa, 0x33, 0x2e, + 0x12, 0x2e, 0x55, 0x37, 0x07, 0x50, 0x66, 0x01, 0x8f, 0xe3, 0xbd, 0x83, 0x7b, 0x93, 0x6b, 0xa3, + 0x0b, 0x9e, 0xfa, 0x26, 0xd7, 0x56, 0x93, 0xf3, 0xde, 0x82, 0xdf, 0xce, 0x3e, 0x94, 0xd9, 0xc5, + 0xfb, 0x18, 0x2f, 0xd6, 0x71, 0x7c, 0xd3, 0xf0, 0x87, 0x6e, 0x85, 0x9c, 0xe1, 0xa9, 0x95, 0x36, + 0x05, 0x8a, 0x3c, 0xb4, 0xfc, 0x1f, 0xb6, 0x82, 0x78, 0xf8, 0x24, 0x86, 0x42, 0xe4, 0xd2, 0x58, + 0xa9, 0x15, 0x1d, 0x3b, 0xaf, 0x8f, 0xc8, 0x25, 0x5e, 0xb8, 0x82, 0x10, 0x9e, 0x20, 0x07, 0x25, + 0x60, 0xb7, 0xa5, 0xff, 0x5c, 0x6c, 0xc0, 0x09, 0xc5, 0x73, 0xc7, 0x76, 0x5b, 0x3a, 0xf1, 0xd0, + 0x72, 0x12, 0xfe, 0xca, 0xa6, 0x27, 0x4a, 0xb5, 0x78, 0xbe, 0x03, 0x79, 0x48, 0x2c, 0x9d, 0x3a, + 0xb7, 0x8f, 0xc8, 0x0a, 0x9f, 0xb6, 0x92, 0x17, 0xc9, 0xda, 0x76, 0xb9, 0x99, 0x2b, 0x1a, 0x1a, + 0x4d, 0x3a, 0x93, 0xea, 0x5e, 0xb9, 0x37, 0x6e, 0x78, 0xca, 0x95, 0x00, 0x3a, 0x6f, 0xd3, 0x03, + 0x63, 0x73, 0xfb, 0x59, 0x31, 0x74, 0xac, 0x18, 0xfa, 0xae, 0x18, 0xfa, 0xa8, 0xd9, 0xe8, 0x58, + 0xb3, 0xd1, 0x57, 0xcd, 0x46, 0x8f, 0xab, 0x83, 0xb4, 0xc9, 0x4b, 0xe4, 0x0b, 0x9d, 0xfd, 0x75, + 0xfe, 0xf2, 0x2a, 0x78, 0x75, 0x7f, 0x60, 0xdf, 0x0c, 0x14, 0xd1, 0xcc, 0xdd, 0xfd, 0xfa, 0x27, + 0x00, 0x00, 0xff, 0xff, 0xb7, 0x9c, 0x24, 0x07, 0xaa, 0x01, 0x00, 0x00, } func (m *AddChainProposal) Marshal() (dAtA []byte, err error) { @@ -223,6 +231,7 @@ func encodeVarintAddChainProposal(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *AddChainProposal) Size() (n int) { if m == nil { return 0 @@ -261,9 +270,11 @@ func (m *AddChainProposal) Size() (n int) { func sovAddChainProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozAddChainProposal(x uint64) (n int) { return sovAddChainProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *AddChainProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -512,6 +523,7 @@ func (m *AddChainProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipAddChainProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/chain_info.pb.go b/x/evm/types/chain_info.pb.go index 2715a076..844dfd40 100644 --- a/x/evm/types/chain_info.pb.go +++ b/x/evm/types/chain_info.pb.go @@ -549,58 +549,58 @@ func init() { } var fileDescriptor_61bfdb7d30bf7e88 = []byte{ - // 806 bytes of a gzipped FileDescriptorProto + // 808 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x51, 0x6f, 0xe3, 0x44, 0x10, 0x8e, 0xdd, 0x34, 0x6d, 0x26, 0x6d, 0x6a, 0x56, 0x85, 0x5b, 0xf2, 0x10, 0xa2, 0xe8, 0xc4, - 0x99, 0x13, 0x4a, 0x4e, 0x01, 0x21, 0x84, 0x40, 0x90, 0x26, 0x6e, 0x6b, 0x28, 0x4e, 0xb5, 0xce, - 0x5d, 0x25, 0x84, 0x64, 0x6d, 0x9c, 0x4d, 0x6a, 0x5d, 0xbc, 0x0e, 0xf6, 0xa6, 0x47, 0x7e, 0x05, - 0xbc, 0xf3, 0x2b, 0xf8, 0x17, 0xf7, 0xd8, 0x47, 0x1e, 0x10, 0x42, 0xed, 0x1f, 0x41, 0x5e, 0xa7, - 0x51, 0xed, 0x38, 0x0f, 0xe8, 0xde, 0x76, 0xbe, 0x99, 0x9d, 0x19, 0x7f, 0xf3, 0x8d, 0x17, 0x9e, - 0xcd, 0xe9, 0x2c, 0xf0, 0xa9, 0x7b, 0x4d, 0x3d, 0xde, 0x4e, 0xce, 0x6d, 0x76, 0xe3, 0xb7, 0x25, - 0xe0, 0x78, 0x7c, 0x12, 0xb4, 0xe6, 0x61, 0x20, 0x02, 0xf4, 0xc1, 0xa3, 0xc0, 0x56, 0x72, 0x6e, - 0xb1, 0x1b, 0xbf, 0xf6, 0x7c, 0x4b, 0x82, 0x90, 0xcd, 0xe8, 0xd2, 0x79, 0xc3, 0xbc, 0xe9, 0xb5, - 0x88, 0x92, 0x1c, 0xb5, 0xe3, 0x69, 0x30, 0x0d, 0xe4, 0xb1, 0x1d, 0x9f, 0x12, 0xb4, 0xf9, 0x47, - 0x09, 0xca, 0xbd, 0xf8, 0xba, 0xc9, 0x27, 0x01, 0x3a, 0x02, 0xd5, 0x1b, 0xe3, 0xdf, 0xac, 0x86, - 0xa2, 0x17, 0x89, 0xea, 0x8d, 0xd1, 0x73, 0xd0, 0x64, 0x72, 0xc2, 0x26, 0x2c, 0x64, 0xdc, 0x65, - 0x66, 0x1f, 0x2b, 0x0d, 0x45, 0x2f, 0x93, 0x0d, 0x1c, 0x61, 0xd8, 0x93, 0x98, 0xd9, 0xc7, 0xaa, - 0x4c, 0xf0, 0x60, 0xa2, 0xcf, 0xe1, 0xfd, 0xc8, 0xa7, 0xa1, 0xe8, 0x05, 0x5c, 0x84, 0xd4, 0x15, - 0x2f, 0xb9, 0xf7, 0xcb, 0x22, 0x4e, 0xb5, 0xd3, 0x50, 0xf4, 0x03, 0x92, 0xef, 0x44, 0x9f, 0xc2, - 0x7b, 0x29, 0x47, 0x77, 0x3c, 0x0e, 0x71, 0x51, 0x16, 0xdf, 0x74, 0xa0, 0x0e, 0x1c, 0x87, 0x0f, - 0xcd, 0x9c, 0xcc, 0x02, 0xf7, 0xf5, 0xb9, 0xfc, 0x7a, 0xbc, 0x2b, 0x5b, 0xc9, 0xf5, 0xa1, 0x16, - 0xa0, 0x0c, 0x4e, 0xa3, 0x6b, 0x5c, 0x92, 0x25, 0x72, 0x3c, 0x48, 0x83, 0x1d, 0x3a, 0xf2, 0xf0, - 0x9e, 0x0c, 0x88, 0x8f, 0xa8, 0x06, 0xfb, 0xa3, 0xa5, 0x60, 0x6e, 0x30, 0x66, 0x78, 0x5f, 0x7e, - 0xcc, 0xda, 0x96, 0xdc, 0x05, 0x3c, 0x12, 0xe1, 0xc2, 0x15, 0x41, 0x68, 0xf2, 0xf9, 0x42, 0xe0, - 0xb2, 0x8c, 0xd9, 0xc0, 0xd1, 0x77, 0x50, 0x8a, 0x04, 0x15, 0x8b, 0x08, 0x43, 0x43, 0xd1, 0xab, - 0x1d, 0xbd, 0x95, 0x3f, 0xf1, 0xd6, 0x7a, 0x56, 0x2d, 0x5b, 0xc6, 0x93, 0xd5, 0xbd, 0x98, 0x63, - 0xea, 0x0a, 0xef, 0x86, 0xd9, 0x8f, 0xa9, 0x31, 0xfb, 0xb8, 0x22, 0x09, 0xc8, 0x77, 0xc6, 0x1c, - 0xfb, 0x1e, 0x1f, 0x70, 0x99, 0xf6, 0x84, 0xce, 0x28, 0x77, 0x19, 0x3e, 0x48, 0x38, 0xde, 0x70, - 0xa0, 0x73, 0x38, 0x90, 0xca, 0xba, 0x4a, 0x84, 0x85, 0x0f, 0x1b, 0x8a, 0x5e, 0xe9, 0x3c, 0xdd, - 0xd6, 0x2b, 0x79, 0x14, 0x4b, 0x52, 0x37, 0xd1, 0xc7, 0x50, 0x9d, 0x30, 0xf6, 0x23, 0xe5, 0x74, - 0xca, 0x42, 0x39, 0xd8, 0xaa, 0x2c, 0x9a, 0x41, 0xd1, 0xd7, 0xf0, 0x61, 0x6a, 0xd4, 0x7d, 0x36, - 0x9f, 0x05, 0xcb, 0xd5, 0x95, 0x23, 0x79, 0x65, 0x7b, 0x40, 0xf3, 0x5b, 0x28, 0x25, 0x2c, 0xa1, - 0x23, 0xa8, 0x98, 0x96, 0x73, 0x49, 0x06, 0x97, 0x03, 0xbb, 0x7b, 0xa1, 0x15, 0x10, 0x40, 0xa9, - 0xdb, 0x1b, 0x9a, 0xaf, 0x0c, 0x4d, 0x41, 0x18, 0x8e, 0xaf, 0xba, 0xe6, 0xd0, 0xb4, 0xce, 0x9c, - 0xd3, 0x01, 0x71, 0x8c, 0x57, 0x66, 0xdf, 0xb0, 0x7a, 0x86, 0xa6, 0x36, 0x5f, 0xc2, 0x61, 0x8a, - 0x31, 0x54, 0x95, 0x0b, 0xa2, 0xac, 0xf7, 0x03, 0xc3, 0x1e, 0x1d, 0x79, 0xdf, 0xdb, 0x03, 0x4b, - 0x6a, 0xbe, 0x4c, 0x1e, 0xcc, 0x94, 0x32, 0x76, 0xd2, 0xca, 0x68, 0xfe, 0xb9, 0x0b, 0x4f, 0xec, - 0xcd, 0xae, 0x7d, 0xc6, 0x05, 0xd2, 0xe1, 0x28, 0xca, 0x4c, 0x30, 0x29, 0x97, 0x85, 0x73, 0x77, - 0x53, 0xdd, 0xb2, 0x9b, 0x35, 0xd8, 0x5f, 0xa4, 0x97, 0x6e, 0x6d, 0x23, 0x6b, 0xad, 0xbd, 0xa2, - 0xd4, 0xde, 0x17, 0xdb, 0xe6, 0xb9, 0xa5, 0xe5, 0xac, 0x12, 0x5f, 0x43, 0x95, 0x85, 0x6e, 0xe7, - 0x85, 0x08, 0x29, 0x8f, 0x26, 0x2c, 0x8c, 0xf0, 0x6e, 0x63, 0x47, 0xaf, 0x74, 0xbe, 0xf9, 0xbf, - 0x79, 0x0d, 0xd2, 0xeb, 0xbc, 0x18, 0xae, 0xb2, 0x9c, 0x14, 0xdf, 0xfe, 0xf3, 0x51, 0x81, 0x64, - 0x52, 0xa3, 0x2f, 0xe1, 0x09, 0x67, 0x6f, 0xec, 0xec, 0xef, 0x80, 0x45, 0xd1, 0x6a, 0x8f, 0xb7, - 0xb9, 0x6b, 0x7f, 0x2b, 0x70, 0x98, 0xaa, 0x80, 0x8e, 0x61, 0x77, 0xcc, 0x78, 0xe0, 0xaf, 0xfe, - 0x70, 0x89, 0x11, 0xa3, 0xb2, 0xe6, 0x8a, 0xdb, 0xc4, 0x88, 0x51, 0x3f, 0x9a, 0xae, 0xd8, 0x2c, - 0x92, 0xc4, 0x40, 0x3f, 0x67, 0xa8, 0xec, 0xbf, 0xd3, 0x27, 0x67, 0x88, 0x6d, 0x3e, 0x5b, 0xcb, - 0xb9, 0x02, 0x7b, 0x97, 0x86, 0xd5, 0x37, 0xad, 0x33, 0xad, 0x80, 0x4a, 0xa0, 0x0e, 0x7e, 0xd0, - 0x14, 0xb4, 0x0f, 0xc5, 0xd3, 0xae, 0x79, 0xa1, 0xa9, 0x5f, 0xa9, 0x58, 0x69, 0x5a, 0xf9, 0xc1, - 0x87, 0x50, 0x36, 0x2d, 0xe7, 0xf4, 0xc2, 0x3c, 0x3b, 0x1f, 0x6a, 0x0a, 0xd2, 0xe1, 0x69, 0x4a, - 0xfa, 0x71, 0x79, 0x67, 0x70, 0x65, 0x19, 0xc4, 0x3e, 0x37, 0x2f, 0x9d, 0x21, 0xe9, 0x5a, 0xf6, - 0xa9, 0x41, 0x34, 0xf5, 0xa4, 0xf7, 0xf6, 0xae, 0xae, 0xdc, 0xde, 0xd5, 0x95, 0x7f, 0xef, 0xea, - 0xca, 0xef, 0xf7, 0xf5, 0xc2, 0xed, 0x7d, 0xbd, 0xf0, 0xd7, 0x7d, 0xbd, 0xf0, 0xd3, 0x27, 0x53, - 0x4f, 0x5c, 0x2f, 0x46, 0x2d, 0x37, 0xf0, 0xdb, 0x39, 0xef, 0xd1, 0xaf, 0xf2, 0x45, 0x12, 0xcb, - 0x39, 0x8b, 0x46, 0x25, 0xf9, 0xe8, 0x7c, 0xf6, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, 0xc2, - 0x5b, 0x28, 0xf9, 0x06, 0x00, 0x00, + 0x59, 0xa7, 0x53, 0x72, 0x0a, 0x08, 0x21, 0x04, 0x82, 0x34, 0x71, 0x5a, 0x43, 0x71, 0xaa, 0x75, + 0xee, 0x2a, 0x21, 0x24, 0x6b, 0xe3, 0x6c, 0x52, 0xeb, 0xe2, 0x75, 0xb0, 0x37, 0x3d, 0xfa, 0x2b, + 0xe0, 0x9d, 0x5f, 0xc1, 0xbf, 0xb8, 0xc7, 0x3e, 0xf2, 0x80, 0x10, 0x6a, 0xff, 0x08, 0xf2, 0x3a, + 0x8d, 0x6a, 0xc7, 0x79, 0x40, 0xf7, 0xb6, 0xf3, 0xcd, 0xec, 0xcc, 0xf8, 0x9b, 0x6f, 0xbc, 0xf0, + 0x6c, 0x41, 0xe7, 0x81, 0x4f, 0xdd, 0x2b, 0xea, 0xf1, 0x76, 0x72, 0x6e, 0xb3, 0x6b, 0xbf, 0x2d, + 0x01, 0xc7, 0xe3, 0xd3, 0xa0, 0xb5, 0x08, 0x03, 0x11, 0xa0, 0x8f, 0x1e, 0x05, 0xb6, 0x92, 0x73, + 0x8b, 0x5d, 0xfb, 0xb5, 0xe7, 0x5b, 0x12, 0x84, 0x6c, 0x4e, 0x6f, 0x9c, 0xb7, 0xcc, 0x9b, 0x5d, + 0x89, 0x28, 0xc9, 0x51, 0x3b, 0x9e, 0x05, 0xb3, 0x40, 0x1e, 0xdb, 0xf1, 0x29, 0x41, 0x9b, 0x7f, + 0x94, 0xa0, 0xdc, 0x8b, 0xaf, 0x9b, 0x7c, 0x1a, 0xa0, 0x23, 0x50, 0xbd, 0x09, 0xfe, 0xcd, 0x6a, + 0x28, 0x7a, 0x91, 0xa8, 0xde, 0x04, 0x3d, 0x07, 0x4d, 0x26, 0x27, 0x6c, 0xca, 0x42, 0xc6, 0x5d, + 0x66, 0xf6, 0xb1, 0xd2, 0x50, 0xf4, 0x32, 0xd9, 0xc0, 0x11, 0x86, 0x3d, 0x89, 0x99, 0x7d, 0xac, + 0xca, 0x04, 0x0f, 0x26, 0xfa, 0x1c, 0x3e, 0x8c, 0x7c, 0x1a, 0x8a, 0x5e, 0xc0, 0x45, 0x48, 0x5d, + 0xf1, 0x8a, 0x7b, 0xbf, 0x2c, 0xe3, 0x54, 0x3b, 0x0d, 0x45, 0x3f, 0x20, 0xf9, 0x4e, 0xf4, 0x02, + 0x3e, 0x48, 0x39, 0xba, 0x93, 0x49, 0x88, 0x8b, 0xb2, 0xf8, 0xa6, 0x03, 0x75, 0xe0, 0x38, 0x7c, + 0x68, 0xe6, 0x64, 0x1e, 0xb8, 0x6f, 0xce, 0xe4, 0xd7, 0xe3, 0x5d, 0xd9, 0x4a, 0xae, 0x0f, 0xb5, + 0x00, 0x65, 0x70, 0x1a, 0x5d, 0xe1, 0x92, 0x2c, 0x91, 0xe3, 0x41, 0x1a, 0xec, 0xd0, 0xb1, 0x87, + 0xf7, 0x64, 0x40, 0x7c, 0x44, 0x35, 0xd8, 0x1f, 0xdf, 0x08, 0xe6, 0x06, 0x13, 0x86, 0xf7, 0xe5, + 0xc7, 0xac, 0x6d, 0xc9, 0x5d, 0xc0, 0x23, 0x11, 0x2e, 0x5d, 0x11, 0x84, 0x26, 0x5f, 0x2c, 0x05, + 0x2e, 0xcb, 0x98, 0x0d, 0x1c, 0x7d, 0x07, 0xa5, 0x48, 0x50, 0xb1, 0x8c, 0x30, 0x34, 0x14, 0xbd, + 0xda, 0xd1, 0x5b, 0xf9, 0x13, 0x6f, 0xad, 0x67, 0xd5, 0xb2, 0x65, 0x3c, 0x59, 0xdd, 0x8b, 0x39, + 0xa6, 0xae, 0xf0, 0xae, 0x99, 0xfd, 0x98, 0x1a, 0xb3, 0x8f, 0x2b, 0x92, 0x80, 0x7c, 0x67, 0xcc, + 0xb1, 0xef, 0xf1, 0x21, 0x97, 0x69, 0x4f, 0xe8, 0x9c, 0x72, 0x97, 0xe1, 0x83, 0x84, 0xe3, 0x0d, + 0x07, 0x3a, 0x83, 0x03, 0xa9, 0xac, 0xcb, 0x44, 0x58, 0xf8, 0xb0, 0xa1, 0xe8, 0x95, 0xce, 0xd3, + 0x6d, 0xbd, 0x92, 0x47, 0xb1, 0x24, 0x75, 0x13, 0x7d, 0x0a, 0xd5, 0x29, 0x63, 0x3f, 0x52, 0x4e, + 0x67, 0x2c, 0x94, 0x83, 0xad, 0xca, 0xa2, 0x19, 0x14, 0x7d, 0x0d, 0x1f, 0xa7, 0x46, 0xdd, 0x67, + 0x8b, 0x79, 0x70, 0xb3, 0xba, 0x72, 0x24, 0xaf, 0x6c, 0x0f, 0x68, 0x7e, 0x0b, 0xa5, 0x84, 0x25, + 0x74, 0x04, 0x15, 0xd3, 0x72, 0x2e, 0xc8, 0xf0, 0x62, 0x68, 0x77, 0xcf, 0xb5, 0x02, 0x02, 0x28, + 0x75, 0x7b, 0x23, 0xf3, 0xb5, 0xa1, 0x29, 0x08, 0xc3, 0xf1, 0x65, 0xd7, 0x1c, 0x99, 0xd6, 0xa9, + 0x33, 0x18, 0x12, 0xc7, 0x78, 0x6d, 0xf6, 0x0d, 0xab, 0x67, 0x68, 0x6a, 0xf3, 0x15, 0x1c, 0xa6, + 0x18, 0x43, 0x55, 0xb9, 0x20, 0xca, 0x7a, 0x3f, 0x30, 0xec, 0xd1, 0xb1, 0xf7, 0xbd, 0x3d, 0xb4, + 0xa4, 0xe6, 0xcb, 0xe4, 0xc1, 0x4c, 0x29, 0x63, 0x27, 0xad, 0x8c, 0xe6, 0x9f, 0xbb, 0xf0, 0xc4, + 0xde, 0xec, 0xda, 0x67, 0x5c, 0x20, 0x1d, 0x8e, 0xa2, 0xcc, 0x04, 0x93, 0x72, 0x59, 0x38, 0x77, + 0x37, 0xd5, 0x2d, 0xbb, 0x59, 0x83, 0xfd, 0x65, 0x7a, 0xe9, 0xd6, 0x36, 0xb2, 0xd6, 0xda, 0x2b, + 0x4a, 0xed, 0x7d, 0xb1, 0x6d, 0x9e, 0x5b, 0x5a, 0xce, 0x2a, 0xf1, 0x0d, 0x54, 0x59, 0xe8, 0x76, + 0x5e, 0x8a, 0x90, 0xf2, 0x68, 0xca, 0xc2, 0x08, 0xef, 0x36, 0x76, 0xf4, 0x4a, 0xe7, 0x9b, 0xff, + 0x9b, 0xd7, 0x20, 0xbd, 0xce, 0xcb, 0xd1, 0x2a, 0xcb, 0x49, 0xf1, 0xdd, 0x3f, 0x9f, 0x14, 0x48, + 0x26, 0x35, 0xfa, 0x12, 0x9e, 0x70, 0xf6, 0xd6, 0xce, 0xfe, 0x0e, 0x58, 0x14, 0xad, 0xf6, 0x78, + 0x9b, 0xbb, 0xf6, 0xb7, 0x02, 0x87, 0xa9, 0x0a, 0xe8, 0x18, 0x76, 0x27, 0x8c, 0x07, 0xfe, 0xea, + 0x0f, 0x97, 0x18, 0x31, 0x2a, 0x6b, 0xae, 0xb8, 0x4d, 0x8c, 0x18, 0xf5, 0xa3, 0xd9, 0x8a, 0xcd, + 0x22, 0x49, 0x0c, 0xf4, 0x73, 0x86, 0xca, 0xfe, 0x7b, 0x7d, 0x72, 0x86, 0xd8, 0xe6, 0xb3, 0xb5, + 0x9c, 0x2b, 0xb0, 0x77, 0x61, 0x58, 0x7d, 0xd3, 0x3a, 0xd5, 0x0a, 0xa8, 0x04, 0xea, 0xf0, 0x07, + 0x4d, 0x41, 0xfb, 0x50, 0x1c, 0x74, 0xcd, 0x73, 0x4d, 0xfd, 0x4a, 0xc5, 0x4a, 0xd3, 0xca, 0x0f, + 0x3e, 0x84, 0xb2, 0x69, 0x39, 0x83, 0x73, 0xf3, 0xf4, 0x6c, 0xa4, 0x29, 0x48, 0x87, 0xa7, 0x29, + 0xe9, 0xc7, 0xe5, 0x9d, 0xe1, 0xa5, 0x65, 0x10, 0xfb, 0xcc, 0xbc, 0x70, 0x46, 0xa4, 0x6b, 0xd9, + 0x03, 0x83, 0x68, 0xea, 0xc9, 0xe0, 0xdd, 0x5d, 0x5d, 0xb9, 0xbd, 0xab, 0x2b, 0xff, 0xde, 0xd5, + 0x95, 0xdf, 0xef, 0xeb, 0x85, 0xdb, 0xfb, 0x7a, 0xe1, 0xaf, 0xfb, 0x7a, 0xe1, 0xa7, 0x17, 0x33, + 0x4f, 0x5c, 0x2d, 0xc7, 0x2d, 0x37, 0xf0, 0xdb, 0x39, 0xef, 0xd1, 0x75, 0xa7, 0xfd, 0xab, 0x7c, + 0x94, 0xc4, 0xcd, 0x82, 0x45, 0xe3, 0x92, 0x7c, 0x77, 0x3e, 0xfb, 0x2f, 0x00, 0x00, 0xff, 0xff, + 0x83, 0xa8, 0x59, 0x8d, 0xfc, 0x06, 0x00, 0x00, } func (m *ChainInfo) Marshal() (dAtA []byte, err error) { diff --git a/x/evm/types/change_min_on_chain_balance_proposal.pb.go b/x/evm/types/change_min_on_chain_balance_proposal.pb.go index ca46962d..a4eb1d8e 100644 --- a/x/evm/types/change_min_on_chain_balance_proposal.pb.go +++ b/x/evm/types/change_min_on_chain_balance_proposal.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*ChangeMinOnChainBalanceProposal) ProtoMessage() {} func (*ChangeMinOnChainBalanceProposal) Descriptor() ([]byte, []int) { return fileDescriptor_b2d320cddd404f42, []int{0} } + func (m *ChangeMinOnChainBalanceProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ChangeMinOnChainBalanceProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangeMinOnChainBalanceProposal.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *ChangeMinOnChainBalanceProposal) XXX_Marshal(b []byte, deterministic bo return b[:n], nil } } + func (m *ChangeMinOnChainBalanceProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangeMinOnChainBalanceProposal.Merge(m, src) } + func (m *ChangeMinOnChainBalanceProposal) XXX_Size() int { return m.Size() } + func (m *ChangeMinOnChainBalanceProposal) XXX_DiscardUnknown() { xxx_messageInfo_ChangeMinOnChainBalanceProposal.DiscardUnknown(m) } @@ -99,7 +107,7 @@ func init() { } var fileDescriptor_b2d320cddd404f42 = []byte{ - // 249 bytes of a gzipped FileDescriptorProto + // 252 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x2c, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x53, 0xcb, 0x72, 0xf5, 0x93, 0x33, 0x12, 0xf3, 0xd2, 0x53, 0xe3, 0x73, 0x33, 0xf3, 0xe2, 0xf3, 0xf3, 0xe2, 0xc1, 0xd2, 0xf1, @@ -111,11 +119,11 @@ var fileDescriptor_b2d320cddd404f42 = []byte{ 0x93, 0x8b, 0x32, 0x0b, 0x4a, 0x32, 0xf3, 0xf3, 0x24, 0x98, 0xc0, 0x72, 0xc8, 0x42, 0x42, 0x5a, 0x5c, 0x02, 0x60, 0xfb, 0x82, 0x52, 0xd3, 0x52, 0x8b, 0x52, 0xf3, 0x92, 0x53, 0x3d, 0x5d, 0x24, 0x98, 0xc1, 0xca, 0x30, 0xc4, 0x85, 0x74, 0xb8, 0x04, 0x73, 0xd1, 0x1d, 0x20, 0xc1, 0x02, 0x56, - 0x8c, 0x29, 0xe1, 0xe4, 0x7c, 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, 0x9a, - 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x58, 0x42, 0xad, 0x02, 0x1c, - 0x6e, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0x90, 0x31, 0x06, 0x04, 0x00, 0x00, 0xff, - 0xff, 0x0b, 0x7a, 0x37, 0x2a, 0x5e, 0x01, 0x00, 0x00, + 0x8c, 0x29, 0xe1, 0xe4, 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, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x58, 0x42, 0xad, 0xcc, 0x48, + 0xbf, 0x02, 0x1c, 0x74, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0xc0, 0x31, 0x06, 0x04, + 0x00, 0x00, 0xff, 0xff, 0x43, 0x08, 0x59, 0xd1, 0x61, 0x01, 0x00, 0x00, } func (m *ChangeMinOnChainBalanceProposal) Marshal() (dAtA []byte, err error) { @@ -180,6 +188,7 @@ func encodeVarintChangeMinOnChainBalanceProposal(dAtA []byte, offset int, v uint dAtA[offset] = uint8(v) return base } + func (m *ChangeMinOnChainBalanceProposal) Size() (n int) { if m == nil { return 0 @@ -208,9 +217,11 @@ func (m *ChangeMinOnChainBalanceProposal) Size() (n int) { func sovChangeMinOnChainBalanceProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozChangeMinOnChainBalanceProposal(x uint64) (n int) { return sovChangeMinOnChainBalanceProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *ChangeMinOnChainBalanceProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -389,6 +400,7 @@ func (m *ChangeMinOnChainBalanceProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipChangeMinOnChainBalanceProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/deploy_new_smart_contract_proposal.pb.go b/x/evm/types/deploy_new_smart_contract_proposal.pb.go index 1ca86947..5c815b1e 100644 --- a/x/evm/types/deploy_new_smart_contract_proposal.pb.go +++ b/x/evm/types/deploy_new_smart_contract_proposal.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*DeployNewSmartContractProposal) ProtoMessage() {} func (*DeployNewSmartContractProposal) Descriptor() ([]byte, []int) { return fileDescriptor_c07dc1cc21afb8fa, []int{0} } + func (m *DeployNewSmartContractProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *DeployNewSmartContractProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeployNewSmartContractProposal.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *DeployNewSmartContractProposal) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *DeployNewSmartContractProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_DeployNewSmartContractProposal.Merge(m, src) } + func (m *DeployNewSmartContractProposal) XXX_Size() int { return m.Size() } + func (m *DeployNewSmartContractProposal) XXX_DiscardUnknown() { xxx_messageInfo_DeployNewSmartContractProposal.DiscardUnknown(m) } @@ -99,7 +107,7 @@ func init() { } var fileDescriptor_c07dc1cc21afb8fa = []byte{ - // 247 bytes of a gzipped FileDescriptorProto + // 250 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x2f, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x53, 0xcb, 0x72, 0xf5, 0x53, 0x52, 0x0b, 0x72, 0xf2, 0x2b, 0xe3, 0xf3, 0x52, 0xcb, 0xe3, 0x8b, 0x73, 0x13, 0x8b, 0x4a, 0xe2, @@ -111,11 +119,11 @@ var fileDescriptor_c07dc1cc21afb8fa = []byte{ 0x5c, 0x94, 0x59, 0x50, 0x92, 0x99, 0x9f, 0x27, 0xc1, 0x04, 0x96, 0x43, 0x16, 0x12, 0x92, 0xe0, 0x62, 0x4f, 0x4c, 0xca, 0xf4, 0x0a, 0xf6, 0xf7, 0x93, 0x60, 0x06, 0xcb, 0xc2, 0xb8, 0x20, 0xbd, 0x49, 0x95, 0x25, 0xa9, 0xc9, 0xf9, 0x29, 0xa9, 0x1e, 0xa9, 0x15, 0x12, 0x2c, 0x10, 0xbd, 0x48, - 0x42, 0x4e, 0xce, 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, 0x8f, 0x25, 0x50, 0x2a, 0xc0, 0xc1, 0x52, - 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xf6, 0xba, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x51, - 0xc0, 0xb7, 0x4c, 0x3d, 0x01, 0x00, 0x00, + 0x42, 0x4e, 0x6e, 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, 0x93, 0x9e, + 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0x25, 0x50, 0xca, 0x8c, 0xf4, 0x2b, + 0xc0, 0x21, 0x53, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xf6, 0xbd, 0x31, 0x20, 0x00, 0x00, + 0xff, 0xff, 0x51, 0x66, 0xe0, 0x43, 0x40, 0x01, 0x00, 0x00, } func (m *DeployNewSmartContractProposal) Marshal() (dAtA []byte, err error) { @@ -180,6 +188,7 @@ func encodeVarintDeployNewSmartContractProposal(dAtA []byte, offset int, v uint6 dAtA[offset] = uint8(v) return base } + func (m *DeployNewSmartContractProposal) Size() (n int) { if m == nil { return 0 @@ -208,9 +217,11 @@ func (m *DeployNewSmartContractProposal) Size() (n int) { func sovDeployNewSmartContractProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozDeployNewSmartContractProposal(x uint64) (n int) { return sovDeployNewSmartContractProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *DeployNewSmartContractProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -389,6 +400,7 @@ func (m *DeployNewSmartContractProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipDeployNewSmartContractProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/evm_reference_block_attestation.pb.go b/x/evm/types/evm_reference_block_attestation.pb.go index 8de169da..34f4adfe 100644 --- a/x/evm/types/evm_reference_block_attestation.pb.go +++ b/x/evm/types/evm_reference_block_attestation.pb.go @@ -5,21 +5,24 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" - github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" - _ "google.golang.org/protobuf/types/known/timestamppb" io "io" math "math" math_bits "math/bits" time "time" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" + _ "google.golang.org/protobuf/types/known/timestamppb" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf -var _ = time.Kitchen +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = math.Inf + _ = time.Kitchen +) // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -37,9 +40,11 @@ func (*ReferenceBlockAttestation) ProtoMessage() {} func (*ReferenceBlockAttestation) Descriptor() ([]byte, []int) { return fileDescriptor_181c5ad50f766137, []int{0} } + func (m *ReferenceBlockAttestation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ReferenceBlockAttestation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReferenceBlockAttestation.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *ReferenceBlockAttestation) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *ReferenceBlockAttestation) XXX_Merge(src proto.Message) { xxx_messageInfo_ReferenceBlockAttestation.Merge(m, src) } + func (m *ReferenceBlockAttestation) XXX_Size() int { return m.Size() } + func (m *ReferenceBlockAttestation) XXX_DiscardUnknown() { xxx_messageInfo_ReferenceBlockAttestation.DiscardUnknown(m) } @@ -82,9 +90,11 @@ func (*ReferenceBlockAttestationRes) ProtoMessage() {} func (*ReferenceBlockAttestationRes) Descriptor() ([]byte, []int) { return fileDescriptor_181c5ad50f766137, []int{1} } + func (m *ReferenceBlockAttestationRes) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ReferenceBlockAttestationRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReferenceBlockAttestationRes.Marshal(b, m, deterministic) @@ -97,12 +107,15 @@ func (m *ReferenceBlockAttestationRes) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *ReferenceBlockAttestationRes) XXX_Merge(src proto.Message) { xxx_messageInfo_ReferenceBlockAttestationRes.Merge(m, src) } + func (m *ReferenceBlockAttestationRes) XXX_Size() int { return m.Size() } + func (m *ReferenceBlockAttestationRes) XXX_DiscardUnknown() { xxx_messageInfo_ReferenceBlockAttestationRes.DiscardUnknown(m) } @@ -133,25 +146,26 @@ func init() { } var fileDescriptor_181c5ad50f766137 = []byte{ - // 288 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x41, 0x4b, 0xfb, 0x30, - 0x18, 0xc6, 0x9b, 0x3f, 0x7f, 0xc4, 0x65, 0x78, 0x29, 0x22, 0x73, 0x8c, 0xac, 0xec, 0x34, 0x2f, - 0x09, 0xe8, 0xd5, 0x8b, 0xf5, 0x22, 0x1e, 0xcb, 0x4e, 0x1e, 0x2c, 0x69, 0x79, 0x9b, 0x06, 0x9b, - 0xa6, 0xb4, 0xd9, 0xd0, 0x6f, 0xb1, 0x8f, 0xb5, 0xe3, 0x8e, 0x9e, 0x54, 0xda, 0x2f, 0x22, 0x4d, - 0x28, 0x9b, 0xa0, 0x87, 0xc0, 0x93, 0x87, 0xe7, 0x7d, 0x7e, 0xbc, 0x2f, 0xbe, 0xad, 0x78, 0xa1, - 0x15, 0x4f, 0x73, 0x2e, 0x4b, 0xe6, 0x34, 0x83, 0x8d, 0xea, 0x5f, 0x5c, 0x43, 0x06, 0x35, 0x94, - 0x29, 0xc4, 0x49, 0xa1, 0xd3, 0x97, 0x98, 0x1b, 0x03, 0x8d, 0xe1, 0x46, 0xea, 0x92, 0x56, 0xb5, - 0x36, 0xda, 0xbf, 0x38, 0x9a, 0xa6, 0x4e, 0x53, 0xd8, 0xa8, 0xe9, 0xb9, 0xd0, 0x42, 0xdb, 0x08, - 0xeb, 0x95, 0x4b, 0x4f, 0xe7, 0x42, 0x6b, 0x51, 0x00, 0xb3, 0xbf, 0x64, 0x9d, 0x31, 0x23, 0x55, - 0x5f, 0xa8, 0x2a, 0x17, 0x58, 0x08, 0x7c, 0x19, 0x0d, 0xcc, 0xb0, 0x47, 0xde, 0x1d, 0x88, 0xfe, - 0x23, 0x3e, 0xcb, 0x6a, 0xad, 0xac, 0xbf, 0x92, 0x0a, 0x26, 0x28, 0x40, 0xcb, 0xf1, 0xf5, 0x94, - 0xba, 0x56, 0x3a, 0xb4, 0xd2, 0xd5, 0xd0, 0x1a, 0x9e, 0xee, 0x3e, 0xe6, 0xde, 0xf6, 0x73, 0x8e, - 0xa2, 0x9f, 0xa3, 0x8b, 0x67, 0x3c, 0xfb, 0x13, 0x14, 0x41, 0xe3, 0x07, 0x78, 0x6c, 0x57, 0x7e, - 0x00, 0x29, 0x72, 0x63, 0x49, 0xff, 0xa3, 0x63, 0xcb, 0x9f, 0xe1, 0x91, 0xfb, 0xf2, 0x26, 0x9f, - 0xfc, 0x0b, 0xd0, 0x72, 0x14, 0x1d, 0x8c, 0xf0, 0x7e, 0xd7, 0x12, 0xb4, 0x6f, 0x09, 0xfa, 0x6a, - 0x09, 0xda, 0x76, 0xc4, 0xdb, 0x77, 0xc4, 0x7b, 0xef, 0x88, 0xf7, 0x74, 0x25, 0xa4, 0xc9, 0xd7, - 0x09, 0x4d, 0xb5, 0x62, 0xbf, 0x9c, 0xfe, 0xd5, 0x1e, 0xdf, 0xbc, 0x55, 0xd0, 0x24, 0x27, 0x76, - 0xa3, 0x9b, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x93, 0x56, 0xe6, 0xa3, 0x01, 0x00, 0x00, + // 289 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0xc1, 0x4b, 0xc3, 0x30, + 0x14, 0xc6, 0x1b, 0x11, 0x71, 0x19, 0x5e, 0x8a, 0xc8, 0x1c, 0x23, 0x1b, 0x3b, 0xed, 0x20, 0x09, + 0xcc, 0xab, 0x17, 0x77, 0x10, 0xf1, 0x58, 0x76, 0xf2, 0x60, 0x49, 0xcb, 0x6b, 0x1a, 0x6c, 0x9a, + 0xd2, 0x66, 0x45, 0xff, 0x8b, 0xfd, 0x59, 0x3b, 0xee, 0xe8, 0x49, 0xa5, 0xfd, 0x47, 0xa4, 0x09, + 0x65, 0x13, 0xf4, 0x10, 0xf8, 0xf2, 0xf1, 0xbd, 0xef, 0xc7, 0x7b, 0xf8, 0xae, 0xe0, 0x99, 0x56, + 0x3c, 0x4e, 0xb9, 0xcc, 0x99, 0xd3, 0x0c, 0x6a, 0xd5, 0xbd, 0xb0, 0x84, 0x04, 0x4a, 0xc8, 0x63, + 0x08, 0xa3, 0x4c, 0xc7, 0xaf, 0x21, 0x37, 0x06, 0x2a, 0xc3, 0x8d, 0xd4, 0x39, 0x2d, 0x4a, 0x6d, + 0xb4, 0x7f, 0x75, 0x34, 0x4d, 0x9d, 0xa6, 0x50, 0xab, 0xf1, 0xa5, 0xd0, 0x42, 0xdb, 0x08, 0xeb, + 0x94, 0x4b, 0x8f, 0xa7, 0x42, 0x6b, 0x91, 0x01, 0xb3, 0xbf, 0x68, 0x93, 0x30, 0x23, 0x55, 0x57, + 0xa8, 0x0a, 0x17, 0x98, 0x0b, 0x7c, 0x1d, 0xf4, 0xcc, 0x55, 0x87, 0xbc, 0x3f, 0x10, 0xfd, 0x27, + 0x7c, 0x91, 0x94, 0x5a, 0x59, 0x7f, 0x2d, 0x15, 0x8c, 0xd0, 0x0c, 0x2d, 0x86, 0xcb, 0x31, 0x75, + 0xad, 0xb4, 0x6f, 0xa5, 0xeb, 0xbe, 0x75, 0x75, 0xbe, 0xfb, 0x9c, 0x7a, 0xdb, 0xaf, 0x29, 0x0a, + 0x7e, 0x8f, 0xce, 0x5f, 0xf0, 0xe4, 0x5f, 0x50, 0x00, 0x95, 0x3f, 0xc3, 0x43, 0xbb, 0xf2, 0x23, + 0x48, 0x91, 0x1a, 0x4b, 0x3a, 0x0d, 0x8e, 0x2d, 0x7f, 0x82, 0x07, 0xee, 0xcb, 0xab, 0x74, 0x74, + 0x32, 0x43, 0x8b, 0x41, 0x70, 0x30, 0x56, 0x0f, 0xbb, 0x86, 0xa0, 0x7d, 0x43, 0xd0, 0x77, 0x43, + 0xd0, 0xb6, 0x25, 0xde, 0xbe, 0x25, 0xde, 0x47, 0x4b, 0xbc, 0xe7, 0x1b, 0x21, 0x4d, 0xba, 0x89, + 0x68, 0xac, 0x15, 0xfb, 0xe3, 0xf4, 0xf5, 0x92, 0xbd, 0xd9, 0xfb, 0x9b, 0xf7, 0x02, 0xaa, 0xe8, + 0xcc, 0x2e, 0x75, 0xfb, 0x13, 0x00, 0x00, 0xff, 0xff, 0x16, 0xfb, 0x72, 0xf1, 0xa6, 0x01, 0x00, + 0x00, } func (m *ReferenceBlockAttestation) Marshal() (dAtA []byte, err error) { @@ -231,6 +245,7 @@ func encodeVarintEvmReferenceBlockAttestation(dAtA []byte, offset int, v uint64) dAtA[offset] = uint8(v) return base } + func (m *ReferenceBlockAttestation) Size() (n int) { if m == nil { return 0 @@ -261,9 +276,11 @@ func (m *ReferenceBlockAttestationRes) Size() (n int) { func sovEvmReferenceBlockAttestation(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozEvmReferenceBlockAttestation(x uint64) (n int) { return sovEvmReferenceBlockAttestation(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *ReferenceBlockAttestation) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -347,6 +364,7 @@ func (m *ReferenceBlockAttestation) Unmarshal(dAtA []byte) error { } return nil } + func (m *ReferenceBlockAttestationRes) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -448,6 +466,7 @@ func (m *ReferenceBlockAttestationRes) Unmarshal(dAtA []byte) error { } return nil } + func skipEvmReferenceBlockAttestation(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/evm_state_attestation.pb.go b/x/evm/types/evm_state_attestation.pb.go index f949d4cf..309c569d 100644 --- a/x/evm/types/evm_state_attestation.pb.go +++ b/x/evm/types/evm_state_attestation.pb.go @@ -5,22 +5,25 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + time "time" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "google.golang.org/protobuf/types/known/timestamppb" - io "io" - math "math" - math_bits "math/bits" - time "time" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf -var _ = time.Kitchen +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = math.Inf + _ = time.Kitchen +) // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -41,9 +44,11 @@ func (*ValidatorBalancesAttestation) ProtoMessage() {} func (*ValidatorBalancesAttestation) Descriptor() ([]byte, []int) { return fileDescriptor_8877ad507a940578, []int{0} } + func (m *ValidatorBalancesAttestation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ValidatorBalancesAttestation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ValidatorBalancesAttestation.Marshal(b, m, deterministic) @@ -56,12 +61,15 @@ func (m *ValidatorBalancesAttestation) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *ValidatorBalancesAttestation) XXX_Merge(src proto.Message) { xxx_messageInfo_ValidatorBalancesAttestation.Merge(m, src) } + func (m *ValidatorBalancesAttestation) XXX_Size() int { return m.Size() } + func (m *ValidatorBalancesAttestation) XXX_DiscardUnknown() { xxx_messageInfo_ValidatorBalancesAttestation.DiscardUnknown(m) } @@ -107,9 +115,11 @@ func (*ValidatorBalancesAttestationRes) ProtoMessage() {} func (*ValidatorBalancesAttestationRes) Descriptor() ([]byte, []int) { return fileDescriptor_8877ad507a940578, []int{1} } + func (m *ValidatorBalancesAttestationRes) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ValidatorBalancesAttestationRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ValidatorBalancesAttestationRes.Marshal(b, m, deterministic) @@ -122,12 +132,15 @@ func (m *ValidatorBalancesAttestationRes) XXX_Marshal(b []byte, deterministic bo return b[:n], nil } } + func (m *ValidatorBalancesAttestationRes) XXX_Merge(src proto.Message) { xxx_messageInfo_ValidatorBalancesAttestationRes.Merge(m, src) } + func (m *ValidatorBalancesAttestationRes) XXX_Size() int { return m.Size() } + func (m *ValidatorBalancesAttestationRes) XXX_DiscardUnknown() { xxx_messageInfo_ValidatorBalancesAttestationRes.DiscardUnknown(m) } @@ -158,30 +171,31 @@ func init() { } var fileDescriptor_8877ad507a940578 = []byte{ - // 365 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0x3d, 0x6f, 0xc2, 0x30, - 0x10, 0x8d, 0xa1, 0x6a, 0xc1, 0xd0, 0x25, 0xaa, 0xaa, 0x28, 0xaa, 0x92, 0x88, 0x29, 0x1d, 0x70, - 0x54, 0xfa, 0x0b, 0x48, 0x97, 0xaa, 0x63, 0x44, 0x19, 0xba, 0x20, 0x27, 0x31, 0x89, 0x45, 0x1c, - 0x47, 0xb1, 0x41, 0x74, 0xec, 0x3f, 0xe0, 0x67, 0x31, 0x32, 0x76, 0xa2, 0x15, 0xfc, 0x8b, 0x4e, - 0x55, 0x12, 0x3e, 0xa5, 0xaa, 0x83, 0xe5, 0x77, 0xa7, 0xf7, 0xee, 0xf4, 0x9e, 0x0e, 0xf6, 0x32, - 0x9c, 0x70, 0x86, 0x83, 0x18, 0xd3, 0xd4, 0xa9, 0xb0, 0x43, 0x66, 0xac, 0x78, 0x23, 0x21, 0xb1, - 0x24, 0x23, 0x2c, 0x25, 0x29, 0x10, 0xe5, 0x29, 0xca, 0x72, 0x2e, 0xb9, 0x7a, 0x7b, 0xa2, 0x41, - 0x15, 0x46, 0x64, 0xc6, 0xf4, 0x9b, 0x88, 0x47, 0xbc, 0xa4, 0x38, 0x05, 0xaa, 0xd8, 0xba, 0x19, - 0x71, 0x1e, 0x25, 0xc4, 0x29, 0x2b, 0x7f, 0x3a, 0x76, 0x24, 0x65, 0xc5, 0x40, 0x96, 0x55, 0x84, - 0xce, 0x47, 0x0d, 0xde, 0x0d, 0x71, 0x42, 0x43, 0x2c, 0x79, 0xee, 0xe2, 0x04, 0xa7, 0x01, 0x11, - 0xfd, 0xe3, 0x56, 0xb5, 0x03, 0xdb, 0x31, 0x99, 0xf7, 0xc3, 0x30, 0x27, 0x42, 0x10, 0xa1, 0x01, - 0xab, 0x6e, 0x37, 0xbd, 0xb3, 0x9e, 0xfa, 0x0a, 0xdb, 0x33, 0x9c, 0x1c, 0x39, 0x35, 0xab, 0x6e, - 0xb7, 0xdd, 0x87, 0x9f, 0xb5, 0xd9, 0x8d, 0xa8, 0x8c, 0xa7, 0x3e, 0x0a, 0x38, 0x73, 0x02, 0x2e, - 0x18, 0x17, 0xbb, 0xaf, 0x2b, 0xc2, 0x89, 0x23, 0xdf, 0x33, 0x22, 0xd0, 0xf0, 0x20, 0xf5, 0xce, - 0xc6, 0xa8, 0x2f, 0xf0, 0x7a, 0x9c, 0x73, 0xe6, 0x26, 0x3c, 0x98, 0x0c, 0x28, 0x23, 0x5a, 0xdd, - 0x02, 0x76, 0xab, 0xa7, 0xa3, 0xca, 0x14, 0xda, 0x9b, 0x42, 0x83, 0xbd, 0x29, 0xb7, 0xb1, 0x5c, - 0x9b, 0xca, 0xe2, 0xcb, 0x04, 0xde, 0xb9, 0x54, 0xd5, 0x61, 0x03, 0x0b, 0x41, 0xa3, 0x94, 0x10, - 0xed, 0xca, 0x02, 0x76, 0xd3, 0x3b, 0xd4, 0x9d, 0x11, 0x34, 0xff, 0x8b, 0xc0, 0x23, 0x42, 0xb5, - 0x60, 0xcb, 0x2f, 0x66, 0x3d, 0x13, 0x1a, 0xc5, 0x52, 0x03, 0x16, 0xb0, 0x2f, 0xbc, 0xd3, 0x56, - 0xb1, 0xc0, 0xdf, 0x69, 0x4b, 0xff, 0x4d, 0xef, 0x50, 0xbb, 0x4f, 0xcb, 0x8d, 0x01, 0x56, 0x1b, - 0x03, 0x7c, 0x6f, 0x0c, 0xb0, 0xd8, 0x1a, 0xca, 0x6a, 0x6b, 0x28, 0x9f, 0x5b, 0x43, 0x79, 0xbb, - 0x3f, 0xc9, 0xe7, 0x8f, 0x63, 0x98, 0x97, 0xe7, 0x50, 0xc6, 0xe4, 0x5f, 0x96, 0x76, 0x1f, 0x7f, - 0x03, 0x00, 0x00, 0xff, 0xff, 0x75, 0xac, 0xcd, 0xd0, 0x35, 0x02, 0x00, 0x00, + // 371 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0x3d, 0x8b, 0xe3, 0x30, + 0x10, 0xb5, 0x92, 0xe3, 0x2e, 0x51, 0x72, 0x8d, 0x39, 0x0e, 0x63, 0x0e, 0xdb, 0xa4, 0x72, 0x71, + 0x91, 0xb8, 0xdc, 0x2f, 0x88, 0x8b, 0xe3, 0xd8, 0xd2, 0x64, 0x53, 0x6c, 0x13, 0x64, 0x5b, 0xb1, + 0x45, 0x2c, 0xcb, 0x58, 0x8a, 0xc9, 0x96, 0xfb, 0x0f, 0xf2, 0xb3, 0x52, 0xa6, 0xdc, 0x2a, 0xbb, + 0x24, 0xff, 0x62, 0xab, 0xc5, 0x76, 0x3e, 0x61, 0xd9, 0x42, 0xe8, 0xcd, 0xf0, 0xde, 0x0c, 0xef, + 0x31, 0x70, 0x94, 0x93, 0x54, 0x70, 0x12, 0x26, 0x84, 0x65, 0xb8, 0xc1, 0x98, 0x96, 0xbc, 0x7a, + 0x33, 0xa9, 0x88, 0xa2, 0x33, 0xa2, 0x14, 0xad, 0x10, 0x13, 0x19, 0xca, 0x0b, 0xa1, 0x84, 0xfe, + 0xf3, 0x4a, 0x83, 0x1a, 0x8c, 0x68, 0xc9, 0xcd, 0x1f, 0xb1, 0x88, 0x45, 0x4d, 0xc1, 0x15, 0x6a, + 0xd8, 0xa6, 0x1d, 0x0b, 0x11, 0xa7, 0x14, 0xd7, 0x55, 0xb0, 0x9c, 0x63, 0xc5, 0x78, 0x35, 0x90, + 0xe7, 0x0d, 0x61, 0xf0, 0xd4, 0x82, 0xbf, 0xa6, 0x24, 0x65, 0x11, 0x51, 0xa2, 0xf0, 0x48, 0x4a, + 0xb2, 0x90, 0xca, 0xf1, 0x65, 0xab, 0x3e, 0x80, 0xfd, 0x84, 0xae, 0xc6, 0x51, 0x54, 0x50, 0x29, + 0xa9, 0x34, 0x80, 0xd3, 0x76, 0xbb, 0xfe, 0x4d, 0x4f, 0xbf, 0x87, 0xfd, 0x92, 0xa4, 0x17, 0x4e, + 0xcb, 0x69, 0xbb, 0x7d, 0xef, 0xcf, 0xdb, 0xce, 0x1e, 0xc6, 0x4c, 0x25, 0xcb, 0x00, 0x85, 0x82, + 0xe3, 0x50, 0x48, 0x2e, 0xe4, 0xf1, 0x1b, 0xca, 0x68, 0x81, 0xd5, 0x63, 0x4e, 0x25, 0x9a, 0x9e, + 0xa5, 0xfe, 0xcd, 0x18, 0xfd, 0x0e, 0x7e, 0x9f, 0x17, 0x82, 0x7b, 0xa9, 0x08, 0x17, 0x13, 0xc6, + 0xa9, 0xd1, 0x76, 0x80, 0xdb, 0x1b, 0x99, 0xa8, 0x31, 0x85, 0x4e, 0xa6, 0xd0, 0xe4, 0x64, 0xca, + 0xeb, 0x6c, 0x76, 0xb6, 0xb6, 0x7e, 0xb1, 0x81, 0x7f, 0x2b, 0xd5, 0x4d, 0xd8, 0x21, 0x52, 0xb2, + 0x38, 0xa3, 0xd4, 0xf8, 0xe6, 0x00, 0xb7, 0xeb, 0x9f, 0xeb, 0xc1, 0x0c, 0xda, 0x9f, 0x45, 0xe0, + 0x53, 0xa9, 0x3b, 0xb0, 0x17, 0x54, 0xb3, 0xfe, 0x53, 0x16, 0x27, 0xca, 0x00, 0x0e, 0x70, 0xbf, + 0xf8, 0xd7, 0xad, 0x6a, 0x41, 0x70, 0xd4, 0xd6, 0xfe, 0xbb, 0xfe, 0xb9, 0xf6, 0xfe, 0x6d, 0xf6, + 0x16, 0xd8, 0xee, 0x2d, 0xf0, 0xba, 0xb7, 0xc0, 0xfa, 0x60, 0x69, 0xdb, 0x83, 0xa5, 0x3d, 0x1f, + 0x2c, 0xed, 0xe1, 0xf7, 0x55, 0x3e, 0x1f, 0x1c, 0x43, 0x39, 0xc2, 0xab, 0xfa, 0x22, 0xea, 0xa4, + 0x82, 0xaf, 0xb5, 0xe3, 0xbf, 0xef, 0x01, 0x00, 0x00, 0xff, 0xff, 0x78, 0x34, 0x3c, 0x05, 0x38, + 0x02, 0x00, 0x00, } func (m *ValidatorBalancesAttestation) Marshal() (dAtA []byte, err error) { @@ -288,6 +302,7 @@ func encodeVarintEvmStateAttestation(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *ValidatorBalancesAttestation) Size() (n int) { if m == nil { return 0 @@ -336,9 +351,11 @@ func (m *ValidatorBalancesAttestationRes) Size() (n int) { func sovEvmStateAttestation(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozEvmStateAttestation(x uint64) (n int) { return sovEvmStateAttestation(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *ValidatorBalancesAttestation) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -518,6 +535,7 @@ func (m *ValidatorBalancesAttestation) Unmarshal(dAtA []byte) error { } return nil } + func (m *ValidatorBalancesAttestationRes) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -619,6 +637,7 @@ func (m *ValidatorBalancesAttestationRes) Unmarshal(dAtA []byte) error { } return nil } + func skipEvmStateAttestation(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/genesis.pb.go b/x/evm/types/genesis.pb.go index 827e7463..05f5cefb 100644 --- a/x/evm/types/genesis.pb.go +++ b/x/evm/types/genesis.pb.go @@ -257,35 +257,35 @@ func init() { } var fileDescriptor_a36103825ee62903 = []byte{ - // 442 bytes of a gzipped FileDescriptorProto + // 445 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0xc1, 0x6e, 0xd3, 0x40, 0x10, 0x8d, 0x9b, 0x90, 0xaa, 0x9b, 0x82, 0xca, 0xaa, 0x42, 0xab, 0x1c, 0x4c, 0x14, 0x2a, 0x14, - 0xaa, 0xca, 0x96, 0xca, 0x95, 0x03, 0x4d, 0x2a, 0x91, 0x20, 0x21, 0xd0, 0x72, 0x40, 0xe2, 0x82, - 0x36, 0xce, 0xc4, 0xb6, 0xb0, 0x77, 0xad, 0xf5, 0x52, 0x9a, 0xbf, 0xe0, 0xb3, 0x72, 0xec, 0x91, + 0x55, 0x91, 0x2d, 0x85, 0x2b, 0x07, 0x9a, 0x56, 0x90, 0x20, 0x21, 0xd0, 0x72, 0x40, 0xe2, 0x82, + 0x36, 0xce, 0xc4, 0xb1, 0xb0, 0x77, 0xad, 0xf5, 0x12, 0x9a, 0xbf, 0xe0, 0xb3, 0x72, 0xec, 0x91, 0x13, 0x42, 0xce, 0x8f, 0x20, 0xcf, 0x3a, 0x92, 0xdb, 0xc4, 0xe2, 0xb6, 0xf3, 0xe6, 0xcd, 0x9b, - 0xd9, 0x37, 0x43, 0xce, 0x32, 0x91, 0xa8, 0x54, 0x04, 0x91, 0x88, 0xa5, 0x6f, 0xdf, 0x3e, 0xdc, - 0xa4, 0x7e, 0x08, 0x12, 0xf2, 0x38, 0xf7, 0x32, 0xad, 0x8c, 0xa2, 0xcf, 0x6a, 0x2c, 0xcf, 0xbe, - 0x3d, 0xb8, 0x49, 0xfb, 0xa7, 0xa1, 0x0a, 0x15, 0x52, 0xfc, 0xf2, 0x65, 0xd9, 0xfd, 0x17, 0x0d, - 0x9a, 0x99, 0xd0, 0x22, 0xad, 0x24, 0xfb, 0xe7, 0x0d, 0x24, 0x0d, 0x89, 0x58, 0x7d, 0xfb, 0x09, - 0x71, 0x18, 0x99, 0x8a, 0x3b, 0x2c, 0x1c, 0x72, 0xfc, 0xce, 0x0e, 0xf4, 0xd9, 0x08, 0x03, 0xf4, - 0x0d, 0xe9, 0x5a, 0x31, 0xe6, 0x0c, 0x9c, 0x51, 0xef, 0xd2, 0xf5, 0xf6, 0x0f, 0xe8, 0x7d, 0x42, - 0xd6, 0xb8, 0xb3, 0xfe, 0xf3, 0xbc, 0xc5, 0xab, 0x1a, 0xca, 0xc9, 0xe3, 0x3c, 0x15, 0xda, 0x4c, - 0x94, 0x34, 0x5a, 0x04, 0x86, 0x1d, 0xa0, 0xc8, 0x45, 0x93, 0xc8, 0xb6, 0x75, 0xbd, 0x86, 0xdf, - 0x97, 0xa0, 0x6f, 0x49, 0x17, 0xeb, 0x72, 0xd6, 0x1e, 0xb4, 0x47, 0xbd, 0xcb, 0xd1, 0x7f, 0xc4, - 0x26, 0x25, 0x3e, 0x93, 0x4b, 0xc5, 0xab, 0xba, 0xe1, 0xfa, 0x80, 0x9c, 0x3c, 0x4c, 0xd2, 0x73, - 0x72, 0x82, 0x69, 0x0e, 0x4b, 0xd0, 0x20, 0x03, 0x98, 0x5d, 0xe3, 0x97, 0x8f, 0xf8, 0x0e, 0x4e, - 0x19, 0x39, 0x44, 0x6c, 0x76, 0x8d, 0x1f, 0xea, 0xf0, 0x6d, 0x48, 0x07, 0xa4, 0x37, 0x4f, 0x54, - 0xf0, 0x7d, 0x8a, 0xae, 0xb2, 0x36, 0x66, 0xeb, 0x10, 0xbd, 0x20, 0x4f, 0x6d, 0x28, 0xf2, 0xe8, - 0xca, 0x54, 0xbc, 0x0e, 0x36, 0xda, 0x4d, 0x94, 0xec, 0x34, 0x96, 0x1f, 0x25, 0xce, 0x39, 0x16, - 0x89, 0x90, 0x01, 0xb0, 0x47, 0x96, 0xbd, 0x93, 0xa0, 0x53, 0x72, 0x8c, 0x4b, 0xfd, 0x62, 0x77, - 0xca, 0xba, 0xe8, 0xf6, 0x59, 0x93, 0x41, 0xbc, 0xc6, 0xe5, 0xf7, 0x2a, 0xe9, 0x4b, 0xf2, 0x64, - 0x09, 0xf0, 0x41, 0x48, 0x11, 0x82, 0xbe, 0x5a, 0x2c, 0x34, 0x3b, 0xc4, 0xa6, 0x0f, 0xd0, 0x21, - 0x27, 0xa7, 0xfb, 0x76, 0x56, 0x3a, 0x24, 0xe6, 0xf1, 0xfb, 0x5c, 0xc9, 0xca, 0xc4, 0x6d, 0x88, - 0x0e, 0xad, 0x0c, 0x04, 0x6a, 0x01, 0x53, 0xb8, 0x45, 0xff, 0x8e, 0x78, 0x1d, 0x1a, 0x4f, 0xd6, - 0x85, 0xeb, 0xdc, 0x15, 0xae, 0xf3, 0xb7, 0x70, 0x9d, 0x5f, 0x1b, 0xb7, 0x75, 0xb7, 0x71, 0x5b, - 0xbf, 0x37, 0x6e, 0xeb, 0xeb, 0xab, 0x30, 0x36, 0xd1, 0x8f, 0xb9, 0x17, 0xa8, 0xd4, 0xdf, 0x73, - 0xd4, 0xb7, 0x78, 0xd6, 0x66, 0x95, 0x41, 0x3e, 0xef, 0xe2, 0x3d, 0xbf, 0xfe, 0x17, 0x00, 0x00, - 0xff, 0xff, 0x38, 0x2a, 0x4f, 0x3c, 0x76, 0x03, 0x00, 0x00, + 0xd9, 0x37, 0x43, 0x2e, 0x52, 0x11, 0xab, 0x44, 0x04, 0x4b, 0x11, 0x49, 0xdf, 0xbe, 0x7d, 0x58, + 0x25, 0x7e, 0x08, 0x12, 0xb2, 0x28, 0xf3, 0x52, 0xad, 0x8c, 0xa2, 0xcf, 0x2a, 0x2c, 0xcf, 0xbe, + 0x3d, 0x58, 0x25, 0xdd, 0xf3, 0x50, 0x85, 0x0a, 0x29, 0x7e, 0xf1, 0xb2, 0xec, 0xee, 0x8b, 0x1a, + 0xcd, 0x54, 0x68, 0x91, 0x94, 0x92, 0xdd, 0xcb, 0x1a, 0x92, 0x86, 0x58, 0xac, 0xbf, 0xfd, 0x84, + 0x28, 0x5c, 0x9a, 0x92, 0xdb, 0xcf, 0x1d, 0x72, 0xfa, 0xce, 0x0e, 0xf4, 0xd9, 0x08, 0x03, 0xf4, + 0x35, 0x69, 0x5b, 0x31, 0xe6, 0xf4, 0x9c, 0x41, 0x67, 0xe4, 0x7a, 0x87, 0x07, 0xf4, 0x3e, 0x21, + 0x6b, 0xdc, 0xda, 0xfc, 0x79, 0xde, 0xe0, 0x65, 0x0d, 0xe5, 0xe4, 0x71, 0x96, 0x08, 0x6d, 0xae, + 0x95, 0x34, 0x5a, 0x04, 0x86, 0x1d, 0xa1, 0xc8, 0xb0, 0x4e, 0x64, 0xd7, 0xba, 0x5a, 0xc3, 0xef, + 0x4b, 0xd0, 0x37, 0xa4, 0x8d, 0x75, 0x19, 0x6b, 0xf6, 0x9a, 0x83, 0xce, 0x68, 0xf0, 0x1f, 0xb1, + 0xeb, 0x02, 0x9f, 0xca, 0x85, 0xe2, 0x65, 0x5d, 0x7f, 0x73, 0x44, 0xce, 0x1e, 0x26, 0xe9, 0x25, + 0x39, 0xc3, 0x34, 0x87, 0x05, 0x68, 0x90, 0x01, 0x4c, 0x6f, 0xf0, 0xcb, 0x27, 0x7c, 0x0f, 0xa7, + 0x8c, 0x1c, 0x23, 0x36, 0xbd, 0xc1, 0x0f, 0xb5, 0xf8, 0x2e, 0xa4, 0x3d, 0xd2, 0x99, 0xc5, 0x2a, + 0xf8, 0x3e, 0x41, 0x57, 0x59, 0x13, 0xb3, 0x55, 0x88, 0x0e, 0xc9, 0x53, 0x1b, 0x8a, 0x6c, 0x79, + 0x65, 0x4a, 0x5e, 0x0b, 0x1b, 0xed, 0x27, 0x0a, 0x76, 0x12, 0xc9, 0x8f, 0x12, 0xe7, 0x1c, 0x8b, + 0x58, 0xc8, 0x00, 0xd8, 0x23, 0xcb, 0xde, 0x4b, 0xd0, 0x09, 0x39, 0xc5, 0xa5, 0x7e, 0xb1, 0x3b, + 0x65, 0x6d, 0x74, 0xfb, 0xa2, 0xce, 0x20, 0x5e, 0xe1, 0xf2, 0x7b, 0x95, 0xf4, 0x25, 0x79, 0xb2, + 0x00, 0xf8, 0x20, 0xa4, 0x08, 0x41, 0x5f, 0xcd, 0xe7, 0x9a, 0x1d, 0x63, 0xd3, 0x07, 0x68, 0x9f, + 0x93, 0xf3, 0x43, 0x3b, 0x2b, 0x1c, 0x12, 0xb3, 0xe8, 0x7d, 0xa6, 0x64, 0x69, 0xe2, 0x2e, 0x44, + 0x87, 0xd6, 0x06, 0x02, 0x35, 0x87, 0x09, 0xdc, 0xa2, 0x7f, 0x27, 0xbc, 0x0a, 0x8d, 0xdf, 0x6e, + 0x72, 0xd7, 0xb9, 0xcb, 0x5d, 0xe7, 0x6f, 0xee, 0x3a, 0xbf, 0xb6, 0x6e, 0xe3, 0x6e, 0xeb, 0x36, + 0x7e, 0x6f, 0xdd, 0xc6, 0xd7, 0x61, 0x18, 0x99, 0xe5, 0x8f, 0x99, 0x17, 0xa8, 0xc4, 0x3f, 0x70, + 0xd4, 0xab, 0x91, 0x7f, 0x8b, 0x97, 0x6d, 0xd6, 0x29, 0x64, 0xb3, 0x36, 0x9e, 0xf4, 0xab, 0x7f, + 0x01, 0x00, 0x00, 0xff, 0xff, 0xc6, 0xf7, 0x11, 0x13, 0x79, 0x03, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/evm/types/job.pb.go b/x/evm/types/job.pb.go index 39717cfe..7400a14c 100644 --- a/x/evm/types/job.pb.go +++ b/x/evm/types/job.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -34,9 +37,11 @@ func (*JobDefinition) ProtoMessage() {} func (*JobDefinition) Descriptor() ([]byte, []int) { return fileDescriptor_0ef90eed6bbce6d4, []int{0} } + func (m *JobDefinition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *JobDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_JobDefinition.Marshal(b, m, deterministic) @@ -49,12 +54,15 @@ func (m *JobDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error return b[:n], nil } } + func (m *JobDefinition) XXX_Merge(src proto.Message) { xxx_messageInfo_JobDefinition.Merge(m, src) } + func (m *JobDefinition) XXX_Size() int { return m.Size() } + func (m *JobDefinition) XXX_DiscardUnknown() { xxx_messageInfo_JobDefinition.DiscardUnknown(m) } @@ -85,9 +93,11 @@ func (*JobPayload) ProtoMessage() {} func (*JobPayload) Descriptor() ([]byte, []int) { return fileDescriptor_0ef90eed6bbce6d4, []int{1} } + func (m *JobPayload) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *JobPayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_JobPayload.Marshal(b, m, deterministic) @@ -100,12 +110,15 @@ func (m *JobPayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *JobPayload) XXX_Merge(src proto.Message) { xxx_messageInfo_JobPayload.Merge(m, src) } + func (m *JobPayload) XXX_Size() int { return m.Size() } + func (m *JobPayload) XXX_DiscardUnknown() { xxx_messageInfo_JobPayload.DiscardUnknown(m) } @@ -127,7 +140,7 @@ func init() { func init() { proto.RegisterFile("palomachain/paloma/evm/job.proto", fileDescriptor_0ef90eed6bbce6d4) } var fileDescriptor_0ef90eed6bbce6d4 = []byte{ - // 210 bytes of a gzipped FileDescriptorProto + // 213 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x28, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x53, 0xcb, 0x72, 0xf5, 0xb3, 0xf2, 0x93, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xc4, 0x90, 0x54, 0xe8, 0x41, 0xd8, 0x7a, @@ -136,12 +149,12 @@ var fileDescriptor_0ef90eed6bbce6d4 = []byte{ 0x9e, 0x90, 0x04, 0x17, 0x7b, 0x62, 0x4a, 0x4a, 0x51, 0x6a, 0x71, 0xb1, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x8c, 0x2b, 0x24, 0xc0, 0xc5, 0xec, 0xe8, 0xe4, 0x29, 0xc1, 0x04, 0x16, 0x05, 0x31, 0x95, 0x74, 0xb8, 0xb8, 0xbc, 0xf2, 0x93, 0x02, 0x12, 0x2b, 0x73, 0xf2, 0x13, 0x53, 0x84, - 0xe4, 0xb8, 0xb8, 0x32, 0x52, 0x2b, 0xa0, 0x3c, 0xa8, 0x66, 0x24, 0x11, 0x27, 0xe7, 0x13, 0x8f, + 0xe4, 0xb8, 0xb8, 0x32, 0x52, 0x2b, 0xa0, 0x3c, 0xa8, 0x66, 0x24, 0x11, 0x27, 0xb7, 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, 0xc7, 0xe2, 0xbf, 0x0a, 0xb0, 0x0f, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, - 0xd8, 0xc0, 0xce, 0x36, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x97, 0x87, 0x60, 0xe2, 0x08, 0x01, - 0x00, 0x00, + 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0xd2, 0x49, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, + 0x4b, 0xce, 0xcf, 0xd5, 0xc7, 0xe2, 0xbf, 0x32, 0x23, 0xfd, 0x0a, 0xb0, 0x27, 0x4b, 0x2a, 0x0b, + 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0x2e, 0x37, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xb8, 0x12, 0x4d, + 0x71, 0x0b, 0x01, 0x00, 0x00, } func (m *JobDefinition) Marshal() (dAtA []byte, err error) { @@ -222,6 +235,7 @@ func encodeVarintJob(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *JobDefinition) Size() (n int) { if m == nil { return 0 @@ -255,9 +269,11 @@ func (m *JobPayload) Size() (n int) { func sovJob(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozJob(x uint64) (n int) { return sovJob(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *JobDefinition) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -372,6 +388,7 @@ func (m *JobDefinition) Unmarshal(dAtA []byte) error { } return nil } + func (m *JobPayload) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -454,6 +471,7 @@ func (m *JobPayload) Unmarshal(dAtA []byte) error { } return nil } + func skipJob(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/params.pb.go b/x/evm/types/params.pb.go index d6cb18ad..6fb519b9 100644 --- a/x/evm/types/params.pb.go +++ b/x/evm/types/params.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -24,8 +27,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Params defines the parameters for the module. -type Params struct { -} +type Params struct{} func (m *Params) Reset() { *m = Params{} } func (m *Params) String() string { return proto.CompactTextString(m) } @@ -33,9 +35,11 @@ func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_a12098455d1f774b, []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) @@ -48,12 +52,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 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) } @@ -69,16 +76,17 @@ func init() { } var fileDescriptor_a12098455d1f774b = []byte{ - // 144 bytes of a gzipped FileDescriptorProto + // 147 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2e, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x53, 0xcb, 0x72, 0xf5, 0x0b, 0x12, 0x8b, 0x12, 0x73, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xc4, 0x90, 0x14, 0xe9, 0x41, 0xd8, 0x7a, 0xa9, 0x65, 0xb9, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x25, 0xfa, 0x20, - 0x16, 0x44, 0xb5, 0x12, 0x07, 0x17, 0x5b, 0x00, 0x58, 0xb7, 0x93, 0xf3, 0x89, 0x47, 0x72, 0x8c, + 0x16, 0x44, 0xb5, 0x12, 0x07, 0x17, 0x5b, 0x00, 0x58, 0xb7, 0x93, 0xdb, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, - 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x69, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, - 0xe7, 0xea, 0x63, 0x71, 0x41, 0x05, 0xd8, 0x0d, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, - 0x53, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x79, 0xfa, 0x11, 0xf7, 0xaa, 0x00, 0x00, 0x00, + 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0xe9, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, + 0xe7, 0xea, 0x63, 0x71, 0x41, 0x99, 0x91, 0x7e, 0x05, 0xd8, 0x19, 0x25, 0x95, 0x05, 0xa9, 0xc5, + 0x49, 0x6c, 0x60, 0x83, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x16, 0xa9, 0xa2, 0x6f, 0xad, + 0x00, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -115,6 +123,7 @@ func encodeVarintParams(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -127,9 +136,11 @@ func (m *Params) Size() (n int) { func sovParams(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozParams(x uint64) (n int) { return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -180,6 +191,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func skipParams(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/query.pb.go b/x/evm/types/query.pb.go index 62e57ffd..a86d3fe1 100644 --- a/x/evm/types/query.pb.go +++ b/x/evm/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/types/query" _ "github.com/cosmos/gogoproto/gogoproto" @@ -15,15 +19,14 @@ import ( 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -32,8 +35,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // QueryParamsRequest is request type for the Query/Params RPC method. -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -41,9 +43,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{0} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -56,12 +60,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -80,9 +87,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{1} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -95,12 +104,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -125,9 +137,11 @@ func (*QueryGetValsetByIDRequest) ProtoMessage() {} func (*QueryGetValsetByIDRequest) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{2} } + func (m *QueryGetValsetByIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetValsetByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetValsetByIDRequest.Marshal(b, m, deterministic) @@ -140,12 +154,15 @@ func (m *QueryGetValsetByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryGetValsetByIDRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetValsetByIDRequest.Merge(m, src) } + func (m *QueryGetValsetByIDRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetValsetByIDRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetValsetByIDRequest.DiscardUnknown(m) } @@ -176,9 +193,11 @@ func (*QueryGetValsetByIDResponse) ProtoMessage() {} func (*QueryGetValsetByIDResponse) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{3} } + func (m *QueryGetValsetByIDResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetValsetByIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetValsetByIDResponse.Marshal(b, m, deterministic) @@ -191,12 +210,15 @@ func (m *QueryGetValsetByIDResponse) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *QueryGetValsetByIDResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetValsetByIDResponse.Merge(m, src) } + func (m *QueryGetValsetByIDResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetValsetByIDResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetValsetByIDResponse.DiscardUnknown(m) } @@ -210,8 +232,7 @@ func (m *QueryGetValsetByIDResponse) GetValset() *Valset { return nil } -type QueryChainsInfosRequest struct { -} +type QueryChainsInfosRequest struct{} func (m *QueryChainsInfosRequest) Reset() { *m = QueryChainsInfosRequest{} } func (m *QueryChainsInfosRequest) String() string { return proto.CompactTextString(m) } @@ -219,9 +240,11 @@ func (*QueryChainsInfosRequest) ProtoMessage() {} func (*QueryChainsInfosRequest) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{4} } + func (m *QueryChainsInfosRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryChainsInfosRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryChainsInfosRequest.Marshal(b, m, deterministic) @@ -234,12 +257,15 @@ func (m *QueryChainsInfosRequest) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryChainsInfosRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryChainsInfosRequest.Merge(m, src) } + func (m *QueryChainsInfosRequest) XXX_Size() int { return m.Size() } + func (m *QueryChainsInfosRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryChainsInfosRequest.DiscardUnknown(m) } @@ -256,9 +282,11 @@ func (*QueryChainsInfosResponse) ProtoMessage() {} func (*QueryChainsInfosResponse) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{5} } + func (m *QueryChainsInfosResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryChainsInfosResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryChainsInfosResponse.Marshal(b, m, deterministic) @@ -271,12 +299,15 @@ func (m *QueryChainsInfosResponse) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryChainsInfosResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryChainsInfosResponse.Merge(m, src) } + func (m *QueryChainsInfosResponse) XXX_Size() int { return m.Size() } + func (m *QueryChainsInfosResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryChainsInfosResponse.DiscardUnknown(m) } @@ -300,9 +331,11 @@ func (*QueryGetSmartContractRequest) ProtoMessage() {} func (*QueryGetSmartContractRequest) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{6} } + func (m *QueryGetSmartContractRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetSmartContractRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetSmartContractRequest.Marshal(b, m, deterministic) @@ -315,12 +348,15 @@ func (m *QueryGetSmartContractRequest) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryGetSmartContractRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetSmartContractRequest.Merge(m, src) } + func (m *QueryGetSmartContractRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetSmartContractRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetSmartContractRequest.DiscardUnknown(m) } @@ -346,9 +382,11 @@ func (*QueryGetSmartContractResponse) ProtoMessage() {} func (*QueryGetSmartContractResponse) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{7} } + func (m *QueryGetSmartContractResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetSmartContractResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetSmartContractResponse.Marshal(b, m, deterministic) @@ -361,12 +399,15 @@ func (m *QueryGetSmartContractResponse) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } + func (m *QueryGetSmartContractResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetSmartContractResponse.Merge(m, src) } + func (m *QueryGetSmartContractResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetSmartContractResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetSmartContractResponse.DiscardUnknown(m) } @@ -394,8 +435,7 @@ func (m *QueryGetSmartContractResponse) GetBytecode() []byte { return nil } -type QueryGetSmartContractDeploymentsRequest struct { -} +type QueryGetSmartContractDeploymentsRequest struct{} func (m *QueryGetSmartContractDeploymentsRequest) Reset() { *m = QueryGetSmartContractDeploymentsRequest{} @@ -405,9 +445,11 @@ func (*QueryGetSmartContractDeploymentsRequest) ProtoMessage() {} func (*QueryGetSmartContractDeploymentsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{8} } + func (m *QueryGetSmartContractDeploymentsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetSmartContractDeploymentsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetSmartContractDeploymentsRequest.Marshal(b, m, deterministic) @@ -420,12 +462,15 @@ func (m *QueryGetSmartContractDeploymentsRequest) XXX_Marshal(b []byte, determin return b[:n], nil } } + func (m *QueryGetSmartContractDeploymentsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetSmartContractDeploymentsRequest.Merge(m, src) } + func (m *QueryGetSmartContractDeploymentsRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetSmartContractDeploymentsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetSmartContractDeploymentsRequest.DiscardUnknown(m) } @@ -444,9 +489,11 @@ func (*QueryGetSmartContractDeploymentsResponse) ProtoMessage() {} func (*QueryGetSmartContractDeploymentsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{9} } + func (m *QueryGetSmartContractDeploymentsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetSmartContractDeploymentsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetSmartContractDeploymentsResponse.Marshal(b, m, deterministic) @@ -459,12 +506,15 @@ func (m *QueryGetSmartContractDeploymentsResponse) XXX_Marshal(b []byte, determi return b[:n], nil } } + func (m *QueryGetSmartContractDeploymentsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetSmartContractDeploymentsResponse.Merge(m, src) } + func (m *QueryGetSmartContractDeploymentsResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetSmartContractDeploymentsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetSmartContractDeploymentsResponse.DiscardUnknown(m) } @@ -488,9 +538,11 @@ func (*QueryUserSmartContractsRequest) ProtoMessage() {} func (*QueryUserSmartContractsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{10} } + func (m *QueryUserSmartContractsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryUserSmartContractsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryUserSmartContractsRequest.Marshal(b, m, deterministic) @@ -503,12 +555,15 @@ func (m *QueryUserSmartContractsRequest) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *QueryUserSmartContractsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryUserSmartContractsRequest.Merge(m, src) } + func (m *QueryUserSmartContractsRequest) XXX_Size() int { return m.Size() } + func (m *QueryUserSmartContractsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryUserSmartContractsRequest.DiscardUnknown(m) } @@ -532,9 +587,11 @@ func (*QueryUserSmartContractsResponse) ProtoMessage() {} func (*QueryUserSmartContractsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_dd77ddf5be861c95, []int{11} } + func (m *QueryUserSmartContractsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryUserSmartContractsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryUserSmartContractsResponse.Marshal(b, m, deterministic) @@ -547,12 +604,15 @@ func (m *QueryUserSmartContractsResponse) XXX_Marshal(b []byte, deterministic bo return b[:n], nil } } + func (m *QueryUserSmartContractsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryUserSmartContractsResponse.Merge(m, src) } + func (m *QueryUserSmartContractsResponse) XXX_Size() int { return m.Size() } + func (m *QueryUserSmartContractsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryUserSmartContractsResponse.DiscardUnknown(m) } @@ -586,65 +646,68 @@ func init() { } var fileDescriptor_dd77ddf5be861c95 = []byte{ - // 846 bytes of a gzipped FileDescriptorProto + // 849 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x4d, 0x6f, 0xeb, 0x44, 0x14, 0x8d, 0xd3, 0x47, 0x44, 0x26, 0x7c, 0x3c, 0x0d, 0x05, 0x52, 0xeb, 0xe1, 0x17, 0x0c, 0xea, - 0x4b, 0x0b, 0x64, 0xda, 0x94, 0x16, 0x21, 0x2a, 0x28, 0x49, 0xa4, 0x36, 0xac, 0xa8, 0x0b, 0x2c, + 0x4b, 0x4b, 0xc9, 0xb4, 0x29, 0x2d, 0x42, 0x54, 0x50, 0xd2, 0x88, 0x36, 0xac, 0xa8, 0x0b, 0x2c, 0x40, 0xc8, 0x9a, 0x38, 0x53, 0xd7, 0x28, 0xf6, 0xb8, 0x9e, 0x49, 0x44, 0x54, 0x65, 0xd3, 0x1d, 0x3b, 0x24, 0xf6, 0xfc, 0x09, 0xf8, 0x11, 0x5d, 0x56, 0xc0, 0x82, 0x15, 0x42, 0x2d, 0x3b, 0xfe, 0x04, 0xf2, 0xcc, 0x38, 0x4d, 0x1a, 0x3b, 0x69, 0xd8, 0x8d, 0x6f, 0xee, 0x39, 0xf7, 0xdc, 0xeb, - 0xdc, 0xe3, 0x01, 0x66, 0x88, 0x7b, 0xd4, 0xc7, 0xce, 0x19, 0xf6, 0x02, 0x24, 0xcf, 0x88, 0x0c, - 0x7c, 0x74, 0xde, 0x27, 0xd1, 0xb0, 0x16, 0x46, 0x94, 0x53, 0xf8, 0xda, 0x44, 0x4e, 0x4d, 0x9e, - 0x6b, 0x64, 0xe0, 0xeb, 0x6b, 0x0e, 0x65, 0x3e, 0x65, 0xb6, 0xc8, 0x42, 0xf2, 0x41, 0x42, 0xf4, - 0x55, 0x97, 0xba, 0x54, 0xc6, 0xe3, 0x93, 0x8a, 0x3e, 0x71, 0x29, 0x75, 0x7b, 0x04, 0xe1, 0xd0, - 0x43, 0x38, 0x08, 0x28, 0xc7, 0xdc, 0xa3, 0x41, 0x82, 0xd9, 0x94, 0x0c, 0xa8, 0x83, 0x19, 0x91, - 0xf5, 0xd1, 0x60, 0xbb, 0x43, 0x38, 0xde, 0x46, 0x21, 0x76, 0xbd, 0x40, 0x24, 0xab, 0xdc, 0xb7, - 0x32, 0x64, 0x87, 0x38, 0xc2, 0x7e, 0x42, 0xb8, 0x9e, 0x91, 0xc4, 0xfb, 0x51, 0xc0, 0x38, 0x0d, - 0x88, 0xca, 0x7b, 0x96, 0x91, 0x27, 0x02, 0xb6, 0x17, 0x9c, 0x26, 0xfa, 0xb7, 0x32, 0x12, 0xfb, - 0x8c, 0x44, 0x36, 0xf3, 0x71, 0xc4, 0x6d, 0x87, 0x06, 0x3c, 0xc2, 0x0e, 0x97, 0x08, 0x73, 0x15, - 0xc0, 0xe3, 0xb8, 0x93, 0xcf, 0x85, 0x2e, 0x8b, 0x9c, 0xf7, 0x09, 0xe3, 0xe6, 0x09, 0x78, 0x65, - 0x2a, 0xca, 0x42, 0x1a, 0x30, 0x02, 0xf7, 0x41, 0x41, 0xea, 0x2f, 0x6b, 0x15, 0xad, 0x5a, 0xaa, + 0xdc, 0xe3, 0x01, 0x66, 0x88, 0xbb, 0xd4, 0xc7, 0xce, 0x19, 0xf6, 0x02, 0x24, 0xcf, 0x88, 0xf4, + 0x7d, 0x74, 0xde, 0x23, 0xd1, 0xa0, 0x16, 0x46, 0x94, 0x53, 0xf8, 0xda, 0x58, 0x4e, 0x4d, 0x9e, + 0x6b, 0xa4, 0xef, 0xeb, 0x2b, 0x0e, 0x65, 0x3e, 0x65, 0xb6, 0xc8, 0x42, 0xf2, 0x41, 0x42, 0xf4, + 0x65, 0x97, 0xba, 0x54, 0xc6, 0xe3, 0x93, 0x8a, 0x3e, 0x71, 0x29, 0x75, 0xbb, 0x04, 0xe1, 0xd0, + 0x43, 0x38, 0x08, 0x28, 0xc7, 0xdc, 0xa3, 0x41, 0x82, 0x59, 0x97, 0x0c, 0xa8, 0x8d, 0x19, 0x91, + 0xf5, 0x51, 0x7f, 0xab, 0x4d, 0x38, 0xde, 0x42, 0x21, 0x76, 0xbd, 0x40, 0x24, 0xab, 0xdc, 0xb7, + 0x32, 0x64, 0x87, 0x38, 0xc2, 0x7e, 0x42, 0xb8, 0x9a, 0x91, 0xc4, 0x7b, 0x51, 0xc0, 0x38, 0x0d, + 0x88, 0xca, 0x7b, 0x96, 0x91, 0x27, 0x02, 0xb6, 0x17, 0x9c, 0x26, 0xfa, 0x37, 0x33, 0x12, 0x7b, + 0x8c, 0x44, 0x36, 0xf3, 0x71, 0xc4, 0x6d, 0x87, 0x06, 0x3c, 0xc2, 0x0e, 0x97, 0x08, 0x73, 0x19, + 0xc0, 0xe3, 0xb8, 0x93, 0xcf, 0x85, 0x2e, 0x8b, 0x9c, 0xf7, 0x08, 0xe3, 0xe6, 0x09, 0x78, 0x65, + 0x22, 0xca, 0x42, 0x1a, 0x30, 0x02, 0xf7, 0x40, 0x41, 0xea, 0x2f, 0x6b, 0x15, 0xad, 0x5a, 0xaa, 0x1b, 0xb5, 0xf4, 0xc1, 0xd7, 0x24, 0xae, 0xf1, 0xe8, 0xea, 0xaf, 0xa7, 0x39, 0x4b, 0x61, 0x4c, - 0x07, 0xac, 0x09, 0xd2, 0x43, 0xc2, 0xbf, 0xc2, 0x3d, 0x46, 0x78, 0x63, 0xd8, 0x6e, 0xa9, 0x8a, - 0x50, 0x07, 0xcf, 0x0f, 0x44, 0xb0, 0xdd, 0x12, 0xe4, 0x8f, 0xac, 0xf1, 0x33, 0xdc, 0x04, 0x8f, - 0x45, 0x05, 0x8b, 0x9c, 0x92, 0x88, 0x04, 0x0e, 0x69, 0xb7, 0xca, 0xf9, 0x8a, 0x56, 0x2d, 0x5a, - 0x33, 0x71, 0xf3, 0x0b, 0xa0, 0xa7, 0x15, 0x51, 0x0d, 0xec, 0x81, 0x82, 0x64, 0x5d, 0xd4, 0x80, - 0xc4, 0x5a, 0x2a, 0xdb, 0x5c, 0x03, 0xaf, 0x0b, 0xd6, 0x66, 0x9c, 0xc7, 0xda, 0xc1, 0x29, 0x1d, - 0x8f, 0xca, 0x06, 0xe5, 0xd9, 0x9f, 0x54, 0xb9, 0x26, 0x28, 0x39, 0x77, 0xe1, 0xb2, 0x56, 0x59, - 0xa9, 0x96, 0xea, 0x6f, 0x66, 0xd5, 0x14, 0x0c, 0x71, 0xa6, 0x35, 0x89, 0x32, 0x8f, 0xc0, 0x93, - 0xa4, 0xa3, 0x93, 0xf8, 0x0d, 0x36, 0xd5, 0x0b, 0x4c, 0x26, 0x57, 0x05, 0x2f, 0xb3, 0xc9, 0xf8, - 0x78, 0x80, 0xf7, 0xc3, 0xe6, 0xb7, 0xe0, 0x8d, 0x0c, 0x26, 0xa5, 0xf7, 0x25, 0x90, 0x1f, 0xa3, - 0xf3, 0xed, 0x16, 0x7c, 0x0c, 0x56, 0x70, 0xc7, 0x53, 0xb3, 0x8e, 0x8f, 0xf1, 0x6b, 0xea, 0x0c, - 0x39, 0x71, 0x68, 0x97, 0x94, 0x57, 0x2a, 0x5a, 0xf5, 0x05, 0x6b, 0xfc, 0x6c, 0x6e, 0x80, 0x67, - 0xa9, 0xf4, 0x2d, 0x12, 0xf6, 0xe8, 0xd0, 0x27, 0x01, 0x1f, 0x0f, 0x6d, 0x04, 0xaa, 0x8b, 0x53, - 0x95, 0xa8, 0x63, 0x50, 0xea, 0xde, 0x85, 0xd5, 0x10, 0x51, 0xd6, 0x10, 0x33, 0xe8, 0xac, 0x49, - 0x0e, 0xf3, 0x1b, 0x60, 0x88, 0xf2, 0x5f, 0x32, 0x12, 0x4d, 0x01, 0x12, 0x81, 0xf0, 0x43, 0x50, - 0x1a, 0xe0, 0x9e, 0x8d, 0xbb, 0xdd, 0x88, 0x30, 0xf9, 0x77, 0x2f, 0x36, 0xca, 0xbf, 0xfd, 0xfa, - 0xde, 0xaa, 0x72, 0x91, 0x4f, 0xe5, 0x2f, 0x27, 0x3c, 0xf2, 0x02, 0xd7, 0x02, 0x03, 0xdc, 0x53, - 0x11, 0xf3, 0x3b, 0xf0, 0x34, 0x93, 0x5c, 0xb5, 0x74, 0x08, 0x8a, 0xc9, 0x1a, 0x26, 0x0d, 0x6d, - 0x64, 0x35, 0x34, 0x43, 0x63, 0xdd, 0x61, 0xeb, 0x97, 0x45, 0xf0, 0x9c, 0x28, 0x06, 0x7f, 0xd0, - 0x40, 0x41, 0x6e, 0x1d, 0xdc, 0xcc, 0xa2, 0x9a, 0x5d, 0x74, 0xfd, 0x9d, 0x07, 0xe5, 0x4a, 0xd9, - 0xe6, 0xfa, 0xe5, 0xef, 0xff, 0xfc, 0x94, 0xaf, 0x40, 0x03, 0xcd, 0x35, 0x37, 0xf8, 0x8b, 0x06, - 0x5e, 0x9c, 0xda, 0x3f, 0xb8, 0x3d, 0xb7, 0x4c, 0x9a, 0x21, 0xe8, 0xf5, 0x65, 0x20, 0x4a, 0xe0, - 0x47, 0x42, 0xe0, 0x2e, 0xdc, 0xc9, 0x12, 0xe8, 0x12, 0x6e, 0xcb, 0x95, 0xb6, 0x3b, 0x43, 0xdb, - 0xeb, 0xa2, 0x8b, 0xc4, 0x64, 0x46, 0xf0, 0x67, 0x0d, 0x94, 0x26, 0x96, 0x18, 0xa2, 0xb9, 0x02, - 0x66, 0x9d, 0x40, 0xdf, 0x7a, 0x38, 0x40, 0xe9, 0x7d, 0x57, 0xe8, 0x5d, 0x87, 0x6f, 0xa3, 0x79, - 0x06, 0xcf, 0x84, 0xc3, 0x33, 0x78, 0xad, 0x81, 0x57, 0x53, 0xb7, 0x06, 0xbe, 0xbf, 0x68, 0x56, - 0x69, 0xc6, 0xa1, 0xef, 0x2e, 0x89, 0x52, 0xa2, 0x3f, 0x13, 0xa2, 0x5b, 0xb0, 0x81, 0xe6, 0x7d, - 0x99, 0xed, 0x78, 0xd4, 0xd3, 0x5f, 0x1c, 0x74, 0x71, 0xcf, 0x90, 0x46, 0xf0, 0x5f, 0x0d, 0x54, - 0x16, 0x19, 0x01, 0xfc, 0x64, 0x29, 0x9d, 0xb3, 0x6e, 0xa3, 0x1f, 0xfc, 0x7f, 0x02, 0xd5, 0x73, - 0x4b, 0xf4, 0xfc, 0x31, 0xdc, 0x5f, 0xb6, 0x67, 0x7b, 0xc2, 0x76, 0xe0, 0x1f, 0x9a, 0xfa, 0x8c, - 0xcc, 0x5a, 0x03, 0xdc, 0x9b, 0xab, 0x31, 0xd3, 0xa8, 0xf4, 0x0f, 0x96, 0xc6, 0xa9, 0x96, 0x8e, - 0x44, 0x4b, 0x0d, 0x78, 0x30, 0xbf, 0xa5, 0x94, 0x9b, 0x03, 0x13, 0x5b, 0x93, 0x78, 0xe3, 0xa8, - 0xd1, 0xbc, 0xba, 0x31, 0xb4, 0xeb, 0x1b, 0x43, 0xfb, 0xfb, 0xc6, 0xd0, 0x7e, 0xbc, 0x35, 0x72, - 0xd7, 0xb7, 0x46, 0xee, 0xcf, 0x5b, 0x23, 0xf7, 0xf5, 0x86, 0xeb, 0xf1, 0xb3, 0x7e, 0xa7, 0xe6, - 0x50, 0x3f, 0xad, 0xca, 0xf7, 0xf2, 0xb2, 0x33, 0x0c, 0x09, 0xeb, 0x14, 0xc4, 0x75, 0x64, 0xe7, - 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2c, 0x5f, 0x99, 0x3c, 0xef, 0x09, 0x00, 0x00, + 0x07, 0xac, 0x08, 0xd2, 0x43, 0xc2, 0xbf, 0xc2, 0x5d, 0x46, 0x78, 0x63, 0xd0, 0x6a, 0xaa, 0x8a, + 0x50, 0x07, 0xcf, 0xf7, 0x45, 0xb0, 0xd5, 0x14, 0xe4, 0x8f, 0xac, 0xd1, 0x33, 0x5c, 0x07, 0x8f, + 0x45, 0x05, 0x8b, 0x9c, 0x92, 0x88, 0x04, 0x0e, 0x69, 0x35, 0xcb, 0xf9, 0x8a, 0x56, 0x2d, 0x5a, + 0x53, 0x71, 0xf3, 0x0b, 0xa0, 0xa7, 0x15, 0x51, 0x0d, 0xec, 0x82, 0x82, 0x64, 0x9d, 0xd7, 0x80, + 0xc4, 0x5a, 0x2a, 0xdb, 0x5c, 0x01, 0xaf, 0x0b, 0xd6, 0x83, 0x38, 0x8f, 0xb5, 0x82, 0x53, 0x3a, + 0x1a, 0x95, 0x0d, 0xca, 0xd3, 0x3f, 0xa9, 0x72, 0x07, 0xa0, 0xe4, 0xdc, 0x85, 0xcb, 0x5a, 0x65, + 0xa9, 0x5a, 0xaa, 0xbf, 0x99, 0x55, 0x53, 0x30, 0xc4, 0x99, 0xd6, 0x38, 0xca, 0x3c, 0x02, 0x4f, + 0x92, 0x8e, 0x4e, 0xe2, 0x37, 0x78, 0xa0, 0x5e, 0x60, 0x32, 0xb9, 0x2a, 0x78, 0x99, 0x8d, 0xc7, + 0x47, 0x03, 0xbc, 0x1f, 0x36, 0xbf, 0x05, 0x6f, 0x64, 0x30, 0x29, 0xbd, 0x2f, 0x81, 0xfc, 0x08, + 0x9d, 0x6f, 0x35, 0xe1, 0x63, 0xb0, 0x84, 0xdb, 0x9e, 0x9a, 0x75, 0x7c, 0x8c, 0x5f, 0x53, 0x7b, + 0xc0, 0x89, 0x43, 0x3b, 0xa4, 0xbc, 0x54, 0xd1, 0xaa, 0x2f, 0x58, 0xa3, 0x67, 0x73, 0x0d, 0x3c, + 0x4b, 0xa5, 0x6f, 0x92, 0xb0, 0x4b, 0x07, 0x3e, 0x09, 0xf8, 0x68, 0x68, 0x43, 0x50, 0x9d, 0x9f, + 0xaa, 0x44, 0x1d, 0x83, 0x52, 0xe7, 0x2e, 0xac, 0x86, 0x88, 0xb2, 0x86, 0x98, 0x41, 0x67, 0x8d, + 0x73, 0x98, 0xdf, 0x00, 0x43, 0x94, 0xff, 0x92, 0x91, 0x68, 0x02, 0x90, 0x08, 0x84, 0x1f, 0x80, + 0x52, 0x1f, 0x77, 0x6d, 0xdc, 0xe9, 0x44, 0x84, 0xc9, 0xbf, 0x7b, 0xb1, 0x51, 0xfe, 0xed, 0xd7, + 0x77, 0x97, 0x95, 0x8b, 0x7c, 0x22, 0x7f, 0x39, 0xe1, 0x91, 0x17, 0xb8, 0x16, 0xe8, 0xe3, 0xae, + 0x8a, 0x98, 0xdf, 0x81, 0xa7, 0x99, 0xe4, 0xaa, 0xa5, 0x43, 0x50, 0x4c, 0xd6, 0x30, 0x69, 0x68, + 0x2d, 0xab, 0xa1, 0x29, 0x1a, 0xeb, 0x0e, 0x5b, 0xbf, 0x2c, 0x82, 0xe7, 0x44, 0x31, 0xf8, 0x83, + 0x06, 0x0a, 0x72, 0xeb, 0xe0, 0x7a, 0x16, 0xd5, 0xf4, 0xa2, 0xeb, 0xef, 0x3c, 0x28, 0x57, 0xca, + 0x36, 0x57, 0x2f, 0x7f, 0xff, 0xe7, 0xa7, 0x7c, 0x05, 0x1a, 0x68, 0xa6, 0xb9, 0xc1, 0x5f, 0x34, + 0xf0, 0xe2, 0xc4, 0xfe, 0xc1, 0xad, 0x99, 0x65, 0xd2, 0x0c, 0x41, 0xaf, 0x2f, 0x02, 0x51, 0x02, + 0x3f, 0x14, 0x02, 0x77, 0xe0, 0x76, 0x96, 0x40, 0x97, 0x70, 0x5b, 0xae, 0xb4, 0xdd, 0x1e, 0xd8, + 0x5e, 0x07, 0x5d, 0x24, 0x26, 0x33, 0x84, 0x3f, 0x6b, 0xa0, 0x34, 0xb6, 0xc4, 0x10, 0xcd, 0x14, + 0x30, 0xed, 0x04, 0xfa, 0xe6, 0xc3, 0x01, 0x4a, 0xef, 0x86, 0xd0, 0xbb, 0x0a, 0xdf, 0x46, 0xb3, + 0x0c, 0x9e, 0x09, 0x87, 0x67, 0xf0, 0x5a, 0x03, 0xaf, 0xa6, 0x6e, 0x0d, 0x7c, 0x6f, 0xde, 0xac, + 0xd2, 0x8c, 0x43, 0xdf, 0x59, 0x10, 0xa5, 0x44, 0x7f, 0x26, 0x44, 0x37, 0x61, 0x03, 0xcd, 0xfa, + 0x32, 0xdb, 0xf1, 0xa8, 0x27, 0xbf, 0x38, 0xe8, 0xe2, 0x9e, 0x21, 0x0d, 0xe1, 0xbf, 0x1a, 0xa8, + 0xcc, 0x33, 0x02, 0xf8, 0xf1, 0x42, 0x3a, 0xa7, 0xdd, 0x46, 0xdf, 0xff, 0xff, 0x04, 0xaa, 0xe7, + 0xa6, 0xe8, 0xf9, 0x23, 0xb8, 0xb7, 0x68, 0xcf, 0xf6, 0x98, 0xed, 0xc0, 0x3f, 0x34, 0xf5, 0x19, + 0x99, 0xb6, 0x06, 0xb8, 0x3b, 0x53, 0x63, 0xa6, 0x51, 0xe9, 0xef, 0x2f, 0x8c, 0x53, 0x2d, 0x1d, + 0x89, 0x96, 0x1a, 0x70, 0x7f, 0x76, 0x4b, 0x29, 0x37, 0x07, 0x26, 0xb6, 0x26, 0xf1, 0xc6, 0x61, + 0xe3, 0xd3, 0xab, 0x1b, 0x43, 0xbb, 0xbe, 0x31, 0xb4, 0xbf, 0x6f, 0x0c, 0xed, 0xc7, 0x5b, 0x23, + 0x77, 0x7d, 0x6b, 0xe4, 0xfe, 0xbc, 0x35, 0x72, 0x5f, 0x6f, 0xb8, 0x1e, 0x3f, 0xeb, 0xb5, 0x6b, + 0x0e, 0xf5, 0xd3, 0xaa, 0xf4, 0xeb, 0xe8, 0x7b, 0x79, 0xdf, 0x19, 0x84, 0x84, 0xb5, 0x0b, 0xe2, + 0x46, 0xb2, 0xfd, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x38, 0x06, 0xc6, 0x35, 0xf2, 0x09, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -747,24 +810,28 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } + func (*UnimplementedQueryServer) GetValsetByID(ctx context.Context, req *QueryGetValsetByIDRequest) (*QueryGetValsetByIDResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetValsetByID not implemented") } + func (*UnimplementedQueryServer) ChainsInfos(ctx context.Context, req *QueryChainsInfosRequest) (*QueryChainsInfosResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ChainsInfos not implemented") } + func (*UnimplementedQueryServer) QueryGetSmartContract(ctx context.Context, req *QueryGetSmartContractRequest) (*QueryGetSmartContractResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryGetSmartContract not implemented") } + func (*UnimplementedQueryServer) QueryGetSmartContractDeployments(ctx context.Context, req *QueryGetSmartContractDeploymentsRequest) (*QueryGetSmartContractDeploymentsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryGetSmartContractDeployments not implemented") } + func (*UnimplementedQueryServer) QueryUserSmartContracts(ctx context.Context, req *QueryUserSmartContractsRequest) (*QueryUserSmartContractsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryUserSmartContracts not implemented") } @@ -1308,6 +1375,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QueryParamsRequest) Size() (n int) { if m == nil { return 0 @@ -1468,9 +1536,11 @@ func (m *QueryUserSmartContractsResponse) Size() (n int) { 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 *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1521,6 +1591,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1604,6 +1675,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetValsetByIDRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1705,6 +1777,7 @@ func (m *QueryGetValsetByIDRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetValsetByIDResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1791,6 +1864,7 @@ func (m *QueryGetValsetByIDResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryChainsInfosRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1841,6 +1915,7 @@ func (m *QueryChainsInfosRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryChainsInfosResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1925,6 +2000,7 @@ func (m *QueryChainsInfosResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetSmartContractRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1994,6 +2070,7 @@ func (m *QueryGetSmartContractRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetSmartContractResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2129,6 +2206,7 @@ func (m *QueryGetSmartContractResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetSmartContractDeploymentsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2179,6 +2257,7 @@ func (m *QueryGetSmartContractDeploymentsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetSmartContractDeploymentsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2263,6 +2342,7 @@ func (m *QueryGetSmartContractDeploymentsResponse) Unmarshal(dAtA []byte) error } return nil } + func (m *QueryUserSmartContractsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2345,6 +2425,7 @@ func (m *QueryUserSmartContractsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryUserSmartContractsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2429,6 +2510,7 @@ func (m *QueryUserSmartContractsResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/relay_weights.pb.go b/x/evm/types/relay_weights.pb.go index 47c9eb53..642b5313 100644 --- a/x/evm/types/relay_weights.pb.go +++ b/x/evm/types/relay_weights.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*RelayWeights) ProtoMessage() {} func (*RelayWeights) Descriptor() ([]byte, []int) { return fileDescriptor_0c5b82d9f8c0a0e3, []int{0} } + func (m *RelayWeights) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *RelayWeights) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RelayWeights.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *RelayWeights) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *RelayWeights) XXX_Merge(src proto.Message) { xxx_messageInfo_RelayWeights.Merge(m, src) } + func (m *RelayWeights) XXX_Size() int { return m.Size() } + func (m *RelayWeights) XXX_DiscardUnknown() { xxx_messageInfo_RelayWeights.DiscardUnknown(m) } @@ -108,7 +116,7 @@ func init() { } var fileDescriptor_0c5b82d9f8c0a0e3 = []byte{ - // 265 bytes of a gzipped FileDescriptorProto + // 268 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x53, 0xcb, 0x72, 0xf5, 0x8b, 0x52, 0x73, 0x12, 0x2b, 0xe3, 0xcb, 0x53, 0x33, 0xd3, 0x33, 0x4a, 0x8a, 0xf5, 0x0a, 0x8a, 0xf2, @@ -121,11 +129,11 @@ var fileDescriptor_0c5b82d9f8c0a0e3 = []byte{ 0x2c, 0x49, 0x95, 0x60, 0xc6, 0xaa, 0x18, 0x59, 0x89, 0x90, 0x09, 0x17, 0x6f, 0x6a, 0x45, 0x6a, 0x72, 0x69, 0x49, 0x66, 0x7e, 0x5e, 0x08, 0xc8, 0x02, 0x16, 0xac, 0x7a, 0x50, 0x15, 0x09, 0xe9, 0x71, 0x71, 0xa5, 0xa5, 0x26, 0x96, 0x94, 0x16, 0xa5, 0x06, 0xa7, 0x96, 0x48, 0xb0, 0x62, 0xd5, - 0x82, 0xa4, 0xc2, 0xc9, 0xf9, 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, 0x34, - 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0x04, 0x7b, 0x05, 0x38, - 0xe0, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0xc1, 0x67, 0x0c, 0x08, 0x00, 0x00, 0xff, - 0xff, 0xfd, 0xa7, 0xb8, 0x15, 0x9f, 0x01, 0x00, 0x00, + 0x82, 0xa4, 0xc2, 0xc9, 0xed, 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, 0x74, + 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0x04, 0x7b, 0x99, 0x91, + 0x7e, 0x05, 0x38, 0xec, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0x21, 0x68, 0x0c, 0x08, + 0x00, 0x00, 0xff, 0xff, 0xfd, 0x22, 0x81, 0x29, 0xa2, 0x01, 0x00, 0x00, } func (m *RelayWeights) Marshal() (dAtA []byte, err error) { @@ -197,6 +205,7 @@ func encodeVarintRelayWeights(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *RelayWeights) Size() (n int) { if m == nil { return 0 @@ -229,9 +238,11 @@ func (m *RelayWeights) Size() (n int) { func sovRelayWeights(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozRelayWeights(x uint64) (n int) { return sovRelayWeights(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *RelayWeights) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -442,6 +453,7 @@ func (m *RelayWeights) Unmarshal(dAtA []byte) error { } return nil } + func skipRelayWeights(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/relay_weights_proposal.pb.go b/x/evm/types/relay_weights_proposal.pb.go index 86041985..b28757ad 100644 --- a/x/evm/types/relay_weights_proposal.pb.go +++ b/x/evm/types/relay_weights_proposal.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -40,9 +43,11 @@ func (*RelayWeightsProposal) ProtoMessage() {} func (*RelayWeightsProposal) Descriptor() ([]byte, []int) { return fileDescriptor_8c69c53864c5bd3a, []int{0} } + func (m *RelayWeightsProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *RelayWeightsProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RelayWeightsProposal.Marshal(b, m, deterministic) @@ -55,12 +60,15 @@ func (m *RelayWeightsProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *RelayWeightsProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_RelayWeightsProposal.Merge(m, src) } + func (m *RelayWeightsProposal) XXX_Size() int { return m.Size() } + func (m *RelayWeightsProposal) XXX_DiscardUnknown() { xxx_messageInfo_RelayWeightsProposal.DiscardUnknown(m) } @@ -132,28 +140,28 @@ func init() { } var fileDescriptor_8c69c53864c5bd3a = []byte{ - // 326 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xc1, 0x4a, 0xfb, 0x40, - 0x10, 0xc6, 0x9b, 0xf6, 0xdf, 0xfe, 0x75, 0x8a, 0x22, 0x4b, 0x91, 0xd5, 0x43, 0x28, 0x1e, 0x44, - 0x05, 0x13, 0xa1, 0x3e, 0x41, 0xed, 0xc5, 0x9b, 0x44, 0x41, 0xf0, 0x52, 0xb6, 0xeb, 0xb4, 0x5d, - 0x48, 0xba, 0x4b, 0x76, 0x52, 0xdb, 0xb7, 0xf0, 0x61, 0x7c, 0x08, 0x8f, 0xc5, 0x93, 0x07, 0x0f, - 0xd2, 0xbe, 0x88, 0x24, 0xdb, 0x43, 0xc4, 0xdc, 0x66, 0xe6, 0xfb, 0x7d, 0x33, 0x03, 0x1f, 0xf4, - 0x8c, 0x88, 0x75, 0x22, 0xe4, 0x54, 0xa8, 0x59, 0xe8, 0xea, 0x10, 0xe7, 0x49, 0x98, 0x62, 0x2c, - 0x96, 0xc3, 0x17, 0x54, 0x93, 0x29, 0xd9, 0xa1, 0x49, 0xb5, 0xd1, 0x56, 0xc4, 0x81, 0x49, 0x35, - 0x69, 0x76, 0x58, 0x32, 0x05, 0xae, 0x0e, 0x70, 0x9e, 0x1c, 0x1f, 0x49, 0x6d, 0x13, 0x5d, 0xe0, - 0xa4, 0x43, 0xd7, 0x38, 0xcb, 0xc9, 0x57, 0x1d, 0x3a, 0x51, 0xbe, 0xf3, 0xd1, 0xad, 0xbc, 0xdb, - 0x6e, 0x64, 0x1d, 0x68, 0x92, 0xa2, 0x18, 0xb9, 0xd7, 0xf5, 0xce, 0x76, 0x23, 0xd7, 0xb0, 0x2e, - 0xb4, 0x9f, 0xd1, 0xca, 0x54, 0x19, 0x52, 0x7a, 0xc6, 0xeb, 0x85, 0x56, 0x1e, 0xb1, 0x0b, 0x38, - 0x28, 0xee, 0x47, 0x38, 0xc6, 0x14, 0x67, 0x12, 0x6f, 0x07, 0xbc, 0x51, 0x60, 0x7f, 0xe6, 0xac, - 0x0b, 0x8d, 0x31, 0x22, 0xff, 0x97, 0xcb, 0xfd, 0xfd, 0x8f, 0xb7, 0x4b, 0xd8, 0xfe, 0x36, 0x40, - 0x19, 0xe5, 0x12, 0x3b, 0x85, 0x56, 0x66, 0x48, 0x25, 0xc8, 0x9b, 0x95, 0xd0, 0x56, 0x65, 0x57, - 0xd0, 0xb6, 0x99, 0x94, 0x68, 0x6d, 0x24, 0x08, 0x79, 0xab, 0x12, 0x2e, 0x23, 0xec, 0x1a, 0xf6, - 0x70, 0x81, 0x32, 0xcb, 0x9f, 0x7e, 0xc8, 0x0f, 0xfc, 0xaf, 0xf4, 0xfc, 0x86, 0x58, 0x00, 0x30, - 0x46, 0x41, 0x59, 0x8a, 0xf7, 0x48, 0x7c, 0xa7, 0xd2, 0x52, 0x22, 0xfa, 0x37, 0xef, 0x6b, 0xdf, - 0x5b, 0xad, 0x7d, 0xef, 0x7b, 0xed, 0x7b, 0xaf, 0x1b, 0xbf, 0xb6, 0xda, 0xf8, 0xb5, 0xcf, 0x8d, - 0x5f, 0x7b, 0x3a, 0x9f, 0x28, 0x9a, 0x66, 0xa3, 0x40, 0xea, 0x24, 0xac, 0xc8, 0x7a, 0x51, 0xa4, - 0x4d, 0x4b, 0x83, 0x76, 0xd4, 0x2a, 0xa2, 0xea, 0xfd, 0x04, 0x00, 0x00, 0xff, 0xff, 0xe2, 0xf3, - 0x8d, 0x51, 0x14, 0x02, 0x00, 0x00, + // 328 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xcf, 0x4a, 0xc3, 0x40, + 0x10, 0xc6, 0x9b, 0xd6, 0x56, 0x9d, 0xa2, 0xc8, 0x52, 0x64, 0xf5, 0x10, 0x8a, 0x07, 0x11, 0xd1, + 0x44, 0xac, 0x4f, 0x50, 0x8a, 0xe0, 0x4d, 0xa2, 0x20, 0x78, 0x29, 0xdb, 0x75, 0xda, 0x2e, 0x24, + 0xdd, 0x25, 0x3b, 0xa9, 0xed, 0x5b, 0xf8, 0x30, 0x3e, 0x84, 0xc7, 0xe2, 0xc9, 0x83, 0x07, 0x69, + 0x5f, 0x44, 0xf2, 0xe7, 0x10, 0x31, 0xb7, 0x99, 0xf9, 0x7e, 0xdf, 0xcc, 0xc0, 0x07, 0x3d, 0x23, + 0x42, 0x1d, 0x09, 0x39, 0x15, 0x6a, 0xe6, 0xe7, 0xb5, 0x8f, 0xf3, 0xc8, 0x8f, 0x31, 0x14, 0xcb, + 0xe1, 0x2b, 0xaa, 0xc9, 0x94, 0xec, 0xd0, 0xc4, 0xda, 0x68, 0x2b, 0x42, 0xcf, 0xc4, 0x9a, 0x34, + 0x3b, 0x2c, 0x99, 0xbc, 0xbc, 0xf6, 0x70, 0x1e, 0x1d, 0x1f, 0x49, 0x6d, 0x23, 0x9d, 0xe1, 0xa4, + 0xfd, 0xbc, 0xc9, 0x2d, 0x27, 0xdf, 0x75, 0xe8, 0x04, 0xe9, 0xce, 0xa7, 0x7c, 0xe5, 0x7d, 0xb1, + 0x91, 0x75, 0xa0, 0x49, 0x8a, 0x42, 0xe4, 0x4e, 0xd7, 0x39, 0xdb, 0x0d, 0xf2, 0x86, 0x75, 0xa1, + 0xfd, 0x82, 0x56, 0xc6, 0xca, 0x90, 0xd2, 0x33, 0x5e, 0xcf, 0xb4, 0xf2, 0x88, 0x9d, 0xc3, 0x41, + 0x76, 0x3f, 0xc0, 0x31, 0xc6, 0x38, 0x93, 0x78, 0x37, 0xe0, 0x8d, 0x0c, 0xfb, 0x37, 0x67, 0x5d, + 0x68, 0x8c, 0x11, 0xf9, 0x56, 0x2a, 0xf7, 0xf7, 0x3f, 0xdf, 0x2f, 0xa1, 0xf8, 0x6d, 0x80, 0x32, + 0x48, 0x25, 0x76, 0x0a, 0xad, 0xc4, 0x90, 0x8a, 0x90, 0x37, 0x2b, 0xa1, 0x42, 0x65, 0x57, 0xd0, + 0xb6, 0x89, 0x94, 0x68, 0x6d, 0x20, 0x08, 0x79, 0xab, 0x12, 0x2e, 0x23, 0xec, 0x06, 0xf6, 0x70, + 0x81, 0x32, 0x49, 0x9f, 0x7e, 0x4c, 0x0f, 0x6c, 0x57, 0x7a, 0xfe, 0x42, 0xcc, 0x03, 0x18, 0xa3, + 0xa0, 0x24, 0xc6, 0x07, 0x24, 0xbe, 0x53, 0x69, 0x29, 0x11, 0xfd, 0xdb, 0x8f, 0xb5, 0xeb, 0xac, + 0xd6, 0xae, 0xf3, 0xb3, 0x76, 0x9d, 0xb7, 0x8d, 0x5b, 0x5b, 0x6d, 0xdc, 0xda, 0xd7, 0xc6, 0xad, + 0x3d, 0x5f, 0x4c, 0x14, 0x4d, 0x93, 0x91, 0x27, 0x75, 0xe4, 0x57, 0x64, 0x3d, 0xbf, 0xf6, 0x17, + 0x59, 0xe0, 0xb4, 0x34, 0x68, 0x47, 0xad, 0x2c, 0xad, 0xde, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x87, 0x9a, 0x9f, 0xb6, 0x17, 0x02, 0x00, 0x00, } func (m *RelayWeightsProposal) Marshal() (dAtA []byte, err error) { @@ -246,6 +254,7 @@ func encodeVarintRelayWeightsProposal(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *RelayWeightsProposal) Size() (n int) { if m == nil { return 0 @@ -290,9 +299,11 @@ func (m *RelayWeightsProposal) Size() (n int) { func sovRelayWeightsProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozRelayWeightsProposal(x uint64) (n int) { return sovRelayWeightsProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *RelayWeightsProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -599,6 +610,7 @@ func (m *RelayWeightsProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipRelayWeightsProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/remove_chain_proposal.pb.go b/x/evm/types/remove_chain_proposal.pb.go index 9d108747..15993e51 100644 --- a/x/evm/types/remove_chain_proposal.pb.go +++ b/x/evm/types/remove_chain_proposal.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -34,9 +37,11 @@ func (*RemoveChainProposal) ProtoMessage() {} func (*RemoveChainProposal) Descriptor() ([]byte, []int) { return fileDescriptor_a0b2845f61092eb8, []int{0} } + func (m *RemoveChainProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *RemoveChainProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveChainProposal.Marshal(b, m, deterministic) @@ -49,12 +54,15 @@ func (m *RemoveChainProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *RemoveChainProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveChainProposal.Merge(m, src) } + func (m *RemoveChainProposal) XXX_Size() int { return m.Size() } + func (m *RemoveChainProposal) XXX_DiscardUnknown() { xxx_messageInfo_RemoveChainProposal.DiscardUnknown(m) } @@ -91,7 +99,7 @@ func init() { } var fileDescriptor_a0b2845f61092eb8 = []byte{ - // 211 bytes of a gzipped FileDescriptorProto + // 214 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x53, 0xcb, 0x72, 0xf5, 0x8b, 0x52, 0x73, 0xf3, 0xcb, 0x52, 0xe3, 0xc1, 0xe2, 0xf1, 0x05, 0x45, 0xf9, 0x05, 0xf9, 0xc5, 0x89, @@ -100,12 +108,12 @@ var fileDescriptor_a0b2845f61092eb8 = []byte{ 0x08, 0x17, 0x6b, 0x49, 0x66, 0x49, 0x4e, 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x84, 0x23, 0xa4, 0xc0, 0xc5, 0x9d, 0x92, 0x5a, 0x9c, 0x5c, 0x94, 0x59, 0x50, 0x92, 0x99, 0x9f, 0x27, 0xc1, 0x04, 0x96, 0x43, 0x16, 0x12, 0xd2, 0xe2, 0x12, 0x00, 0x5b, 0x11, 0x94, 0x9a, 0x96, 0x5a, - 0x94, 0x9a, 0x97, 0x9c, 0xea, 0xe9, 0x22, 0xc1, 0x0c, 0x56, 0x86, 0x21, 0xee, 0xe4, 0x7c, 0xe2, + 0x94, 0x9a, 0x97, 0x9c, 0xea, 0xe9, 0x22, 0xc1, 0x0c, 0x56, 0x86, 0x21, 0xee, 0xe4, 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, 0x9a, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, - 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x58, 0xfc, 0x5a, 0x01, 0xf6, 0x6d, 0x49, 0x65, 0x41, 0x6a, 0x71, - 0x12, 0x1b, 0xd8, 0x7b, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7a, 0x59, 0x02, 0x40, 0x14, - 0x01, 0x00, 0x00, + 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0x3a, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, + 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x58, 0xfc, 0x5a, 0x66, 0xa4, 0x5f, 0x01, 0xf6, 0x70, 0x49, 0x65, + 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x87, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0c, 0xb9, + 0x70, 0x6c, 0x17, 0x01, 0x00, 0x00, } func (m *RemoveChainProposal) Marshal() (dAtA []byte, err error) { @@ -163,6 +171,7 @@ func encodeVarintRemoveChainProposal(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *RemoveChainProposal) Size() (n int) { if m == nil { return 0 @@ -187,9 +196,11 @@ func (m *RemoveChainProposal) Size() (n int) { func sovRemoveChainProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozRemoveChainProposal(x uint64) (n int) { return sovRemoveChainProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *RemoveChainProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -336,6 +347,7 @@ func (m *RemoveChainProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipRemoveChainProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/set_fee_mgr_proposal.pb.go b/x/evm/types/set_fee_mgr_proposal.pb.go index b977f4c8..b7394b50 100644 --- a/x/evm/types/set_fee_mgr_proposal.pb.go +++ b/x/evm/types/set_fee_mgr_proposal.pb.go @@ -107,7 +107,7 @@ func init() { } var fileDescriptor_b189b7cf6349646e = []byte{ - // 237 bytes of a gzipped FileDescriptorProto + // 240 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2c, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x53, 0xcb, 0x72, 0xf5, 0x8b, 0x53, 0x4b, 0xe2, 0xd3, 0x52, 0x53, 0xe3, 0x73, 0xd3, 0x8b, 0xe2, 0x0b, 0x8a, 0xf2, 0x0b, 0xf2, @@ -118,11 +118,11 @@ var fileDescriptor_b189b7cf6349646e = []byte{ 0x20, 0x1c, 0x21, 0x09, 0x2e, 0xf6, 0xe2, 0xd2, 0xdc, 0xdc, 0xc4, 0xa2, 0x4a, 0x09, 0x26, 0xb0, 0x38, 0x8c, 0x2b, 0xa4, 0xc5, 0x25, 0x00, 0xb6, 0x24, 0x28, 0x35, 0x2d, 0xb5, 0x28, 0x35, 0x2f, 0x39, 0xd5, 0xd3, 0x45, 0x82, 0x19, 0xac, 0x04, 0x43, 0x5c, 0x48, 0x87, 0x4b, 0x30, 0x0d, 0xdd, - 0x62, 0x09, 0x16, 0xb0, 0x62, 0x4c, 0x09, 0x27, 0xe7, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, + 0x62, 0x09, 0x16, 0xb0, 0x62, 0x4c, 0x09, 0x27, 0xb7, 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, 0xc7, - 0x12, 0x34, 0x15, 0xe0, 0xc0, 0x29, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x07, 0x87, 0x31, - 0x20, 0x00, 0x00, 0xff, 0xff, 0x8e, 0x34, 0x13, 0x01, 0x43, 0x01, 0x00, 0x00, + 0x96, 0x63, 0x88, 0xd2, 0x49, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0xc7, + 0x12, 0x34, 0x65, 0x46, 0xfa, 0x15, 0xe0, 0xf0, 0x29, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, + 0x87, 0x88, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x59, 0x57, 0x5e, 0x64, 0x46, 0x01, 0x00, 0x00, } func (m *SetFeeManagerAddressProposal) Marshal() (dAtA []byte, err error) { diff --git a/x/evm/types/set_smart_contract_deployers_proposal.pb.go b/x/evm/types/set_smart_contract_deployers_proposal.pb.go index c4bea235..1c8c64ea 100644 --- a/x/evm/types/set_smart_contract_deployers_proposal.pb.go +++ b/x/evm/types/set_smart_contract_deployers_proposal.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*SetSmartContractDeployersProposal) ProtoMessage() {} func (*SetSmartContractDeployersProposal) Descriptor() ([]byte, []int) { return fileDescriptor_98112a37abfe69b8, []int{0} } + func (m *SetSmartContractDeployersProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetSmartContractDeployersProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetSmartContractDeployersProposal.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *SetSmartContractDeployersProposal) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *SetSmartContractDeployersProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetSmartContractDeployersProposal.Merge(m, src) } + func (m *SetSmartContractDeployersProposal) XXX_Size() int { return m.Size() } + func (m *SetSmartContractDeployersProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetSmartContractDeployersProposal.DiscardUnknown(m) } @@ -91,6 +99,7 @@ type SetSmartContractDeployersProposal_Deployer struct { func (m *SetSmartContractDeployersProposal_Deployer) Reset() { *m = SetSmartContractDeployersProposal_Deployer{} } + func (m *SetSmartContractDeployersProposal_Deployer) String() string { return proto.CompactTextString(m) } @@ -98,9 +107,11 @@ func (*SetSmartContractDeployersProposal_Deployer) ProtoMessage() {} func (*SetSmartContractDeployersProposal_Deployer) Descriptor() ([]byte, []int) { return fileDescriptor_98112a37abfe69b8, []int{0, 0} } + func (m *SetSmartContractDeployersProposal_Deployer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetSmartContractDeployersProposal_Deployer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetSmartContractDeployersProposal_Deployer.Marshal(b, m, deterministic) @@ -113,12 +124,15 @@ func (m *SetSmartContractDeployersProposal_Deployer) XXX_Marshal(b []byte, deter return b[:n], nil } } + func (m *SetSmartContractDeployersProposal_Deployer) XXX_Merge(src proto.Message) { xxx_messageInfo_SetSmartContractDeployersProposal_Deployer.Merge(m, src) } + func (m *SetSmartContractDeployersProposal_Deployer) XXX_Size() int { return m.Size() } + func (m *SetSmartContractDeployersProposal_Deployer) XXX_DiscardUnknown() { xxx_messageInfo_SetSmartContractDeployersProposal_Deployer.DiscardUnknown(m) } @@ -149,26 +163,27 @@ func init() { } var fileDescriptor_98112a37abfe69b8 = []byte{ - // 301 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xbf, 0x4e, 0xc3, 0x30, - 0x10, 0xc6, 0x93, 0x96, 0x7f, 0x35, 0x03, 0xc8, 0xaa, 0x50, 0xd4, 0xc1, 0x14, 0xa6, 0xc2, 0xe0, - 0x48, 0xf0, 0x04, 0xa4, 0x5d, 0xd8, 0x50, 0xba, 0xb1, 0x04, 0x37, 0xb9, 0xa6, 0x91, 0xe2, 0xd8, - 0xb2, 0xdd, 0x8a, 0xbc, 0x05, 0x2f, 0xc0, 0xfb, 0x74, 0xec, 0xc8, 0x84, 0x50, 0xf2, 0x22, 0xa8, - 0xf9, 0x03, 0x08, 0x2a, 0xb1, 0x7d, 0xf7, 0xf9, 0xf4, 0xf3, 0x77, 0x77, 0xc8, 0x93, 0x2c, 0x15, - 0x9c, 0x85, 0x0b, 0x96, 0x64, 0x6e, 0xad, 0x5d, 0x58, 0x71, 0x57, 0x83, 0x09, 0x34, 0x67, 0xca, - 0x04, 0xa1, 0xc8, 0x8c, 0x62, 0xa1, 0x09, 0x22, 0x90, 0xa9, 0xc8, 0x41, 0xe9, 0x40, 0x2a, 0x21, - 0x85, 0x66, 0x29, 0x95, 0x4a, 0x18, 0x81, 0xcf, 0x7e, 0x30, 0x68, 0xad, 0x29, 0xac, 0xf8, 0xa0, - 0x1f, 0x8b, 0x58, 0x54, 0x2d, 0xee, 0x56, 0xd5, 0xdd, 0x97, 0xaf, 0x1d, 0x74, 0x31, 0x05, 0x33, - 0xdd, 0xc2, 0xc7, 0x0d, 0x7b, 0xd2, 0xa2, 0x1f, 0x1a, 0x32, 0xee, 0xa3, 0x7d, 0x93, 0x98, 0x14, - 0x1c, 0x7b, 0x68, 0x8f, 0x7a, 0x7e, 0x5d, 0x60, 0x07, 0x1d, 0xea, 0x25, 0xe7, 0x4c, 0xe5, 0x4e, - 0xa7, 0xf2, 0xdb, 0x12, 0xcf, 0x51, 0xef, 0x2b, 0x9f, 0xd3, 0x1d, 0x76, 0x47, 0xc7, 0x37, 0x1e, - 0xdd, 0x9d, 0x8b, 0xfe, 0xfb, 0x3b, 0x6d, 0x1d, 0x6f, 0x6f, 0xfd, 0x7e, 0x6e, 0xf9, 0xdf, 0xe8, - 0xc1, 0x13, 0x3a, 0x6a, 0x1f, 0xf1, 0x35, 0x3a, 0xad, 0xd8, 0x3e, 0xcc, 0x41, 0x41, 0x16, 0xc2, - 0xfd, 0xa4, 0x89, 0xfb, 0xc7, 0xc7, 0x23, 0x74, 0xd2, 0x2e, 0xf2, 0x2e, 0x8a, 0x14, 0x68, 0xdd, - 0x4c, 0xf0, 0xdb, 0xf6, 0xc6, 0xeb, 0x82, 0xd8, 0x9b, 0x82, 0xd8, 0x1f, 0x05, 0xb1, 0x5f, 0x4a, - 0x62, 0x6d, 0x4a, 0x62, 0xbd, 0x95, 0xc4, 0x7a, 0xbc, 0x8a, 0x13, 0xb3, 0x58, 0xce, 0x68, 0x28, - 0xb8, 0xbb, 0xe3, 0x6c, 0xcf, 0xd5, 0xe1, 0x4c, 0x2e, 0x41, 0xcf, 0x0e, 0xaa, 0x5d, 0xdf, 0x7e, - 0x06, 0x00, 0x00, 0xff, 0xff, 0xf7, 0xe6, 0x62, 0xea, 0xdf, 0x01, 0x00, 0x00, + // 305 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x2a, 0x48, 0xcc, 0xc9, + 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x53, 0xcb, 0x72, 0xf5, 0x8b, + 0x53, 0x4b, 0xe2, 0x8b, 0x73, 0x13, 0x8b, 0x4a, 0xe2, 0x93, 0xf3, 0xf3, 0x4a, 0x8a, 0x12, 0x93, + 0x4b, 0xe2, 0x53, 0x52, 0x0b, 0x72, 0xf2, 0x2b, 0x53, 0x8b, 0x8a, 0xe3, 0x0b, 0x8a, 0xf2, 0x0b, + 0xf2, 0x8b, 0x13, 0x73, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xc4, 0x90, 0xcc, 0xd0, 0x83, + 0xb0, 0xf5, 0x52, 0xcb, 0x72, 0xa5, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x4a, 0xf4, 0x41, 0x2c, + 0x88, 0x6a, 0xa5, 0xb9, 0x4c, 0x5c, 0x8a, 0xc1, 0xa9, 0x25, 0xc1, 0x20, 0xc3, 0x9d, 0xa1, 0x66, + 0xbb, 0xc0, 0x8c, 0x0e, 0x80, 0x9a, 0x2c, 0x24, 0xc2, 0xc5, 0x5a, 0x92, 0x59, 0x92, 0x93, 0x2a, + 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0xe1, 0x08, 0x49, 0x70, 0xb1, 0x17, 0x97, 0xe6, 0xe6, + 0x26, 0x16, 0x55, 0x4a, 0x30, 0x81, 0xc5, 0x61, 0x5c, 0xa1, 0x34, 0x2e, 0x4e, 0xb8, 0xfb, 0x24, + 0x98, 0x15, 0x98, 0x35, 0xb8, 0x8d, 0x9c, 0xf4, 0xb0, 0xbb, 0x4b, 0x8f, 0xa0, 0xed, 0x7a, 0x30, + 0x11, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0x10, 0x46, 0x4b, 0x25, 0x70, 0x71, 0xc0, 0x24, + 0x85, 0xb4, 0xb8, 0x04, 0xc0, 0x66, 0x07, 0xa5, 0xa6, 0xa5, 0x16, 0xa5, 0xe6, 0x25, 0xa7, 0x7a, + 0xba, 0x40, 0x9d, 0x8b, 0x21, 0x2e, 0xa4, 0xc1, 0xc5, 0x0f, 0x0b, 0x48, 0xc7, 0x94, 0x94, 0xa2, + 0xd4, 0xe2, 0x62, 0xa8, 0x0f, 0xd0, 0x85, 0x9d, 0xdc, 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, 0x27, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, + 0x4b, 0xb4, 0x95, 0x19, 0xe9, 0x57, 0x80, 0xe3, 0xae, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, + 0x1c, 0xdc, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xe2, 0x72, 0xab, 0xe2, 0x01, 0x00, + 0x00, } func (m *SetSmartContractDeployersProposal) Marshal() (dAtA []byte, err error) { @@ -270,6 +285,7 @@ func encodeVarintSetSmartContractDeployersProposal(dAtA []byte, offset int, v ui dAtA[offset] = uint8(v) return base } + func (m *SetSmartContractDeployersProposal) Size() (n int) { if m == nil { return 0 @@ -313,9 +329,11 @@ func (m *SetSmartContractDeployersProposal_Deployer) Size() (n int) { func sovSetSmartContractDeployersProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozSetSmartContractDeployersProposal(x uint64) (n int) { return sovSetSmartContractDeployersProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetSmartContractDeployersProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -464,6 +482,7 @@ func (m *SetSmartContractDeployersProposal) Unmarshal(dAtA []byte) error { } return nil } + func (m *SetSmartContractDeployersProposal_Deployer) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -578,6 +597,7 @@ func (m *SetSmartContractDeployersProposal_Deployer) Unmarshal(dAtA []byte) erro } return nil } + func skipSetSmartContractDeployersProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/treasury.pb.go b/x/evm/types/treasury.pb.go index abe10686..d760b28a 100644 --- a/x/evm/types/treasury.pb.go +++ b/x/evm/types/treasury.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -36,9 +39,11 @@ func (*FundCollectedEvent) ProtoMessage() {} func (*FundCollectedEvent) Descriptor() ([]byte, []int) { return fileDescriptor_a3d48b3c1757ff6c, []int{0} } + func (m *FundCollectedEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *FundCollectedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_FundCollectedEvent.Marshal(b, m, deterministic) @@ -51,12 +56,15 @@ func (m *FundCollectedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *FundCollectedEvent) XXX_Merge(src proto.Message) { xxx_messageInfo_FundCollectedEvent.Merge(m, src) } + func (m *FundCollectedEvent) XXX_Size() int { return m.Size() } + func (m *FundCollectedEvent) XXX_DiscardUnknown() { xxx_messageInfo_FundCollectedEvent.DiscardUnknown(m) } @@ -103,9 +111,11 @@ func (*CollectFunds) ProtoMessage() {} func (*CollectFunds) Descriptor() ([]byte, []int) { return fileDescriptor_a3d48b3c1757ff6c, []int{1} } + func (m *CollectFunds) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *CollectFunds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CollectFunds.Marshal(b, m, deterministic) @@ -118,12 +128,15 @@ func (m *CollectFunds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *CollectFunds) XXX_Merge(src proto.Message) { xxx_messageInfo_CollectFunds.Merge(m, src) } + func (m *CollectFunds) XXX_Size() int { return m.Size() } + func (m *CollectFunds) XXX_DiscardUnknown() { xxx_messageInfo_CollectFunds.DiscardUnknown(m) } @@ -161,25 +174,25 @@ func init() { } var fileDescriptor_a3d48b3c1757ff6c = []byte{ - // 281 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0xf3, 0x40, - 0x14, 0x85, 0x3b, 0xfd, 0xfb, 0x17, 0x1d, 0x15, 0x61, 0x28, 0x25, 0x74, 0x31, 0x94, 0xa2, 0x10, - 0x37, 0xc9, 0xc2, 0x37, 0x68, 0x55, 0x74, 0xdb, 0xa5, 0xbb, 0x49, 0x72, 0x4d, 0xa2, 0x99, 0xb9, - 0x21, 0x99, 0x04, 0xdb, 0xa7, 0xf0, 0xb1, 0x5c, 0x76, 0xe9, 0x52, 0x92, 0x17, 0x91, 0xcc, 0x04, - 0x89, 0xe2, 0xee, 0x9c, 0xc3, 0x77, 0xb9, 0x87, 0x43, 0x2f, 0x73, 0x91, 0xa1, 0x14, 0x61, 0x22, - 0x52, 0xe5, 0x5b, 0xed, 0x43, 0x2d, 0x7d, 0x5d, 0x80, 0x28, 0xab, 0x62, 0xe7, 0xe5, 0x05, 0x6a, - 0x64, 0xf3, 0x01, 0xe6, 0x59, 0xed, 0x41, 0x2d, 0x17, 0xb3, 0x18, 0x63, 0x34, 0x88, 0xdf, 0x29, - 0x4b, 0xaf, 0xf6, 0x94, 0xdd, 0x55, 0x2a, 0xda, 0x60, 0x96, 0x41, 0xa8, 0x21, 0xba, 0xad, 0x41, - 0x69, 0x36, 0xa3, 0xff, 0x9f, 0x31, 0x78, 0xb8, 0x71, 0xc8, 0x92, 0xb8, 0xc7, 0x5b, 0x6b, 0xd8, - 0x9c, 0x4e, 0x85, 0xc4, 0x4a, 0x69, 0x67, 0x6c, 0xe2, 0xde, 0x75, 0x74, 0x04, 0x0a, 0xa5, 0xf3, - 0xcf, 0xd2, 0xc6, 0xb0, 0x25, 0x3d, 0x09, 0x32, 0x0c, 0x5f, 0xee, 0x21, 0x8d, 0x13, 0xed, 0x4c, - 0x96, 0xc4, 0x9d, 0x6c, 0x87, 0xd1, 0x6a, 0x4f, 0x4f, 0xfb, 0xbf, 0x5d, 0x85, 0x92, 0xb9, 0xf4, - 0xfc, 0xa9, 0x40, 0xb9, 0x1e, 0x5c, 0x11, 0x73, 0xf5, 0x3b, 0x66, 0x17, 0xf4, 0x4c, 0xe3, 0x90, - 0x1b, 0x1b, 0xee, 0x67, 0xc8, 0x16, 0xf4, 0x48, 0x94, 0x65, 0x1a, 0x2b, 0x80, 0xbe, 0xda, 0xb7, - 0x5f, 0x6f, 0xde, 0x1b, 0x4e, 0x0e, 0x0d, 0x27, 0x9f, 0x0d, 0x27, 0x6f, 0x2d, 0x1f, 0x1d, 0x5a, - 0x3e, 0xfa, 0x68, 0xf9, 0xe8, 0xf1, 0x2a, 0x4e, 0x75, 0x52, 0x05, 0x5e, 0x88, 0xd2, 0xff, 0x63, - 0xf1, 0x57, 0xbb, 0xf9, 0x2e, 0x87, 0x32, 0x98, 0x9a, 0x0d, 0xaf, 0xbf, 0x02, 0x00, 0x00, 0xff, - 0xff, 0x53, 0x1b, 0xab, 0x8a, 0x9a, 0x01, 0x00, 0x00, + // 282 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0xc3, 0x40, + 0x18, 0x84, 0xbb, 0xb5, 0x16, 0x5d, 0x15, 0x61, 0x29, 0x25, 0xf4, 0xb0, 0x84, 0xa2, 0x90, 0x83, + 0x64, 0x41, 0xdf, 0xa0, 0x6a, 0xd1, 0x6b, 0x8f, 0xde, 0x36, 0xc9, 0x9a, 0x44, 0xb3, 0xfb, 0x87, + 0x64, 0x13, 0x6c, 0x9f, 0xc2, 0xc7, 0xf2, 0xd8, 0xa3, 0x47, 0x49, 0x5e, 0x44, 0xb2, 0x1b, 0x24, + 0x8a, 0xb7, 0x99, 0xe1, 0xfb, 0xf9, 0x87, 0xc1, 0x97, 0x39, 0xcf, 0x40, 0xf2, 0x30, 0xe1, 0xa9, + 0x62, 0x56, 0x33, 0x51, 0x4b, 0xa6, 0x0b, 0xc1, 0xcb, 0xaa, 0xd8, 0xfa, 0x79, 0x01, 0x1a, 0xc8, + 0x7c, 0x80, 0xf9, 0x56, 0xfb, 0xa2, 0x96, 0x8b, 0x59, 0x0c, 0x31, 0x18, 0x84, 0x75, 0xca, 0xd2, + 0xcb, 0x1d, 0x26, 0xeb, 0x4a, 0x45, 0xb7, 0x90, 0x65, 0x22, 0xd4, 0x22, 0xba, 0xaf, 0x85, 0xd2, + 0x64, 0x86, 0x0f, 0x5f, 0x20, 0x78, 0xbc, 0x73, 0x90, 0x8b, 0xbc, 0xe3, 0x8d, 0x35, 0x64, 0x8e, + 0xa7, 0x5c, 0x42, 0xa5, 0xb4, 0x33, 0x36, 0x71, 0xef, 0x3a, 0x3a, 0x12, 0x0a, 0xa4, 0x73, 0x60, + 0x69, 0x63, 0x88, 0x8b, 0x4f, 0x82, 0x0c, 0xc2, 0xd7, 0x07, 0x91, 0xc6, 0x89, 0x76, 0x26, 0x2e, + 0xf2, 0x26, 0x9b, 0x61, 0xb4, 0xdc, 0xe1, 0xd3, 0xfe, 0x6f, 0x57, 0xa1, 0x24, 0x1e, 0x3e, 0x7f, + 0x2e, 0x40, 0xae, 0x06, 0x57, 0xc8, 0x5c, 0xfd, 0x8d, 0xc9, 0x05, 0x3e, 0xd3, 0x30, 0xe4, 0xc6, + 0x86, 0xfb, 0x1d, 0x92, 0x05, 0x3e, 0xe2, 0x65, 0x99, 0xc6, 0x4a, 0x88, 0xbe, 0xda, 0x8f, 0x5f, + 0xad, 0x3f, 0x1a, 0x8a, 0xf6, 0x0d, 0x45, 0x5f, 0x0d, 0x45, 0xef, 0x2d, 0x1d, 0xed, 0x5b, 0x3a, + 0xfa, 0x6c, 0xe9, 0xe8, 0xe9, 0x2a, 0x4e, 0x75, 0x52, 0x05, 0x7e, 0x08, 0x92, 0xfd, 0xb3, 0x78, + 0x7d, 0xcd, 0xde, 0xec, 0xec, 0xdb, 0x5c, 0x94, 0xc1, 0xd4, 0xcc, 0x78, 0xf3, 0x1d, 0x00, 0x00, + 0xff, 0xff, 0x62, 0xf2, 0xa9, 0x36, 0x9d, 0x01, 0x00, 0x00, } func (m *FundCollectedEvent) Marshal() (dAtA []byte, err error) { @@ -282,6 +295,7 @@ func encodeVarintTreasury(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *FundCollectedEvent) Size() (n int) { if m == nil { return 0 @@ -328,9 +342,11 @@ func (m *CollectFunds) Size() (n int) { func sovTreasury(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozTreasury(x uint64) (n int) { return sovTreasury(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *FundCollectedEvent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -496,6 +512,7 @@ func (m *FundCollectedEvent) Unmarshal(dAtA []byte) error { } return nil } + func (m *CollectFunds) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -616,6 +633,7 @@ func (m *CollectFunds) Unmarshal(dAtA []byte) error { } return nil } + func skipTreasury(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/turnstone.pb.go b/x/evm/types/turnstone.pb.go index a9281252..14384263 100644 --- a/x/evm/types/turnstone.pb.go +++ b/x/evm/types/turnstone.pb.go @@ -979,75 +979,76 @@ func init() { } var fileDescriptor_86cc126a804337fd = []byte{ - // 1086 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x41, 0x6f, 0x1b, 0x45, - 0x14, 0xf6, 0xda, 0xae, 0x63, 0x8f, 0x5d, 0xdc, 0x6e, 0x49, 0xba, 0x44, 0xc8, 0xb5, 0xac, 0x0a, - 0x4c, 0x11, 0xeb, 0xca, 0xa0, 0x72, 0xe2, 0x90, 0xa4, 0x89, 0x9c, 0x8a, 0x0a, 0x34, 0x69, 0x2a, - 0x04, 0x48, 0xd1, 0x78, 0xf7, 0xd9, 0x1e, 0x65, 0x77, 0x67, 0x99, 0x99, 0x4d, 0x62, 0xae, 0xfc, - 0x01, 0xae, 0x5c, 0x91, 0x90, 0x38, 0x72, 0xe0, 0x47, 0xf4, 0x58, 0x71, 0x42, 0x1c, 0x2a, 0x94, - 0x1c, 0x10, 0xff, 0x02, 0xcd, 0xec, 0xda, 0xdd, 0x5d, 0xaf, 0x4b, 0x7b, 0x59, 0xcd, 0xfb, 0xe6, - 0xcd, 0x9b, 0x37, 0x6f, 0xbe, 0xef, 0xed, 0xa0, 0xf7, 0x42, 0xe2, 0x31, 0x9f, 0x38, 0x33, 0x42, - 0x83, 0x41, 0x3c, 0x1e, 0xc0, 0x99, 0x3f, 0x90, 0x11, 0x0f, 0x84, 0x64, 0x01, 0xd8, 0x21, 0x67, - 0x92, 0x99, 0x5b, 0x29, 0x3f, 0x3b, 0x1e, 0xdb, 0x70, 0xe6, 0x6f, 0xbf, 0x3d, 0x65, 0x53, 0xa6, - 0x5d, 0x06, 0x6a, 0x14, 0x7b, 0x6f, 0xbf, 0xe3, 0x30, 0xe1, 0x33, 0x71, 0x12, 0x4f, 0xc4, 0x46, - 0x32, 0x75, 0x93, 0xf8, 0x34, 0x60, 0x03, 0xfd, 0x8d, 0xa1, 0xde, 0xb7, 0xa8, 0xf6, 0x94, 0x78, - 0x02, 0xa4, 0xd9, 0x41, 0xe8, 0x8c, 0x78, 0xd4, 0x25, 0x92, 0x71, 0x61, 0x19, 0xdd, 0x4a, 0xbf, - 0x81, 0x53, 0x88, 0xb9, 0x85, 0x6a, 0x21, 0x3b, 0x07, 0x2e, 0xac, 0x72, 0xb7, 0xd2, 0xaf, 0xe2, - 0xc4, 0x32, 0xb7, 0x51, 0xfd, 0x4c, 0x47, 0x38, 0x7c, 0x68, 0x55, 0xba, 0x46, 0xbf, 0x8a, 0x97, - 0x76, 0xcf, 0x43, 0xd5, 0x03, 0x00, 0xa1, 0x62, 0x73, 0xf0, 0xc8, 0x1c, 0xf8, 0x01, 0x80, 0x65, - 0x68, 0xaf, 0x14, 0x62, 0xf6, 0x50, 0xcb, 0x61, 0xbe, 0x1f, 0x05, 0x54, 0xce, 0x95, 0x47, 0x59, - 0x7b, 0x64, 0x30, 0xb3, 0x8b, 0x9a, 0x02, 0x9c, 0x88, 0x27, 0x2e, 0xf1, 0x56, 0x69, 0xa8, 0xf7, - 0x6f, 0x05, 0xb5, 0x8f, 0xa2, 0xb1, 0x4f, 0xe5, 0xe7, 0x6c, 0x4a, 0x9d, 0x3d, 0xe2, 0x79, 0xa6, - 0x8d, 0xcc, 0x19, 0x5c, 0xec, 0xb1, 0x40, 0x72, 0xe2, 0xc8, 0x1d, 0xd7, 0xe5, 0x20, 0x84, 0xce, - 0xa0, 0x81, 0x0b, 0x66, 0xcc, 0x1b, 0xa8, 0x42, 0xc6, 0x54, 0x27, 0xd0, 0xc2, 0x6a, 0x68, 0x5a, - 0x68, 0x23, 0x24, 0x73, 0x8f, 0x11, 0x57, 0xef, 0xd9, 0xc2, 0x0b, 0x53, 0x9d, 0xdc, 0x05, 0xe2, - 0x7a, 0x34, 0x00, 0xab, 0xda, 0x35, 0xfa, 0x15, 0xbc, 0xb4, 0xcd, 0xbb, 0xe8, 0xba, 0x80, 0xc0, - 0x05, 0xbe, 0xd8, 0xf2, 0x9a, 0x5e, 0x9b, 0x05, 0xcd, 0x3e, 0x6a, 0x3b, 0xb9, 0xd4, 0x6a, 0xda, - 0x2f, 0x0f, 0x9b, 0x73, 0xb4, 0x09, 0x17, 0xe0, 0x44, 0x92, 0xb2, 0x00, 0xc3, 0x77, 0x11, 0xe5, - 0xe0, 0x43, 0x20, 0x85, 0xb5, 0xd1, 0x35, 0xfa, 0xcd, 0xe1, 0x67, 0x76, 0x31, 0x47, 0xec, 0x5c, - 0x3d, 0xec, 0xfd, 0xa2, 0x20, 0xbb, 0xd5, 0x67, 0x2f, 0xee, 0x94, 0x70, 0xf1, 0x0e, 0xaa, 0x00, - 0x1c, 0x24, 0xa7, 0x20, 0xac, 0x7a, 0xd7, 0xe8, 0x5f, 0xc7, 0x0b, 0xd3, 0x7c, 0x80, 0xaa, 0x13, - 0x00, 0x61, 0x21, 0x9d, 0xc3, 0xbb, 0xeb, 0x72, 0x50, 0x14, 0xd0, 0x5b, 0x18, 0x58, 0xfb, 0x6f, - 0xef, 0xa0, 0xcd, 0xc2, 0x3c, 0x54, 0x3d, 0x20, 0x98, 0x30, 0xee, 0xc0, 0xe3, 0xfd, 0xa7, 0x58, - 0xf1, 0x43, 0x5f, 0x55, 0x1d, 0xe7, 0xe1, 0xde, 0x01, 0x6a, 0x1d, 0x87, 0x2e, 0x91, 0x90, 0xb0, - 0xf7, 0x01, 0xaa, 0xc5, 0xac, 0xd3, 0x0b, 0x9a, 0xc3, 0xce, 0xba, 0x64, 0x62, 0x7f, 0x9c, 0x78, - 0xf7, 0x7e, 0x28, 0xa3, 0xf6, 0x1e, 0xf3, 0x43, 0x22, 0xc4, 0x88, 0x04, 0x2e, 0x3b, 0x03, 0x6e, - 0x4e, 0x51, 0x7b, 0xc2, 0xf8, 0x39, 0xe1, 0xae, 0x2a, 0xd9, 0x0e, 0x9f, 0xc6, 0x72, 0x68, 0x0e, - 0x3f, 0x5d, 0x17, 0x34, 0x17, 0xc1, 0x3e, 0xc8, 0x2e, 0x4f, 0xea, 0x9b, 0x8f, 0x9a, 0x21, 0x50, - 0x39, 0x47, 0xa0, 0xb7, 0x50, 0x99, 0xba, 0x09, 0xcb, 0xcb, 0xd4, 0xdd, 0xfe, 0x06, 0xb5, 0x73, - 0x51, 0xdf, 0x98, 0xdb, 0x29, 0x26, 0x97, 0x33, 0x4c, 0xee, 0xfd, 0x64, 0xa0, 0x5b, 0xc7, 0xa1, - 0x1a, 0x1e, 0xf9, 0x84, 0xcb, 0xc5, 0x42, 0x95, 0xe0, 0x78, 0x2e, 0xc1, 0x61, 0x6e, 0xac, 0xda, - 0x16, 0x5e, 0xda, 0x69, 0xa5, 0x34, 0x62, 0xa5, 0xdc, 0x43, 0x37, 0x1c, 0x16, 0x08, 0xc9, 0x23, - 0x47, 0x32, 0x7e, 0x18, 0x84, 0x91, 0x4c, 0x24, 0xb3, 0x82, 0x27, 0xc7, 0xab, 0x2e, 0x8e, 0x97, - 0x26, 0xd9, 0xb5, 0x0c, 0xc9, 0x7a, 0xbf, 0x94, 0xd1, 0xed, 0x38, 0xb7, 0x63, 0x01, 0xfc, 0xf5, - 0xf3, 0xeb, 0xa3, 0xb6, 0x0b, 0xa1, 0xc7, 0xe6, 0x2f, 0x35, 0x18, 0xe7, 0x9a, 0x87, 0x33, 0xd7, - 0x50, 0xf9, 0x3f, 0x1d, 0x57, 0x8b, 0x74, 0xdc, 0x45, 0xcd, 0xb1, 0xc7, 0x9c, 0xd3, 0x11, 0xd0, - 0xe9, 0x4c, 0xea, 0x13, 0x54, 0x70, 0x1a, 0x4a, 0xce, 0x5b, 0x2b, 0x3a, 0xef, 0x46, 0xb1, 0xa8, - 0xea, 0x6f, 0x26, 0xaa, 0xde, 0xcf, 0x35, 0xb4, 0xf1, 0x18, 0x84, 0x20, 0x53, 0xdd, 0x2b, 0x97, - 0x3f, 0x91, 0xc3, 0x87, 0x09, 0x25, 0xd2, 0x90, 0xbe, 0x2b, 0x15, 0x12, 0xc3, 0x04, 0x38, 0x04, - 0x8e, 0x72, 0x8b, 0xcb, 0xb3, 0x82, 0x9b, 0x47, 0xa8, 0x2d, 0xb2, 0x6d, 0x44, 0x97, 0xa9, 0x39, - 0x7c, 0xff, 0x35, 0xbb, 0xce, 0xa8, 0x84, 0xf3, 0x11, 0xcc, 0x47, 0xa8, 0x15, 0xa5, 0x04, 0xac, - 0xeb, 0xda, 0x1c, 0xde, 0x5d, 0x17, 0x31, 0x2d, 0xf6, 0x51, 0x09, 0x67, 0xd6, 0x9a, 0x27, 0xe8, - 0x56, 0xb4, 0xca, 0x5e, 0x7d, 0x0d, 0xcd, 0xe1, 0x87, 0xeb, 0x43, 0xae, 0x2c, 0x19, 0x95, 0x70, - 0x51, 0x24, 0xf3, 0x14, 0xdd, 0x8e, 0x8a, 0x29, 0x68, 0x35, 0xf5, 0x26, 0x83, 0x57, 0x6f, 0xb2, - 0xb2, 0x6c, 0x54, 0xc2, 0xeb, 0x22, 0xaa, 0x72, 0x3b, 0xd9, 0x7e, 0x62, 0xb5, 0x5e, 0x5d, 0xee, - 0x5c, 0xfb, 0x51, 0xe5, 0xce, 0x45, 0x50, 0x8c, 0x48, 0x20, 0xc5, 0x59, 0x4d, 0xc4, 0x06, 0x4e, - 0x43, 0x4a, 0x05, 0x44, 0x08, 0x3a, 0x0d, 0x00, 0x34, 0x25, 0x1b, 0x78, 0x69, 0x9b, 0x14, 0x59, - 0xc9, 0xd8, 0x3d, 0x21, 0xf2, 0x44, 0x13, 0xfb, 0x64, 0x16, 0x93, 0xbd, 0xa1, 0x7c, 0x77, 0xef, - 0xab, 0x0e, 0xf7, 0xd7, 0x8b, 0x3b, 0x9b, 0xf1, 0x83, 0x43, 0xb8, 0xa7, 0x36, 0x65, 0x03, 0x9f, - 0xc8, 0x99, 0x7d, 0x18, 0xc8, 0x3f, 0x7e, 0xff, 0x08, 0x25, 0x2f, 0x91, 0xc3, 0x40, 0xfe, 0xfa, - 0xcf, 0x6f, 0xf7, 0x0c, 0xbc, 0xb9, 0x88, 0xb8, 0x23, 0x77, 0x53, 0x42, 0xf9, 0x04, 0x2d, 0x26, - 0x00, 0x83, 0xcf, 0x24, 0x2c, 0x84, 0x87, 0x74, 0x4e, 0xc5, 0x93, 0xbb, 0x75, 0x54, 0x23, 0x8e, - 0xfa, 0x9d, 0x3c, 0xaa, 0xd6, 0xeb, 0x37, 0x1a, 0x78, 0x4b, 0x72, 0x12, 0x88, 0x09, 0xf0, 0x7d, - 0xbc, 0x37, 0xbc, 0xff, 0xc5, 0x79, 0x00, 0x5c, 0xcc, 0x68, 0xd8, 0xa3, 0xa8, 0xfd, 0xe4, 0x22, - 0xfe, 0xf7, 0x80, 0xfb, 0x25, 0x67, 0x6c, 0xa2, 0xde, 0x1e, 0x02, 0x38, 0x25, 0x1e, 0xfd, 0x1e, - 0xdc, 0x27, 0x5f, 0x25, 0x7d, 0x24, 0x83, 0x99, 0x43, 0x74, 0xf3, 0xa5, 0x8d, 0xc1, 0x01, 0x1a, - 0xca, 0xb8, 0x87, 0x26, 0x12, 0x5c, 0x9d, 0xee, 0x1d, 0xa0, 0x6e, 0xe6, 0x5e, 0x97, 0x7f, 0xbc, - 0x7d, 0xce, 0x19, 0x5f, 0xee, 0x0d, 0xca, 0x4a, 0x74, 0x9b, 0x08, 0x35, 0x83, 0xed, 0xee, 0x3d, - 0xbb, 0xec, 0x18, 0xcf, 0x2f, 0x3b, 0xc6, 0xdf, 0x97, 0x1d, 0xe3, 0xc7, 0xab, 0x4e, 0xe9, 0xf9, - 0x55, 0xa7, 0xf4, 0xe7, 0x55, 0xa7, 0xf4, 0xf5, 0x07, 0x53, 0x2a, 0x67, 0xd1, 0xd8, 0x76, 0x98, - 0x3f, 0x28, 0x78, 0x4a, 0x5e, 0xc4, 0x8f, 0xc9, 0x79, 0x08, 0x62, 0x5c, 0xd3, 0xaf, 0xbd, 0x8f, - 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xa2, 0x79, 0xe5, 0x92, 0x73, 0x0a, 0x00, 0x00, + // 1089 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x41, 0x8f, 0xdb, 0x44, + 0x14, 0x8e, 0x93, 0x34, 0x9b, 0x4c, 0x52, 0xd2, 0xba, 0xec, 0xd6, 0xac, 0x50, 0x1a, 0x45, 0x15, + 0x44, 0x05, 0x92, 0x2a, 0xa0, 0x72, 0xe2, 0xb0, 0xbb, 0xdd, 0x28, 0x5b, 0x51, 0x81, 0x66, 0xbb, + 0x15, 0x02, 0xa4, 0xd5, 0xc4, 0x7e, 0x49, 0x46, 0x6b, 0x7b, 0xcc, 0xcc, 0x38, 0xbb, 0xe1, 0xca, + 0x1f, 0xe0, 0xca, 0x15, 0x09, 0x89, 0x23, 0x07, 0x7e, 0x44, 0x8f, 0x15, 0x27, 0xc4, 0xa1, 0x42, + 0xbb, 0x07, 0xc4, 0xbf, 0x40, 0x33, 0x76, 0x52, 0xdb, 0x71, 0x4a, 0x7b, 0xb1, 0xe6, 0x7d, 0xf3, + 0xe6, 0xcd, 0x9b, 0x37, 0xdf, 0xf7, 0x3c, 0xe8, 0xbd, 0x80, 0xb8, 0xcc, 0x23, 0xf6, 0x8c, 0x50, + 0xbf, 0x1f, 0x8d, 0xfb, 0x30, 0xf7, 0xfa, 0x32, 0xe4, 0xbe, 0x90, 0xcc, 0x87, 0x5e, 0xc0, 0x99, + 0x64, 0xe6, 0x4e, 0xc2, 0xaf, 0x17, 0x8d, 0x7b, 0x30, 0xf7, 0x76, 0xdf, 0x9e, 0xb2, 0x29, 0xd3, + 0x2e, 0x7d, 0x35, 0x8a, 0xbc, 0x77, 0xdf, 0xb1, 0x99, 0xf0, 0x98, 0x38, 0x8d, 0x26, 0x22, 0x23, + 0x9e, 0xba, 0x49, 0x3c, 0xea, 0xb3, 0xbe, 0xfe, 0x46, 0x50, 0xe7, 0x5b, 0x54, 0x79, 0x4a, 0x5c, + 0x01, 0xd2, 0x6c, 0x21, 0x34, 0x27, 0x2e, 0x75, 0x88, 0x64, 0x5c, 0x58, 0x46, 0xbb, 0xd4, 0xad, + 0xe1, 0x04, 0x62, 0xee, 0xa0, 0x4a, 0xc0, 0xce, 0x81, 0x0b, 0xab, 0xd8, 0x2e, 0x75, 0xcb, 0x38, + 0xb6, 0xcc, 0x5d, 0x54, 0x9d, 0xeb, 0x08, 0x47, 0x0f, 0xad, 0x52, 0xdb, 0xe8, 0x96, 0xf1, 0xca, + 0xee, 0xb8, 0xa8, 0x3c, 0x04, 0x10, 0x2a, 0x36, 0x07, 0x97, 0x2c, 0x80, 0x0f, 0x01, 0x2c, 0x43, + 0x7b, 0x25, 0x10, 0xb3, 0x83, 0x1a, 0x36, 0xf3, 0xbc, 0xd0, 0xa7, 0x72, 0xa1, 0x3c, 0x8a, 0xda, + 0x23, 0x85, 0x99, 0x6d, 0x54, 0x17, 0x60, 0x87, 0x3c, 0x76, 0x89, 0xb6, 0x4a, 0x42, 0x9d, 0x7f, + 0x4b, 0xa8, 0x79, 0x1c, 0x8e, 0x3d, 0x2a, 0x3f, 0x67, 0x53, 0x6a, 0x1f, 0x10, 0xd7, 0x35, 0x7b, + 0xc8, 0x9c, 0xc1, 0xc5, 0x01, 0xf3, 0x25, 0x27, 0xb6, 0xdc, 0x73, 0x1c, 0x0e, 0x42, 0xe8, 0x0c, + 0x6a, 0x38, 0x67, 0xc6, 0xbc, 0x81, 0x4a, 0x64, 0x4c, 0x75, 0x02, 0x0d, 0xac, 0x86, 0xa6, 0x85, + 0xb6, 0x02, 0xb2, 0x70, 0x19, 0x71, 0xf4, 0x9e, 0x0d, 0xbc, 0x34, 0xd5, 0xc9, 0x1d, 0x20, 0x8e, + 0x4b, 0x7d, 0xb0, 0xca, 0x6d, 0xa3, 0x5b, 0xc2, 0x2b, 0xdb, 0xbc, 0x8b, 0xae, 0x0b, 0xf0, 0x1d, + 0xe0, 0xcb, 0x2d, 0xaf, 0xe9, 0xb5, 0x69, 0xd0, 0xec, 0xa2, 0xa6, 0x9d, 0x49, 0xad, 0xa2, 0xfd, + 0xb2, 0xb0, 0xb9, 0x40, 0xdb, 0x70, 0x01, 0x76, 0x28, 0x29, 0xf3, 0x31, 0x7c, 0x17, 0x52, 0x0e, + 0x1e, 0xf8, 0x52, 0x58, 0x5b, 0x6d, 0xa3, 0x5b, 0x1f, 0x7c, 0xd6, 0xcb, 0xe7, 0x48, 0x2f, 0x53, + 0x8f, 0xde, 0x61, 0x5e, 0x90, 0xfd, 0xf2, 0xb3, 0x17, 0x77, 0x0a, 0x38, 0x7f, 0x07, 0x55, 0x00, + 0x0e, 0x92, 0x53, 0x10, 0x56, 0xb5, 0x6d, 0x74, 0xaf, 0xe3, 0xa5, 0x69, 0x3e, 0x40, 0xe5, 0x09, + 0x80, 0xb0, 0x90, 0xce, 0xe1, 0xdd, 0x4d, 0x39, 0x28, 0x0a, 0xe8, 0x2d, 0x0c, 0xac, 0xfd, 0x77, + 0xf7, 0xd0, 0x76, 0x6e, 0x1e, 0xaa, 0x1e, 0xe0, 0x4f, 0x18, 0xb7, 0xe1, 0xf1, 0xe1, 0x53, 0xac, + 0xf8, 0xa1, 0xaf, 0xaa, 0x8a, 0xb3, 0x70, 0x67, 0x88, 0x1a, 0x27, 0x81, 0x43, 0x24, 0xc4, 0xec, + 0x7d, 0x80, 0x2a, 0x11, 0xeb, 0xf4, 0x82, 0xfa, 0xa0, 0xb5, 0x29, 0x99, 0xc8, 0x1f, 0xc7, 0xde, + 0x9d, 0x1f, 0x8a, 0xa8, 0x79, 0xc0, 0xbc, 0x80, 0x08, 0x31, 0x22, 0xbe, 0xc3, 0xe6, 0xc0, 0xcd, + 0x29, 0x6a, 0x4e, 0x18, 0x3f, 0x27, 0xdc, 0x51, 0x25, 0xdb, 0xe3, 0xd3, 0x48, 0x0e, 0xf5, 0xc1, + 0xa7, 0x9b, 0x82, 0x66, 0x22, 0xf4, 0x86, 0xe9, 0xe5, 0x71, 0x7d, 0xb3, 0x51, 0x53, 0x04, 0x2a, + 0x66, 0x08, 0xf4, 0x16, 0x2a, 0x52, 0x27, 0x66, 0x79, 0x91, 0x3a, 0xbb, 0xdf, 0xa0, 0x66, 0x26, + 0xea, 0x1b, 0x73, 0x3b, 0xc1, 0xe4, 0x62, 0x8a, 0xc9, 0x9d, 0x9f, 0x0c, 0x74, 0xeb, 0x24, 0x50, + 0xc3, 0x63, 0x8f, 0x70, 0xb9, 0x5c, 0xa8, 0x12, 0x1c, 0x2f, 0x24, 0xd8, 0xcc, 0x89, 0x54, 0xdb, + 0xc0, 0x2b, 0x3b, 0xa9, 0x94, 0x5a, 0xa4, 0x94, 0x7b, 0xe8, 0x86, 0xcd, 0x7c, 0x21, 0x79, 0x68, + 0x4b, 0xc6, 0x8f, 0xfc, 0x20, 0x94, 0xb1, 0x64, 0xd6, 0xf0, 0xf8, 0x78, 0xe5, 0xe5, 0xf1, 0x92, + 0x24, 0xbb, 0x96, 0x22, 0x59, 0xe7, 0x97, 0x22, 0xba, 0x1d, 0xe5, 0x76, 0x22, 0x80, 0xbf, 0x7e, + 0x7e, 0x5d, 0xd4, 0x74, 0x20, 0x70, 0xd9, 0xe2, 0xa5, 0x06, 0xa3, 0x5c, 0xb3, 0x70, 0xea, 0x1a, + 0x4a, 0xff, 0xa7, 0xe3, 0x72, 0x9e, 0x8e, 0xdb, 0xa8, 0x3e, 0x76, 0x99, 0x7d, 0x36, 0x02, 0x3a, + 0x9d, 0x49, 0x7d, 0x82, 0x12, 0x4e, 0x42, 0xf1, 0x79, 0x2b, 0x79, 0xe7, 0xdd, 0xca, 0x17, 0x55, + 0xf5, 0xcd, 0x44, 0xd5, 0xf9, 0xb9, 0x82, 0xb6, 0x1e, 0x83, 0x10, 0x64, 0xaa, 0x7b, 0xe5, 0xea, + 0x27, 0x72, 0xf4, 0x30, 0xa6, 0x44, 0x12, 0xd2, 0x77, 0xa5, 0x42, 0x62, 0x98, 0x00, 0x07, 0xdf, + 0x56, 0x6e, 0x51, 0x79, 0xd6, 0x70, 0xf3, 0x18, 0x35, 0x45, 0xba, 0x8d, 0xe8, 0x32, 0xd5, 0x07, + 0xef, 0xbf, 0x66, 0xd7, 0x19, 0x15, 0x70, 0x36, 0x82, 0xf9, 0x08, 0x35, 0xc2, 0x84, 0x80, 0x75, + 0x5d, 0xeb, 0x83, 0xbb, 0x9b, 0x22, 0x26, 0xc5, 0x3e, 0x2a, 0xe0, 0xd4, 0x5a, 0xf3, 0x14, 0xdd, + 0x0a, 0xd7, 0xd9, 0xab, 0xaf, 0xa1, 0x3e, 0xf8, 0x60, 0x73, 0xc8, 0xb5, 0x25, 0xa3, 0x02, 0xce, + 0x8b, 0x64, 0x9e, 0xa1, 0xdb, 0x61, 0x3e, 0x05, 0xad, 0xba, 0xde, 0xa4, 0xff, 0xea, 0x4d, 0xd6, + 0x96, 0x8d, 0x0a, 0x78, 0x53, 0x44, 0x55, 0x6e, 0x3b, 0xdd, 0x4f, 0xac, 0xc6, 0xab, 0xcb, 0x9d, + 0x69, 0x3f, 0xaa, 0xdc, 0x99, 0x08, 0x8a, 0x11, 0x31, 0xa4, 0x38, 0xab, 0x89, 0x58, 0xc3, 0x49, + 0x48, 0xa9, 0x80, 0x08, 0x41, 0xa7, 0x3e, 0x80, 0xa6, 0x64, 0x0d, 0xaf, 0x6c, 0x93, 0x22, 0x2b, + 0x1e, 0x3b, 0xa7, 0x44, 0x9e, 0x6a, 0x62, 0x9f, 0xce, 0x22, 0xb2, 0xd7, 0x94, 0xef, 0xfe, 0x7d, + 0xd5, 0xe1, 0xfe, 0x7a, 0x71, 0x67, 0x3b, 0x7a, 0x70, 0x08, 0xe7, 0xac, 0x47, 0x59, 0xdf, 0x23, + 0x72, 0xd6, 0x3b, 0xf2, 0xe5, 0x1f, 0xbf, 0x7f, 0x84, 0xe2, 0x97, 0xc8, 0x91, 0x2f, 0x7f, 0xfd, + 0xe7, 0xb7, 0x7b, 0x06, 0xde, 0x5e, 0x46, 0xdc, 0x93, 0xfb, 0x09, 0xa1, 0x7c, 0x82, 0x96, 0x13, + 0x80, 0xc1, 0x63, 0x12, 0x96, 0xc2, 0x43, 0x3a, 0xa7, 0xfc, 0xc9, 0xfd, 0x2a, 0xaa, 0x10, 0x5b, + 0xfd, 0x4e, 0x1e, 0x95, 0xab, 0xd5, 0x1b, 0x35, 0xbc, 0x23, 0x39, 0xf1, 0xc5, 0x04, 0xf8, 0x21, + 0x3e, 0x18, 0xdc, 0xff, 0xe2, 0xdc, 0x07, 0x2e, 0x66, 0x34, 0xe8, 0x50, 0xd4, 0x7c, 0x72, 0x11, + 0xfd, 0x7b, 0xc0, 0xf9, 0x92, 0x33, 0x36, 0x51, 0x6f, 0x0f, 0x01, 0x9c, 0x12, 0x97, 0x7e, 0x0f, + 0xce, 0x93, 0xaf, 0xe2, 0x3e, 0x92, 0xc2, 0xcc, 0x01, 0xba, 0xf9, 0xd2, 0xc6, 0x60, 0x03, 0x0d, + 0x64, 0xd4, 0x43, 0x63, 0x09, 0xae, 0x4f, 0x77, 0x86, 0xa8, 0x9d, 0xba, 0xd7, 0xd5, 0x1f, 0xef, + 0x90, 0x73, 0xc6, 0x57, 0x7b, 0x83, 0xb2, 0x62, 0xdd, 0xc6, 0x42, 0x4d, 0x61, 0xfb, 0xc3, 0x67, + 0x97, 0x2d, 0xe3, 0xf9, 0x65, 0xcb, 0xf8, 0xfb, 0xb2, 0x65, 0xfc, 0x78, 0xd5, 0x2a, 0x3c, 0xbf, + 0x6a, 0x15, 0xfe, 0xbc, 0x6a, 0x15, 0xbe, 0xfe, 0x70, 0x4a, 0xe5, 0x2c, 0x1c, 0xf7, 0x6c, 0xe6, + 0xf5, 0x73, 0x9e, 0x92, 0xf3, 0x41, 0xff, 0x22, 0x7a, 0x4f, 0x2e, 0x02, 0x10, 0xe3, 0x8a, 0x7e, + 0xf0, 0x7d, 0xfc, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2f, 0x8e, 0x00, 0x44, 0x76, 0x0a, 0x00, + 0x00, } func (m *Valset) Marshal() (dAtA []byte, err error) { diff --git a/x/evm/types/tx.pb.go b/x/evm/types/tx.pb.go index b3cf0a3e..ed9060d0 100644 --- a/x/evm/types/tx.pb.go +++ b/x/evm/types/tx.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/cosmos/gogoproto/gogoproto" @@ -16,15 +20,14 @@ import ( codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" emptypb "google.golang.org/protobuf/types/known/emptypb" - 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -46,9 +49,11 @@ func (*MsgRemoveSmartContractDeploymentRequest) ProtoMessage() {} func (*MsgRemoveSmartContractDeploymentRequest) Descriptor() ([]byte, []int) { return fileDescriptor_631cfc68eb1fd278, []int{0} } + func (m *MsgRemoveSmartContractDeploymentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgRemoveSmartContractDeploymentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgRemoveSmartContractDeploymentRequest.Marshal(b, m, deterministic) @@ -61,12 +66,15 @@ func (m *MsgRemoveSmartContractDeploymentRequest) XXX_Marshal(b []byte, determin return b[:n], nil } } + func (m *MsgRemoveSmartContractDeploymentRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgRemoveSmartContractDeploymentRequest.Merge(m, src) } + func (m *MsgRemoveSmartContractDeploymentRequest) XXX_Size() int { return m.Size() } + func (m *MsgRemoveSmartContractDeploymentRequest) XXX_DiscardUnknown() { xxx_messageInfo_MsgRemoveSmartContractDeploymentRequest.DiscardUnknown(m) } @@ -94,8 +102,7 @@ func (m *MsgRemoveSmartContractDeploymentRequest) GetMetadata() types.MsgMetadat return types.MsgMetadata{} } -type RemoveSmartContractDeploymentResponse struct { -} +type RemoveSmartContractDeploymentResponse struct{} func (m *RemoveSmartContractDeploymentResponse) Reset() { *m = RemoveSmartContractDeploymentResponse{} } func (m *RemoveSmartContractDeploymentResponse) String() string { return proto.CompactTextString(m) } @@ -103,9 +110,11 @@ func (*RemoveSmartContractDeploymentResponse) ProtoMessage() {} func (*RemoveSmartContractDeploymentResponse) Descriptor() ([]byte, []int) { return fileDescriptor_631cfc68eb1fd278, []int{1} } + func (m *RemoveSmartContractDeploymentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *RemoveSmartContractDeploymentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveSmartContractDeploymentResponse.Marshal(b, m, deterministic) @@ -118,12 +127,15 @@ func (m *RemoveSmartContractDeploymentResponse) XXX_Marshal(b []byte, determinis return b[:n], nil } } + func (m *RemoveSmartContractDeploymentResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveSmartContractDeploymentResponse.Merge(m, src) } + func (m *RemoveSmartContractDeploymentResponse) XXX_Size() int { return m.Size() } + func (m *RemoveSmartContractDeploymentResponse) XXX_DiscardUnknown() { xxx_messageInfo_RemoveSmartContractDeploymentResponse.DiscardUnknown(m) } @@ -144,9 +156,11 @@ func (*MsgUploadUserSmartContractRequest) ProtoMessage() {} func (*MsgUploadUserSmartContractRequest) Descriptor() ([]byte, []int) { return fileDescriptor_631cfc68eb1fd278, []int{2} } + func (m *MsgUploadUserSmartContractRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgUploadUserSmartContractRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgUploadUserSmartContractRequest.Marshal(b, m, deterministic) @@ -159,12 +173,15 @@ func (m *MsgUploadUserSmartContractRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *MsgUploadUserSmartContractRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgUploadUserSmartContractRequest.Merge(m, src) } + func (m *MsgUploadUserSmartContractRequest) XXX_Size() int { return m.Size() } + func (m *MsgUploadUserSmartContractRequest) XXX_DiscardUnknown() { xxx_messageInfo_MsgUploadUserSmartContractRequest.DiscardUnknown(m) } @@ -216,9 +233,11 @@ func (*MsgUploadUserSmartContractResponse) ProtoMessage() {} func (*MsgUploadUserSmartContractResponse) Descriptor() ([]byte, []int) { return fileDescriptor_631cfc68eb1fd278, []int{3} } + func (m *MsgUploadUserSmartContractResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgUploadUserSmartContractResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgUploadUserSmartContractResponse.Marshal(b, m, deterministic) @@ -231,12 +250,15 @@ func (m *MsgUploadUserSmartContractResponse) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *MsgUploadUserSmartContractResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgUploadUserSmartContractResponse.Merge(m, src) } + func (m *MsgUploadUserSmartContractResponse) XXX_Size() int { return m.Size() } + func (m *MsgUploadUserSmartContractResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgUploadUserSmartContractResponse.DiscardUnknown(m) } @@ -261,9 +283,11 @@ func (*MsgRemoveUserSmartContractRequest) ProtoMessage() {} func (*MsgRemoveUserSmartContractRequest) Descriptor() ([]byte, []int) { return fileDescriptor_631cfc68eb1fd278, []int{4} } + func (m *MsgRemoveUserSmartContractRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgRemoveUserSmartContractRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgRemoveUserSmartContractRequest.Marshal(b, m, deterministic) @@ -276,12 +300,15 @@ func (m *MsgRemoveUserSmartContractRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *MsgRemoveUserSmartContractRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgRemoveUserSmartContractRequest.Merge(m, src) } + func (m *MsgRemoveUserSmartContractRequest) XXX_Size() int { return m.Size() } + func (m *MsgRemoveUserSmartContractRequest) XXX_DiscardUnknown() { xxx_messageInfo_MsgRemoveUserSmartContractRequest.DiscardUnknown(m) } @@ -314,9 +341,11 @@ func (*MsgDeployUserSmartContractRequest) ProtoMessage() {} func (*MsgDeployUserSmartContractRequest) Descriptor() ([]byte, []int) { return fileDescriptor_631cfc68eb1fd278, []int{5} } + func (m *MsgDeployUserSmartContractRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgDeployUserSmartContractRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgDeployUserSmartContractRequest.Marshal(b, m, deterministic) @@ -329,12 +358,15 @@ func (m *MsgDeployUserSmartContractRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *MsgDeployUserSmartContractRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgDeployUserSmartContractRequest.Merge(m, src) } + func (m *MsgDeployUserSmartContractRequest) XXX_Size() int { return m.Size() } + func (m *MsgDeployUserSmartContractRequest) XXX_DiscardUnknown() { xxx_messageInfo_MsgDeployUserSmartContractRequest.DiscardUnknown(m) } @@ -372,9 +404,11 @@ func (*MsgDeployUserSmartContractResponse) ProtoMessage() {} func (*MsgDeployUserSmartContractResponse) Descriptor() ([]byte, []int) { return fileDescriptor_631cfc68eb1fd278, []int{6} } + func (m *MsgDeployUserSmartContractResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgDeployUserSmartContractResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgDeployUserSmartContractResponse.Marshal(b, m, deterministic) @@ -387,12 +421,15 @@ func (m *MsgDeployUserSmartContractResponse) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *MsgDeployUserSmartContractResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgDeployUserSmartContractResponse.Merge(m, src) } + func (m *MsgDeployUserSmartContractResponse) XXX_Size() int { return m.Size() } + func (m *MsgDeployUserSmartContractResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgDeployUserSmartContractResponse.DiscardUnknown(m) } @@ -419,52 +456,55 @@ func init() { func init() { proto.RegisterFile("palomachain/paloma/evm/tx.proto", fileDescriptor_631cfc68eb1fd278) } var fileDescriptor_631cfc68eb1fd278 = []byte{ - // 640 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x95, 0xcf, 0x4f, 0xd4, 0x40, - 0x14, 0xc7, 0x77, 0x96, 0x05, 0x97, 0xc1, 0x1f, 0x38, 0x41, 0x58, 0x6a, 0x2c, 0xd0, 0x44, 0x58, - 0x31, 0x69, 0x23, 0x7a, 0x11, 0x63, 0x4c, 0x00, 0x13, 0x97, 0x64, 0x2f, 0x25, 0x5c, 0xbc, 0x6c, - 0xa6, 0xed, 0x63, 0xa8, 0xe9, 0x74, 0x6a, 0x67, 0x76, 0xc3, 0x5e, 0x3d, 0x7b, 0xe0, 0x3f, 0xf0, - 0x4f, 0xd0, 0xbb, 0xff, 0x00, 0x47, 0x8e, 0x9e, 0x8c, 0x81, 0x44, 0xff, 0x03, 0xcf, 0x66, 0x3b, - 0x65, 0xc5, 0x75, 0xb7, 0x10, 0x4d, 0x38, 0x75, 0xde, 0x9b, 0x99, 0xbe, 0xef, 0xfb, 0xcc, 0x9b, - 0x37, 0x78, 0x21, 0xa1, 0x91, 0xe0, 0xd4, 0xdf, 0xa7, 0x61, 0xec, 0xe8, 0xb1, 0x03, 0x1d, 0xee, - 0xa8, 0x03, 0x3b, 0x49, 0x85, 0x12, 0x64, 0xf6, 0xdc, 0x02, 0x5b, 0x8f, 0x6d, 0xe8, 0x70, 0x63, - 0xce, 0x17, 0x92, 0x0b, 0xe9, 0x70, 0xc9, 0x9c, 0xce, 0xa3, 0xde, 0x47, 0x6f, 0x30, 0xe6, 0xf5, - 0x44, 0x2b, 0xb3, 0x1c, 0x6d, 0xe4, 0x53, 0x33, 0x4c, 0x30, 0xa1, 0xfd, 0xbd, 0x51, 0xee, 0xbd, - 0xcb, 0x84, 0x60, 0x11, 0x38, 0x99, 0xe5, 0xb5, 0xf7, 0x1c, 0xe0, 0x89, 0xea, 0xe6, 0x93, 0xcb, - 0x43, 0xf4, 0x75, 0x68, 0x24, 0x41, 0x39, 0xbe, 0xe0, 0x5c, 0xc4, 0x7a, 0x9d, 0xf5, 0x1d, 0xe1, - 0x95, 0xa6, 0x64, 0x2e, 0x70, 0xd1, 0x81, 0x1d, 0x4e, 0x53, 0xb5, 0x29, 0x62, 0x95, 0x52, 0x5f, - 0x6d, 0x41, 0x12, 0x89, 0x2e, 0x87, 0x58, 0xb9, 0xf0, 0xb6, 0x0d, 0x52, 0x91, 0x3a, 0xbe, 0x25, - 0xcf, 0xaf, 0x68, 0x6c, 0xd5, 0xca, 0x8b, 0xa8, 0x5e, 0x71, 0x07, 0xdd, 0x64, 0x15, 0x4f, 0x67, - 0x91, 0x5d, 0xd8, 0x83, 0x14, 0x62, 0x1f, 0x1a, 0x5b, 0xb5, 0xb1, 0x45, 0x54, 0x9f, 0x74, 0xff, - 0xf2, 0x93, 0x57, 0xb8, 0xca, 0x41, 0xd1, 0x80, 0x2a, 0x5a, 0xab, 0x2c, 0xa2, 0xfa, 0xd4, 0xda, - 0xb2, 0x3d, 0x84, 0x9d, 0x16, 0x6f, 0x37, 0x25, 0x6b, 0xe6, 0xab, 0x37, 0x2a, 0x47, 0x5f, 0x17, - 0x4a, 0x6e, 0x7f, 0xf7, 0xfa, 0x8d, 0x77, 0x3f, 0x3e, 0xad, 0xf6, 0xcd, 0xed, 0x4a, 0x15, 0x4d, - 0x97, 0xdd, 0x89, 0x1d, 0x88, 0x03, 0x48, 0xad, 0x15, 0x7c, 0xff, 0x82, 0x24, 0x65, 0x22, 0x62, - 0x09, 0xd6, 0x4f, 0x84, 0x97, 0x9a, 0x92, 0xed, 0x26, 0x91, 0xa0, 0xc1, 0xae, 0x84, 0xf4, 0x8f, - 0x0d, 0x67, 0x2c, 0xce, 0xab, 0x46, 0xff, 0xa3, 0x9a, 0xcc, 0xe0, 0x71, 0x15, 0xaa, 0x08, 0x32, - 0x96, 0x93, 0xae, 0x36, 0xc8, 0x3c, 0xae, 0x52, 0x2f, 0x6c, 0xbd, 0x91, 0x22, 0xce, 0xc9, 0x5d, - 0xa3, 0x5e, 0xb8, 0x2d, 0x45, 0x4c, 0x0c, 0x5c, 0xf5, 0xba, 0x0a, 0x7c, 0x11, 0x40, 0x06, 0x6c, - 0xd2, 0xed, 0xdb, 0xe4, 0x21, 0xbe, 0xed, 0x8b, 0x58, 0xaa, 0xb4, 0xed, 0x2b, 0x91, 0xb6, 0xc2, - 0x38, 0x69, 0xab, 0xda, 0x78, 0x4e, 0xfe, 0xf7, 0x44, 0xa3, 0xe7, 0x1f, 0xe0, 0x65, 0x3d, 0xc1, - 0x56, 0x51, 0xde, 0x1a, 0x0f, 0xb9, 0x89, 0xcb, 0x61, 0x90, 0xa5, 0x5c, 0x71, 0xcb, 0x61, 0x60, - 0xbd, 0xd7, 0xb8, 0x34, 0xdb, 0x2b, 0xc0, 0xa5, 0xe3, 0x97, 0xcf, 0xe2, 0x0f, 0x26, 0xf1, 0x51, - 0xcb, 0xd1, 0xe7, 0x7a, 0xf5, 0x72, 0xc8, 0x12, 0xbe, 0xae, 0x68, 0xca, 0x40, 0xb5, 0xb2, 0x3f, - 0xe5, 0x67, 0x37, 0xa5, 0x7d, 0x9b, 0x3d, 0xd7, 0xa0, 0xe2, 0x67, 0x19, 0xf6, 0x91, 0x82, 0x73, - 0xec, 0x77, 0xf0, 0x04, 0x97, 0xac, 0xd5, 0x47, 0x3f, 0xce, 0x25, 0x6b, 0x04, 0x6b, 0x9f, 0x2b, - 0x78, 0xac, 0x29, 0x19, 0xf9, 0x80, 0xf0, 0xbd, 0xc2, 0xf2, 0x26, 0x2f, 0xec, 0xe1, 0x0d, 0xc9, - 0xbe, 0xe4, 0xed, 0x37, 0x9e, 0x8f, 0xfa, 0xc1, 0xa5, 0xae, 0x15, 0x39, 0x44, 0x78, 0x6e, 0x44, - 0x6d, 0x91, 0xa7, 0x05, 0xda, 0x8a, 0xef, 0xa1, 0xb1, 0xfe, 0x2f, 0x5b, 0x73, 0x49, 0x11, 0x9e, - 0x1b, 0x51, 0xb6, 0x85, 0x8a, 0x8a, 0x4b, 0xdd, 0x98, 0xb5, 0x75, 0x5f, 0xb6, 0xcf, 0xfa, 0xb2, - 0xfd, 0xb2, 0xd7, 0x97, 0x33, 0x00, 0x23, 0x4e, 0xb9, 0x30, 0x5c, 0x71, 0x29, 0x17, 0x02, 0xb8, - 0xa0, 0xa8, 0x36, 0x36, 0x8f, 0x4e, 0x4c, 0x74, 0x7c, 0x62, 0xa2, 0x6f, 0x27, 0x26, 0x3a, 0x3c, - 0x35, 0x4b, 0xc7, 0xa7, 0x66, 0xe9, 0xcb, 0xa9, 0x59, 0x7a, 0xfd, 0x80, 0x85, 0x6a, 0xbf, 0xed, - 0xd9, 0xbe, 0xe0, 0xce, 0x90, 0x97, 0xe4, 0x40, 0xbf, 0x75, 0xdd, 0x04, 0xa4, 0x37, 0x91, 0xe5, - 0xf9, 0xf8, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x16, 0x5a, 0x98, 0x12, 0x07, 0x00, 0x00, + // 642 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x95, 0xc1, 0x4f, 0xd4, 0x4e, + 0x14, 0xc7, 0x77, 0x96, 0x85, 0xdf, 0x32, 0xfc, 0x54, 0x9c, 0x20, 0x2c, 0x35, 0x16, 0x68, 0x22, + 0x6c, 0xd0, 0xb4, 0x11, 0xbd, 0x88, 0x31, 0x26, 0x80, 0xc6, 0x25, 0xd9, 0x4b, 0x09, 0x17, 0x2f, + 0x9b, 0x69, 0xfb, 0x18, 0x6a, 0x3a, 0x9d, 0xda, 0x99, 0xdd, 0xb0, 0x57, 0xcf, 0x1e, 0xf8, 0x0f, + 0xfc, 0x13, 0xf4, 0xee, 0x3f, 0xc0, 0x91, 0xa3, 0x27, 0x63, 0x20, 0xd1, 0xff, 0xc0, 0xb3, 0xd9, + 0x4e, 0x59, 0x71, 0xdd, 0x2d, 0x44, 0x13, 0x4e, 0x9d, 0xf7, 0x66, 0xa6, 0xef, 0xfb, 0x3e, 0xf3, + 0xe6, 0x0d, 0x5e, 0x48, 0x68, 0x24, 0x38, 0xf5, 0xf7, 0x69, 0x18, 0x3b, 0x7a, 0xec, 0x40, 0x87, + 0x3b, 0xea, 0xc0, 0x4e, 0x52, 0xa1, 0x04, 0x99, 0x3d, 0xb7, 0xc0, 0xd6, 0x63, 0x1b, 0x3a, 0xdc, + 0x98, 0xf3, 0x85, 0xe4, 0x42, 0x3a, 0x5c, 0x32, 0xa7, 0xf3, 0xa0, 0xf7, 0xd1, 0x1b, 0x8c, 0x79, + 0x3d, 0xd1, 0xca, 0x2c, 0x47, 0x1b, 0xf9, 0xd4, 0x0c, 0x13, 0x4c, 0x68, 0x7f, 0x6f, 0x94, 0x7b, + 0x6f, 0x33, 0x21, 0x58, 0x04, 0x4e, 0x66, 0x79, 0xed, 0x3d, 0x07, 0x78, 0xa2, 0xba, 0xf9, 0xe4, + 0xf2, 0x10, 0x7d, 0x1d, 0x1a, 0x49, 0x50, 0x8e, 0x2f, 0x38, 0x17, 0xb1, 0x5e, 0x67, 0x7d, 0x43, + 0x78, 0xa5, 0x29, 0x99, 0x0b, 0x5c, 0x74, 0x60, 0x87, 0xd3, 0x54, 0x6d, 0x8a, 0x58, 0xa5, 0xd4, + 0x57, 0x5b, 0x90, 0x44, 0xa2, 0xcb, 0x21, 0x56, 0x2e, 0xbc, 0x69, 0x83, 0x54, 0xa4, 0x8e, 0x6f, + 0xc8, 0xf3, 0x2b, 0x1a, 0x5b, 0xb5, 0xf2, 0x22, 0xaa, 0x57, 0xdc, 0x41, 0x37, 0x59, 0xc5, 0xd3, + 0x59, 0x64, 0x17, 0xf6, 0x20, 0x85, 0xd8, 0x87, 0xc6, 0x56, 0x6d, 0x6c, 0x11, 0xd5, 0x27, 0xdd, + 0x3f, 0xfc, 0xe4, 0x25, 0xae, 0x72, 0x50, 0x34, 0xa0, 0x8a, 0xd6, 0x2a, 0x8b, 0xa8, 0x3e, 0xb5, + 0xb6, 0x6c, 0x0f, 0x61, 0xa7, 0xc5, 0xdb, 0x4d, 0xc9, 0x9a, 0xf9, 0xea, 0x8d, 0xca, 0xd1, 0x97, + 0x85, 0x92, 0xdb, 0xdf, 0xbd, 0x7e, 0xed, 0xed, 0xf7, 0x8f, 0xab, 0x7d, 0x73, 0xbb, 0x52, 0x45, + 0xd3, 0x65, 0x77, 0x62, 0x07, 0xe2, 0x00, 0x52, 0x6b, 0x05, 0xdf, 0xbd, 0x20, 0x49, 0x99, 0x88, + 0x58, 0x82, 0xf5, 0x03, 0xe1, 0xa5, 0xa6, 0x64, 0xbb, 0x49, 0x24, 0x68, 0xb0, 0x2b, 0x21, 0xfd, + 0x6d, 0xc3, 0x19, 0x8b, 0xf3, 0xaa, 0xd1, 0xbf, 0xa8, 0x26, 0x33, 0x78, 0x5c, 0x85, 0x2a, 0x82, + 0x8c, 0xe5, 0xa4, 0xab, 0x0d, 0x32, 0x8f, 0xab, 0xd4, 0x0b, 0x5b, 0xaf, 0xa5, 0x88, 0x73, 0x72, + 0xff, 0x51, 0x2f, 0xdc, 0x96, 0x22, 0x26, 0x06, 0xae, 0x7a, 0x5d, 0x05, 0xbe, 0x08, 0x20, 0x03, + 0x36, 0xe9, 0xf6, 0x6d, 0x72, 0x0f, 0xdf, 0xf4, 0x45, 0x2c, 0x55, 0xda, 0xf6, 0x95, 0x48, 0x5b, + 0x61, 0x9c, 0xb4, 0x55, 0x6d, 0x3c, 0x27, 0xff, 0x6b, 0xa2, 0xd1, 0xf3, 0x0f, 0xf0, 0xb2, 0x1e, + 0x61, 0xab, 0x28, 0x6f, 0x8d, 0x87, 0x5c, 0xc7, 0xe5, 0x30, 0xc8, 0x52, 0xae, 0xb8, 0xe5, 0x30, + 0xb0, 0xde, 0x69, 0x5c, 0x9a, 0xed, 0x15, 0xe0, 0xd2, 0xf1, 0xcb, 0x67, 0xf1, 0x07, 0x93, 0xf8, + 0xa0, 0xe5, 0xe8, 0x73, 0xbd, 0x7a, 0x39, 0x64, 0x09, 0xff, 0xaf, 0x68, 0xca, 0x40, 0xb5, 0xb2, + 0x3f, 0xe5, 0x67, 0x37, 0xa5, 0x7d, 0x9b, 0x3d, 0xd7, 0xa0, 0xe2, 0x27, 0x19, 0xf6, 0x91, 0x82, + 0x73, 0xec, 0xb7, 0xf0, 0x04, 0x97, 0xac, 0xd5, 0x47, 0x3f, 0xce, 0x25, 0x6b, 0x04, 0x6b, 0x9f, + 0x2a, 0x78, 0xac, 0x29, 0x19, 0x79, 0x8f, 0xf0, 0x9d, 0xc2, 0xf2, 0x26, 0xcf, 0xec, 0xe1, 0x0d, + 0xc9, 0xbe, 0xe4, 0xed, 0x37, 0x9e, 0x8e, 0xfa, 0xc1, 0xa5, 0xae, 0x15, 0x39, 0x44, 0x78, 0x6e, + 0x44, 0x6d, 0x91, 0xc7, 0x05, 0xda, 0x8a, 0xef, 0xa1, 0xb1, 0xfe, 0x37, 0x5b, 0x73, 0x49, 0x11, + 0x9e, 0x1b, 0x51, 0xb6, 0x85, 0x8a, 0x8a, 0x4b, 0xdd, 0x98, 0xb5, 0x75, 0x5f, 0xb6, 0xcf, 0xfa, + 0xb2, 0xfd, 0xbc, 0xd7, 0x97, 0x33, 0x00, 0x23, 0x4e, 0xb9, 0x30, 0x5c, 0x71, 0x29, 0x17, 0x02, + 0xb8, 0xa0, 0xa8, 0x36, 0x5e, 0x1c, 0x9d, 0x98, 0xe8, 0xf8, 0xc4, 0x44, 0x5f, 0x4f, 0x4c, 0x74, + 0x78, 0x6a, 0x96, 0x8e, 0x4f, 0xcd, 0xd2, 0xe7, 0x53, 0xb3, 0xf4, 0xea, 0x3e, 0x0b, 0xd5, 0x7e, + 0xdb, 0xb3, 0x7d, 0xc1, 0x9d, 0x61, 0x2f, 0xc9, 0x9a, 0x73, 0xa0, 0x9f, 0xbb, 0x6e, 0x02, 0xd2, + 0x9b, 0xc8, 0x52, 0x7d, 0xf8, 0x33, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x79, 0x07, 0x91, 0x15, 0x07, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -535,18 +575,20 @@ type MsgServer interface { } // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func (*UnimplementedMsgServer) RemoveSmartContractDeployment(ctx context.Context, req *MsgRemoveSmartContractDeploymentRequest) (*RemoveSmartContractDeploymentResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RemoveSmartContractDeployment not implemented") } + func (*UnimplementedMsgServer) UploadUserSmartContract(ctx context.Context, req *MsgUploadUserSmartContractRequest) (*MsgUploadUserSmartContractResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UploadUserSmartContract not implemented") } + func (*UnimplementedMsgServer) RemoveUserSmartContract(ctx context.Context, req *MsgRemoveUserSmartContractRequest) (*emptypb.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method RemoveUserSmartContract not implemented") } + func (*UnimplementedMsgServer) DeployUserSmartContract(ctx context.Context, req *MsgDeployUserSmartContractRequest) (*MsgDeployUserSmartContractResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method DeployUserSmartContract not implemented") } @@ -931,6 +973,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgRemoveSmartContractDeploymentRequest) Size() (n int) { if m == nil { return 0 @@ -1044,9 +1087,11 @@ func (m *MsgDeployUserSmartContractResponse) Size() (n int) { 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 *MsgRemoveSmartContractDeploymentRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1181,6 +1226,7 @@ func (m *MsgRemoveSmartContractDeploymentRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *RemoveSmartContractDeploymentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1231,6 +1277,7 @@ func (m *RemoveSmartContractDeploymentResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgUploadUserSmartContractRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1442,6 +1489,7 @@ func (m *MsgUploadUserSmartContractRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgUploadUserSmartContractResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1511,6 +1559,7 @@ func (m *MsgUploadUserSmartContractResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgRemoveUserSmartContractRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1613,6 +1662,7 @@ func (m *MsgRemoveUserSmartContractRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgDeployUserSmartContractRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1747,6 +1797,7 @@ func (m *MsgDeployUserSmartContractRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgDeployUserSmartContractResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1816,6 +1867,7 @@ func (m *MsgDeployUserSmartContractResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/user_smart_contract.pb.go b/x/evm/types/user_smart_contract.pb.go index 3a0e64ea..28af3f52 100644 --- a/x/evm/types/user_smart_contract.pb.go +++ b/x/evm/types/user_smart_contract.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -74,9 +77,11 @@ func (*UserSmartContract) ProtoMessage() {} func (*UserSmartContract) Descriptor() ([]byte, []int) { return fileDescriptor_5825d6d955923c9c, []int{0} } + func (m *UserSmartContract) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *UserSmartContract) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UserSmartContract.Marshal(b, m, deterministic) @@ -89,12 +94,15 @@ func (m *UserSmartContract) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *UserSmartContract) XXX_Merge(src proto.Message) { xxx_messageInfo_UserSmartContract.Merge(m, src) } + func (m *UserSmartContract) XXX_Size() int { return m.Size() } + func (m *UserSmartContract) XXX_DiscardUnknown() { xxx_messageInfo_UserSmartContract.DiscardUnknown(m) } @@ -178,9 +186,11 @@ func (*UserSmartContract_Deployment) ProtoMessage() {} func (*UserSmartContract_Deployment) Descriptor() ([]byte, []int) { return fileDescriptor_5825d6d955923c9c, []int{0, 0} } + func (m *UserSmartContract_Deployment) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *UserSmartContract_Deployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UserSmartContract_Deployment.Marshal(b, m, deterministic) @@ -193,12 +203,15 @@ func (m *UserSmartContract_Deployment) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *UserSmartContract_Deployment) XXX_Merge(src proto.Message) { xxx_messageInfo_UserSmartContract_Deployment.Merge(m, src) } + func (m *UserSmartContract_Deployment) XXX_Size() int { return m.Size() } + func (m *UserSmartContract_Deployment) XXX_DiscardUnknown() { xxx_messageInfo_UserSmartContract_Deployment.DiscardUnknown(m) } @@ -251,40 +264,40 @@ func init() { } var fileDescriptor_5825d6d955923c9c = []byte{ - // 518 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x4f, 0x6f, 0xd3, 0x3e, - 0x18, 0xc7, 0x9b, 0xfe, 0x49, 0x5b, 0x57, 0xbf, 0x29, 0xb3, 0xaa, 0x1f, 0x59, 0x0f, 0x51, 0xb5, - 0x53, 0x11, 0x90, 0x4e, 0x03, 0x4e, 0x3b, 0xb5, 0x5d, 0xd9, 0x82, 0x50, 0x41, 0xee, 0xd8, 0x81, - 0x8b, 0xe5, 0x38, 0xa6, 0x35, 0x34, 0x71, 0x64, 0x3b, 0x13, 0x7d, 0x17, 0xbc, 0x18, 0x5e, 0x04, - 0xc7, 0x09, 0x71, 0xe0, 0x88, 0xda, 0x2b, 0x2f, 0x02, 0xd5, 0xc9, 0x46, 0x11, 0x85, 0xc3, 0x6e, - 0x7e, 0xfc, 0x79, 0xbe, 0x5f, 0x3d, 0x7f, 0xf4, 0x80, 0xa3, 0x94, 0x2c, 0x44, 0x4c, 0xe8, 0x9c, - 0xf0, 0xa4, 0x9f, 0xbf, 0xfb, 0xec, 0x2a, 0xee, 0x67, 0x8a, 0x49, 0xac, 0x62, 0x22, 0x35, 0xa6, - 0x22, 0xd1, 0x92, 0x50, 0xed, 0xa7, 0x52, 0x68, 0x01, 0xff, 0xdf, 0x52, 0xf8, 0xf9, 0xdb, 0x67, - 0x57, 0x71, 0xe7, 0x80, 0x0a, 0x15, 0x0b, 0x85, 0x4d, 0x56, 0x3f, 0x0f, 0x72, 0xc9, 0xe1, 0x8f, - 0x1a, 0xd8, 0x7f, 0xad, 0x98, 0x9c, 0x6e, 0xfc, 0x46, 0x85, 0x1d, 0x3c, 0x02, 0x36, 0xc9, 0xf4, - 0x5c, 0x48, 0xd7, 0xea, 0x5a, 0xbd, 0xe6, 0xd0, 0xfd, 0xf2, 0xe9, 0x51, 0xbb, 0xd0, 0x0d, 0xa2, - 0x48, 0x32, 0xa5, 0xa6, 0x5a, 0xf2, 0x64, 0x86, 0x8a, 0x3c, 0xb8, 0x07, 0xca, 0x3c, 0x72, 0xcb, - 0x5d, 0xab, 0x57, 0x45, 0x65, 0x1e, 0xc1, 0x36, 0xa8, 0x69, 0xae, 0x17, 0xcc, 0xad, 0x6c, 0x0c, - 0x50, 0x1e, 0xc0, 0x03, 0xd0, 0x20, 0x21, 0xc7, 0xef, 0x94, 0x48, 0xdc, 0xaa, 0x01, 0x75, 0x12, - 0xf2, 0xe7, 0x4a, 0x24, 0xb0, 0x03, 0x1a, 0xe1, 0x52, 0x33, 0x2a, 0x22, 0xe6, 0xd6, 0x0c, 0xba, - 0x8d, 0xe1, 0x03, 0xb0, 0x4f, 0x45, 0xa2, 0xb4, 0xcc, 0xa8, 0x16, 0x12, 0xf3, 0x24, 0xcd, 0xb4, - 0x6b, 0x9b, 0x24, 0x67, 0x0b, 0x04, 0x9b, 0x7f, 0x78, 0x09, 0x5a, 0x11, 0x4b, 0x17, 0x62, 0x19, - 0xb3, 0x44, 0x2b, 0xb7, 0xde, 0xad, 0xf4, 0x5a, 0xc7, 0x4f, 0xfc, 0xdd, 0xa3, 0xf1, 0xff, 0xe8, - 0xdd, 0x3f, 0xbd, 0x15, 0xa3, 0x6d, 0x23, 0xf8, 0x14, 0xdc, 0xa3, 0x92, 0x11, 0xcd, 0x22, 0x4c, - 0x34, 0x0e, 0x17, 0x82, 0xbe, 0xc7, 0x73, 0xc6, 0x67, 0x73, 0xed, 0x36, 0xba, 0x56, 0xaf, 0x82, - 0xda, 0x05, 0x1e, 0xe8, 0xe1, 0x06, 0x9e, 0x1b, 0xb6, 0x91, 0x65, 0x69, 0xb4, 0x53, 0xd6, 0xcc, - 0x65, 0x05, 0xfe, 0x4d, 0xd6, 0xf9, 0x5a, 0x06, 0xe0, 0x57, 0x25, 0xf0, 0x21, 0x80, 0xa6, 0x74, - 0x2c, 0xd9, 0x5b, 0x26, 0x59, 0x42, 0x19, 0xe6, 0x51, 0xbe, 0x1c, 0xe4, 0x18, 0x82, 0x6e, 0x40, - 0x10, 0xc1, 0x29, 0xb0, 0x95, 0x26, 0x3a, 0x53, 0x66, 0x21, 0x7b, 0xc7, 0x27, 0x77, 0xe9, 0xde, - 0x9f, 0x1a, 0x0b, 0x54, 0x58, 0x41, 0x17, 0xd4, 0x49, 0xbe, 0xfa, 0x62, 0xa7, 0x37, 0xe1, 0xbf, - 0x26, 0x53, 0xbd, 0xdb, 0x64, 0x6a, 0x7f, 0x9f, 0xcc, 0xe1, 0x09, 0xb0, 0xf3, 0xca, 0x60, 0x0b, - 0xd4, 0x5f, 0x8d, 0x27, 0xa7, 0xc1, 0xe4, 0xcc, 0x29, 0xc1, 0xff, 0x40, 0x33, 0x98, 0xe0, 0x67, - 0x2f, 0x82, 0xb3, 0xf3, 0x0b, 0xc7, 0x82, 0x00, 0xd8, 0x83, 0xd1, 0x45, 0x70, 0x39, 0x76, 0xca, - 0xb0, 0x09, 0x6a, 0x63, 0x84, 0x5e, 0x22, 0xa7, 0x32, 0x1c, 0x7d, 0x5e, 0x79, 0xd6, 0xf5, 0xca, - 0xb3, 0xbe, 0xaf, 0x3c, 0xeb, 0xe3, 0xda, 0x2b, 0x5d, 0xaf, 0xbd, 0xd2, 0xb7, 0xb5, 0x57, 0x7a, - 0x73, 0x7f, 0xc6, 0xf5, 0x3c, 0x0b, 0x7d, 0x2a, 0xe2, 0xfe, 0x8e, 0xc3, 0xfb, 0x60, 0x4e, 0x4f, - 0x2f, 0x53, 0xa6, 0x42, 0xdb, 0x9c, 0xce, 0xe3, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x26, 0x57, - 0x70, 0xfd, 0xa1, 0x03, 0x00, 0x00, + // 519 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x4d, 0x6f, 0xd3, 0x30, + 0x18, 0xc7, 0x9b, 0xbe, 0xa4, 0xad, 0x2b, 0xa6, 0xcc, 0xaa, 0x20, 0xeb, 0x21, 0xaa, 0x76, 0xaa, + 0xc4, 0x48, 0xa6, 0x02, 0xa7, 0x9d, 0xda, 0xad, 0xdb, 0x82, 0x50, 0x41, 0xe9, 0xd8, 0x81, 0x8b, + 0xe5, 0x38, 0xa6, 0x35, 0x34, 0x71, 0x64, 0x3b, 0x15, 0xfd, 0x16, 0x7c, 0x18, 0x3e, 0x04, 0xc7, + 0x09, 0x71, 0xe0, 0x88, 0xda, 0x2b, 0x1f, 0x02, 0xd5, 0xc9, 0x46, 0x11, 0x85, 0xc3, 0x6e, 0x7e, + 0xfc, 0x7b, 0xfe, 0x7f, 0x3d, 0x2f, 0x7a, 0xc0, 0x71, 0x8a, 0xe7, 0x3c, 0xc6, 0x64, 0x86, 0x59, + 0xe2, 0xe5, 0x6f, 0x8f, 0x2e, 0x62, 0x2f, 0x93, 0x54, 0x20, 0x19, 0x63, 0xa1, 0x10, 0xe1, 0x89, + 0x12, 0x98, 0x28, 0x37, 0x15, 0x5c, 0x71, 0xf8, 0x70, 0x4b, 0xe1, 0xe6, 0x6f, 0x97, 0x2e, 0xe2, + 0xce, 0x01, 0xe1, 0x32, 0xe6, 0x12, 0xe9, 0x2c, 0x2f, 0x0f, 0x72, 0xc9, 0xe1, 0xcf, 0x1a, 0xd8, + 0x7f, 0x23, 0xa9, 0x98, 0x6c, 0xfc, 0x4e, 0x0b, 0x3b, 0x78, 0x0c, 0x4c, 0x9c, 0xa9, 0x19, 0x17, + 0xb6, 0xd1, 0x35, 0x7a, 0xcd, 0xa1, 0xfd, 0xf5, 0xf3, 0x93, 0x76, 0xa1, 0x1b, 0x44, 0x91, 0xa0, + 0x52, 0x4e, 0x94, 0x60, 0xc9, 0x34, 0x28, 0xf2, 0xe0, 0x1e, 0x28, 0xb3, 0xc8, 0x2e, 0x77, 0x8d, + 0x5e, 0x35, 0x28, 0xb3, 0x08, 0xb6, 0x41, 0x4d, 0x31, 0x35, 0xa7, 0x76, 0x65, 0x63, 0x10, 0xe4, + 0x01, 0x3c, 0x00, 0x0d, 0x1c, 0x32, 0xf4, 0x5e, 0xf2, 0xc4, 0xae, 0x6a, 0x50, 0xc7, 0x21, 0x7b, + 0x21, 0x79, 0x02, 0x3b, 0xa0, 0x11, 0x2e, 0x15, 0x25, 0x3c, 0xa2, 0x76, 0x4d, 0xa3, 0xbb, 0x18, + 0x3e, 0x06, 0xfb, 0x84, 0x27, 0x52, 0x89, 0x8c, 0x28, 0x2e, 0x10, 0x4b, 0xd2, 0x4c, 0xd9, 0xa6, + 0x4e, 0xb2, 0xb6, 0x80, 0xbf, 0xf9, 0x87, 0xd7, 0xa0, 0x15, 0xd1, 0x74, 0xce, 0x97, 0x31, 0x4d, + 0x94, 0xb4, 0xeb, 0xdd, 0x4a, 0xaf, 0xd5, 0x7f, 0xe6, 0xee, 0x1e, 0x8d, 0xfb, 0x57, 0xef, 0xee, + 0xd9, 0x9d, 0x38, 0xd8, 0x36, 0x82, 0xcf, 0xc1, 0x23, 0x22, 0x28, 0x56, 0x34, 0x42, 0x58, 0xa1, + 0x70, 0xce, 0xc9, 0x07, 0x34, 0xa3, 0x6c, 0x3a, 0x53, 0x76, 0xa3, 0x6b, 0xf4, 0x2a, 0x41, 0xbb, + 0xc0, 0x03, 0x35, 0xdc, 0xc0, 0x4b, 0xcd, 0x36, 0xb2, 0x2c, 0x8d, 0x76, 0xca, 0x9a, 0xb9, 0xac, + 0xc0, 0x7f, 0xc8, 0x3a, 0xdf, 0xca, 0x00, 0xfc, 0xae, 0x04, 0x1e, 0x01, 0xa8, 0x4b, 0x47, 0x82, + 0xbe, 0xa3, 0x82, 0x26, 0x84, 0x22, 0x16, 0xe5, 0xcb, 0x09, 0x2c, 0x4d, 0x82, 0x5b, 0xe0, 0x47, + 0x70, 0x02, 0x4c, 0xa9, 0xb0, 0xca, 0xa4, 0x5e, 0xc8, 0x5e, 0xff, 0xe4, 0x3e, 0xdd, 0xbb, 0x13, + 0x6d, 0x11, 0x14, 0x56, 0xd0, 0x06, 0x75, 0x9c, 0xaf, 0xbe, 0xd8, 0xe9, 0x6d, 0xf8, 0xbf, 0xc9, + 0x54, 0xef, 0x37, 0x99, 0xda, 0xbf, 0x27, 0x73, 0x78, 0x02, 0xcc, 0xbc, 0x32, 0xd8, 0x02, 0xf5, + 0xd7, 0xa3, 0xf1, 0x99, 0x3f, 0xbe, 0xb0, 0x4a, 0xf0, 0x01, 0x68, 0xfa, 0x63, 0x74, 0xfe, 0xd2, + 0xbf, 0xb8, 0xbc, 0xb2, 0x0c, 0x08, 0x80, 0x39, 0x38, 0xbd, 0xf2, 0xaf, 0x47, 0x56, 0x19, 0x36, + 0x41, 0x6d, 0x14, 0x04, 0xaf, 0x02, 0xab, 0x32, 0x3c, 0xff, 0xb2, 0x72, 0x8c, 0x9b, 0x95, 0x63, + 0xfc, 0x58, 0x39, 0xc6, 0xa7, 0xb5, 0x53, 0xba, 0x59, 0x3b, 0xa5, 0xef, 0x6b, 0xa7, 0xf4, 0xf6, + 0x68, 0xca, 0xd4, 0x2c, 0x0b, 0x5d, 0xc2, 0x63, 0x6f, 0xc7, 0xe1, 0x2d, 0xfa, 0xde, 0x47, 0x7d, + 0x7d, 0x6a, 0x99, 0x52, 0x19, 0x9a, 0xfa, 0x7a, 0x9e, 0xfe, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xfb, + 0x53, 0x5e, 0x29, 0xa4, 0x03, 0x00, 0x00, } func (m *UserSmartContract) Marshal() (dAtA []byte, err error) { @@ -437,6 +450,7 @@ func encodeVarintUserSmartContract(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *UserSmartContract) Size() (n int) { if m == nil { return 0 @@ -510,9 +524,11 @@ func (m *UserSmartContract_Deployment) Size() (n int) { func sovUserSmartContract(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozUserSmartContract(x uint64) (n int) { return sovUserSmartContract(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *UserSmartContract) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -814,6 +830,7 @@ func (m *UserSmartContract) Unmarshal(dAtA []byte) error { } return nil } + func (m *UserSmartContract_Deployment) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -985,6 +1002,7 @@ func (m *UserSmartContract_Deployment) Unmarshal(dAtA []byte) error { } return nil } + func skipUserSmartContract(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/metrix/types/genesis.pb.go b/x/metrix/types/genesis.pb.go index 45ce3dd8..90c97b9e 100644 --- a/x/metrix/types/genesis.pb.go +++ b/x/metrix/types/genesis.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -34,9 +37,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_8784068bd0578a97, []int{0} } + 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) @@ -49,12 +54,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) 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) } @@ -77,7 +85,7 @@ func init() { } var fileDescriptor_8784068bd0578a97 = []byte{ - // 194 bytes of a gzipped FileDescriptorProto + // 197 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2f, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x73, 0x53, 0x4b, 0x8a, 0x32, 0x2b, 0xf4, 0xd3, 0x53, 0xf3, 0x52, 0x8b, 0x33, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, @@ -85,12 +93,12 @@ var fileDescriptor_8784068bd0578a97 = []byte{ 0x55, 0xfa, 0x20, 0x16, 0x44, 0x83, 0x94, 0x1a, 0x6e, 0x93, 0x0b, 0x12, 0x8b, 0x12, 0x73, 0xa1, 0x06, 0x2b, 0xf9, 0x73, 0xf1, 0xb8, 0x43, 0x6c, 0x0a, 0x2e, 0x49, 0x2c, 0x49, 0x15, 0xb2, 0xe7, 0x62, 0x83, 0xc8, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x29, 0xea, 0xe1, 0xb4, 0x59, 0x2f, - 0x00, 0xac, 0xd0, 0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0xa8, 0x36, 0x27, 0xb7, 0x13, 0x8f, + 0x00, 0xac, 0xd0, 0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0xa8, 0x36, 0x27, 0xcf, 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, 0x49, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, - 0x4b, 0xce, 0xcf, 0xd5, 0xc7, 0xe2, 0xba, 0x0a, 0x98, 0xfb, 0x4a, 0x2a, 0x0b, 0x52, 0x8b, 0x93, - 0xd8, 0xc0, 0xee, 0x33, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xe7, 0xe4, 0x8f, 0x23, 0x01, - 0x00, 0x00, + 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0xd2, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, + 0x4b, 0xce, 0xcf, 0xd5, 0xc7, 0xe2, 0xba, 0x32, 0x23, 0xfd, 0x0a, 0x98, 0x13, 0x4b, 0x2a, 0x0b, + 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0x4e, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x63, 0x6d, 0xd6, + 0x37, 0x26, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -137,6 +145,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -151,9 +160,11 @@ func (m *GenesisState) Size() (n int) { 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 *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -237,6 +248,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/metrix/types/metrix.pb.go b/x/metrix/types/metrix.pb.go index 55d3b473..3b663d48 100644 --- a/x/metrix/types/metrix.pb.go +++ b/x/metrix/types/metrix.pb.go @@ -4,23 +4,26 @@ package types import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + cosmossdk_io_math "cosmossdk.io/math" _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/types/query" _ "github.com/cosmos/cosmos-sdk/types/tx/amino" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" _ "google.golang.org/genproto/googleapis/api/annotations" - 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -57,9 +60,11 @@ func (*ValidatorMetrics) ProtoMessage() {} func (*ValidatorMetrics) Descriptor() ([]byte, []int) { return fileDescriptor_bb382b6ba8ce0e33, []int{0} } + func (m *ValidatorMetrics) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ValidatorMetrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ValidatorMetrics.Marshal(b, m, deterministic) @@ -72,12 +77,15 @@ func (m *ValidatorMetrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *ValidatorMetrics) XXX_Merge(src proto.Message) { xxx_messageInfo_ValidatorMetrics.Merge(m, src) } + func (m *ValidatorMetrics) XXX_Size() int { return m.Size() } + func (m *ValidatorMetrics) XXX_DiscardUnknown() { xxx_messageInfo_ValidatorMetrics.DiscardUnknown(m) } @@ -107,9 +115,11 @@ func (*ValidatorHistory) ProtoMessage() {} func (*ValidatorHistory) Descriptor() ([]byte, []int) { return fileDescriptor_bb382b6ba8ce0e33, []int{1} } + func (m *ValidatorHistory) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ValidatorHistory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ValidatorHistory.Marshal(b, m, deterministic) @@ -122,12 +132,15 @@ func (m *ValidatorHistory) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *ValidatorHistory) XXX_Merge(src proto.Message) { xxx_messageInfo_ValidatorHistory.Merge(m, src) } + func (m *ValidatorHistory) XXX_Size() int { return m.Size() } + func (m *ValidatorHistory) XXX_DiscardUnknown() { xxx_messageInfo_ValidatorHistory.DiscardUnknown(m) } @@ -160,9 +173,11 @@ func (*HistoricRelayData) ProtoMessage() {} func (*HistoricRelayData) Descriptor() ([]byte, []int) { return fileDescriptor_bb382b6ba8ce0e33, []int{2} } + func (m *HistoricRelayData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *HistoricRelayData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_HistoricRelayData.Marshal(b, m, deterministic) @@ -175,12 +190,15 @@ func (m *HistoricRelayData) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *HistoricRelayData) XXX_Merge(src proto.Message) { xxx_messageInfo_HistoricRelayData.Merge(m, src) } + func (m *HistoricRelayData) XXX_Size() int { return m.Size() } + func (m *HistoricRelayData) XXX_DiscardUnknown() { xxx_messageInfo_HistoricRelayData.DiscardUnknown(m) } @@ -219,44 +237,44 @@ func init() { } var fileDescriptor_bb382b6ba8ce0e33 = []byte{ - // 582 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xcf, 0x4f, 0x14, 0x31, - 0x14, 0xc7, 0x77, 0xd8, 0x95, 0x1f, 0x5d, 0x35, 0x32, 0x41, 0x33, 0xa0, 0xee, 0x12, 0x0e, 0x86, - 0x10, 0x98, 0x8a, 0x26, 0x26, 0x70, 0x73, 0x43, 0x8c, 0x9b, 0xa8, 0x89, 0x83, 0x91, 0xe8, 0x65, - 0xf2, 0xb6, 0xf3, 0x18, 0x1a, 0x66, 0xa6, 0x63, 0xdb, 0x21, 0xec, 0x7f, 0xa1, 0x37, 0x8f, 0x9c, - 0x8c, 0x47, 0x0f, 0xfc, 0x11, 0x1c, 0x09, 0x27, 0xe3, 0x81, 0x18, 0x38, 0xe8, 0x9f, 0xe0, 0xd1, - 0xcc, 0xb4, 0x0b, 0x24, 0xa8, 0x07, 0xf7, 0xb2, 0xdb, 0xf6, 0x7d, 0xdf, 0xa7, 0xdf, 0xf6, 0xf5, - 0x0d, 0xb9, 0x97, 0x43, 0x22, 0x52, 0x60, 0x5b, 0xc0, 0x33, 0x6a, 0xc6, 0x34, 0x45, 0x2d, 0xf9, - 0xae, 0xfd, 0xf3, 0x73, 0x29, 0xb4, 0x70, 0xa7, 0x2f, 0xe8, 0x7c, 0x33, 0xf6, 0x8d, 0x60, 0x66, - 0x2a, 0x16, 0xb1, 0xa8, 0x54, 0xb4, 0x1c, 0x99, 0x84, 0x99, 0x3b, 0xb1, 0x10, 0x71, 0x82, 0x14, - 0x72, 0x4e, 0x21, 0xcb, 0x84, 0x06, 0xcd, 0x45, 0xa6, 0x6c, 0x74, 0x81, 0x09, 0x95, 0x0a, 0x45, - 0x7b, 0xa0, 0x90, 0xbe, 0x2b, 0x50, 0xf6, 0xe9, 0xce, 0x72, 0x0f, 0x35, 0x2c, 0xd3, 0x1c, 0x62, - 0x9e, 0x55, 0x62, 0xab, 0x9d, 0x36, 0xda, 0xd0, 0x6c, 0x61, 0x26, 0x36, 0xf4, 0x0f, 0xf7, 0x39, - 0x48, 0x48, 0x07, 0xba, 0x49, 0x48, 0x79, 0x26, 0x68, 0xf5, 0x6b, 0x96, 0xe6, 0x7e, 0xd5, 0xc9, - 0x8d, 0xd7, 0x90, 0xf0, 0x08, 0xb4, 0x90, 0xcf, 0xcb, 0x1c, 0xa6, 0xdc, 0x15, 0xd2, 0xdc, 0x81, - 0x24, 0x84, 0x28, 0x92, 0xa8, 0x94, 0xe7, 0xcc, 0x3a, 0xf3, 0x13, 0x1d, 0xef, 0x68, 0x7f, 0x69, - 0xca, 0x6e, 0xfb, 0xd8, 0x44, 0xd6, 0xb5, 0xe4, 0x59, 0x1c, 0x90, 0x1d, 0x48, 0xec, 0x8a, 0xfb, - 0x82, 0x8c, 0x16, 0xb9, 0xe6, 0x29, 0x7a, 0x23, 0x55, 0xd6, 0xa3, 0x83, 0xe3, 0x76, 0xed, 0xdb, - 0x71, 0xfb, 0xb6, 0xc9, 0x54, 0xd1, 0xb6, 0xcf, 0x05, 0x4d, 0x41, 0x6f, 0xf9, 0xcf, 0x30, 0x06, - 0xd6, 0x5f, 0x43, 0x76, 0xb4, 0xbf, 0x44, 0x2c, 0x78, 0x0d, 0xd9, 0xe7, 0x1f, 0x5f, 0x16, 0x9c, - 0xc0, 0x52, 0xdc, 0x37, 0xe4, 0xaa, 0x2a, 0x18, 0x43, 0xa5, 0x42, 0x09, 0x1a, 0xbd, 0xfa, 0x50, - 0xd4, 0xa6, 0x65, 0x05, 0xa0, 0xd1, 0xdd, 0x20, 0xd7, 0x71, 0x17, 0x59, 0x51, 0xde, 0x71, 0x58, - 0x59, 0x6e, 0x54, 0xf0, 0xfb, 0x16, 0x7e, 0xf3, 0x32, 0xbc, 0x9b, 0xe9, 0x0b, 0xd8, 0x6e, 0xa6, - 0x0d, 0xf6, 0xda, 0x19, 0xe7, 0x55, 0xe9, 0xb9, 0x43, 0xea, 0x9b, 0x88, 0xde, 0x95, 0xff, 0xa4, - 0x95, 0xc9, 0xee, 0x06, 0x69, 0x6e, 0x22, 0xe8, 0x42, 0x62, 0xa8, 0x50, 0x7b, 0xa3, 0x43, 0x1d, - 0x9b, 0x58, 0xd4, 0x3a, 0xea, 0xd5, 0xf1, 0x8f, 0x7b, 0x6d, 0xe7, 0xe7, 0x5e, 0xdb, 0x99, 0xfb, - 0xe4, 0x5c, 0x28, 0xfd, 0x53, 0xae, 0xb4, 0x90, 0xfd, 0x61, 0x4a, 0xff, 0x92, 0x8c, 0x49, 0x64, - 0x42, 0x46, 0xca, 0x1b, 0x99, 0xad, 0xcf, 0x37, 0x1f, 0x2c, 0xfa, 0x7f, 0xed, 0x16, 0xdf, 0xec, - 0xc7, 0x59, 0x80, 0x09, 0xf4, 0xd7, 0x40, 0x43, 0x67, 0xa2, 0x3c, 0x9c, 0xf1, 0x3b, 0xe0, 0xac, - 0x36, 0x4a, 0xb3, 0x73, 0x1f, 0x1c, 0x32, 0x79, 0x49, 0xef, 0xde, 0x25, 0x24, 0x45, 0xa5, 0x20, - 0xc6, 0x90, 0x47, 0x95, 0xd1, 0x46, 0x30, 0x61, 0x57, 0xba, 0x91, 0xeb, 0x91, 0x31, 0x5b, 0xec, - 0xea, 0x25, 0x8e, 0x07, 0x83, 0xa9, 0xbb, 0x42, 0xa6, 0xcf, 0xeb, 0xae, 0x72, 0xc4, 0x28, 0xe4, - 0x59, 0xd8, 0x4b, 0x04, 0xdb, 0x56, 0xd5, 0xfb, 0x6a, 0x04, 0xb7, 0xce, 0x04, 0xeb, 0x65, 0xbc, - 0x9b, 0x75, 0xaa, 0xe8, 0xf9, 0xe5, 0x75, 0x9e, 0x1c, 0x9c, 0xb4, 0x9c, 0xc3, 0x93, 0x96, 0xf3, - 0xfd, 0xa4, 0xe5, 0xbc, 0x3f, 0x6d, 0xd5, 0x0e, 0x4f, 0x5b, 0xb5, 0xaf, 0xa7, 0xad, 0xda, 0xdb, - 0xc5, 0x98, 0xeb, 0xad, 0xa2, 0xe7, 0x33, 0x91, 0xd2, 0x3f, 0xf4, 0xe5, 0xe0, 0x83, 0x42, 0x75, - 0x3f, 0x47, 0xd5, 0x1b, 0xad, 0xda, 0xf0, 0xe1, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x26, 0x30, - 0x76, 0xa9, 0x81, 0x04, 0x00, 0x00, + // 585 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x4f, 0x4f, 0x14, 0x3f, + 0x18, 0xc7, 0x77, 0xd8, 0xfd, 0xf1, 0xa7, 0xfb, 0xd3, 0xc8, 0x04, 0xcd, 0x80, 0xba, 0x4b, 0x38, + 0x18, 0x42, 0x64, 0x2a, 0x98, 0x98, 0xc0, 0xcd, 0x0d, 0x07, 0x37, 0x51, 0x13, 0x07, 0x23, 0xd1, + 0xcb, 0xe4, 0xd9, 0xce, 0xc3, 0xd0, 0x30, 0x33, 0x1d, 0xdb, 0xce, 0x86, 0x7d, 0x17, 0x7a, 0xf3, + 0xc8, 0xc9, 0x78, 0xf4, 0xc0, 0x8b, 0xe0, 0x48, 0x38, 0x19, 0x0f, 0xc4, 0xc0, 0x41, 0x5f, 0x82, + 0x47, 0x33, 0xd3, 0x2e, 0x90, 0xa0, 0x1e, 0xdc, 0xcb, 0x6e, 0xdb, 0xe7, 0xfb, 0x7c, 0xfa, 0x6d, + 0x9f, 0x3e, 0x43, 0xee, 0xe5, 0x90, 0x88, 0x14, 0xd8, 0x0e, 0xf0, 0x8c, 0x9a, 0x31, 0x4d, 0x51, + 0x4b, 0xbe, 0x67, 0xff, 0xfc, 0x5c, 0x0a, 0x2d, 0xdc, 0xd9, 0x4b, 0x3a, 0xdf, 0x8c, 0x7d, 0x23, + 0x98, 0x9b, 0x89, 0x45, 0x2c, 0x2a, 0x15, 0x2d, 0x47, 0x26, 0x61, 0xee, 0x4e, 0x2c, 0x44, 0x9c, + 0x20, 0x85, 0x9c, 0x53, 0xc8, 0x32, 0xa1, 0x41, 0x73, 0x91, 0x29, 0x1b, 0x5d, 0x62, 0x42, 0xa5, + 0x42, 0xd1, 0x1e, 0x28, 0xa4, 0x6f, 0x0b, 0x94, 0x03, 0xda, 0x5f, 0xe9, 0xa1, 0x86, 0x15, 0x9a, + 0x43, 0xcc, 0xb3, 0x4a, 0x6c, 0xb5, 0xb3, 0x46, 0x1b, 0x9a, 0x2d, 0xcc, 0xc4, 0x86, 0xfe, 0xe2, + 0x3e, 0x07, 0x09, 0xe9, 0x50, 0x37, 0x0d, 0x29, 0xcf, 0x04, 0xad, 0x7e, 0xcd, 0xd2, 0xc2, 0xcf, + 0x3a, 0xb9, 0xf1, 0x0a, 0x12, 0x1e, 0x81, 0x16, 0xf2, 0x59, 0x99, 0xc3, 0x94, 0xbb, 0x46, 0x9a, + 0x7d, 0x48, 0x42, 0x88, 0x22, 0x89, 0x4a, 0x79, 0xce, 0xbc, 0xb3, 0x38, 0xd5, 0xf1, 0x8e, 0x0f, + 0x96, 0x67, 0xec, 0xb6, 0x8f, 0x4d, 0x64, 0x53, 0x4b, 0x9e, 0xc5, 0x01, 0xe9, 0x43, 0x62, 0x57, + 0xdc, 0xe7, 0x64, 0xbc, 0xc8, 0x35, 0x4f, 0xd1, 0x1b, 0xab, 0xb2, 0x1e, 0x1d, 0x9e, 0xb4, 0x6b, + 0x5f, 0x4f, 0xda, 0xb7, 0x4d, 0xa6, 0x8a, 0x76, 0x7d, 0x2e, 0x68, 0x0a, 0x7a, 0xc7, 0x7f, 0x8a, + 0x31, 0xb0, 0xc1, 0x06, 0xb2, 0xe3, 0x83, 0x65, 0x62, 0xc1, 0x1b, 0xc8, 0x3e, 0x7d, 0xff, 0xbc, + 0xe4, 0x04, 0x96, 0xe2, 0xbe, 0x26, 0xff, 0xab, 0x82, 0x31, 0x54, 0x2a, 0x94, 0xa0, 0xd1, 0xab, + 0x8f, 0x44, 0x6d, 0x5a, 0x56, 0x00, 0x1a, 0xdd, 0x2d, 0x72, 0x1d, 0xf7, 0x90, 0x15, 0xe5, 0x1d, + 0x87, 0x95, 0xe5, 0x46, 0x05, 0x7f, 0x60, 0xe1, 0x37, 0xaf, 0xc2, 0xbb, 0x99, 0xbe, 0x84, 0xed, + 0x66, 0xda, 0x60, 0xaf, 0x9d, 0x73, 0x5e, 0x96, 0x9e, 0x3b, 0xa4, 0xbe, 0x8d, 0xe8, 0xfd, 0xf7, + 0x8f, 0xb4, 0x32, 0xd9, 0xdd, 0x22, 0xcd, 0x6d, 0x04, 0x5d, 0x48, 0x0c, 0x15, 0x6a, 0x6f, 0x7c, + 0xa4, 0x63, 0x13, 0x8b, 0xda, 0x44, 0xbd, 0x3e, 0xf9, 0x61, 0xbf, 0xed, 0xfc, 0xd8, 0x6f, 0x3b, + 0x0b, 0x1f, 0x9d, 0x4b, 0xa5, 0x7f, 0xc2, 0x95, 0x16, 0x72, 0x30, 0x4a, 0xe9, 0x5f, 0x90, 0x09, + 0x89, 0x4c, 0xc8, 0x48, 0x79, 0x63, 0xf3, 0xf5, 0xc5, 0xe6, 0xea, 0x7d, 0xff, 0x8f, 0xdd, 0xe2, + 0x9b, 0xfd, 0x38, 0x0b, 0x30, 0x81, 0xc1, 0x06, 0x68, 0xe8, 0x4c, 0x95, 0x87, 0x33, 0x7e, 0x87, + 0x9c, 0xf5, 0x46, 0x69, 0x76, 0xe1, 0xbd, 0x43, 0xa6, 0xaf, 0xe8, 0xdd, 0xbb, 0x84, 0xa4, 0xa8, + 0x14, 0xc4, 0x18, 0xf2, 0xa8, 0x32, 0xda, 0x08, 0xa6, 0xec, 0x4a, 0x37, 0x72, 0x3d, 0x32, 0x61, + 0x8b, 0x5d, 0xbd, 0xc4, 0xc9, 0x60, 0x38, 0x75, 0xd7, 0xc8, 0xec, 0x45, 0xdd, 0x55, 0x8e, 0x18, + 0x85, 0x3c, 0x0b, 0x7b, 0x89, 0x60, 0xbb, 0xaa, 0x7a, 0x5f, 0x8d, 0xe0, 0xd6, 0xb9, 0x60, 0xb3, + 0x8c, 0x77, 0xb3, 0x4e, 0x15, 0xbd, 0xb8, 0xbc, 0x4e, 0xf7, 0xf0, 0xb4, 0xe5, 0x1c, 0x9d, 0xb6, + 0x9c, 0x6f, 0xa7, 0x2d, 0xe7, 0xdd, 0x59, 0xab, 0x76, 0x74, 0xd6, 0xaa, 0x7d, 0x39, 0x6b, 0xd5, + 0xde, 0xd0, 0x98, 0xeb, 0x9d, 0xa2, 0xe7, 0x33, 0x91, 0xd2, 0xdf, 0xf4, 0x65, 0x7f, 0x95, 0x0e, + 0xbf, 0x29, 0x54, 0x0f, 0x72, 0x54, 0xbd, 0xf1, 0xaa, 0x13, 0x1f, 0xfe, 0x0a, 0x00, 0x00, 0xff, + 0xff, 0xc1, 0x5d, 0x45, 0xba, 0x84, 0x04, 0x00, 0x00, } func (this *ValidatorMetrics) Equal(that interface{}) bool { @@ -298,6 +316,7 @@ func (this *ValidatorMetrics) Equal(that interface{}) bool { } return true } + func (this *HistoricRelayData) Equal(that interface{}) bool { if that == nil { return this == nil @@ -328,6 +347,7 @@ func (this *HistoricRelayData) Equal(that interface{}) bool { } return true } + func (m *ValidatorMetrics) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -506,6 +526,7 @@ func encodeVarintMetrix(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *ValidatorMetrics) Size() (n int) { if m == nil { return 0 @@ -569,9 +590,11 @@ func (m *HistoricRelayData) Size() (n int) { func sovMetrix(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozMetrix(x uint64) (n int) { return sovMetrix(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *ValidatorMetrics) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -824,6 +847,7 @@ func (m *ValidatorMetrics) Unmarshal(dAtA []byte) error { } return nil } + func (m *ValidatorHistory) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -940,6 +964,7 @@ func (m *ValidatorHistory) Unmarshal(dAtA []byte) error { } return nil } + func (m *HistoricRelayData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1048,6 +1073,7 @@ func (m *HistoricRelayData) Unmarshal(dAtA []byte) error { } return nil } + func skipMetrix(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/metrix/types/params.pb.go b/x/metrix/types/params.pb.go index 9348d8bb..c9816044 100644 --- a/x/metrix/types/params.pb.go +++ b/x/metrix/types/params.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -24,17 +27,18 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Params defines the parameters for the module. -type Params struct { -} +type Params struct{} func (m *Params) Reset() { *m = Params{} } func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_4599a2135100af36, []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) @@ -47,12 +51,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 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) } @@ -68,17 +75,17 @@ func init() { } var fileDescriptor_4599a2135100af36 = []byte{ - // 152 bytes of a gzipped FileDescriptorProto + // 155 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2b, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x73, 0x53, 0x4b, 0x8a, 0x32, 0x2b, 0xf4, 0x0b, 0x12, 0x8b, 0x12, 0x73, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x24, 0x91, 0xd4, 0xe9, 0x41, 0xd8, 0x7a, 0x10, 0x75, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x55, 0xfa, 0x20, 0x16, 0x44, 0x83, 0x12, 0x1f, 0x17, 0x5b, 0x00, 0xd8, 0x00, 0x2b, 0x96, 0x19, 0x0b, - 0xe4, 0x19, 0x9c, 0xdc, 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, 0x27, - 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x8b, 0x6b, 0x2a, 0x60, 0xee, - 0x29, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x1b, 0x6f, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, - 0x87, 0xe7, 0x32, 0x35, 0xb9, 0x00, 0x00, 0x00, + 0xe4, 0x19, 0x9c, 0x3c, 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, 0x3f, + 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x8b, 0x6b, 0xca, 0x8c, 0xf4, + 0x2b, 0x60, 0x4e, 0x2a, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0xdb, 0x60, 0x0c, 0x08, 0x00, + 0x00, 0xff, 0xff, 0x5b, 0xbc, 0x37, 0xdd, 0xbc, 0x00, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -115,6 +122,7 @@ func encodeVarintParams(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -127,9 +135,11 @@ func (m *Params) Size() (n int) { func sovParams(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozParams(x uint64) (n int) { return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -180,6 +190,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func skipParams(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/metrix/types/query.pb.go b/x/metrix/types/query.pb.go index a72c4496..eed99719 100644 --- a/x/metrix/types/query.pb.go +++ b/x/metrix/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/types/query" _ "github.com/cosmos/cosmos-sdk/types/tx/amino" @@ -16,15 +20,14 @@ import ( 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -33,8 +36,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Empty represents an empty message -type Empty struct { -} +type Empty struct{} func (m *Empty) Reset() { *m = Empty{} } func (m *Empty) String() string { return proto.CompactTextString(m) } @@ -42,9 +44,11 @@ func (*Empty) ProtoMessage() {} func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor_3c46127e87024275, []int{0} } + func (m *Empty) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Empty.Marshal(b, m, deterministic) @@ -57,12 +61,15 @@ func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Empty) XXX_Merge(src proto.Message) { xxx_messageInfo_Empty.Merge(m, src) } + func (m *Empty) XXX_Size() int { return m.Size() } + func (m *Empty) XXX_DiscardUnknown() { xxx_messageInfo_Empty.DiscardUnknown(m) } @@ -70,8 +77,7 @@ func (m *Empty) XXX_DiscardUnknown() { var xxx_messageInfo_Empty proto.InternalMessageInfo // QueryParamsRequest is request type for the Query/Params RPC method. -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -79,9 +85,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_3c46127e87024275, []int{1} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -94,12 +102,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -118,9 +129,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_3c46127e87024275, []int{2} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -133,12 +146,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -165,9 +181,11 @@ func (*QueryValidatorRequest) ProtoMessage() {} func (*QueryValidatorRequest) Descriptor() ([]byte, []int) { return fileDescriptor_3c46127e87024275, []int{3} } + func (m *QueryValidatorRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryValidatorRequest.Marshal(b, m, deterministic) @@ -180,12 +198,15 @@ func (m *QueryValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byt return b[:n], nil } } + func (m *QueryValidatorRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryValidatorRequest.Merge(m, src) } + func (m *QueryValidatorRequest) XXX_Size() int { return m.Size() } + func (m *QueryValidatorRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryValidatorRequest.DiscardUnknown(m) } @@ -212,9 +233,11 @@ func (*QueryValidatorResponse) ProtoMessage() {} func (*QueryValidatorResponse) Descriptor() ([]byte, []int) { return fileDescriptor_3c46127e87024275, []int{4} } + func (m *QueryValidatorResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryValidatorResponse.Marshal(b, m, deterministic) @@ -227,12 +250,15 @@ func (m *QueryValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *QueryValidatorResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryValidatorResponse.Merge(m, src) } + func (m *QueryValidatorResponse) XXX_Size() int { return m.Size() } + func (m *QueryValidatorResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryValidatorResponse.DiscardUnknown(m) } @@ -259,9 +285,11 @@ func (*QueryValidatorsResponse) ProtoMessage() {} func (*QueryValidatorsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_3c46127e87024275, []int{5} } + func (m *QueryValidatorsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryValidatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryValidatorsResponse.Marshal(b, m, deterministic) @@ -274,12 +302,15 @@ func (m *QueryValidatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryValidatorsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryValidatorsResponse.Merge(m, src) } + func (m *QueryValidatorsResponse) XXX_Size() int { return m.Size() } + func (m *QueryValidatorsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryValidatorsResponse.DiscardUnknown(m) } @@ -307,9 +338,11 @@ func (*QueryHistoricRelayDataRequest) ProtoMessage() {} func (*QueryHistoricRelayDataRequest) Descriptor() ([]byte, []int) { return fileDescriptor_3c46127e87024275, []int{6} } + func (m *QueryHistoricRelayDataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryHistoricRelayDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryHistoricRelayDataRequest.Marshal(b, m, deterministic) @@ -322,12 +355,15 @@ func (m *QueryHistoricRelayDataRequest) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } + func (m *QueryHistoricRelayDataRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryHistoricRelayDataRequest.Merge(m, src) } + func (m *QueryHistoricRelayDataRequest) XXX_Size() int { return m.Size() } + func (m *QueryHistoricRelayDataRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryHistoricRelayDataRequest.DiscardUnknown(m) } @@ -354,9 +390,11 @@ func (*QueryHistoricRelayDataResponse) ProtoMessage() {} func (*QueryHistoricRelayDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor_3c46127e87024275, []int{7} } + func (m *QueryHistoricRelayDataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryHistoricRelayDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryHistoricRelayDataResponse.Marshal(b, m, deterministic) @@ -369,12 +407,15 @@ func (m *QueryHistoricRelayDataResponse) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *QueryHistoricRelayDataResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryHistoricRelayDataResponse.Merge(m, src) } + func (m *QueryHistoricRelayDataResponse) XXX_Size() int { return m.Size() } + func (m *QueryHistoricRelayDataResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryHistoricRelayDataResponse.DiscardUnknown(m) } @@ -404,49 +445,51 @@ func init() { } var fileDescriptor_3c46127e87024275 = []byte{ - // 578 bytes of a gzipped FileDescriptorProto + // 580 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xbd, 0x6f, 0xd3, 0x40, - 0x18, 0xc6, 0x63, 0x20, 0xa9, 0x72, 0x9d, 0x7a, 0x04, 0x68, 0x2d, 0x30, 0xad, 0x69, 0x0b, 0x84, - 0xc6, 0x47, 0xc2, 0x42, 0x27, 0x44, 0x04, 0x88, 0x05, 0xa9, 0x04, 0xa9, 0x48, 0x5d, 0xaa, 0x37, - 0xc9, 0xc9, 0x39, 0xc9, 0xf6, 0x39, 0xbe, 0x4b, 0x84, 0x57, 0x26, 0x46, 0x3e, 0x76, 0x66, 0x46, - 0x86, 0xfe, 0x11, 0x1d, 0x2b, 0x58, 0x98, 0x10, 0x4a, 0x90, 0xf8, 0x37, 0x50, 0xee, 0x2e, 0xe9, - 0x17, 0xf9, 0x28, 0xea, 0x92, 0x9c, 0xef, 0x9e, 0xf7, 0x79, 0x7e, 0xf7, 0xea, 0xb5, 0xd1, 0x5a, - 0x0c, 0x01, 0x0f, 0xa1, 0xd1, 0x02, 0x16, 0x11, 0xbd, 0x26, 0x21, 0x95, 0x09, 0x7b, 0x43, 0xda, - 0x1d, 0x9a, 0xa4, 0x5e, 0x9c, 0x70, 0xc9, 0xf1, 0xd2, 0x11, 0x99, 0xa7, 0xd7, 0x9e, 0x96, 0xd9, - 0x05, 0x9f, 0xfb, 0x5c, 0xa9, 0xc8, 0x60, 0xa5, 0x0b, 0xec, 0xeb, 0x3e, 0xe7, 0x7e, 0x40, 0x09, - 0xc4, 0x8c, 0x40, 0x14, 0x71, 0x09, 0x92, 0xf1, 0x48, 0x98, 0xd3, 0x62, 0x83, 0x8b, 0x90, 0x0b, - 0x52, 0x07, 0x41, 0x75, 0x0e, 0xe9, 0x96, 0xeb, 0x54, 0x42, 0x99, 0xc4, 0xe0, 0xb3, 0x48, 0x89, - 0x8d, 0x76, 0x49, 0x6b, 0x77, 0x75, 0x84, 0x7e, 0x30, 0x47, 0xeb, 0xe3, 0xe1, 0x63, 0x48, 0x20, - 0x9c, 0x41, 0xa7, 0xff, 0x8c, 0x6e, 0x01, 0x42, 0x16, 0x71, 0xa2, 0x7e, 0xf5, 0x96, 0x3b, 0x87, - 0xb2, 0x4f, 0xc3, 0x58, 0xa6, 0x6e, 0x01, 0xe1, 0x97, 0x03, 0xd0, 0x2d, 0x65, 0x5c, 0xa3, 0xed, - 0x0e, 0x15, 0xd2, 0xdd, 0x46, 0x97, 0x8f, 0xed, 0x8a, 0x98, 0x47, 0x82, 0xe2, 0x47, 0x28, 0xa7, - 0x01, 0x16, 0xad, 0x65, 0xeb, 0xce, 0x7c, 0x65, 0xc5, 0x1b, 0xdb, 0x3f, 0x4f, 0x97, 0x56, 0x2f, - 0xed, 0xff, 0xbc, 0x99, 0xa9, 0x99, 0x32, 0xb7, 0x86, 0xae, 0x28, 0xdf, 0x6d, 0x08, 0x58, 0x13, - 0x24, 0x4f, 0x4c, 0x20, 0xde, 0x44, 0xf3, 0x5d, 0x08, 0x76, 0xa1, 0xd9, 0x4c, 0xa8, 0xd0, 0xf6, - 0xf9, 0xea, 0xe2, 0xb7, 0xbd, 0x52, 0xc1, 0x74, 0xe6, 0xb1, 0x3e, 0x79, 0x25, 0x13, 0x16, 0xf9, - 0x35, 0xd4, 0x85, 0xc0, 0xec, 0xb8, 0x6d, 0x74, 0xf5, 0xa4, 0xa7, 0xc1, 0x7d, 0xad, 0x4d, 0x15, - 0x50, 0x63, 0xc8, 0x7c, 0x6f, 0x02, 0xf3, 0xc8, 0xe2, 0x85, 0x2e, 0xa9, 0xe6, 0x07, 0xf4, 0x5f, - 0xfe, 0x7c, 0x2d, 0x5a, 0x2a, 0xd2, 0x6c, 0xbb, 0x09, 0xba, 0x76, 0x3c, 0x52, 0x8c, 0xcf, 0xbc, - 0x78, 0x4e, 0x99, 0x3b, 0xe8, 0x86, 0xca, 0x7c, 0xce, 0x84, 0xe4, 0x09, 0x6b, 0xd4, 0x68, 0x00, - 0xe9, 0x13, 0x90, 0x70, 0x0e, 0x2d, 0x4c, 0x90, 0x33, 0xce, 0xdb, 0x5c, 0x6b, 0x0b, 0xcd, 0xb5, - 0xd4, 0x61, 0x7a, 0x96, 0x36, 0x6a, 0xbf, 0xf4, 0xe8, 0x95, 0x86, 0x36, 0x95, 0x77, 0x59, 0x94, - 0x55, 0xa1, 0xf8, 0xa3, 0x85, 0x72, 0x7a, 0x5a, 0x70, 0x69, 0x82, 0xeb, 0xe9, 0x31, 0xb5, 0xbd, - 0x59, 0xe5, 0xfa, 0x16, 0xee, 0xdd, 0xb7, 0xdf, 0x7f, 0x7f, 0xba, 0x70, 0x0b, 0xaf, 0x90, 0x69, - 0x6f, 0x18, 0xfe, 0x6c, 0xa1, 0xfc, 0xe8, 0x1e, 0xf8, 0xfe, 0xb4, 0xa0, 0x93, 0x03, 0x6d, 0x97, - 0xcf, 0x50, 0x61, 0xe8, 0x36, 0x14, 0xdd, 0x3a, 0x5e, 0x9d, 0x40, 0xd7, 0x1d, 0x21, 0x7d, 0xb0, - 0x10, 0x3a, 0x9c, 0x3f, 0xbc, 0x3c, 0x21, 0x4f, 0xbd, 0xe9, 0x76, 0x65, 0x66, 0xa2, 0xc3, 0x86, - 0x95, 0x14, 0xd2, 0x6d, 0xbc, 0x36, 0x0b, 0x92, 0xc0, 0x7b, 0x16, 0x5a, 0x38, 0x35, 0x43, 0xf8, - 0xe1, 0xb4, 0xe0, 0x71, 0x23, 0x6d, 0x6f, 0xfe, 0x47, 0xa5, 0x21, 0x2f, 0x2a, 0xf2, 0x55, 0xec, - 0x4e, 0x20, 0x37, 0xa3, 0x58, 0x7d, 0xb6, 0xdf, 0x73, 0xac, 0x83, 0x9e, 0x63, 0xfd, 0xea, 0x39, - 0xd6, 0xfb, 0xbe, 0x93, 0x39, 0xe8, 0x3b, 0x99, 0x1f, 0x7d, 0x27, 0xb3, 0xb3, 0xe1, 0x33, 0xd9, - 0xea, 0xd4, 0xbd, 0x06, 0x0f, 0xff, 0xe5, 0x33, 0xfc, 0xce, 0x12, 0x99, 0xc6, 0x54, 0xd4, 0x73, - 0xea, 0xdb, 0xfa, 0xe0, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0xcf, 0xdc, 0x37, 0x7d, 0x06, - 0x00, 0x00, + 0x18, 0xc6, 0x63, 0x20, 0xa9, 0x72, 0x9d, 0x7a, 0x04, 0x68, 0x2d, 0x30, 0xad, 0x69, 0x0b, 0x04, + 0xe2, 0x23, 0x61, 0xa1, 0x13, 0x22, 0x02, 0x09, 0x06, 0xa4, 0x12, 0xa4, 0x22, 0x75, 0xa9, 0xde, + 0x24, 0x27, 0xe7, 0x24, 0xdb, 0xe7, 0xf8, 0x2e, 0x11, 0x5e, 0x99, 0x18, 0xf9, 0xd8, 0x99, 0x19, + 0x19, 0xfa, 0x47, 0x74, 0xac, 0x60, 0x61, 0x42, 0x28, 0x41, 0xe2, 0xdf, 0x40, 0xb9, 0xbb, 0xa4, + 0x5f, 0xe4, 0xa3, 0x55, 0x97, 0xe4, 0x7c, 0xf7, 0xbc, 0xcf, 0xf3, 0xbb, 0x57, 0xaf, 0x8d, 0xd6, + 0x62, 0x08, 0x78, 0x08, 0x8d, 0x16, 0xb0, 0x88, 0xe8, 0x35, 0x09, 0xa9, 0x4c, 0xd8, 0x5b, 0xd2, + 0xee, 0xd0, 0x24, 0xf5, 0xe2, 0x84, 0x4b, 0x8e, 0x97, 0x0e, 0xc9, 0x3c, 0xbd, 0xf6, 0xb4, 0xcc, + 0x2e, 0xf8, 0xdc, 0xe7, 0x4a, 0x45, 0x06, 0x2b, 0x5d, 0x60, 0x5f, 0xf7, 0x39, 0xf7, 0x03, 0x4a, + 0x20, 0x66, 0x04, 0xa2, 0x88, 0x4b, 0x90, 0x8c, 0x47, 0xc2, 0x9c, 0x16, 0x1b, 0x5c, 0x84, 0x5c, + 0x90, 0x3a, 0x08, 0xaa, 0x73, 0x48, 0xb7, 0x5c, 0xa7, 0x12, 0xca, 0x24, 0x06, 0x9f, 0x45, 0x4a, + 0x6c, 0xb4, 0x4b, 0x5a, 0xbb, 0xa3, 0x23, 0xf4, 0x83, 0x39, 0x5a, 0x1f, 0x0f, 0x1f, 0x43, 0x02, + 0xe1, 0x0c, 0x3a, 0xfd, 0x67, 0x74, 0x0b, 0x10, 0xb2, 0x88, 0x13, 0xf5, 0xab, 0xb7, 0xdc, 0x39, + 0x94, 0x7d, 0x16, 0xc6, 0x32, 0x75, 0x0b, 0x08, 0xbf, 0x1a, 0x80, 0x6e, 0x2a, 0xe3, 0x1a, 0x6d, + 0x77, 0xa8, 0x90, 0xee, 0x16, 0xba, 0x7c, 0x64, 0x57, 0xc4, 0x3c, 0x12, 0x14, 0x3f, 0x46, 0x39, + 0x0d, 0xb0, 0x68, 0x2d, 0x5b, 0x77, 0xe6, 0x2b, 0x2b, 0xde, 0xd8, 0xfe, 0x79, 0xba, 0xb4, 0x7a, + 0x69, 0xef, 0xd7, 0xcd, 0x4c, 0xcd, 0x94, 0xb9, 0x35, 0x74, 0x45, 0xf9, 0x6e, 0x41, 0xc0, 0x9a, + 0x20, 0x79, 0x62, 0x02, 0xf1, 0x06, 0x9a, 0xef, 0x42, 0xb0, 0x03, 0xcd, 0x66, 0x42, 0x85, 0xb6, + 0xcf, 0x57, 0x17, 0xbf, 0xef, 0x96, 0x0a, 0xa6, 0x33, 0x4f, 0xf4, 0xc9, 0x6b, 0x99, 0xb0, 0xc8, + 0xaf, 0xa1, 0x2e, 0x04, 0x66, 0xc7, 0x6d, 0xa3, 0xab, 0xc7, 0x3d, 0x0d, 0xee, 0x1b, 0x6d, 0xaa, + 0x80, 0x1a, 0x43, 0xe6, 0x7b, 0x13, 0x98, 0x47, 0x16, 0x2f, 0x75, 0x49, 0x35, 0x3f, 0xa0, 0xff, + 0xfa, 0xf7, 0x5b, 0xd1, 0x52, 0x91, 0x66, 0xdb, 0x4d, 0xd0, 0xb5, 0xa3, 0x91, 0x62, 0x7c, 0xe6, + 0xc5, 0x73, 0xca, 0xdc, 0x46, 0x37, 0x54, 0xe6, 0x73, 0x26, 0x24, 0x4f, 0x58, 0xa3, 0x46, 0x03, + 0x48, 0x9f, 0x82, 0x84, 0x73, 0x68, 0x61, 0x82, 0x9c, 0x71, 0xde, 0xe6, 0x5a, 0x9b, 0x68, 0xae, + 0xa5, 0x0e, 0xd3, 0xd3, 0xb4, 0x51, 0xfb, 0xa5, 0x87, 0xaf, 0x34, 0xb4, 0xa9, 0xbc, 0xcf, 0xa2, + 0xac, 0x0a, 0xc5, 0x9f, 0x2c, 0x94, 0xd3, 0xd3, 0x82, 0x4b, 0x13, 0x5c, 0x4f, 0x8e, 0xa9, 0xed, + 0xcd, 0x2a, 0xd7, 0xb7, 0x70, 0xef, 0xbe, 0xfb, 0xf1, 0xe7, 0xf3, 0x85, 0x5b, 0x78, 0x85, 0x4c, + 0x7b, 0xc3, 0xf0, 0x17, 0x0b, 0xe5, 0x47, 0xf7, 0xc0, 0x0f, 0xa6, 0x05, 0x1d, 0x1f, 0x68, 0xbb, + 0x7c, 0x8a, 0x0a, 0x43, 0x77, 0x5f, 0xd1, 0xad, 0xe3, 0xd5, 0x09, 0x74, 0xdd, 0x11, 0xd2, 0x47, + 0x0b, 0xa1, 0x83, 0xf9, 0xc3, 0xcb, 0x13, 0xf2, 0xd4, 0x9b, 0x6e, 0x57, 0x66, 0x26, 0x3a, 0x68, + 0x58, 0x49, 0x21, 0xdd, 0xc6, 0x6b, 0xb3, 0x20, 0x09, 0xbc, 0x6b, 0xa1, 0x85, 0x13, 0x33, 0x84, + 0x1f, 0x4d, 0x0b, 0x1e, 0x37, 0xd2, 0xf6, 0xc6, 0x19, 0x2a, 0x0d, 0x79, 0x51, 0x91, 0xaf, 0x62, + 0x77, 0x02, 0xb9, 0x19, 0xc5, 0xea, 0x8b, 0xbd, 0x9e, 0x63, 0xed, 0xf7, 0x1c, 0xeb, 0x77, 0xcf, + 0xb1, 0x3e, 0xf4, 0x9d, 0xcc, 0x7e, 0xdf, 0xc9, 0xfc, 0xec, 0x3b, 0x99, 0x6d, 0xe2, 0x33, 0xd9, + 0xea, 0xd4, 0xbd, 0x06, 0x0f, 0xff, 0xe7, 0xd3, 0xad, 0x90, 0xe1, 0xa7, 0x96, 0xc8, 0x34, 0xa6, + 0xa2, 0x9e, 0x53, 0x9f, 0xd7, 0x87, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xbe, 0xba, 0x60, 0x22, + 0x80, 0x06, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -525,18 +568,20 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } + func (*UnimplementedQueryServer) Validator(ctx context.Context, req *QueryValidatorRequest) (*QueryValidatorResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Validator not implemented") } + func (*UnimplementedQueryServer) Validators(ctx context.Context, req *Empty) (*QueryValidatorsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Validators not implemented") } + func (*UnimplementedQueryServer) HistoricRelayData(ctx context.Context, req *QueryHistoricRelayDataRequest) (*QueryHistoricRelayDataResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method HistoricRelayData not implemented") } @@ -895,6 +940,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Empty) Size() (n int) { if m == nil { return 0 @@ -990,9 +1036,11 @@ func (m *QueryHistoricRelayDataResponse) Size() (n int) { 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 *Empty) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1043,6 +1091,7 @@ func (m *Empty) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1093,6 +1142,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1176,6 +1226,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryValidatorRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1258,6 +1309,7 @@ func (m *QueryValidatorRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryValidatorResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1341,6 +1393,7 @@ func (m *QueryValidatorResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryValidatorsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1425,6 +1478,7 @@ func (m *QueryValidatorsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryHistoricRelayDataRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1507,6 +1561,7 @@ func (m *QueryHistoricRelayDataRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryHistoricRelayDataResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1590,6 +1645,7 @@ func (m *QueryHistoricRelayDataResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/metrix/types/tx.pb.go b/x/metrix/types/tx.pb.go index 07af0836..ffb7b659 100644 --- a/x/metrix/types/tx.pb.go +++ b/x/metrix/types/tx.pb.go @@ -6,17 +6,20 @@ package types import ( context "context" fmt "fmt" + math "math" + _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" grpc "google.golang.org/grpc" - math "math" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -29,21 +32,23 @@ func init() { } var fileDescriptor_76ac2829fb25bb75 = []byte{ - // 141 bytes of a gzipped FileDescriptorProto + // 144 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x73, 0x53, 0x4b, 0x8a, 0x32, 0x2b, 0xf4, 0x4b, 0x2a, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x24, 0x91, 0xd4, 0xe8, 0x41, 0xd8, 0x7a, 0x10, 0x35, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x55, 0xfa, 0x20, 0x16, 0x44, - 0x83, 0x11, 0x2b, 0x17, 0xb3, 0x6f, 0x71, 0xba, 0x93, 0xdb, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, + 0x83, 0x11, 0x2b, 0x17, 0xb3, 0x6f, 0x71, 0xba, 0x93, 0xe7, 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, 0xe9, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, - 0x63, 0x71, 0x40, 0x05, 0xdc, 0x09, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0x53, 0x8d, 0x01, - 0x01, 0x00, 0x00, 0xff, 0xff, 0x1e, 0x5a, 0x9c, 0x89, 0xac, 0x00, 0x00, 0x00, + 0x1e, 0xcb, 0x31, 0x44, 0xe9, 0xa7, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, + 0x63, 0x71, 0x40, 0x99, 0x91, 0x7e, 0x05, 0xdc, 0x15, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, + 0x83, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x82, 0x61, 0xf0, 0x4f, 0xaf, 0x00, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -52,8 +57,7 @@ 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 { -} +type MsgClient interface{} type msgClient struct { cc grpc1.ClientConn @@ -64,12 +68,10 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient { } // MsgServer is the server API for Msg service. -type MsgServer interface { -} +type MsgServer interface{} // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) diff --git a/x/paloma/types/light_node_client_feegranter.pb.go b/x/paloma/types/light_node_client_feegranter.pb.go index d039d0c6..ded9ba44 100644 --- a/x/paloma/types/light_node_client_feegranter.pb.go +++ b/x/paloma/types/light_node_client_feegranter.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-proto" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*LightNodeClientFeegranter) ProtoMessage() {} func (*LightNodeClientFeegranter) Descriptor() ([]byte, []int) { return fileDescriptor_8b3e305dcd8c47a6, []int{0} } + func (m *LightNodeClientFeegranter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *LightNodeClientFeegranter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LightNodeClientFeegranter.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *LightNodeClientFeegranter) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *LightNodeClientFeegranter) XXX_Merge(src proto.Message) { xxx_messageInfo_LightNodeClientFeegranter.Merge(m, src) } + func (m *LightNodeClientFeegranter) XXX_Size() int { return m.Size() } + func (m *LightNodeClientFeegranter) XXX_DiscardUnknown() { xxx_messageInfo_LightNodeClientFeegranter.DiscardUnknown(m) } @@ -78,7 +86,7 @@ func init() { } var fileDescriptor_8b3e305dcd8c47a6 = []byte{ - // 234 bytes of a gzipped FileDescriptorProto + // 237 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x29, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0x61, 0x54, 0x4e, 0x66, 0x7a, 0x46, 0x49, 0x7c, 0x5e, 0x7e, 0x4a, 0x6a, 0x7c, 0x72, 0x4e, 0x66, 0x6a, 0x5e, 0x49, 0x7c, 0x5a, 0x6a, @@ -90,10 +98,10 @@ var fileDescriptor_8b3e305dcd8c47a6 = []byte{ 0x05, 0x46, 0x0d, 0x1e, 0x27, 0xc3, 0x5f, 0xf7, 0xe4, 0x75, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xa1, 0x16, 0x40, 0x29, 0xdd, 0xe2, 0x94, 0x6c, 0xfd, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x3d, 0xc7, 0xe4, 0x64, 0xc7, 0x94, 0x94, 0xa2, 0xd4, 0xe2, 0xe2, 0x20, 0x98, 0x09, - 0x4e, 0x6e, 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, 0x83, 0x64, 0x22, - 0x96, 0x80, 0xa9, 0x80, 0x31, 0xc0, 0x66, 0x27, 0xb1, 0x81, 0x1d, 0x6e, 0x0c, 0x08, 0x00, 0x00, - 0xff, 0xff, 0x9b, 0x2d, 0x82, 0xa1, 0x44, 0x01, 0x00, 0x00, + 0x4e, 0x9e, 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, 0x8f, 0x64, 0x22, + 0x96, 0x80, 0x29, 0x33, 0xd2, 0xaf, 0x80, 0xb1, 0xc1, 0xc6, 0x27, 0xb1, 0x81, 0xdd, 0x6e, 0x0c, + 0x08, 0x00, 0x00, 0xff, 0xff, 0x0d, 0x24, 0xb0, 0x96, 0x47, 0x01, 0x00, 0x00, } func (m *LightNodeClientFeegranter) Marshal() (dAtA []byte, err error) { @@ -137,6 +145,7 @@ func encodeVarintLightNodeClientFeegranter(dAtA []byte, offset int, v uint64) in dAtA[offset] = uint8(v) return base } + func (m *LightNodeClientFeegranter) Size() (n int) { if m == nil { return 0 @@ -153,9 +162,11 @@ func (m *LightNodeClientFeegranter) Size() (n int) { func sovLightNodeClientFeegranter(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozLightNodeClientFeegranter(x uint64) (n int) { return sovLightNodeClientFeegranter(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *LightNodeClientFeegranter) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -240,6 +251,7 @@ func (m *LightNodeClientFeegranter) Unmarshal(dAtA []byte) error { } return nil } + func skipLightNodeClientFeegranter(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/paloma/types/light_node_client_feegranter_proposal.pb.go b/x/paloma/types/light_node_client_feegranter_proposal.pb.go index 46558830..329fe24c 100644 --- a/x/paloma/types/light_node_client_feegranter_proposal.pb.go +++ b/x/paloma/types/light_node_client_feegranter_proposal.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -34,9 +37,11 @@ func (*SetLightNodeClientFeegranterProposal) ProtoMessage() {} func (*SetLightNodeClientFeegranterProposal) Descriptor() ([]byte, []int) { return fileDescriptor_1ee4bc8885962708, []int{0} } + func (m *SetLightNodeClientFeegranterProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetLightNodeClientFeegranterProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetLightNodeClientFeegranterProposal.Marshal(b, m, deterministic) @@ -49,12 +54,15 @@ func (m *SetLightNodeClientFeegranterProposal) XXX_Marshal(b []byte, determinist return b[:n], nil } } + func (m *SetLightNodeClientFeegranterProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetLightNodeClientFeegranterProposal.Merge(m, src) } + func (m *SetLightNodeClientFeegranterProposal) XXX_Size() int { return m.Size() } + func (m *SetLightNodeClientFeegranterProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetLightNodeClientFeegranterProposal.DiscardUnknown(m) } @@ -91,7 +99,7 @@ func init() { } var fileDescriptor_1ee4bc8885962708 = []byte{ - // 235 bytes of a gzipped FileDescriptorProto + // 238 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x2d, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0x61, 0x54, 0x4e, 0x66, 0x7a, 0x46, 0x49, 0x7c, 0x5e, 0x7e, 0x4a, 0x6a, 0x7c, 0x72, 0x4e, 0x66, 0x6a, 0x5e, 0x49, 0x7c, 0x5a, 0x6a, @@ -102,11 +110,11 @@ var fileDescriptor_1ee4bc8885962708 = []byte{ 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xce, 0x20, 0x08, 0x47, 0x48, 0x81, 0x8b, 0x3b, 0x25, 0xb5, 0x38, 0xb9, 0x28, 0xb3, 0xa0, 0x24, 0x33, 0x3f, 0x4f, 0x82, 0x09, 0x2c, 0x87, 0x2c, 0x24, 0xa4, 0xcb, 0x25, 0x84, 0xe4, 0xb0, 0xc4, 0xe4, 0xe4, 0xfc, 0xd2, 0xbc, 0x12, 0x09, 0x66, 0xb0, 0x42, - 0x41, 0x84, 0x8c, 0x23, 0x44, 0xc2, 0xc9, 0xed, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, + 0x41, 0x84, 0x8c, 0x23, 0x44, 0xc2, 0xc9, 0xf3, 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, 0x74, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0x04, - 0x4b, 0x05, 0x8c, 0x51, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xf6, 0xb9, 0x31, 0x20, 0x00, - 0x00, 0xff, 0xff, 0x96, 0xa2, 0x34, 0xcc, 0x42, 0x01, 0x00, 0x00, + 0x18, 0xa2, 0xf4, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0x04, + 0x4b, 0x99, 0x91, 0x7e, 0x05, 0x8c, 0x5d, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xf6, 0xbc, + 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x25, 0x71, 0x00, 0x45, 0x01, 0x00, 0x00, } func (m *SetLightNodeClientFeegranterProposal) Marshal() (dAtA []byte, err error) { @@ -164,6 +172,7 @@ func encodeVarintLightNodeClientFeegranterProposal(dAtA []byte, offset int, v ui dAtA[offset] = uint8(v) return base } + func (m *SetLightNodeClientFeegranterProposal) Size() (n int) { if m == nil { return 0 @@ -188,9 +197,11 @@ func (m *SetLightNodeClientFeegranterProposal) Size() (n int) { func sovLightNodeClientFeegranterProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozLightNodeClientFeegranterProposal(x uint64) (n int) { return sovLightNodeClientFeegranterProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetLightNodeClientFeegranterProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -337,6 +348,7 @@ func (m *SetLightNodeClientFeegranterProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipLightNodeClientFeegranterProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/paloma/types/light_node_client_funders.pb.go b/x/paloma/types/light_node_client_funders.pb.go index b77dfd78..b96188c0 100644 --- a/x/paloma/types/light_node_client_funders.pb.go +++ b/x/paloma/types/light_node_client_funders.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-proto" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*LightNodeClientFunders) ProtoMessage() {} func (*LightNodeClientFunders) Descriptor() ([]byte, []int) { return fileDescriptor_d52da0e3b0b8faf1, []int{0} } + func (m *LightNodeClientFunders) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *LightNodeClientFunders) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LightNodeClientFunders.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *LightNodeClientFunders) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *LightNodeClientFunders) XXX_Merge(src proto.Message) { xxx_messageInfo_LightNodeClientFunders.Merge(m, src) } + func (m *LightNodeClientFunders) XXX_Size() int { return m.Size() } + func (m *LightNodeClientFunders) XXX_DiscardUnknown() { xxx_messageInfo_LightNodeClientFunders.DiscardUnknown(m) } @@ -78,7 +86,7 @@ func init() { } var fileDescriptor_d52da0e3b0b8faf1 = []byte{ - // 232 bytes of a gzipped FileDescriptorProto + // 235 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x2c, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0x61, 0x54, 0x4e, 0x66, 0x7a, 0x46, 0x49, 0x7c, 0x5e, 0x7e, 0x4a, 0x6a, 0x7c, 0x72, 0x4e, 0x66, 0x6a, 0x5e, 0x49, 0x7c, 0x5a, 0x69, @@ -89,11 +97,11 @@ var fileDescriptor_d52da0e3b0b8faf1 = []byte{ 0x21, 0x5f, 0x2e, 0x8e, 0xc4, 0xe4, 0xe4, 0xfc, 0xd2, 0xbc, 0x92, 0x62, 0x09, 0x46, 0x05, 0x66, 0x0d, 0x1e, 0x27, 0xc3, 0x5f, 0xf7, 0xe4, 0x75, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xa1, 0xc6, 0x43, 0x29, 0xdd, 0xe2, 0x94, 0x6c, 0xfd, 0x92, 0xca, 0x82, 0xd4, 0x62, - 0x3d, 0xc7, 0xe4, 0x64, 0xc7, 0x94, 0x94, 0xa2, 0xd4, 0xe2, 0xe2, 0x20, 0xb8, 0x11, 0x4e, 0x6e, + 0x3d, 0xc7, 0xe4, 0x64, 0xc7, 0x94, 0x94, 0xa2, 0xd4, 0xe2, 0xe2, 0x20, 0xb8, 0x11, 0x4e, 0x9e, 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, 0x83, 0x64, 0x24, 0x96, 0x40, - 0xa9, 0x80, 0x31, 0xc0, 0x86, 0x27, 0xb1, 0x81, 0xdd, 0x6d, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, - 0xa1, 0x36, 0xea, 0xbf, 0x40, 0x01, 0x00, 0x00, + 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x8f, 0x64, 0x24, 0x96, 0x40, + 0x29, 0x33, 0xd2, 0xaf, 0x80, 0xb1, 0xc1, 0xe6, 0x27, 0xb1, 0x81, 0x9d, 0x6e, 0x0c, 0x08, 0x00, + 0x00, 0xff, 0xff, 0xa5, 0x66, 0x13, 0x55, 0x43, 0x01, 0x00, 0x00, } func (m *LightNodeClientFunders) Marshal() (dAtA []byte, err error) { @@ -139,6 +147,7 @@ func encodeVarintLightNodeClientFunders(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *LightNodeClientFunders) Size() (n int) { if m == nil { return 0 @@ -157,9 +166,11 @@ func (m *LightNodeClientFunders) Size() (n int) { func sovLightNodeClientFunders(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozLightNodeClientFunders(x uint64) (n int) { return sovLightNodeClientFunders(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *LightNodeClientFunders) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -242,6 +253,7 @@ func (m *LightNodeClientFunders) Unmarshal(dAtA []byte) error { } return nil } + func skipLightNodeClientFunders(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/paloma/types/light_node_client_funders_proposal.pb.go b/x/paloma/types/light_node_client_funders_proposal.pb.go index a42cfd62..708fc025 100644 --- a/x/paloma/types/light_node_client_funders_proposal.pb.go +++ b/x/paloma/types/light_node_client_funders_proposal.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -34,9 +37,11 @@ func (*SetLightNodeClientFundersProposal) ProtoMessage() {} func (*SetLightNodeClientFundersProposal) Descriptor() ([]byte, []int) { return fileDescriptor_3ae998f0acf2d7e9, []int{0} } + func (m *SetLightNodeClientFundersProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetLightNodeClientFundersProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetLightNodeClientFundersProposal.Marshal(b, m, deterministic) @@ -49,12 +54,15 @@ func (m *SetLightNodeClientFundersProposal) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *SetLightNodeClientFundersProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetLightNodeClientFundersProposal.Merge(m, src) } + func (m *SetLightNodeClientFundersProposal) XXX_Size() int { return m.Size() } + func (m *SetLightNodeClientFundersProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetLightNodeClientFundersProposal.DiscardUnknown(m) } @@ -91,7 +99,7 @@ func init() { } var fileDescriptor_3ae998f0acf2d7e9 = []byte{ - // 237 bytes of a gzipped FileDescriptorProto + // 240 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0x61, 0x54, 0x4e, 0x66, 0x7a, 0x46, 0x49, 0x7c, 0x5e, 0x7e, 0x4a, 0x6a, 0x7c, 0x72, 0x4e, 0x66, 0x6a, 0x5e, 0x49, 0x7c, 0x5a, 0x69, @@ -102,11 +110,11 @@ var fileDescriptor_3ae998f0acf2d7e9 = []byte{ 0x05, 0x46, 0x0d, 0xce, 0x20, 0x08, 0x47, 0x48, 0x81, 0x8b, 0x3b, 0x25, 0xb5, 0x38, 0xb9, 0x28, 0xb3, 0xa0, 0x24, 0x33, 0x3f, 0x4f, 0x82, 0x09, 0x2c, 0x87, 0x2c, 0x24, 0xa4, 0xce, 0xc5, 0x0f, 0x71, 0x52, 0x7c, 0x62, 0x72, 0x72, 0x7e, 0x69, 0x5e, 0x49, 0xb1, 0x04, 0xb3, 0x02, 0xb3, 0x06, - 0x67, 0x10, 0x1f, 0x44, 0xd8, 0x11, 0x2a, 0xea, 0xe4, 0x76, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, + 0x67, 0x10, 0x1f, 0x44, 0xd8, 0x11, 0x2a, 0xea, 0xe4, 0x79, 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, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, - 0x58, 0x82, 0xa2, 0x02, 0xc6, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x7b, 0xd8, 0x18, - 0x10, 0x00, 0x00, 0xff, 0xff, 0x48, 0x4f, 0x20, 0x32, 0x36, 0x01, 0x00, 0x00, + 0xc7, 0x72, 0x0c, 0x51, 0xfa, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, + 0x58, 0x82, 0xa2, 0xcc, 0x48, 0xbf, 0x02, 0xc6, 0x2e, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, + 0xfb, 0xd9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x16, 0x64, 0x6c, 0x76, 0x39, 0x01, 0x00, 0x00, } func (m *SetLightNodeClientFundersProposal) Marshal() (dAtA []byte, err error) { @@ -166,6 +174,7 @@ func encodeVarintLightNodeClientFundersProposal(dAtA []byte, offset int, v uint6 dAtA[offset] = uint8(v) return base } + func (m *SetLightNodeClientFundersProposal) Size() (n int) { if m == nil { return 0 @@ -192,9 +201,11 @@ func (m *SetLightNodeClientFundersProposal) Size() (n int) { func sovLightNodeClientFundersProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozLightNodeClientFundersProposal(x uint64) (n int) { return sovLightNodeClientFundersProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetLightNodeClientFundersProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -341,6 +352,7 @@ func (m *SetLightNodeClientFundersProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipLightNodeClientFundersProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/paloma/types/light_node_client_license.pb.go b/x/paloma/types/light_node_client_license.pb.go index 3b1e3bc5..bc1d939a 100644 --- a/x/paloma/types/light_node_client_license.pb.go +++ b/x/paloma/types/light_node_client_license.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-proto" types "github.com/cosmos/cosmos-sdk/types" _ "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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*LightNodeClientLicense) ProtoMessage() {} func (*LightNodeClientLicense) Descriptor() ([]byte, []int) { return fileDescriptor_9a9c668113db9311, []int{0} } + func (m *LightNodeClientLicense) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *LightNodeClientLicense) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LightNodeClientLicense.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *LightNodeClientLicense) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *LightNodeClientLicense) XXX_Merge(src proto.Message) { xxx_messageInfo_LightNodeClientLicense.Merge(m, src) } + func (m *LightNodeClientLicense) XXX_Size() int { return m.Size() } + func (m *LightNodeClientLicense) XXX_DiscardUnknown() { xxx_messageInfo_LightNodeClientLicense.DiscardUnknown(m) } @@ -94,27 +102,27 @@ func init() { } var fileDescriptor_9a9c668113db9311 = []byte{ - // 316 bytes of a gzipped FileDescriptorProto + // 318 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0x31, 0x4b, 0xc3, 0x40, - 0x18, 0x86, 0x73, 0x2a, 0x05, 0x23, 0xed, 0x10, 0x8a, 0xa4, 0x1d, 0xce, 0x22, 0x08, 0x1d, 0xf4, - 0x8e, 0xea, 0x20, 0x4e, 0x62, 0x0b, 0x4e, 0xd5, 0xa1, 0x6e, 0x2e, 0xe1, 0x72, 0x39, 0x2e, 0x07, - 0xc9, 0x7d, 0xa5, 0x77, 0x2d, 0xfa, 0x2f, 0xfc, 0x31, 0x2e, 0xfe, 0x83, 0x8e, 0xc5, 0xc9, 0x49, - 0xa4, 0xf9, 0x23, 0x92, 0xdc, 0x15, 0x1c, 0x9c, 0xbe, 0xf7, 0x7b, 0xbf, 0xf7, 0x0d, 0x0f, 0xb9, - 0xf0, 0x66, 0xce, 0x0a, 0x28, 0x19, 0xcf, 0x99, 0xd2, 0xd4, 0xe9, 0xdd, 0x28, 0x94, 0xcc, 0x6d, - 0xa2, 0x21, 0x13, 0x09, 0x2f, 0x94, 0xd0, 0x36, 0x29, 0x14, 0x17, 0xda, 0x08, 0x32, 0x5f, 0x80, - 0x85, 0xa8, 0xf7, 0xa7, 0x4a, 0x9c, 0xf6, 0xa3, 0x8f, 0x39, 0x98, 0x12, 0x0c, 0x4d, 0x99, 0x11, - 0x74, 0x35, 0x4a, 0x85, 0x65, 0x23, 0xca, 0xa1, 0xce, 0xd5, 0xd5, 0x7e, 0xcf, 0xdd, 0x93, 0x66, - 0xa3, 0x6e, 0xf1, 0xa7, 0xae, 0x04, 0x09, 0xce, 0xaf, 0x95, 0x73, 0x4f, 0x3f, 0x50, 0x78, 0x3c, - 0xad, 0x79, 0x1e, 0x21, 0x13, 0x93, 0x86, 0x66, 0xea, 0x60, 0xa2, 0xdb, 0xb0, 0xe3, 0xf1, 0x58, - 0x96, 0x2d, 0x84, 0x31, 0x31, 0x1a, 0xa0, 0xe1, 0xe1, 0x38, 0xfe, 0x7c, 0xbf, 0xe8, 0xfa, 0x4f, - 0xdf, 0xb9, 0xcb, 0x93, 0x5d, 0x28, 0x2d, 0x67, 0x6d, 0x97, 0xf7, 0x66, 0x74, 0x1d, 0xb6, 0x58, - 0x09, 0x4b, 0x6d, 0xe3, 0xbd, 0x01, 0x1a, 0x1e, 0x5d, 0xf6, 0x88, 0x6f, 0xd5, 0xf4, 0xc4, 0xd3, - 0x93, 0x09, 0x28, 0x3d, 0x3e, 0x58, 0x7f, 0x9f, 0x04, 0x33, 0x1f, 0x8f, 0xce, 0xc2, 0xce, 0x4a, - 0x18, 0xab, 0xb4, 0x4c, 0x4a, 0xd0, 0x36, 0x37, 0xf1, 0xfe, 0x00, 0x0d, 0xdb, 0xb3, 0xb6, 0x77, - 0x1f, 0x1a, 0x73, 0x7c, 0xbf, 0xde, 0x62, 0xb4, 0xd9, 0x62, 0xf4, 0xb3, 0xc5, 0xe8, 0xad, 0xc2, - 0xc1, 0xa6, 0xc2, 0xc1, 0x57, 0x85, 0x83, 0xe7, 0x73, 0xa9, 0x6c, 0xbe, 0x4c, 0x09, 0x87, 0x92, - 0xfe, 0xf3, 0x0e, 0x2f, 0x3b, 0x61, 0x5f, 0xe7, 0xc2, 0xa4, 0xad, 0xe6, 0x57, 0x5c, 0xfd, 0x06, - 0x00, 0x00, 0xff, 0xff, 0xdb, 0x7c, 0x00, 0x5d, 0xb3, 0x01, 0x00, 0x00, + 0x18, 0x86, 0x73, 0x2a, 0x05, 0x23, 0xed, 0x10, 0x8a, 0xa4, 0x1d, 0xce, 0x22, 0x08, 0x5d, 0xbc, + 0xa3, 0x75, 0x10, 0x27, 0xb1, 0x9d, 0x84, 0xea, 0x50, 0x37, 0x97, 0x70, 0xb9, 0x1c, 0x97, 0x83, + 0xe4, 0xbe, 0xd2, 0xbb, 0x16, 0xfd, 0x17, 0xfe, 0x18, 0x17, 0xff, 0x41, 0xc7, 0xe2, 0xe4, 0x24, + 0xd2, 0xfc, 0x11, 0x49, 0xee, 0x0a, 0x0e, 0x4e, 0xdf, 0xfb, 0xbd, 0xdf, 0xfb, 0x86, 0x87, 0x5c, + 0x78, 0xb3, 0x60, 0x05, 0x94, 0x8c, 0xe7, 0x4c, 0x69, 0xea, 0xf4, 0x7e, 0x14, 0x4a, 0xe6, 0x36, + 0xd1, 0x90, 0x89, 0x84, 0x17, 0x4a, 0x68, 0x9b, 0x14, 0x8a, 0x0b, 0x6d, 0x04, 0x59, 0x2c, 0xc1, + 0x42, 0xd4, 0xfb, 0x53, 0x25, 0x4e, 0xfb, 0xd1, 0xc7, 0x1c, 0x4c, 0x09, 0x86, 0xa6, 0xcc, 0x08, + 0xba, 0x1e, 0xa5, 0xc2, 0xb2, 0x11, 0xe5, 0x50, 0xe7, 0xea, 0x6a, 0xbf, 0xe7, 0xee, 0x49, 0xb3, + 0x51, 0xb7, 0xf8, 0x53, 0x57, 0x82, 0x04, 0xe7, 0xd7, 0xca, 0xb9, 0xe7, 0x1f, 0x28, 0x3c, 0x9d, + 0xd5, 0x3c, 0x8f, 0x90, 0x89, 0x69, 0x43, 0x33, 0x73, 0x30, 0xd1, 0x6d, 0xd8, 0xf1, 0x78, 0x2c, + 0xcb, 0x96, 0xc2, 0x98, 0x18, 0x0d, 0xd0, 0xf0, 0x78, 0x12, 0x7f, 0xbe, 0x5f, 0x76, 0xfd, 0xa7, + 0xef, 0xdc, 0xe5, 0xc9, 0x2e, 0x95, 0x96, 0xf3, 0xb6, 0xcb, 0x7b, 0x33, 0xba, 0x0e, 0x5b, 0xac, + 0x84, 0x95, 0xb6, 0xf1, 0xc1, 0x00, 0x0d, 0x4f, 0xc6, 0x3d, 0xe2, 0x5b, 0x35, 0x3d, 0xf1, 0xf4, + 0x64, 0x0a, 0x4a, 0x4f, 0x8e, 0x36, 0xdf, 0x67, 0xc1, 0xdc, 0xc7, 0xa3, 0x8b, 0xb0, 0xb3, 0x16, + 0xc6, 0x2a, 0x2d, 0x93, 0x12, 0xb4, 0xcd, 0x4d, 0x7c, 0x38, 0x40, 0xc3, 0xf6, 0xbc, 0xed, 0xdd, + 0x87, 0xc6, 0x9c, 0xdc, 0x6f, 0x76, 0x18, 0x6d, 0x77, 0x18, 0xfd, 0xec, 0x30, 0x7a, 0xab, 0x70, + 0xb0, 0xad, 0x70, 0xf0, 0x55, 0xe1, 0xe0, 0x99, 0x4a, 0x65, 0xf3, 0x55, 0x4a, 0x38, 0x94, 0xf4, + 0x9f, 0x77, 0x58, 0x8f, 0xe9, 0xcb, 0x5e, 0xdb, 0xd7, 0x85, 0x30, 0x69, 0xab, 0xf9, 0x1b, 0x57, + 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x28, 0x27, 0x3c, 0x46, 0xb6, 0x01, 0x00, 0x00, } func (m *LightNodeClientLicense) Marshal() (dAtA []byte, err error) { @@ -173,6 +181,7 @@ func encodeVarintLightNodeClientLicense(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *LightNodeClientLicense) Size() (n int) { if m == nil { return 0 @@ -194,9 +203,11 @@ func (m *LightNodeClientLicense) Size() (n int) { func sovLightNodeClientLicense(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozLightNodeClientLicense(x uint64) (n int) { return sovLightNodeClientLicense(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *LightNodeClientLicense) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -331,6 +342,7 @@ func (m *LightNodeClientLicense) Unmarshal(dAtA []byte) error { } return nil } + func skipLightNodeClientLicense(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/scheduler/types/genesis.pb.go b/x/scheduler/types/genesis.pb.go index 6594d79f..6aeb471e 100644 --- a/x/scheduler/types/genesis.pb.go +++ b/x/scheduler/types/genesis.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_bf14dd4a65f93f6d, []int{0} } + 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) @@ -50,12 +55,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) 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) } @@ -85,7 +93,7 @@ func init() { } var fileDescriptor_bf14dd4a65f93f6d = []byte{ - // 220 bytes of a gzipped FileDescriptorProto + // 223 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x8b, 0x93, 0x33, 0x52, 0x53, 0x4a, 0x73, 0x52, 0x8b, 0xf4, 0xd3, 0x53, 0xf3, 0x52, 0x8b, 0x33, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, @@ -95,11 +103,11 @@ var fileDescriptor_bf14dd4a65f93f6d = []byte{ 0x15, 0x72, 0xe2, 0x62, 0x83, 0xc8, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0xa9, 0xe8, 0xe1, 0xb3, 0x5f, 0x2f, 0x00, 0xac, 0xd6, 0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0xa8, 0x4e, 0x21, 0x71, 0x2e, 0xf6, 0x82, 0xfc, 0xa2, 0x92, 0xf8, 0xcc, 0x14, 0x09, 0x26, 0x05, 0x46, 0x0d, 0xce, - 0x20, 0x36, 0x10, 0xd7, 0x33, 0xc5, 0xc9, 0xf3, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, + 0x20, 0x36, 0x10, 0xd7, 0x33, 0xc5, 0xc9, 0xe7, 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, 0xf4, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0x38, - 0xbe, 0x02, 0xc9, 0xf9, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0xe7, 0x1b, 0x03, 0x02, - 0x00, 0x00, 0xff, 0xff, 0x45, 0x9d, 0xec, 0x91, 0x4b, 0x01, 0x00, 0x00, + 0x18, 0xa2, 0x8c, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0x38, + 0xbe, 0xcc, 0x48, 0xbf, 0x02, 0xc9, 0x07, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0x1f, + 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xb7, 0xe9, 0x48, 0x01, 0x4e, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -153,6 +161,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -171,9 +180,11 @@ func (m *GenesisState) Size() (n int) { 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 *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -289,6 +300,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/scheduler/types/job.pb.go b/x/scheduler/types/job.pb.go index 6199c7d2..4456b9e0 100644 --- a/x/scheduler/types/job.pb.go +++ b/x/scheduler/types/job.pb.go @@ -5,18 +5,21 @@ package types import ( fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -46,9 +49,11 @@ func (*Job) ProtoMessage() {} func (*Job) Descriptor() ([]byte, []int) { return fileDescriptor_a344810cdf97f973, []int{0} } + func (m *Job) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Job) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Job.Marshal(b, m, deterministic) @@ -61,12 +66,15 @@ func (m *Job) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Job) XXX_Merge(src proto.Message) { xxx_messageInfo_Job.Merge(m, src) } + func (m *Job) XXX_Size() int { return m.Size() } + func (m *Job) XXX_DiscardUnknown() { xxx_messageInfo_Job.DiscardUnknown(m) } @@ -150,9 +158,11 @@ func (*Trigger) ProtoMessage() {} func (*Trigger) Descriptor() ([]byte, []int) { return fileDescriptor_a344810cdf97f973, []int{1} } + func (m *Trigger) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Trigger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Trigger.Marshal(b, m, deterministic) @@ -165,12 +175,15 @@ func (m *Trigger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Trigger) XXX_Merge(src proto.Message) { xxx_messageInfo_Trigger.Merge(m, src) } + func (m *Trigger) XXX_Size() int { return m.Size() } + func (m *Trigger) XXX_DiscardUnknown() { xxx_messageInfo_Trigger.DiscardUnknown(m) } @@ -222,8 +235,7 @@ func (*Trigger) XXX_OneofWrappers() []interface{} { } } -type ScheduleTrigger struct { -} +type ScheduleTrigger struct{} func (m *ScheduleTrigger) Reset() { *m = ScheduleTrigger{} } func (m *ScheduleTrigger) String() string { return proto.CompactTextString(m) } @@ -231,9 +243,11 @@ func (*ScheduleTrigger) ProtoMessage() {} func (*ScheduleTrigger) Descriptor() ([]byte, []int) { return fileDescriptor_a344810cdf97f973, []int{2} } + func (m *ScheduleTrigger) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ScheduleTrigger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScheduleTrigger.Marshal(b, m, deterministic) @@ -246,20 +260,22 @@ func (m *ScheduleTrigger) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } + func (m *ScheduleTrigger) XXX_Merge(src proto.Message) { xxx_messageInfo_ScheduleTrigger.Merge(m, src) } + func (m *ScheduleTrigger) XXX_Size() int { return m.Size() } + func (m *ScheduleTrigger) XXX_DiscardUnknown() { xxx_messageInfo_ScheduleTrigger.DiscardUnknown(m) } var xxx_messageInfo_ScheduleTrigger proto.InternalMessageInfo -type EventTrigger struct { -} +type EventTrigger struct{} func (m *EventTrigger) Reset() { *m = EventTrigger{} } func (m *EventTrigger) String() string { return proto.CompactTextString(m) } @@ -267,9 +283,11 @@ func (*EventTrigger) ProtoMessage() {} func (*EventTrigger) Descriptor() ([]byte, []int) { return fileDescriptor_a344810cdf97f973, []int{3} } + func (m *EventTrigger) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventTrigger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventTrigger.Marshal(b, m, deterministic) @@ -282,12 +300,15 @@ func (m *EventTrigger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *EventTrigger) XXX_Merge(src proto.Message) { xxx_messageInfo_EventTrigger.Merge(m, src) } + func (m *EventTrigger) XXX_Size() int { return m.Size() } + func (m *EventTrigger) XXX_DiscardUnknown() { xxx_messageInfo_EventTrigger.DiscardUnknown(m) } @@ -305,9 +326,11 @@ func (*Permissions) ProtoMessage() {} func (*Permissions) Descriptor() ([]byte, []int) { return fileDescriptor_a344810cdf97f973, []int{4} } + func (m *Permissions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Permissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Permissions.Marshal(b, m, deterministic) @@ -320,12 +343,15 @@ func (m *Permissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *Permissions) XXX_Merge(src proto.Message) { xxx_messageInfo_Permissions.Merge(m, src) } + func (m *Permissions) XXX_Size() int { return m.Size() } + func (m *Permissions) XXX_DiscardUnknown() { xxx_messageInfo_Permissions.DiscardUnknown(m) } @@ -361,9 +387,11 @@ func (*Runner) ProtoMessage() {} func (*Runner) Descriptor() ([]byte, []int) { return fileDescriptor_a344810cdf97f973, []int{5} } + func (m *Runner) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Runner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Runner.Marshal(b, m, deterministic) @@ -376,12 +404,15 @@ func (m *Runner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Runner) XXX_Merge(src proto.Message) { xxx_messageInfo_Runner.Merge(m, src) } + func (m *Runner) XXX_Size() int { return m.Size() } + func (m *Runner) XXX_DiscardUnknown() { xxx_messageInfo_Runner.DiscardUnknown(m) } @@ -421,9 +452,11 @@ func (*Routing) ProtoMessage() {} func (*Routing) Descriptor() ([]byte, []int) { return fileDescriptor_a344810cdf97f973, []int{6} } + func (m *Routing) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Routing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Routing.Marshal(b, m, deterministic) @@ -436,12 +469,15 @@ func (m *Routing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Routing) XXX_Merge(src proto.Message) { xxx_messageInfo_Routing.Merge(m, src) } + func (m *Routing) XXX_Size() int { return m.Size() } + func (m *Routing) XXX_DiscardUnknown() { xxx_messageInfo_Routing.DiscardUnknown(m) } @@ -477,43 +513,43 @@ func init() { } var fileDescriptor_a344810cdf97f973 = []byte{ - // 562 bytes of a gzipped FileDescriptorProto + // 566 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xcd, 0x6e, 0xd3, 0x4c, - 0x14, 0x8d, 0x93, 0x36, 0x8e, 0xaf, 0xa3, 0xb6, 0xdf, 0x7c, 0x2c, 0x2c, 0x54, 0xb9, 0x91, 0x05, - 0x28, 0x54, 0x8a, 0x0d, 0xe1, 0x09, 0x62, 0x25, 0x82, 0x14, 0x55, 0x2a, 0xd3, 0x8a, 0x05, 0x3b, - 0xff, 0x4c, 0x9c, 0xa1, 0x8e, 0xc7, 0x9a, 0x71, 0x28, 0x79, 0x0b, 0x36, 0x3c, 0x02, 0xef, 0xd2, + 0x14, 0x8d, 0x93, 0xb6, 0x8e, 0xaf, 0xa3, 0xb6, 0xdf, 0x7c, 0x2c, 0x2c, 0x54, 0xb9, 0x91, 0x05, + 0x28, 0x54, 0x8a, 0x0d, 0xe1, 0x09, 0x62, 0x25, 0x82, 0x14, 0x2a, 0x95, 0x69, 0xc5, 0x82, 0x9d, + 0x7f, 0x26, 0xce, 0x50, 0xc7, 0x63, 0xcd, 0x38, 0x2d, 0x79, 0x0b, 0x36, 0x3c, 0x02, 0xef, 0xd2, 0x65, 0x77, 0xb0, 0xaa, 0x50, 0xf2, 0x16, 0xac, 0x50, 0xc6, 0x4e, 0x62, 0x95, 0x2a, 0x15, 0x12, - 0x2b, 0xdf, 0x7b, 0xe7, 0x9c, 0x33, 0x77, 0xae, 0xe7, 0x0c, 0x3c, 0x4b, 0xbd, 0x98, 0x4d, 0xbc, - 0x60, 0xec, 0xd1, 0xc4, 0xc9, 0x63, 0x47, 0x04, 0x63, 0x12, 0x4e, 0x63, 0xc2, 0x9d, 0x8f, 0xcc, - 0xb7, 0x53, 0xce, 0x32, 0x86, 0x0e, 0x4b, 0x38, 0x3b, 0x8f, 0xed, 0x35, 0xee, 0xf1, 0xa3, 0x88, - 0x45, 0x4c, 0x02, 0x9d, 0x65, 0x94, 0x73, 0xac, 0xef, 0x35, 0xa8, 0x9d, 0x30, 0x1f, 0xed, 0x41, - 0x75, 0xd8, 0x37, 0x94, 0x96, 0xd2, 0xd6, 0x70, 0x75, 0xd8, 0x47, 0xaf, 0x61, 0x97, 0x5d, 0x25, - 0x84, 0x1b, 0xd5, 0x96, 0xd2, 0x6e, 0xba, 0x2f, 0x7f, 0xdd, 0x1e, 0x75, 0x22, 0x9a, 0x8d, 0xa7, - 0xbe, 0x1d, 0xb0, 0x89, 0x13, 0x30, 0x31, 0x61, 0xa2, 0xf8, 0x74, 0x44, 0x78, 0xe9, 0x64, 0xb3, - 0x94, 0x08, 0xbb, 0x17, 0x04, 0xbd, 0x30, 0xe4, 0x44, 0x08, 0x9c, 0xf3, 0xd1, 0x00, 0x54, 0xce, - 0xa6, 0x19, 0x4d, 0x22, 0xa3, 0xd6, 0x52, 0xda, 0x7a, 0xf7, 0xa9, 0xbd, 0xad, 0x4d, 0x1b, 0xe7, - 0x60, 0x77, 0xe7, 0xfa, 0xf6, 0xa8, 0x82, 0x57, 0x5c, 0x64, 0x02, 0x84, 0x64, 0x44, 0x13, 0x9a, - 0x51, 0x96, 0x18, 0xbb, 0xcb, 0xa6, 0x70, 0xa9, 0x82, 0x0c, 0x50, 0x53, 0x6f, 0x16, 0x33, 0x2f, - 0x34, 0xea, 0x72, 0x71, 0x95, 0xa2, 0x17, 0xf0, 0x3f, 0x15, 0x67, 0x79, 0x72, 0xca, 0x42, 0x3a, - 0xa2, 0x9e, 0x1f, 0x13, 0x43, 0x6d, 0x29, 0xed, 0x06, 0xbe, 0x6f, 0x09, 0xbd, 0x03, 0x3d, 0x25, - 0x7c, 0x42, 0x85, 0xa0, 0x2c, 0x11, 0x46, 0x43, 0xb6, 0xfd, 0x7c, 0x7b, 0xdb, 0x67, 0x1b, 0x42, - 0xd1, 0x7a, 0x59, 0x03, 0xf5, 0xa0, 0x91, 0x71, 0x1a, 0x45, 0x84, 0x0b, 0x43, 0x6b, 0xd5, 0x1e, - 0x1e, 0xc3, 0x45, 0x8e, 0xc6, 0x6b, 0x1a, 0x6a, 0xc3, 0x3e, 0x49, 0x46, 0x8c, 0x07, 0xe4, 0x74, - 0xf0, 0x1e, 0x93, 0xd8, 0x9b, 0x19, 0xba, 0x3c, 0xc3, 0xdd, 0xf2, 0xc9, 0x4e, 0x03, 0x0e, 0x74, - 0xeb, 0x9b, 0x02, 0x6a, 0xa1, 0x82, 0xde, 0x42, 0x63, 0x25, 0x2d, 0xff, 0xb1, 0xde, 0xed, 0x6c, - 0xdf, 0xfe, 0xbc, 0x88, 0x0a, 0x81, 0x37, 0x15, 0xbc, 0x16, 0x40, 0x2e, 0xec, 0x92, 0x4f, 0x24, - 0xc9, 0xe4, 0xd5, 0xd0, 0xbb, 0xc7, 0xdb, 0x95, 0x06, 0x4b, 0xe8, 0x46, 0x26, 0xa7, 0xba, 0x1a, - 0xa8, 0xc5, 0xc1, 0xac, 0xff, 0x60, 0xff, 0xce, 0x6e, 0xd6, 0x1e, 0x34, 0xcb, 0x34, 0xeb, 0xab, - 0x02, 0x7a, 0x69, 0xc0, 0xc8, 0x05, 0xed, 0x6a, 0x4c, 0x33, 0x12, 0x53, 0x91, 0x19, 0x8a, 0x1c, - 0xe7, 0x93, 0x07, 0x6e, 0xd5, 0x34, 0x49, 0x08, 0xc7, 0x1b, 0xda, 0x52, 0xc3, 0x8f, 0xbd, 0xe0, - 0x52, 0x6a, 0x54, 0xff, 0x46, 0x63, 0x4d, 0xb3, 0x62, 0xa8, 0xe7, 0x45, 0x74, 0x08, 0x9a, 0x64, - 0x5d, 0xcc, 0x52, 0x52, 0xb8, 0x68, 0x53, 0x40, 0xc7, 0x70, 0x20, 0x13, 0x4c, 0x46, 0x84, 0x93, - 0x24, 0x20, 0xc3, 0xbe, 0x1c, 0x9e, 0x86, 0xff, 0xa8, 0x2f, 0x2f, 0xb2, 0x97, 0x3b, 0x48, 0xfa, - 0xa5, 0x89, 0x57, 0xa9, 0x75, 0x0e, 0x6a, 0x61, 0x8e, 0x7f, 0xb7, 0x9d, 0x3b, 0xbc, 0x9e, 0x9b, - 0xca, 0xcd, 0xdc, 0x54, 0x7e, 0xce, 0x4d, 0xe5, 0xcb, 0xc2, 0xac, 0xdc, 0x2c, 0xcc, 0xca, 0x8f, - 0x85, 0x59, 0xf9, 0xe0, 0x94, 0xec, 0x7e, 0xcf, 0x03, 0xf4, 0xb9, 0xf4, 0x04, 0x49, 0xef, 0xfb, - 0x75, 0xf9, 0xa2, 0xbc, 0xfa, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x2b, 0x76, 0xf5, 0x4b, 0xaf, 0x04, - 0x00, 0x00, + 0x2b, 0xdf, 0x7b, 0xe7, 0x9c, 0x33, 0x77, 0xae, 0xe7, 0x0c, 0x3c, 0x4b, 0xbd, 0x98, 0x8d, 0xbd, + 0x60, 0xe4, 0xd1, 0xc4, 0xc9, 0x63, 0x47, 0x04, 0x23, 0x12, 0x4e, 0x62, 0xc2, 0x9d, 0x4f, 0xcc, + 0xb7, 0x53, 0xce, 0x32, 0x86, 0x0e, 0x4a, 0x38, 0x3b, 0x8f, 0xed, 0x15, 0xee, 0xf1, 0xa3, 0x88, + 0x45, 0x4c, 0x02, 0x9d, 0x45, 0x94, 0x73, 0xac, 0xef, 0x35, 0xa8, 0x1d, 0x33, 0x1f, 0xed, 0x42, + 0x75, 0xd0, 0x33, 0x94, 0xa6, 0xd2, 0xd2, 0x70, 0x75, 0xd0, 0x43, 0xaf, 0x61, 0x9b, 0x5d, 0x25, + 0x84, 0x1b, 0xd5, 0xa6, 0xd2, 0x6a, 0xb8, 0x2f, 0x7f, 0xdd, 0x1e, 0xb6, 0x23, 0x9a, 0x8d, 0x26, + 0xbe, 0x1d, 0xb0, 0xb1, 0x13, 0x30, 0x31, 0x66, 0xa2, 0xf8, 0xb4, 0x45, 0x78, 0xe1, 0x64, 0xd3, + 0x94, 0x08, 0xbb, 0x1b, 0x04, 0xdd, 0x30, 0xe4, 0x44, 0x08, 0x9c, 0xf3, 0x51, 0x1f, 0x54, 0xce, + 0x26, 0x19, 0x4d, 0x22, 0xa3, 0xd6, 0x54, 0x5a, 0x7a, 0xe7, 0xa9, 0xbd, 0xa9, 0x4d, 0x1b, 0xe7, + 0x60, 0x77, 0xeb, 0xfa, 0xf6, 0xb0, 0x82, 0x97, 0x5c, 0x64, 0x02, 0x84, 0x64, 0x48, 0x13, 0x9a, + 0x51, 0x96, 0x18, 0xdb, 0x8b, 0xa6, 0x70, 0xa9, 0x82, 0x0c, 0x50, 0x53, 0x6f, 0x1a, 0x33, 0x2f, + 0x34, 0x76, 0xe4, 0xe2, 0x32, 0x45, 0x2f, 0xe0, 0x7f, 0x2a, 0x4e, 0xf3, 0xe4, 0x84, 0x85, 0x74, + 0x48, 0x3d, 0x3f, 0x26, 0x86, 0xda, 0x54, 0x5a, 0x75, 0x7c, 0xdf, 0x12, 0x7a, 0x0f, 0x7a, 0x4a, + 0xf8, 0x98, 0x0a, 0x41, 0x59, 0x22, 0x8c, 0xba, 0x6c, 0xfb, 0xf9, 0xe6, 0xb6, 0x4f, 0xd7, 0x84, + 0xa2, 0xf5, 0xb2, 0x06, 0xea, 0x42, 0x3d, 0xe3, 0x34, 0x8a, 0x08, 0x17, 0x86, 0xd6, 0xac, 0x3d, + 0x3c, 0x86, 0xf3, 0x1c, 0x8d, 0x57, 0x34, 0xd4, 0x82, 0x3d, 0x92, 0x0c, 0x19, 0x0f, 0xc8, 0x49, + 0xff, 0x03, 0x26, 0xb1, 0x37, 0x35, 0x74, 0x79, 0x86, 0xbb, 0xe5, 0xe3, 0xad, 0x3a, 0xec, 0xeb, + 0xd6, 0x37, 0x05, 0xd4, 0x42, 0x05, 0xbd, 0x85, 0xfa, 0x52, 0x5a, 0xfe, 0x63, 0xbd, 0xd3, 0xde, + 0xbc, 0xfd, 0x59, 0x11, 0x15, 0x02, 0x6f, 0x2a, 0x78, 0x25, 0x80, 0x5c, 0xd8, 0x26, 0x97, 0x24, + 0xc9, 0xe4, 0xd5, 0xd0, 0x3b, 0x47, 0x9b, 0x95, 0xfa, 0x0b, 0xe8, 0x5a, 0x26, 0xa7, 0xba, 0x1a, + 0xa8, 0xc5, 0xc1, 0xac, 0xff, 0x60, 0xef, 0xce, 0x6e, 0xd6, 0x2e, 0x34, 0xca, 0x34, 0xeb, 0xab, + 0x02, 0x7a, 0x69, 0xc0, 0xc8, 0x05, 0xed, 0x6a, 0x44, 0x33, 0x12, 0x53, 0x91, 0x19, 0x8a, 0x1c, + 0xe7, 0x93, 0x07, 0x6e, 0xd5, 0x24, 0x49, 0x08, 0xc7, 0x6b, 0xda, 0x42, 0xc3, 0x8f, 0xbd, 0xe0, + 0x42, 0x6a, 0x54, 0xff, 0x46, 0x63, 0x45, 0xb3, 0x62, 0xd8, 0xc9, 0x8b, 0xe8, 0x00, 0x34, 0xc9, + 0x3a, 0x9f, 0xa6, 0xa4, 0x70, 0xd1, 0xba, 0x80, 0x8e, 0x60, 0x5f, 0x26, 0x98, 0x0c, 0x09, 0x27, + 0x49, 0x40, 0x06, 0x3d, 0x39, 0x3c, 0x0d, 0xff, 0x51, 0x5f, 0x5c, 0x64, 0x2f, 0x77, 0x90, 0xf4, + 0x4b, 0x03, 0x2f, 0x53, 0xeb, 0x0c, 0xd4, 0xc2, 0x1c, 0xff, 0x6e, 0x3b, 0xf7, 0xdd, 0xf5, 0xcc, + 0x54, 0x6e, 0x66, 0xa6, 0xf2, 0x73, 0x66, 0x2a, 0x5f, 0xe6, 0x66, 0xe5, 0x66, 0x6e, 0x56, 0x7e, + 0xcc, 0xcd, 0xca, 0xc7, 0x4e, 0xc9, 0xee, 0xf7, 0x3c, 0x40, 0x97, 0x1d, 0xe7, 0x73, 0xe9, 0x15, + 0x92, 0xf6, 0xf7, 0x77, 0xe4, 0xa3, 0xf2, 0xea, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa0, 0x8d, + 0xe0, 0x9a, 0xb2, 0x04, 0x00, 0x00, } func (m *Job) Marshal() (dAtA []byte, err error) { @@ -674,6 +710,7 @@ func (m *Trigger_Schedule) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } + func (m *Trigger_Event) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) @@ -695,6 +732,7 @@ func (m *Trigger_Event) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } + func (m *ScheduleTrigger) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -884,6 +922,7 @@ func encodeVarintJob(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Job) Size() (n int) { if m == nil { return 0 @@ -949,6 +988,7 @@ func (m *Trigger_Schedule) Size() (n int) { } return n } + func (m *Trigger_Event) Size() (n int) { if m == nil { return 0 @@ -961,6 +1001,7 @@ func (m *Trigger_Event) Size() (n int) { } return n } + func (m *ScheduleTrigger) Size() (n int) { if m == nil { return 0 @@ -1041,9 +1082,11 @@ func (m *Routing) Size() (n int) { func sovJob(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozJob(x uint64) (n int) { return sovJob(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Job) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1368,6 +1411,7 @@ func (m *Job) Unmarshal(dAtA []byte) error { } return nil } + func (m *Trigger) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1488,6 +1532,7 @@ func (m *Trigger) Unmarshal(dAtA []byte) error { } return nil } + func (m *ScheduleTrigger) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1538,6 +1583,7 @@ func (m *ScheduleTrigger) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventTrigger) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1588,6 +1634,7 @@ func (m *EventTrigger) Unmarshal(dAtA []byte) error { } return nil } + func (m *Permissions) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1706,6 +1753,7 @@ func (m *Permissions) Unmarshal(dAtA []byte) error { } return nil } + func (m *Runner) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1854,6 +1902,7 @@ func (m *Runner) Unmarshal(dAtA []byte) error { } return nil } + func (m *Routing) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1968,6 +2017,7 @@ func (m *Routing) Unmarshal(dAtA []byte) error { } return nil } + func skipJob(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/scheduler/types/packet.pb.go b/x/scheduler/types/packet.pb.go index 36dc6fe9..5e3ee535 100644 --- a/x/scheduler/types/packet.pb.go +++ b/x/scheduler/types/packet.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*SchedulerPacketData) ProtoMessage() {} func (*SchedulerPacketData) Descriptor() ([]byte, []int) { return fileDescriptor_2ffdf6913f358fb1, []int{0} } + func (m *SchedulerPacketData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SchedulerPacketData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SchedulerPacketData.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *SchedulerPacketData) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *SchedulerPacketData) XXX_Merge(src proto.Message) { xxx_messageInfo_SchedulerPacketData.Merge(m, src) } + func (m *SchedulerPacketData) XXX_Size() int { return m.Size() } + func (m *SchedulerPacketData) XXX_DiscardUnknown() { xxx_messageInfo_SchedulerPacketData.DiscardUnknown(m) } @@ -95,8 +103,7 @@ func (*SchedulerPacketData) XXX_OneofWrappers() []interface{} { } } -type NoData struct { -} +type NoData struct{} func (m *NoData) Reset() { *m = NoData{} } func (m *NoData) String() string { return proto.CompactTextString(m) } @@ -104,9 +111,11 @@ func (*NoData) ProtoMessage() {} func (*NoData) Descriptor() ([]byte, []int) { return fileDescriptor_2ffdf6913f358fb1, []int{1} } + func (m *NoData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *NoData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NoData.Marshal(b, m, deterministic) @@ -119,12 +128,15 @@ func (m *NoData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *NoData) XXX_Merge(src proto.Message) { xxx_messageInfo_NoData.Merge(m, src) } + func (m *NoData) XXX_Size() int { return m.Size() } + func (m *NoData) XXX_DiscardUnknown() { xxx_messageInfo_NoData.DiscardUnknown(m) } @@ -141,7 +153,7 @@ func init() { } var fileDescriptor_2ffdf6913f358fb1 = []byte{ - // 183 bytes of a gzipped FileDescriptorProto + // 186 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2c, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x8b, 0x93, 0x33, 0x52, 0x53, 0x4a, 0x73, 0x52, 0x8b, 0xf4, 0x0b, 0x12, 0x93, 0xb3, 0x53, 0x4b, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, @@ -149,11 +161,11 @@ var fileDescriptor_2ffdf6913f358fb1 = []byte{ 0x30, 0x4e, 0x00, 0x58, 0x9b, 0x4b, 0x62, 0x49, 0xa2, 0x90, 0x1d, 0x17, 0x5b, 0x5e, 0x3e, 0x88, 0x25, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0xa4, 0xa2, 0x87, 0xcf, 0x14, 0x3d, 0x3f, 0xb0, 0x5a, 0x0f, 0x86, 0x20, 0xa8, 0x2e, 0x27, 0x0e, 0x2e, 0x36, 0x88, 0x23, 0x94, 0x38, 0xb8, 0xd8, 0x20, - 0xb2, 0x4e, 0x9e, 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, 0x9f, 0x9e, - 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0xc5, 0x63, 0x15, 0x48, 0x5e, 0x2b, - 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x7b, 0xcd, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x15, - 0x94, 0x53, 0x3a, 0x07, 0x01, 0x00, 0x00, + 0xb2, 0x4e, 0x3e, 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, 0x65, 0x94, 0x9e, + 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0xc5, 0x63, 0x65, 0x46, 0xfa, 0x15, + 0x48, 0xbe, 0x2b, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0xfb, 0xce, 0x18, 0x10, 0x00, 0x00, + 0xff, 0xff, 0xf8, 0xd2, 0xe8, 0xe7, 0x0a, 0x01, 0x00, 0x00, } func (m *SchedulerPacketData) Marshal() (dAtA []byte, err error) { @@ -209,6 +221,7 @@ func (m *SchedulerPacketData_NoData) MarshalToSizedBuffer(dAtA []byte) (int, err } return len(dAtA) - i, nil } + func (m *NoData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -243,6 +256,7 @@ func encodeVarintPacket(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *SchedulerPacketData) Size() (n int) { if m == nil { return 0 @@ -267,6 +281,7 @@ func (m *SchedulerPacketData_NoData) Size() (n int) { } return n } + func (m *NoData) Size() (n int) { if m == nil { return 0 @@ -279,9 +294,11 @@ func (m *NoData) Size() (n int) { func sovPacket(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozPacket(x uint64) (n int) { return sovPacket(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SchedulerPacketData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -367,6 +384,7 @@ func (m *SchedulerPacketData) Unmarshal(dAtA []byte) error { } return nil } + func (m *NoData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -417,6 +435,7 @@ func (m *NoData) Unmarshal(dAtA []byte) error { } return nil } + func skipPacket(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/scheduler/types/params.pb.go b/x/scheduler/types/params.pb.go index b066f8b4..fc6c1a4d 100644 --- a/x/scheduler/types/params.pb.go +++ b/x/scheduler/types/params.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -24,17 +27,18 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Params defines the parameters for the module. -type Params struct { -} +type Params struct{} func (m *Params) Reset() { *m = Params{} } func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_34ae85085fad180e, []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) @@ -47,12 +51,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 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) } @@ -68,17 +75,17 @@ func init() { } var fileDescriptor_34ae85085fad180e = []byte{ - // 155 bytes of a gzipped FileDescriptorProto + // 158 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2c, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x8b, 0x93, 0x33, 0x52, 0x53, 0x4a, 0x73, 0x52, 0x8b, 0xf4, 0x0b, 0x12, 0x8b, 0x12, 0x73, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x64, 0x90, 0x94, 0xea, 0x41, 0xd8, 0x7a, 0x70, 0xa5, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x85, 0xfa, 0x20, 0x16, 0x44, 0x8f, 0x12, 0x1f, 0x17, 0x5b, 0x00, 0xd8, 0x0c, 0x2b, - 0x96, 0x19, 0x0b, 0xe4, 0x19, 0x9c, 0x3c, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, + 0x96, 0x19, 0x0b, 0xe4, 0x19, 0x9c, 0x7c, 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, 0x3f, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x8b, 0x9b, - 0x2a, 0x90, 0x5c, 0x55, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xb6, 0xc1, 0x18, 0x10, 0x00, - 0x00, 0xff, 0xff, 0x0d, 0x82, 0x8e, 0xd5, 0xc2, 0x00, 0x00, 0x00, + 0x21, 0xca, 0x28, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x8b, 0x9b, + 0xca, 0x8c, 0xf4, 0x2b, 0x90, 0x1c, 0x56, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xb6, 0xc4, + 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x61, 0x3b, 0x27, 0x11, 0xc5, 0x00, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -115,6 +122,7 @@ func encodeVarintParams(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -127,9 +135,11 @@ func (m *Params) Size() (n int) { func sovParams(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozParams(x uint64) (n int) { return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -180,6 +190,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func skipParams(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/scheduler/types/query.pb.go b/x/scheduler/types/query.pb.go index 5388c235..6d71444b 100644 --- a/x/scheduler/types/query.pb.go +++ b/x/scheduler/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-sdk/types/query" _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" @@ -14,15 +18,14 @@ import ( 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -31,8 +34,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // QueryParamsRequest is request type for the Query/Params RPC method. -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -40,9 +42,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_200967cdd6bd676b, []int{0} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -55,12 +59,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -79,9 +86,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_200967cdd6bd676b, []int{1} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -94,12 +103,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -123,9 +135,11 @@ func (*QueryGetJobByIDRequest) ProtoMessage() {} func (*QueryGetJobByIDRequest) Descriptor() ([]byte, []int) { return fileDescriptor_200967cdd6bd676b, []int{2} } + func (m *QueryGetJobByIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetJobByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetJobByIDRequest.Marshal(b, m, deterministic) @@ -138,12 +152,15 @@ func (m *QueryGetJobByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *QueryGetJobByIDRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetJobByIDRequest.Merge(m, src) } + func (m *QueryGetJobByIDRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetJobByIDRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetJobByIDRequest.DiscardUnknown(m) } @@ -167,9 +184,11 @@ func (*QueryGetJobByIDResponse) ProtoMessage() {} func (*QueryGetJobByIDResponse) Descriptor() ([]byte, []int) { return fileDescriptor_200967cdd6bd676b, []int{3} } + func (m *QueryGetJobByIDResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetJobByIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetJobByIDResponse.Marshal(b, m, deterministic) @@ -182,12 +201,15 @@ func (m *QueryGetJobByIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryGetJobByIDResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetJobByIDResponse.Merge(m, src) } + func (m *QueryGetJobByIDResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetJobByIDResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetJobByIDResponse.DiscardUnknown(m) } @@ -213,38 +235,40 @@ func init() { } var fileDescriptor_200967cdd6bd676b = []byte{ - // 411 bytes of a gzipped FileDescriptorProto + // 414 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcd, 0xaa, 0xd3, 0x40, - 0x14, 0xc7, 0x93, 0x6a, 0x0b, 0x8e, 0x0b, 0x61, 0x2c, 0x2a, 0xa1, 0x44, 0x0d, 0xa5, 0xd4, 0xaf, - 0x8c, 0x6d, 0xf5, 0x05, 0x42, 0x41, 0xda, 0x85, 0x68, 0x76, 0xba, 0x29, 0x33, 0xe9, 0x90, 0x26, - 0x34, 0x39, 0x69, 0x66, 0x22, 0x66, 0xeb, 0x13, 0x08, 0x2e, 0x7d, 0x0c, 0x5f, 0xa2, 0xcb, 0x82, - 0x1b, 0x41, 0x10, 0x69, 0x7d, 0x10, 0xe9, 0x4c, 0x94, 0xde, 0xdb, 0x4b, 0x68, 0x77, 0x27, 0xc9, - 0xff, 0xe3, 0x97, 0x33, 0x83, 0xfa, 0x19, 0x5d, 0x42, 0x42, 0x83, 0x05, 0x8d, 0x52, 0xa2, 0x67, - 0x22, 0x82, 0x05, 0x9f, 0x17, 0x4b, 0x9e, 0x93, 0x55, 0xc1, 0xf3, 0xd2, 0xcd, 0x72, 0x90, 0x80, - 0x3b, 0x07, 0x4a, 0x57, 0xcf, 0xee, 0x7f, 0xa5, 0xd5, 0x0e, 0x21, 0x04, 0x25, 0x24, 0xfb, 0x49, - 0x7b, 0xac, 0x4e, 0x08, 0x10, 0x2e, 0x39, 0xa1, 0x59, 0x44, 0x68, 0x9a, 0x82, 0xa4, 0x32, 0x82, - 0x54, 0x54, 0x5f, 0x1f, 0x07, 0x20, 0x12, 0x10, 0x84, 0x51, 0xc1, 0x75, 0x15, 0xf9, 0x30, 0x60, - 0x5c, 0xd2, 0x01, 0xc9, 0x68, 0x18, 0xa5, 0x4a, 0x5c, 0x69, 0x1f, 0xd5, 0x72, 0x66, 0x34, 0xa7, - 0xc9, 0xbf, 0xd8, 0x5e, 0xad, 0x34, 0x06, 0xa6, 0x75, 0x4e, 0x1b, 0xe1, 0xb7, 0xfb, 0xd2, 0x37, - 0xca, 0xec, 0xf3, 0x55, 0xc1, 0x85, 0x74, 0xde, 0xa1, 0xdb, 0x17, 0xde, 0x8a, 0x0c, 0x52, 0xc1, - 0xb1, 0x87, 0x5a, 0xba, 0xe4, 0x9e, 0xf9, 0xc0, 0xec, 0xdf, 0x1c, 0x76, 0xdd, 0xba, 0x75, 0xb8, - 0xda, 0xed, 0x5d, 0x5f, 0xff, 0xba, 0x6f, 0xf8, 0x95, 0xd3, 0x71, 0xd1, 0x1d, 0x15, 0xfd, 0x8a, - 0xcb, 0x29, 0x30, 0xaf, 0x9c, 0x8c, 0xab, 0x52, 0xdc, 0x46, 0xcd, 0x18, 0xd8, 0x64, 0xac, 0xc2, - 0x6f, 0xf8, 0xfa, 0xc1, 0x79, 0x8d, 0xee, 0x1e, 0xe9, 0x2b, 0x9c, 0x11, 0xba, 0x16, 0x03, 0xab, - 0x58, 0x1e, 0xd6, 0xb3, 0x4c, 0x81, 0xf9, 0x7b, 0xf5, 0xf0, 0x67, 0x03, 0x35, 0x55, 0x20, 0xfe, - 0x6a, 0xa2, 0x96, 0x46, 0xc4, 0xcf, 0xeb, 0xcd, 0xc7, 0x1b, 0xb2, 0x06, 0x67, 0x38, 0x34, 0xae, - 0xf3, 0xf4, 0xd3, 0xf7, 0x3f, 0x5f, 0x1a, 0x3d, 0xdc, 0x25, 0x27, 0x1c, 0x23, 0xfe, 0x66, 0xa2, - 0x5b, 0x97, 0x7e, 0x1c, 0xbf, 0x38, 0xa1, 0xf4, 0x68, 0xaf, 0xd6, 0xcb, 0x33, 0x5d, 0x15, 0xee, - 0x48, 0xe1, 0x3e, 0xc3, 0x4f, 0xea, 0x71, 0x43, 0x2e, 0x67, 0x31, 0xb0, 0x19, 0x2b, 0x67, 0xd1, - 0xdc, 0x9b, 0xac, 0xb7, 0xb6, 0xb9, 0xd9, 0xda, 0xe6, 0xef, 0xad, 0x6d, 0x7e, 0xde, 0xd9, 0xc6, - 0x66, 0x67, 0x1b, 0x3f, 0x76, 0xb6, 0xf1, 0x9e, 0x84, 0x91, 0x5c, 0x14, 0xcc, 0x0d, 0x20, 0xb9, - 0x2a, 0xf0, 0xe3, 0x41, 0xa4, 0x2c, 0x33, 0x2e, 0x58, 0x4b, 0x5d, 0xd0, 0xd1, 0xdf, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x09, 0x06, 0xae, 0x6d, 0x9d, 0x03, 0x00, 0x00, + 0x14, 0xc7, 0x93, 0xab, 0xb7, 0xe0, 0xb8, 0x10, 0xc6, 0xa2, 0x12, 0x2e, 0x51, 0x43, 0x29, 0xf5, + 0x2b, 0x63, 0x53, 0x7d, 0x81, 0x50, 0x90, 0x16, 0x11, 0xcd, 0x4e, 0x37, 0x65, 0x26, 0x1d, 0xd2, + 0x84, 0x26, 0x27, 0xcd, 0x4c, 0x8a, 0xd9, 0xfa, 0x04, 0x82, 0x4b, 0x1f, 0xc3, 0x97, 0xe8, 0xb2, + 0xe0, 0x46, 0x10, 0x44, 0x5a, 0x1f, 0x44, 0x3a, 0x13, 0xa5, 0xda, 0x4b, 0x68, 0x77, 0x27, 0xc9, + 0xff, 0xe3, 0x97, 0x33, 0x83, 0x7a, 0x39, 0x9d, 0x43, 0x4a, 0xc3, 0x19, 0x8d, 0x33, 0xa2, 0x67, + 0x22, 0xc2, 0x19, 0x9f, 0x96, 0x73, 0x5e, 0x90, 0x45, 0xc9, 0x8b, 0xca, 0xcd, 0x0b, 0x90, 0x80, + 0x2f, 0xf6, 0x94, 0xae, 0x9e, 0xdd, 0xbf, 0x4a, 0xab, 0x1d, 0x41, 0x04, 0x4a, 0x48, 0x76, 0x93, + 0xf6, 0x58, 0x17, 0x11, 0x40, 0x34, 0xe7, 0x84, 0xe6, 0x31, 0xa1, 0x59, 0x06, 0x92, 0xca, 0x18, + 0x32, 0x51, 0x7f, 0x7d, 0x18, 0x82, 0x48, 0x41, 0x10, 0x46, 0x05, 0xd7, 0x55, 0x64, 0xd9, 0x67, + 0x5c, 0xd2, 0x3e, 0xc9, 0x69, 0x14, 0x67, 0x4a, 0x5c, 0x6b, 0x1f, 0x34, 0x72, 0xe6, 0xb4, 0xa0, + 0xe9, 0x9f, 0xd8, 0x6e, 0xa3, 0x34, 0x01, 0xa6, 0x75, 0x4e, 0x1b, 0xe1, 0x37, 0xbb, 0xd2, 0xd7, + 0xca, 0x1c, 0xf0, 0x45, 0xc9, 0x85, 0x74, 0xde, 0xa2, 0x9b, 0xff, 0xbc, 0x15, 0x39, 0x64, 0x82, + 0x63, 0x1f, 0xb5, 0x74, 0xc9, 0x1d, 0xf3, 0x9e, 0xd9, 0xbb, 0xee, 0x75, 0xdc, 0xa6, 0x75, 0xb8, + 0xda, 0xed, 0x5f, 0x5d, 0xfd, 0xb8, 0x6b, 0x04, 0xb5, 0xd3, 0x71, 0xd1, 0x2d, 0x15, 0xfd, 0x82, + 0xcb, 0x31, 0x30, 0xbf, 0x1a, 0x0d, 0xeb, 0x52, 0xdc, 0x46, 0xe7, 0x09, 0xb0, 0xd1, 0x50, 0x85, + 0x5f, 0x0b, 0xf4, 0x83, 0xf3, 0x0a, 0xdd, 0x3e, 0xd0, 0xd7, 0x38, 0x03, 0x74, 0x25, 0x01, 0x56, + 0xb3, 0xdc, 0x6f, 0x66, 0x19, 0x03, 0x0b, 0x76, 0x6a, 0xef, 0xfb, 0x19, 0x3a, 0x57, 0x81, 0xf8, + 0xb3, 0x89, 0x5a, 0x1a, 0x11, 0x3f, 0x6d, 0x36, 0x1f, 0x6e, 0xc8, 0xea, 0x9f, 0xe0, 0xd0, 0xb8, + 0xce, 0xe3, 0x0f, 0x5f, 0x7f, 0x7d, 0x3a, 0xeb, 0xe2, 0x0e, 0x39, 0xe2, 0x18, 0xf1, 0x17, 0x13, + 0xdd, 0xf8, 0xef, 0xc7, 0xf1, 0xb3, 0x23, 0x4a, 0x0f, 0xf6, 0x6a, 0x3d, 0x3f, 0xd1, 0x55, 0xe3, + 0x0e, 0x14, 0xee, 0x13, 0xfc, 0xa8, 0x19, 0x37, 0xe2, 0x72, 0x92, 0x00, 0x9b, 0xb0, 0x6a, 0x12, + 0x4f, 0xfd, 0x97, 0xab, 0x8d, 0x6d, 0xae, 0x37, 0xb6, 0xf9, 0x73, 0x63, 0x9b, 0x1f, 0xb7, 0xb6, + 0xb1, 0xde, 0xda, 0xc6, 0xb7, 0xad, 0x6d, 0xbc, 0xf3, 0xa2, 0x58, 0xce, 0x4a, 0xe6, 0x86, 0x90, + 0x5e, 0x16, 0xb8, 0xf4, 0xc8, 0xfb, 0xbd, 0x54, 0x59, 0xe5, 0x5c, 0xb0, 0x96, 0xba, 0xa3, 0x83, + 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x82, 0xee, 0xaf, 0x72, 0xa0, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -295,12 +319,12 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } + func (*UnimplementedQueryServer) QueryGetJobByID(ctx context.Context, req *QueryGetJobByIDRequest) (*QueryGetJobByIDResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryGetJobByID not implemented") } @@ -494,6 +518,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QueryParamsRequest) Size() (n int) { if m == nil { return 0 @@ -543,9 +568,11 @@ func (m *QueryGetJobByIDResponse) Size() (n int) { 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 *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -596,6 +623,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -679,6 +707,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetJobByIDRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -761,6 +790,7 @@ func (m *QueryGetJobByIDRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetJobByIDResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -847,6 +877,7 @@ func (m *QueryGetJobByIDResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/scheduler/types/tx.pb.go b/x/scheduler/types/tx.pb.go index f9ee17d7..bdee560f 100644 --- a/x/scheduler/types/tx.pb.go +++ b/x/scheduler/types/tx.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" @@ -14,15 +18,14 @@ import ( 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -41,9 +44,11 @@ func (*MsgCreateJob) ProtoMessage() {} func (*MsgCreateJob) Descriptor() ([]byte, []int) { return fileDescriptor_5f63022306b4a0a9, []int{0} } + func (m *MsgCreateJob) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgCreateJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgCreateJob.Marshal(b, m, deterministic) @@ -56,12 +61,15 @@ func (m *MsgCreateJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *MsgCreateJob) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgCreateJob.Merge(m, src) } + func (m *MsgCreateJob) XXX_Size() int { return m.Size() } + func (m *MsgCreateJob) XXX_DiscardUnknown() { xxx_messageInfo_MsgCreateJob.DiscardUnknown(m) } @@ -82,8 +90,7 @@ func (m *MsgCreateJob) GetMetadata() types.MsgMetadata { return types.MsgMetadata{} } -type MsgCreateJobResponse struct { -} +type MsgCreateJobResponse struct{} func (m *MsgCreateJobResponse) Reset() { *m = MsgCreateJobResponse{} } func (m *MsgCreateJobResponse) String() string { return proto.CompactTextString(m) } @@ -91,9 +98,11 @@ func (*MsgCreateJobResponse) ProtoMessage() {} func (*MsgCreateJobResponse) Descriptor() ([]byte, []int) { return fileDescriptor_5f63022306b4a0a9, []int{1} } + func (m *MsgCreateJobResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgCreateJobResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgCreateJobResponse.Marshal(b, m, deterministic) @@ -106,12 +115,15 @@ func (m *MsgCreateJobResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *MsgCreateJobResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgCreateJobResponse.Merge(m, src) } + func (m *MsgCreateJobResponse) XXX_Size() int { return m.Size() } + func (m *MsgCreateJobResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgCreateJobResponse.DiscardUnknown(m) } @@ -130,9 +142,11 @@ func (*MsgExecuteJob) ProtoMessage() {} func (*MsgExecuteJob) Descriptor() ([]byte, []int) { return fileDescriptor_5f63022306b4a0a9, []int{2} } + func (m *MsgExecuteJob) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgExecuteJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgExecuteJob.Marshal(b, m, deterministic) @@ -145,12 +159,15 @@ func (m *MsgExecuteJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error return b[:n], nil } } + func (m *MsgExecuteJob) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgExecuteJob.Merge(m, src) } + func (m *MsgExecuteJob) XXX_Size() int { return m.Size() } + func (m *MsgExecuteJob) XXX_DiscardUnknown() { xxx_messageInfo_MsgExecuteJob.DiscardUnknown(m) } @@ -190,9 +207,11 @@ func (*MsgExecuteJobResponse) ProtoMessage() {} func (*MsgExecuteJobResponse) Descriptor() ([]byte, []int) { return fileDescriptor_5f63022306b4a0a9, []int{3} } + func (m *MsgExecuteJobResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgExecuteJobResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgExecuteJobResponse.Marshal(b, m, deterministic) @@ -205,12 +224,15 @@ func (m *MsgExecuteJobResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt return b[:n], nil } } + func (m *MsgExecuteJobResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgExecuteJobResponse.Merge(m, src) } + func (m *MsgExecuteJobResponse) XXX_Size() int { return m.Size() } + func (m *MsgExecuteJobResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgExecuteJobResponse.DiscardUnknown(m) } @@ -236,39 +258,41 @@ func init() { } var fileDescriptor_5f63022306b4a0a9 = []byte{ - // 418 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x93, 0x31, 0xef, 0xd2, 0x40, - 0x18, 0xc6, 0x7b, 0x7f, 0xaa, 0xc0, 0x09, 0x89, 0x69, 0x50, 0x1b, 0x42, 0x2a, 0x92, 0x48, 0x08, - 0x26, 0xbd, 0x08, 0x71, 0x71, 0x44, 0x4c, 0x84, 0xa4, 0x4b, 0x47, 0xb7, 0x6b, 0xb9, 0x1c, 0x60, - 0xaf, 0x6f, 0xd3, 0x2b, 0x04, 0x56, 0x3f, 0x81, 0xdf, 0xc2, 0xc1, 0xc5, 0x8f, 0xc1, 0xc8, 0xe8, - 0x64, 0x4c, 0x19, 0xfc, 0x1a, 0xa6, 0x2d, 0x94, 0x92, 0x10, 0xd4, 0xe1, 0x3f, 0xf5, 0x79, 0xaf, - 0xbf, 0xf7, 0xed, 0xf3, 0xdc, 0xf5, 0xf0, 0xcb, 0x80, 0x7a, 0x20, 0xa8, 0x3b, 0xa7, 0x0b, 0x9f, - 0x64, 0x9a, 0x48, 0x77, 0xce, 0x66, 0x2b, 0x8f, 0x85, 0x24, 0xda, 0x98, 0x41, 0x08, 0x11, 0x68, - 0xad, 0x02, 0x66, 0x66, 0xda, 0xcc, 0xb1, 0x66, 0xf7, 0xe6, 0x90, 0x25, 0x38, 0xd9, 0x94, 0xab, - 0xdc, 0x9a, 0x7a, 0x92, 0x45, 0xc4, 0x05, 0x21, 0xc0, 0x3f, 0x72, 0x0d, 0x0e, 0x1c, 0x52, 0x49, - 0x12, 0x75, 0x5c, 0x7d, 0xe6, 0x82, 0x14, 0x20, 0x89, 0x90, 0x9c, 0xac, 0x5f, 0x27, 0x8f, 0xec, - 0x45, 0xe7, 0x1b, 0xc2, 0x35, 0x4b, 0xf2, 0x77, 0x21, 0xa3, 0x11, 0x9b, 0x82, 0xa3, 0x0d, 0x71, - 0x69, 0x09, 0x8e, 0x7e, 0xd7, 0x46, 0xbd, 0x47, 0x83, 0x17, 0xe6, 0x2d, 0xef, 0xe6, 0x14, 0x1c, - 0x3b, 0xa1, 0xb5, 0x0f, 0xb8, 0x22, 0x58, 0x44, 0x67, 0x34, 0xa2, 0x7a, 0x29, 0xed, 0xec, 0x5e, - 0xeb, 0xcc, 0xfc, 0x9a, 0x96, 0xe4, 0xd6, 0x91, 0x1e, 0xa9, 0xbb, 0x9f, 0xcf, 0x15, 0x3b, 0xef, - 0x7e, 0x5b, 0xff, 0xfc, 0xfb, 0x7b, 0x3f, 0x2f, 0xa7, 0x6a, 0x05, 0x3d, 0xbe, 0xb3, 0xcb, 0x6e, - 0x62, 0x0f, 0xc2, 0xce, 0x53, 0xdc, 0x28, 0x9a, 0xb5, 0x99, 0x0c, 0xc0, 0x97, 0xac, 0xf3, 0x15, - 0xe1, 0xba, 0x25, 0xf9, 0xfb, 0x0d, 0x73, 0x57, 0x59, 0x8c, 0x06, 0x7e, 0xb0, 0x04, 0x67, 0x32, - 0x4e, 0x83, 0x54, 0xed, 0xac, 0xd0, 0x74, 0x5c, 0x0e, 0xe8, 0xd6, 0x03, 0x3a, 0x4b, 0x6d, 0xd6, - 0xec, 0x53, 0x79, 0x91, 0x40, 0xbd, 0xc7, 0x04, 0x6f, 0xf0, 0x93, 0x0b, 0xa3, 0xa7, 0x08, 0x5a, - 0x0b, 0x57, 0x05, 0x93, 0x92, 0x72, 0x36, 0x19, 0xeb, 0xa8, 0x8d, 0x7a, 0xaa, 0x7d, 0x5e, 0x18, - 0xc4, 0x08, 0x97, 0x2c, 0xc9, 0xb5, 0x4f, 0xb8, 0x7a, 0x3e, 0xaa, 0xfe, 0xed, 0xd3, 0x29, 0xee, - 0x54, 0x73, 0xf0, 0xef, 0x6c, 0x6e, 0xc9, 0xc7, 0xb8, 0xb0, 0xa3, 0xaf, 0xfe, 0x3a, 0xe1, 0x0c, - 0x37, 0x87, 0xff, 0x01, 0x9f, 0xbe, 0x37, 0x9a, 0xec, 0x62, 0x03, 0xed, 0x63, 0x03, 0xfd, 0x8a, - 0x0d, 0xf4, 0xe5, 0x60, 0x28, 0xfb, 0x83, 0xa1, 0xfc, 0x38, 0x18, 0xca, 0x47, 0xc2, 0x17, 0xd1, - 0x7c, 0xe5, 0x98, 0x2e, 0x08, 0x72, 0xe5, 0x1e, 0x6c, 0x8a, 0xd7, 0x6e, 0x1b, 0x30, 0xe9, 0x3c, - 0x4c, 0xff, 0xee, 0xe1, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe2, 0xc2, 0x7c, 0xce, 0xa3, 0x03, - 0x00, 0x00, + // 420 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x93, 0xc1, 0xae, 0xd2, 0x40, + 0x14, 0x86, 0x3b, 0x97, 0xea, 0xbd, 0x8c, 0x90, 0x98, 0x06, 0xb5, 0x21, 0xa4, 0x22, 0x89, 0x84, + 0x60, 0xd2, 0x89, 0x25, 0x6e, 0x5c, 0x22, 0x26, 0x42, 0xec, 0xa6, 0x4b, 0x77, 0xd3, 0x32, 0x19, + 0xc0, 0x4e, 0x4f, 0xd3, 0x29, 0x04, 0xb6, 0x3e, 0x81, 0x6f, 0xe1, 0xc2, 0x8d, 0x8f, 0xc1, 0x92, + 0xa5, 0x2b, 0x63, 0xca, 0xc2, 0xd7, 0x30, 0x6d, 0xa1, 0x94, 0x84, 0xa0, 0x2e, 0x5c, 0xf5, 0x3f, + 0xd3, 0xef, 0x9c, 0xfe, 0xff, 0x4c, 0x07, 0x3f, 0x0f, 0xa9, 0x0f, 0x82, 0x7a, 0x33, 0x3a, 0x0f, + 0x48, 0xae, 0x89, 0xf4, 0x66, 0x6c, 0xba, 0xf4, 0x59, 0x44, 0xe2, 0xb5, 0x19, 0x46, 0x10, 0x83, + 0xd6, 0x2a, 0x61, 0x66, 0xae, 0xcd, 0x02, 0x6b, 0x76, 0xaf, 0x0e, 0x59, 0x80, 0x9b, 0x4f, 0xb9, + 0xc8, 0xad, 0xa8, 0x2f, 0x59, 0x4c, 0x3c, 0x10, 0x02, 0x82, 0x03, 0xd7, 0xe0, 0xc0, 0x21, 0x93, + 0x24, 0x55, 0x87, 0xd5, 0x27, 0x1e, 0x48, 0x01, 0x92, 0x08, 0xc9, 0xc9, 0xea, 0x65, 0xfa, 0xc8, + 0x5f, 0x74, 0xbe, 0x22, 0x5c, 0xb3, 0x25, 0x7f, 0x13, 0x31, 0x1a, 0xb3, 0x09, 0xb8, 0xda, 0x00, + 0x57, 0x16, 0xe0, 0xea, 0x37, 0x6d, 0xd4, 0x7b, 0x60, 0x3d, 0x33, 0xaf, 0x79, 0x37, 0x27, 0xe0, + 0x3a, 0x29, 0xad, 0xbd, 0xc3, 0x77, 0x82, 0xc5, 0x74, 0x4a, 0x63, 0xaa, 0x57, 0xb2, 0xce, 0xee, + 0xa5, 0xce, 0xdc, 0xaf, 0x69, 0x4b, 0x6e, 0x1f, 0xe8, 0xa1, 0xba, 0xfd, 0xf1, 0x54, 0x71, 0x8a, + 0xee, 0xd7, 0xf5, 0x4f, 0xbf, 0xbe, 0xf5, 0x8b, 0x72, 0xa2, 0xde, 0xa1, 0x87, 0x37, 0xce, 0xad, + 0x97, 0xda, 0x83, 0xa8, 0xf3, 0x18, 0x37, 0xca, 0x66, 0x1d, 0x26, 0x43, 0x08, 0x24, 0xeb, 0x7c, + 0x41, 0xb8, 0x6e, 0x4b, 0xfe, 0x76, 0xcd, 0xbc, 0x65, 0x1e, 0xa3, 0x81, 0xef, 0x2d, 0xc0, 0x1d, + 0x8f, 0xb2, 0x20, 0x55, 0x27, 0x2f, 0x34, 0x1d, 0xdf, 0x86, 0x74, 0xe3, 0x03, 0x9d, 0x66, 0x36, + 0x6b, 0xce, 0xb1, 0x3c, 0x4b, 0xa0, 0xfe, 0xc7, 0x04, 0xaf, 0xf0, 0xa3, 0x33, 0xa3, 0xc7, 0x08, + 0x5a, 0x0b, 0x57, 0x05, 0x93, 0x92, 0x72, 0x36, 0x1e, 0xe9, 0xa8, 0x8d, 0x7a, 0xaa, 0x73, 0x5a, + 0xb0, 0x12, 0x84, 0x2b, 0xb6, 0xe4, 0xda, 0x47, 0x5c, 0x3d, 0x1d, 0x55, 0xff, 0xfa, 0xe9, 0x94, + 0x77, 0xaa, 0x69, 0xfd, 0x3d, 0x5b, 0x58, 0x0a, 0x30, 0x2e, 0xed, 0xe8, 0x8b, 0x3f, 0x4e, 0x38, + 0xc1, 0xcd, 0xc1, 0x3f, 0xc0, 0xc7, 0xef, 0x0d, 0xdf, 0x6f, 0x13, 0x03, 0xed, 0x12, 0x03, 0xfd, + 0x4c, 0x0c, 0xf4, 0x79, 0x6f, 0x28, 0xbb, 0xbd, 0xa1, 0x7c, 0xdf, 0x1b, 0xca, 0x07, 0x8b, 0xcf, + 0xe3, 0xd9, 0xd2, 0x35, 0x3d, 0x10, 0xe4, 0xd2, 0x3d, 0xb0, 0xc8, 0xba, 0x7c, 0xf3, 0x36, 0x21, + 0x93, 0xee, 0xfd, 0xec, 0x07, 0x1f, 0xfc, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xd2, 0x70, 0x53, 0x10, + 0xa6, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -315,12 +339,12 @@ type MsgServer interface { } // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func (*UnimplementedMsgServer) CreateJob(ctx context.Context, req *MsgCreateJob) (*MsgCreateJobResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CreateJob not implemented") } + func (*UnimplementedMsgServer) ExecuteJob(ctx context.Context, req *MsgExecuteJob) (*MsgExecuteJobResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ExecuteJob not implemented") } @@ -536,6 +560,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgCreateJob) Size() (n int) { if m == nil { return 0 @@ -594,9 +619,11 @@ func (m *MsgExecuteJobResponse) Size() (n int) { 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 *MsgCreateJob) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -716,6 +743,7 @@ func (m *MsgCreateJob) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgCreateJobResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -766,6 +794,7 @@ func (m *MsgCreateJobResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgExecuteJob) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -915,6 +944,7 @@ func (m *MsgExecuteJob) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgExecuteJobResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -984,6 +1014,7 @@ func (m *MsgExecuteJobResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/client/cli/tx.go b/x/skyway/client/cli/tx.go index 3c407b05..57855f34 100644 --- a/x/skyway/client/cli/tx.go +++ b/x/skyway/client/cli/tx.go @@ -1,6 +1,7 @@ package cli import ( + "fmt" "strconv" sdkerrors "cosmossdk.io/errors" @@ -9,6 +10,7 @@ import ( "github.com/cosmos/cosmos-sdk/client/tx" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/palomachain/paloma/v2/x/skyway/types" + tokenfactorytypes "github.com/palomachain/paloma/v2/x/tokenfactory/types" vtypes "github.com/palomachain/paloma/v2/x/valset/types" "github.com/spf13/cobra" ) @@ -27,6 +29,7 @@ func GetTxCmd(storeKey string) *cobra.Command { skywayTxCmd.AddCommand([]*cobra.Command{ CmdSendToRemote(), CmdCancelSendToRemote(), + CmdSetErc20ToTokenDenom(), }...) return skywayTxCmd @@ -111,3 +114,42 @@ func CmdCancelSendToRemote() *cobra.Command { flags.AddTxFlagsToCmd(cmd) return cmd } + +func CmdSetErc20ToTokenDenom() *cobra.Command { + cmd := &cobra.Command{ + Use: "set-erc20-to-token-denom [erc20-address] [chain-reference-id] [token-denom]", + Short: "Creates or updates the ERC20 tracking address mapping for the given denom. Must have admin authority to do so.", + Args: cobra.ExactArgs(3), + RunE: func(cmd *cobra.Command, args []string) error { + cliCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + sender := cliCtx.GetFromAddress() + erc20, err := types.NewEthAddress(args[0]) + if err != nil { + return err + } + if erc20 == nil { + return fmt.Errorf("invalid eth address") + } + chainReferenceID := args[1] + denom := args[2] + if _, _, err := tokenfactorytypes.DeconstructDenom(denom); err != nil { + return err + } + + msg := types.NewMsgSetERC20ToTokenDenom(sender, *erc20, chainReferenceID, denom) + if err := msg.ValidateBasic(); err != nil { + return err + } + + // Send it + return tx.GenerateOrBroadcastTxCLI(cliCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/skyway/keeper/keeper.go b/x/skyway/keeper/keeper.go index b1f2a733..0fd681c4 100644 --- a/x/skyway/keeper/keeper.go +++ b/x/skyway/keeper/keeper.go @@ -35,18 +35,19 @@ var ( // Keeper maintains the link to storage and exposes getter/setter methods for the various parts of the state machine type Keeper struct { - cdc codec.BinaryCodec // The wire codec for binary encoding/decoding. - bankKeeper types.BankKeeper - StakingKeeper types.StakingKeeper - SlashingKeeper types.SlashingKeeper - DistKeeper distrkeeper.Keeper - accountKeeper types.AccountKeeper - ibcTransferKeeper ibctransferkeeper.Keeper - EVMKeeper types.EVMKeeper - consensusKeeper types.ConsensusKeeper - palomaKeeper types.PalomaKeeper - AddressCodec address.Codec - storeGetter keeperutil.StoreGetter + cdc codec.BinaryCodec // The wire codec for binary encoding/decoding. + bankKeeper types.BankKeeper + StakingKeeper types.StakingKeeper + SlashingKeeper types.SlashingKeeper + DistKeeper distrkeeper.Keeper + accountKeeper types.AccountKeeper + ibcTransferKeeper ibctransferkeeper.Keeper + EVMKeeper types.EVMKeeper + consensusKeeper types.ConsensusKeeper + palomaKeeper types.PalomaKeeper + tokenFactoryKeeper types.TokenFactoryKeeper + AddressCodec address.Codec + storeGetter keeperutil.StoreGetter AttestationHandler interface { Handle(context.Context, types.Attestation, types.EthereumClaim) error @@ -66,6 +67,7 @@ func NewKeeper( evmKeeper types.EVMKeeper, consensusKeeper types.ConsensusKeeper, palomaKeeper types.PalomaKeeper, + tokenFactoryKeeper types.TokenFactoryKeeper, storeGetter keeperutil.StoreGetter, authority string, valAddressCodec address.Codec, @@ -81,6 +83,7 @@ func NewKeeper( EVMKeeper: evmKeeper, consensusKeeper: consensusKeeper, palomaKeeper: palomaKeeper, + tokenFactoryKeeper: tokenFactoryKeeper, storeGetter: storeGetter, AttestationHandler: nil, AddressCodec: valAddressCodec, diff --git a/x/skyway/keeper/msg_server.go b/x/skyway/keeper/msg_server.go index 94431a56..93e8909b 100644 --- a/x/skyway/keeper/msg_server.go +++ b/x/skyway/keeper/msg_server.go @@ -12,6 +12,7 @@ import ( govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" utilkeeper "github.com/palomachain/paloma/v2/util/keeper" "github.com/palomachain/paloma/v2/x/skyway/types" + tokenfactorytypes "github.com/palomachain/paloma/v2/x/tokenfactory/types" "google.golang.org/protobuf/types/known/emptypb" ) @@ -423,3 +424,45 @@ func (k *msgServer) OverrideNonceProposal(ctx context.Context, req *types.MsgNon } return &emptypb.Empty{}, k.overrideNonce(ctx, req.ChainReferenceId, req.Nonce) } + +func (k *msgServer) SetERC20ToTokenDenom(ctx context.Context, msg *types.MsgSetERC20ToTokenDenom) (*emptypb.Empty, error) { + sdkCtx := sdk.UnwrapSDKContext(ctx) + sender, err := sdk.AccAddressFromBech32(msg.Metadata.Creator) + if err != nil { + return nil, sdkerrors.Wrap(types.ErrInvalid, "sender address invalid") + } + erc20, err := types.NewEthAddress(msg.Erc20) + if err != nil || erc20 == nil { + return nil, sdkerrors.Wrap(types.ErrInvalid, "erc20 address invalid") + } + ci, err := k.EVMKeeper.GetChainInfo(ctx, msg.ChainReferenceId) + if err != nil { + return nil, sdkerrors.Wrap(types.ErrUnsupported, "sender address invalid") + } + _, _, err = tokenfactorytypes.DeconstructDenom(msg.Denom) + if err != nil { + return nil, sdkerrors.Wrap(types.ErrUnsupported, "denom invalid") + } + md, err := k.tokenFactoryKeeper.GetAuthorityMetadata(ctx, msg.Denom) + if err != nil { + return nil, sdkerrors.Wrap(types.ErrDenomNotFound, err.Error()) + } + if md.Admin != sender.String() { + return nil, sdkerrors.Wrap(types.ErrUnauthorized, "missing token admin permission") + } + + if err := k.setDenomToERC20(ctx, ci.ChainReferenceID, msg.Denom, *erc20); err != nil { + return nil, sdkerrors.Wrap(types.ErrInternal, err.Error()) + } + + sdkCtx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + types.EventTypeSetERC20ToTokenDenom, + sdk.NewAttribute(types.AttributeKeyChainReferenceID, ci.ChainReferenceID), + sdk.NewAttribute(types.AttributeKeyERC20Address, msg.Erc20), + sdk.NewAttribute(types.AttributeKeyTokenDenom, msg.Denom), + ), + }) + + return &emptypb.Empty{}, nil +} diff --git a/x/skyway/keeper/test_common.go b/x/skyway/keeper/test_common.go index 65b0e139..e023a0c5 100644 --- a/x/skyway/keeper/test_common.go +++ b/x/skyway/keeper/test_common.go @@ -782,6 +782,7 @@ func CreateTestEnv(t *testing.T) TestInput { evmKeeper, consensusKeeper, nil, + nil, NewSkywayStoreGetter(skywayKey), "", authcodec.NewBech32Codec(chainparams.ValidatorAddressPrefix), diff --git a/x/skyway/types/attestation.pb.go b/x/skyway/types/attestation.pb.go index 8268df8e..9c6406f7 100644 --- a/x/skyway/types/attestation.pb.go +++ b/x/skyway/types/attestation.pb.go @@ -4,20 +4,23 @@ package types import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" - types "github.com/cosmos/cosmos-sdk/codec/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + cosmossdk_io_math "cosmossdk.io/math" + types "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -90,9 +93,11 @@ func (*Attestation) ProtoMessage() {} func (*Attestation) Descriptor() ([]byte, []int) { return fileDescriptor_92888c16a425b01b, []int{0} } + func (m *Attestation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Attestation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Attestation.Marshal(b, m, deterministic) @@ -105,12 +110,15 @@ func (m *Attestation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *Attestation) XXX_Merge(src proto.Message) { xxx_messageInfo_Attestation.Merge(m, src) } + func (m *Attestation) XXX_Size() int { return m.Size() } + func (m *Attestation) XXX_DiscardUnknown() { xxx_messageInfo_Attestation.DiscardUnknown(m) } @@ -163,9 +171,11 @@ func (*ERC20Token) ProtoMessage() {} func (*ERC20Token) Descriptor() ([]byte, []int) { return fileDescriptor_92888c16a425b01b, []int{1} } + func (m *ERC20Token) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ERC20Token) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ERC20Token.Marshal(b, m, deterministic) @@ -178,12 +188,15 @@ func (m *ERC20Token) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *ERC20Token) XXX_Merge(src proto.Message) { xxx_messageInfo_ERC20Token.Merge(m, src) } + func (m *ERC20Token) XXX_Size() int { return m.Size() } + func (m *ERC20Token) XXX_DiscardUnknown() { xxx_messageInfo_ERC20Token.DiscardUnknown(m) } @@ -218,9 +231,11 @@ func (*EventObservation) ProtoMessage() {} func (*EventObservation) Descriptor() ([]byte, []int) { return fileDescriptor_92888c16a425b01b, []int{2} } + func (m *EventObservation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventObservation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventObservation.Marshal(b, m, deterministic) @@ -233,12 +248,15 @@ func (m *EventObservation) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *EventObservation) XXX_Merge(src proto.Message) { xxx_messageInfo_EventObservation.Merge(m, src) } + func (m *EventObservation) XXX_Size() int { return m.Size() } + func (m *EventObservation) XXX_DiscardUnknown() { xxx_messageInfo_EventObservation.DiscardUnknown(m) } @@ -293,9 +311,11 @@ func (*EventInvalidSendToPalomaReceiver) ProtoMessage() {} func (*EventInvalidSendToPalomaReceiver) Descriptor() ([]byte, []int) { return fileDescriptor_92888c16a425b01b, []int{3} } + func (m *EventInvalidSendToPalomaReceiver) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventInvalidSendToPalomaReceiver) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventInvalidSendToPalomaReceiver.Marshal(b, m, deterministic) @@ -308,12 +328,15 @@ func (m *EventInvalidSendToPalomaReceiver) XXX_Marshal(b []byte, deterministic b return b[:n], nil } } + func (m *EventInvalidSendToPalomaReceiver) XXX_Merge(src proto.Message) { xxx_messageInfo_EventInvalidSendToPalomaReceiver.Merge(m, src) } + func (m *EventInvalidSendToPalomaReceiver) XXX_Size() int { return m.Size() } + func (m *EventInvalidSendToPalomaReceiver) XXX_DiscardUnknown() { xxx_messageInfo_EventInvalidSendToPalomaReceiver.DiscardUnknown(m) } @@ -360,9 +383,11 @@ func (*EventSendToPaloma) ProtoMessage() {} func (*EventSendToPaloma) Descriptor() ([]byte, []int) { return fileDescriptor_92888c16a425b01b, []int{4} } + func (m *EventSendToPaloma) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventSendToPaloma) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventSendToPaloma.Marshal(b, m, deterministic) @@ -375,12 +400,15 @@ func (m *EventSendToPaloma) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *EventSendToPaloma) XXX_Merge(src proto.Message) { xxx_messageInfo_EventSendToPaloma.Merge(m, src) } + func (m *EventSendToPaloma) XXX_Size() int { return m.Size() } + func (m *EventSendToPaloma) XXX_DiscardUnknown() { xxx_messageInfo_EventSendToPaloma.DiscardUnknown(m) } @@ -421,9 +449,11 @@ func (*EventSendToPalomaLocal) ProtoMessage() {} func (*EventSendToPalomaLocal) Descriptor() ([]byte, []int) { return fileDescriptor_92888c16a425b01b, []int{5} } + func (m *EventSendToPalomaLocal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventSendToPalomaLocal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventSendToPalomaLocal.Marshal(b, m, deterministic) @@ -436,12 +466,15 @@ func (m *EventSendToPalomaLocal) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *EventSendToPalomaLocal) XXX_Merge(src proto.Message) { xxx_messageInfo_EventSendToPalomaLocal.Merge(m, src) } + func (m *EventSendToPalomaLocal) XXX_Size() int { return m.Size() } + func (m *EventSendToPalomaLocal) XXX_DiscardUnknown() { xxx_messageInfo_EventSendToPalomaLocal.DiscardUnknown(m) } @@ -491,48 +524,48 @@ func init() { } var fileDescriptor_92888c16a425b01b = []byte{ - // 649 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xc1, 0x4e, 0xdb, 0x4c, - 0x10, 0xce, 0x86, 0x80, 0xc8, 0x22, 0xc0, 0xff, 0x8a, 0x1f, 0x05, 0xab, 0x98, 0x28, 0x52, 0xdb, - 0x94, 0x22, 0xbb, 0xa2, 0xea, 0x03, 0x98, 0x60, 0x8a, 0xa5, 0x40, 0x22, 0xc7, 0x55, 0xd5, 0x5e, - 0xac, 0x8d, 0xbd, 0x38, 0x16, 0xc9, 0x6e, 0x64, 0x2f, 0x29, 0xbe, 0xf4, 0xd2, 0x4b, 0x2f, 0xad, - 0xfa, 0x0e, 0x7d, 0x19, 0xa4, 0x5e, 0x38, 0x56, 0x3d, 0xa0, 0x0a, 0x5e, 0xa4, 0xf2, 0xae, 0x63, - 0x2c, 0xb5, 0xbd, 0xf5, 0xb6, 0xdf, 0xcc, 0xe7, 0x99, 0xef, 0x9b, 0x59, 0x2f, 0x7c, 0x3a, 0xc5, - 0x63, 0x36, 0xc1, 0xfe, 0x08, 0x47, 0xd4, 0x90, 0x67, 0x23, 0x39, 0x4f, 0xdf, 0xe1, 0xd4, 0xc0, - 0x9c, 0x93, 0x84, 0x63, 0x1e, 0x31, 0xaa, 0x4f, 0x63, 0xc6, 0x19, 0xda, 0x2a, 0x91, 0x75, 0x79, - 0xd6, 0x25, 0x59, 0xdd, 0x08, 0x59, 0xc8, 0x04, 0xcb, 0xc8, 0x4e, 0xf2, 0x03, 0x75, 0x2b, 0x64, - 0x2c, 0x1c, 0x13, 0x43, 0xa0, 0xe1, 0xc5, 0x99, 0x81, 0x69, 0x2a, 0x53, 0xad, 0x0f, 0x00, 0xae, - 0x98, 0xf7, 0x1d, 0x90, 0x0a, 0x97, 0xd9, 0x30, 0x21, 0xf1, 0x8c, 0x04, 0x0d, 0xd0, 0x04, 0xed, - 0x65, 0xa7, 0xc0, 0x68, 0x03, 0x2e, 0xce, 0x18, 0x27, 0x49, 0xa3, 0xda, 0x5c, 0x68, 0xd7, 0x1d, - 0x09, 0xd0, 0x26, 0x5c, 0x1a, 0x91, 0x28, 0x1c, 0xf1, 0xc6, 0x42, 0x13, 0xb4, 0x6b, 0x4e, 0x8e, - 0xd0, 0x2e, 0x5c, 0xf4, 0xc7, 0x38, 0x9a, 0x34, 0x6a, 0x4d, 0xd0, 0x5e, 0xd9, 0xdf, 0xd0, 0xa5, - 0x08, 0x7d, 0x2e, 0x42, 0x37, 0x69, 0xea, 0x48, 0x4a, 0xeb, 0x13, 0x80, 0xd0, 0x72, 0x3a, 0xfb, - 0xcf, 0x5c, 0x76, 0x4e, 0x84, 0x08, 0x9f, 0x51, 0x1e, 0x63, 0x9f, 0x0b, 0x11, 0x75, 0xa7, 0xc0, - 0xe8, 0x05, 0x5c, 0xc2, 0x13, 0x76, 0x41, 0x79, 0xa3, 0x9a, 0x65, 0x0e, 0xb6, 0xaf, 0x6e, 0x76, - 0x2a, 0x3f, 0x6e, 0x76, 0xfe, 0xf7, 0x59, 0x32, 0x61, 0x49, 0x12, 0x9c, 0xeb, 0x11, 0x33, 0x26, - 0x98, 0x8f, 0x74, 0x9b, 0x72, 0x27, 0x27, 0xa3, 0x3d, 0x88, 0xc4, 0xbc, 0xbc, 0x98, 0x9c, 0x91, - 0x98, 0x50, 0x9f, 0x78, 0x51, 0x20, 0x14, 0xd7, 0x1d, 0x45, 0x64, 0x9c, 0x79, 0xc2, 0x0e, 0x5a, - 0xdf, 0x00, 0x54, 0xac, 0x19, 0xa1, 0xbc, 0x27, 0xbc, 0xcb, 0xd1, 0x3c, 0x81, 0x4a, 0x69, 0x17, - 0x1e, 0x4f, 0xa7, 0x24, 0x57, 0xb7, 0x5e, 0x8a, 0xbb, 0xe9, 0x94, 0xa0, 0xc7, 0x70, 0x7d, 0x18, - 0x47, 0x41, 0x48, 0xbc, 0xc2, 0x87, 0x50, 0xeb, 0xac, 0xc9, 0x70, 0x67, 0xee, 0xe6, 0xd1, 0x3d, - 0x51, 0xa8, 0x2b, 0x34, 0xad, 0xe6, 0xc4, 0x2c, 0x6a, 0x07, 0xe8, 0x21, 0x5c, 0x2b, 0xf7, 0x8e, - 0x02, 0x31, 0xd5, 0xba, 0xb3, 0x5a, 0x8a, 0xda, 0x62, 0x43, 0x94, 0x51, 0x9f, 0x34, 0x16, 0x45, - 0x56, 0x82, 0xd6, 0x7b, 0xd8, 0x14, 0x66, 0x6c, 0x3a, 0xc3, 0xe3, 0x28, 0x18, 0x10, 0x1a, 0xb8, - 0xac, 0x2f, 0xee, 0x8d, 0x43, 0x7c, 0x12, 0xcd, 0x48, 0x9c, 0x6d, 0x31, 0x1f, 0xab, 0xb4, 0x34, - 0x9f, 0x5b, 0x51, 0xb1, 0x5a, 0xaa, 0x98, 0x45, 0x79, 0xb6, 0xa9, 0x5c, 0xac, 0x04, 0x59, 0x8d, - 0x84, 0xd0, 0x80, 0xc4, 0xb9, 0xb8, 0x1c, 0xb5, 0x5e, 0xc3, 0xff, 0x44, 0xff, 0x72, 0xe3, 0x7f, - 0xd1, 0xb0, 0x75, 0x09, 0x37, 0x7f, 0x2b, 0xdc, 0x65, 0x3e, 0x1e, 0xdf, 0x57, 0x01, 0xe5, 0x2a, - 0x2a, 0x5c, 0x8e, 0x73, 0xc3, 0x79, 0xf9, 0x02, 0xff, 0xdd, 0x52, 0xae, 0xb2, 0x56, 0x56, 0xb9, - 0xfb, 0x19, 0xc0, 0x7a, 0x27, 0xbb, 0xba, 0x62, 0xdd, 0x2a, 0xdc, 0xec, 0x74, 0x4d, 0xfb, 0xc4, - 0x73, 0xdf, 0xf4, 0x2d, 0xef, 0xd5, 0xe9, 0xa0, 0x6f, 0x75, 0xec, 0x23, 0xdb, 0x3a, 0x54, 0x2a, - 0x68, 0x1b, 0x6e, 0x95, 0x72, 0x03, 0xeb, 0xf4, 0xd0, 0x73, 0x7b, 0x5e, 0xdf, 0xec, 0xf6, 0x4e, - 0x4c, 0x05, 0xa0, 0x26, 0x7c, 0x50, 0x4a, 0x1f, 0x98, 0x6e, 0xe7, 0xb8, 0x20, 0x59, 0xee, 0xb1, - 0x52, 0x45, 0x1a, 0x54, 0x4b, 0x8c, 0xae, 0xfd, 0xf2, 0xd8, 0xf5, 0x4e, 0x7b, 0x87, 0x96, 0x37, - 0x30, 0xbb, 0x96, 0xb2, 0xa0, 0xd6, 0x3e, 0x7e, 0xd5, 0x2a, 0x07, 0x47, 0x57, 0xb7, 0x1a, 0xb8, - 0xbe, 0xd5, 0xc0, 0xcf, 0x5b, 0x0d, 0x7c, 0xb9, 0xd3, 0x2a, 0xd7, 0x77, 0x5a, 0xe5, 0xfb, 0x9d, - 0x56, 0x79, 0xbb, 0x17, 0x46, 0x7c, 0x74, 0x31, 0xd4, 0x7d, 0x36, 0x31, 0xfe, 0xf0, 0xca, 0x5c, - 0xce, 0xdf, 0x99, 0xec, 0x3e, 0x27, 0xc3, 0x25, 0xf1, 0x7b, 0x3e, 0xff, 0x15, 0x00, 0x00, 0xff, - 0xff, 0x0b, 0xfb, 0xcf, 0x94, 0x91, 0x04, 0x00, 0x00, + // 651 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xc1, 0x6e, 0xd3, 0x4c, + 0x10, 0xce, 0xa6, 0x69, 0xd5, 0x6c, 0xd5, 0xd6, 0xff, 0xaa, 0x7f, 0x95, 0x5a, 0xd4, 0x8d, 0x22, + 0x01, 0xa1, 0x20, 0x1b, 0x15, 0xf1, 0x00, 0x6e, 0x6a, 0xa8, 0xa5, 0xb4, 0x89, 0x1c, 0x23, 0x04, + 0x17, 0x6b, 0x63, 0x6f, 0x1d, 0xab, 0xc9, 0x6e, 0x64, 0x6f, 0x43, 0x7d, 0xe1, 0xc2, 0x85, 0x0b, + 0x88, 0x77, 0xe0, 0x65, 0x2a, 0x71, 0xe9, 0x11, 0x71, 0xa8, 0x50, 0xfb, 0x22, 0xc8, 0xbb, 0x8e, + 0x63, 0x09, 0xb8, 0x71, 0xdb, 0x6f, 0xe6, 0xf3, 0xcc, 0xf7, 0xcd, 0xac, 0x17, 0x3e, 0x9e, 0xe2, + 0x31, 0x9b, 0x60, 0x7f, 0x84, 0x23, 0x6a, 0xc8, 0xb3, 0x91, 0x9c, 0xa7, 0xef, 0x70, 0x6a, 0x60, + 0xce, 0x49, 0xc2, 0x31, 0x8f, 0x18, 0xd5, 0xa7, 0x31, 0xe3, 0x0c, 0xed, 0x94, 0xc8, 0xba, 0x3c, + 0xeb, 0x92, 0xac, 0x6e, 0x85, 0x2c, 0x64, 0x82, 0x65, 0x64, 0x27, 0xf9, 0x81, 0xba, 0x13, 0x32, + 0x16, 0x8e, 0x89, 0x21, 0xd0, 0xf0, 0xe2, 0xcc, 0xc0, 0x34, 0x95, 0xa9, 0xd6, 0x07, 0x00, 0xd7, + 0xcc, 0x45, 0x07, 0xa4, 0xc2, 0x55, 0x36, 0x4c, 0x48, 0x3c, 0x23, 0x41, 0x03, 0x34, 0x41, 0x7b, + 0xd5, 0x29, 0x30, 0xda, 0x82, 0xcb, 0x33, 0xc6, 0x49, 0xd2, 0xa8, 0x36, 0x97, 0xda, 0x75, 0x47, + 0x02, 0xb4, 0x0d, 0x57, 0x46, 0x24, 0x0a, 0x47, 0xbc, 0xb1, 0xd4, 0x04, 0xed, 0x9a, 0x93, 0x23, + 0xb4, 0x0f, 0x97, 0xfd, 0x31, 0x8e, 0x26, 0x8d, 0x5a, 0x13, 0xb4, 0xd7, 0x0e, 0xb6, 0x74, 0x29, + 0x42, 0x9f, 0x8b, 0xd0, 0x4d, 0x9a, 0x3a, 0x92, 0xd2, 0xfa, 0x04, 0x20, 0xb4, 0x9c, 0xce, 0xc1, + 0x53, 0x97, 0x9d, 0x13, 0x21, 0xc2, 0x67, 0x94, 0xc7, 0xd8, 0xe7, 0x42, 0x44, 0xdd, 0x29, 0x30, + 0x7a, 0x0e, 0x57, 0xf0, 0x84, 0x5d, 0x50, 0xde, 0xa8, 0x66, 0x99, 0xc3, 0xdd, 0xab, 0x9b, 0xbd, + 0xca, 0x8f, 0x9b, 0xbd, 0xff, 0x7d, 0x96, 0x4c, 0x58, 0x92, 0x04, 0xe7, 0x7a, 0xc4, 0x8c, 0x09, + 0xe6, 0x23, 0xdd, 0xa6, 0xdc, 0xc9, 0xc9, 0xe8, 0x09, 0x44, 0x62, 0x5e, 0x5e, 0x4c, 0xce, 0x48, + 0x4c, 0xa8, 0x4f, 0xbc, 0x28, 0x10, 0x8a, 0xeb, 0x8e, 0x22, 0x32, 0xce, 0x3c, 0x61, 0x07, 0xad, + 0x6f, 0x00, 0x2a, 0xd6, 0x8c, 0x50, 0xde, 0x13, 0xde, 0xe5, 0x68, 0x1e, 0x41, 0xa5, 0xb4, 0x0b, + 0x8f, 0xa7, 0x53, 0x92, 0xab, 0xdb, 0x2c, 0xc5, 0xdd, 0x74, 0x4a, 0xd0, 0x43, 0xb8, 0x39, 0x8c, + 0xa3, 0x20, 0x24, 0x5e, 0xe1, 0x43, 0xa8, 0x75, 0x36, 0x64, 0xb8, 0x33, 0x77, 0xf3, 0x60, 0x41, + 0x14, 0xea, 0x0a, 0x4d, 0xeb, 0x39, 0x31, 0x8b, 0xda, 0x01, 0xba, 0x0f, 0x37, 0xca, 0xbd, 0xa3, + 0x40, 0x4c, 0xb5, 0xee, 0xac, 0x97, 0xa2, 0xb6, 0xd8, 0x10, 0x65, 0xd4, 0x27, 0x8d, 0x65, 0x91, + 0x95, 0xa0, 0xf5, 0x1e, 0x36, 0x85, 0x19, 0x9b, 0xce, 0xf0, 0x38, 0x0a, 0x06, 0x84, 0x06, 0x2e, + 0xeb, 0x8b, 0x7b, 0xe3, 0x10, 0x9f, 0x44, 0x33, 0x12, 0x67, 0x5b, 0xcc, 0xc7, 0x2a, 0x2d, 0xcd, + 0xe7, 0x56, 0x54, 0xac, 0x96, 0x2a, 0x66, 0x51, 0x9e, 0x6d, 0x2a, 0x17, 0x2b, 0x41, 0x56, 0x23, + 0x21, 0x34, 0x20, 0x71, 0x2e, 0x2e, 0x47, 0xad, 0xd7, 0xf0, 0x3f, 0xd1, 0xbf, 0xdc, 0xf8, 0x5f, + 0x34, 0x6c, 0x5d, 0xc2, 0xed, 0xdf, 0x0a, 0x77, 0x99, 0x8f, 0xc7, 0x8b, 0x2a, 0xa0, 0x5c, 0x45, + 0x85, 0xab, 0x71, 0x6e, 0x38, 0x2f, 0x5f, 0xe0, 0xbf, 0x5b, 0xca, 0x55, 0xd6, 0xca, 0x2a, 0xf7, + 0x3f, 0x03, 0x58, 0xef, 0x64, 0x57, 0x57, 0xac, 0x5b, 0x85, 0xdb, 0x9d, 0xae, 0x69, 0x9f, 0x78, + 0xee, 0x9b, 0xbe, 0xe5, 0xbd, 0x3a, 0x1d, 0xf4, 0xad, 0x8e, 0xfd, 0xc2, 0xb6, 0x8e, 0x94, 0x0a, + 0xda, 0x85, 0x3b, 0xa5, 0xdc, 0xc0, 0x3a, 0x3d, 0xf2, 0xdc, 0x9e, 0xd7, 0x37, 0xbb, 0xbd, 0x13, + 0x53, 0x01, 0xa8, 0x09, 0xef, 0x95, 0xd2, 0x87, 0xa6, 0xdb, 0x39, 0x2e, 0x48, 0x96, 0x7b, 0xac, + 0x54, 0x91, 0x06, 0xd5, 0x12, 0xa3, 0x6b, 0xbf, 0x3c, 0x76, 0xbd, 0xd3, 0xde, 0x91, 0xe5, 0x0d, + 0xcc, 0xae, 0xa5, 0x2c, 0xa9, 0xb5, 0x8f, 0x5f, 0xb5, 0xca, 0xa1, 0x7d, 0x75, 0xab, 0x81, 0xeb, + 0x5b, 0x0d, 0xfc, 0xbc, 0xd5, 0xc0, 0x97, 0x3b, 0xad, 0x72, 0x7d, 0xa7, 0x55, 0xbe, 0xdf, 0x69, + 0x95, 0xb7, 0x46, 0x18, 0xf1, 0xd1, 0xc5, 0x50, 0xf7, 0xd9, 0xc4, 0xf8, 0xc3, 0x2b, 0x33, 0x3b, + 0x30, 0x2e, 0xe7, 0x4f, 0x4d, 0x76, 0xa5, 0x93, 0xe1, 0x8a, 0xf8, 0x43, 0x9f, 0xfd, 0x0a, 0x00, + 0x00, 0xff, 0xff, 0x4e, 0x22, 0xd6, 0xf2, 0x94, 0x04, 0x00, 0x00, } func (m *Attestation) Marshal() (dAtA []byte, err error) { @@ -856,6 +889,7 @@ func encodeVarintAttestation(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Attestation) Size() (n int) { if m == nil { return 0 @@ -1003,9 +1037,11 @@ func (m *EventSendToPalomaLocal) Size() (n int) { func sovAttestation(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozAttestation(x uint64) (n int) { return sovAttestation(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Attestation) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1163,6 +1199,7 @@ func (m *Attestation) Unmarshal(dAtA []byte) error { } return nil } + func (m *ERC20Token) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1311,6 +1348,7 @@ func (m *ERC20Token) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventObservation) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1521,6 +1559,7 @@ func (m *EventObservation) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventInvalidSendToPalomaReceiver) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1699,6 +1738,7 @@ func (m *EventInvalidSendToPalomaReceiver) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventSendToPaloma) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1845,6 +1885,7 @@ func (m *EventSendToPaloma) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventSendToPalomaLocal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2023,6 +2064,7 @@ func (m *EventSendToPalomaLocal) Unmarshal(dAtA []byte) error { } return nil } + func skipAttestation(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/batch.pb.go b/x/skyway/types/batch.pb.go index f4ce4bbc..690e5bbb 100644 --- a/x/skyway/types/batch.pb.go +++ b/x/skyway/types/batch.pb.go @@ -4,19 +4,22 @@ package types import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + cosmossdk_io_math "cosmossdk.io/math" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -44,9 +47,11 @@ func (*OutgoingTxBatch) ProtoMessage() {} func (*OutgoingTxBatch) Descriptor() ([]byte, []int) { return fileDescriptor_16a379404a8854af, []int{0} } + func (m *OutgoingTxBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *OutgoingTxBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_OutgoingTxBatch.Marshal(b, m, deterministic) @@ -59,12 +64,15 @@ func (m *OutgoingTxBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } + func (m *OutgoingTxBatch) XXX_Merge(src proto.Message) { xxx_messageInfo_OutgoingTxBatch.Merge(m, src) } + func (m *OutgoingTxBatch) XXX_Size() int { return m.Size() } + func (m *OutgoingTxBatch) XXX_DiscardUnknown() { xxx_messageInfo_OutgoingTxBatch.DiscardUnknown(m) } @@ -156,9 +164,11 @@ func (*OutgoingTransferTx) ProtoMessage() {} func (*OutgoingTransferTx) Descriptor() ([]byte, []int) { return fileDescriptor_16a379404a8854af, []int{1} } + func (m *OutgoingTransferTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *OutgoingTransferTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_OutgoingTransferTx.Marshal(b, m, deterministic) @@ -171,12 +181,15 @@ func (m *OutgoingTransferTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *OutgoingTransferTx) XXX_Merge(src proto.Message) { xxx_messageInfo_OutgoingTransferTx.Merge(m, src) } + func (m *OutgoingTransferTx) XXX_Size() int { return m.Size() } + func (m *OutgoingTransferTx) XXX_DiscardUnknown() { xxx_messageInfo_OutgoingTransferTx.DiscardUnknown(m) } @@ -224,9 +237,11 @@ func (*EventOutgoingBatchCanceled) ProtoMessage() {} func (*EventOutgoingBatchCanceled) Descriptor() ([]byte, []int) { return fileDescriptor_16a379404a8854af, []int{2} } + func (m *EventOutgoingBatchCanceled) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventOutgoingBatchCanceled) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventOutgoingBatchCanceled.Marshal(b, m, deterministic) @@ -239,12 +254,15 @@ func (m *EventOutgoingBatchCanceled) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *EventOutgoingBatchCanceled) XXX_Merge(src proto.Message) { xxx_messageInfo_EventOutgoingBatchCanceled.Merge(m, src) } + func (m *EventOutgoingBatchCanceled) XXX_Size() int { return m.Size() } + func (m *EventOutgoingBatchCanceled) XXX_DiscardUnknown() { xxx_messageInfo_EventOutgoingBatchCanceled.DiscardUnknown(m) } @@ -293,9 +311,11 @@ func (*EventOutgoingBatch) ProtoMessage() {} func (*EventOutgoingBatch) Descriptor() ([]byte, []int) { return fileDescriptor_16a379404a8854af, []int{3} } + func (m *EventOutgoingBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventOutgoingBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventOutgoingBatch.Marshal(b, m, deterministic) @@ -308,12 +328,15 @@ func (m *EventOutgoingBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *EventOutgoingBatch) XXX_Merge(src proto.Message) { xxx_messageInfo_EventOutgoingBatch.Merge(m, src) } + func (m *EventOutgoingBatch) XXX_Size() int { return m.Size() } + func (m *EventOutgoingBatch) XXX_DiscardUnknown() { xxx_messageInfo_EventOutgoingBatch.DiscardUnknown(m) } @@ -367,48 +390,48 @@ func init() { } var fileDescriptor_16a379404a8854af = []byte{ - // 654 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x54, 0xcf, 0x6e, 0x13, 0x3f, - 0x10, 0xce, 0x36, 0xfd, 0x17, 0x27, 0x69, 0x7f, 0x3f, 0xab, 0x85, 0x6d, 0x24, 0xd2, 0x10, 0x54, - 0x88, 0x44, 0xd9, 0x54, 0x41, 0xe2, 0xde, 0x44, 0x45, 0x8a, 0x84, 0x40, 0x5a, 0x22, 0x21, 0x71, - 0xb1, 0x9c, 0xf5, 0x74, 0x63, 0xa5, 0x6b, 0x57, 0x6b, 0x07, 0x92, 0xb7, 0xe0, 0x09, 0x78, 0x08, - 0x9e, 0xa2, 0xc7, 0x8a, 0x13, 0xe2, 0x50, 0xa1, 0xf6, 0x25, 0x38, 0xa2, 0x1d, 0x6f, 0x52, 0xaa, - 0x52, 0xae, 0xdc, 0xec, 0xef, 0xfb, 0x66, 0xe6, 0xb3, 0x67, 0x6c, 0xb2, 0x77, 0xca, 0x4f, 0x74, - 0xc2, 0xa3, 0x11, 0x97, 0xaa, 0xed, 0xd6, 0x6d, 0x33, 0x9e, 0x7d, 0xe4, 0xb3, 0xf6, 0x90, 0xdb, - 0x68, 0x14, 0x9c, 0xa6, 0xda, 0x6a, 0xba, 0xf3, 0x9b, 0x2c, 0x70, 0xeb, 0xc0, 0xc9, 0x6a, 0x5b, - 0xb1, 0x8e, 0x35, 0xaa, 0xda, 0xd9, 0xca, 0x05, 0xd4, 0x9e, 0xde, 0x9d, 0x97, 0x5b, 0x0b, 0xc6, - 0x72, 0x2b, 0xb5, 0x72, 0xe2, 0xe6, 0xd7, 0x22, 0xd9, 0x7c, 0x33, 0xb1, 0xb1, 0x96, 0x2a, 0x1e, - 0x4c, 0xbb, 0x59, 0x5d, 0xba, 0x4b, 0xca, 0x68, 0x80, 0x29, 0xad, 0x22, 0xf0, 0xbd, 0x86, 0xd7, - 0x5a, 0x0e, 0x09, 0x42, 0xaf, 0x33, 0x84, 0x3e, 0x22, 0x55, 0x27, 0xb0, 0x32, 0x01, 0x3d, 0xb1, - 0xfe, 0x12, 0x4a, 0x2a, 0x08, 0x0e, 0x1c, 0x46, 0xdf, 0x91, 0x8a, 0x4d, 0xb9, 0x32, 0x3c, 0xca, - 0xca, 0x19, 0xbf, 0xd8, 0x28, 0xb6, 0xca, 0x9d, 0x67, 0xc1, 0x9d, 0xc7, 0x09, 0x16, 0x3e, 0xb2, - 0xb0, 0x63, 0x48, 0x07, 0xd3, 0xee, 0xf2, 0xd9, 0xc5, 0x6e, 0x21, 0xbc, 0x91, 0x88, 0xee, 0x91, - 0x0d, 0xab, 0xc7, 0xa0, 0x58, 0xa4, 0x95, 0x4d, 0x79, 0x64, 0xfd, 0xe5, 0x86, 0xd7, 0x2a, 0x85, - 0x55, 0x44, 0x7b, 0x39, 0x48, 0x0f, 0xc8, 0x96, 0x4b, 0xcf, 0x86, 0x27, 0x3a, 0x1a, 0xb3, 0x28, - 0x05, 0x6e, 0x41, 0xf8, 0x2b, 0xe8, 0x95, 0x3a, 0xae, 0x9b, 0x51, 0x3d, 0xc7, 0xd0, 0x7d, 0x42, - 0xd1, 0x16, 0x4b, 0xe1, 0x18, 0x52, 0x50, 0x11, 0x30, 0x29, 0xfc, 0x55, 0x4c, 0xfe, 0x1f, 0x32, - 0xe1, 0x9c, 0xe8, 0x0b, 0xda, 0x24, 0xd5, 0xe1, 0xcc, 0x82, 0x61, 0x56, 0x33, 0x23, 0x63, 0xe5, - 0xaf, 0x35, 0xbc, 0x56, 0x25, 0x2c, 0x23, 0x38, 0xd0, 0x6f, 0x65, 0xac, 0x68, 0x8d, 0xac, 0x73, - 0x93, 0x91, 0x00, 0xfe, 0x3a, 0xe6, 0x59, 0xec, 0xe9, 0x43, 0x52, 0x89, 0xb9, 0x61, 0x60, 0xac, - 0x4c, 0xb8, 0x05, 0xbf, 0x84, 0xbe, 0xca, 0x31, 0x37, 0x47, 0x39, 0x44, 0x5f, 0x90, 0xfb, 0x73, - 0x39, 0x4b, 0x21, 0xd1, 0x16, 0x18, 0x17, 0x22, 0x05, 0x63, 0x7c, 0x82, 0xc5, 0xb6, 0xe7, 0x74, - 0x88, 0xec, 0xa1, 0x23, 0x9b, 0x3f, 0x3d, 0x42, 0x6f, 0x5f, 0x26, 0xdd, 0x20, 0x4b, 0x52, 0xe4, - 0xed, 0x5c, 0x92, 0x82, 0xde, 0x23, 0xab, 0x06, 0x94, 0x80, 0x14, 0xfb, 0x57, 0x0a, 0xf3, 0x5d, - 0xe6, 0x4c, 0x80, 0xb1, 0x8b, 0x5a, 0x45, 0x64, 0xcb, 0x19, 0x96, 0x57, 0xa0, 0xaf, 0x48, 0x19, - 0xd2, 0xa8, 0x73, 0xc0, 0xf0, 0xce, 0xb1, 0x01, 0xe5, 0xce, 0xde, 0x5f, 0x7a, 0x7b, 0x14, 0xf6, - 0x3a, 0x07, 0x83, 0x4c, 0x9c, 0xf7, 0x94, 0x60, 0x3c, 0x22, 0xb4, 0x4f, 0xfe, 0x1f, 0xa6, 0x52, - 0xc4, 0xc0, 0x2c, 0x9f, 0x32, 0x9e, 0xe8, 0x89, 0xb2, 0xd8, 0xa7, 0x52, 0xf7, 0x41, 0x26, 0xfe, - 0x7e, 0xb1, 0xbb, 0x1d, 0x69, 0x93, 0x68, 0x63, 0xc4, 0x38, 0x90, 0xba, 0x9d, 0x70, 0x3b, 0x0a, - 0xfa, 0xca, 0x86, 0x9b, 0x2e, 0x6e, 0xc0, 0xa7, 0x87, 0x18, 0xd5, 0xfc, 0xec, 0x91, 0xda, 0xd1, - 0x07, 0x50, 0x76, 0x7e, 0x7e, 0x1c, 0xe9, 0x1e, 0x57, 0x11, 0x9c, 0x80, 0xa0, 0x4f, 0x48, 0x1e, - 0x71, 0x3d, 0x3c, 0x1e, 0x9e, 0x6e, 0xc3, 0xc1, 0x8b, 0xe9, 0x79, 0x7c, 0x2d, 0xc4, 0x91, 0x90, - 0x22, 0xbf, 0xa4, 0x6a, 0x2e, 0xcc, 0xd0, 0xbe, 0xa0, 0x3b, 0x64, 0xdd, 0x3d, 0x05, 0x29, 0xf2, - 0x7b, 0x5a, 0xc3, 0x7d, 0x5f, 0xd0, 0x2d, 0xb2, 0xe2, 0x1e, 0x90, 0x1b, 0x4f, 0xb7, 0x69, 0x7e, - 0xf1, 0x08, 0xbd, 0x6d, 0xf0, 0xdf, 0x1b, 0xbb, 0x31, 0xab, 0x2b, 0x37, 0x67, 0xb5, 0xfb, 0xf2, - 0xec, 0xb2, 0xee, 0x9d, 0x5f, 0xd6, 0xbd, 0x1f, 0x97, 0x75, 0xef, 0xd3, 0x55, 0xbd, 0x70, 0x7e, - 0x55, 0x2f, 0x7c, 0xbb, 0xaa, 0x17, 0xde, 0xef, 0xc7, 0xd2, 0x8e, 0x26, 0xc3, 0x20, 0xd2, 0x49, - 0xfb, 0x0f, 0xff, 0xce, 0x74, 0xfe, 0xf3, 0xd8, 0xd9, 0x29, 0x98, 0xe1, 0x2a, 0x7e, 0x3a, 0xcf, - 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x9a, 0xbf, 0x82, 0xcb, 0xfb, 0x04, 0x00, 0x00, + // 655 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x54, 0xcd, 0x6e, 0x13, 0x31, + 0x10, 0xce, 0x36, 0xfd, 0x8b, 0x37, 0x69, 0xc1, 0x6a, 0x61, 0x1b, 0x89, 0x34, 0x04, 0x15, 0x22, + 0x01, 0xbb, 0x55, 0x90, 0xb8, 0x37, 0x51, 0x0f, 0x91, 0x10, 0x48, 0x4b, 0x24, 0x24, 0x2e, 0x2b, + 0x67, 0x3d, 0xdd, 0x58, 0xe9, 0xda, 0xd5, 0xda, 0x29, 0xc9, 0x5b, 0xf0, 0x04, 0x3c, 0x04, 0x4f, + 0xd1, 0x63, 0xc5, 0x09, 0x71, 0xa8, 0x50, 0xfb, 0x12, 0x1c, 0xd1, 0x8e, 0x37, 0x29, 0x55, 0x29, + 0x57, 0x6e, 0xf6, 0xf7, 0x7d, 0x33, 0xf3, 0xd9, 0x33, 0x36, 0xd9, 0x3b, 0x61, 0xc7, 0x2a, 0x65, + 0xf1, 0x88, 0x09, 0x19, 0xd8, 0x75, 0xa0, 0xc7, 0xb3, 0x4f, 0x6c, 0x16, 0x0c, 0x99, 0x89, 0x47, + 0xfe, 0x49, 0xa6, 0x8c, 0xa2, 0x3b, 0x7f, 0xc8, 0x7c, 0xbb, 0xf6, 0xad, 0xac, 0xbe, 0x95, 0xa8, + 0x44, 0xa1, 0x2a, 0xc8, 0x57, 0x36, 0xa0, 0xfe, 0xfc, 0xee, 0xbc, 0xcc, 0x18, 0xd0, 0x86, 0x19, + 0xa1, 0xa4, 0x15, 0xb7, 0xbe, 0x95, 0xc9, 0xe6, 0xbb, 0x89, 0x49, 0x94, 0x90, 0xc9, 0x60, 0xda, + 0xcd, 0xeb, 0xd2, 0x5d, 0xe2, 0xa2, 0x81, 0x48, 0x2a, 0x19, 0x83, 0xe7, 0x34, 0x9d, 0xf6, 0x72, + 0x48, 0x10, 0x7a, 0x9b, 0x23, 0xf4, 0x09, 0xa9, 0x59, 0x81, 0x11, 0x29, 0xa8, 0x89, 0xf1, 0x96, + 0x50, 0x52, 0x45, 0x70, 0x60, 0x31, 0xfa, 0x81, 0x54, 0x4d, 0xc6, 0xa4, 0x66, 0x71, 0x5e, 0x4e, + 0x7b, 0xe5, 0x66, 0xb9, 0xed, 0x76, 0x5e, 0xfa, 0x77, 0x1e, 0xc7, 0x5f, 0xf8, 0xc8, 0xc3, 0x8e, + 0x20, 0x1b, 0x4c, 0xbb, 0xcb, 0x67, 0x17, 0xbb, 0xa5, 0xf0, 0x46, 0x22, 0xba, 0x47, 0x36, 0x8c, + 0x1a, 0x83, 0x8c, 0x62, 0x25, 0x4d, 0xc6, 0x62, 0xe3, 0x2d, 0x37, 0x9d, 0x76, 0x25, 0xac, 0x21, + 0xda, 0x2b, 0x40, 0xba, 0x4f, 0xb6, 0x6c, 0xfa, 0x68, 0x78, 0xac, 0xe2, 0x71, 0x14, 0x67, 0xc0, + 0x0c, 0x70, 0x6f, 0x05, 0xbd, 0x52, 0xcb, 0x75, 0x73, 0xaa, 0x67, 0x19, 0xfa, 0x82, 0x50, 0xb4, + 0x15, 0x65, 0x70, 0x04, 0x19, 0xc8, 0x18, 0x22, 0xc1, 0xbd, 0x55, 0x4c, 0x7e, 0x0f, 0x99, 0x70, + 0x4e, 0xf4, 0x39, 0x6d, 0x91, 0xda, 0x70, 0x66, 0x40, 0x47, 0x46, 0x45, 0x5a, 0x24, 0xd2, 0x5b, + 0x6b, 0x3a, 0xed, 0x6a, 0xe8, 0x22, 0x38, 0x50, 0xef, 0x45, 0x22, 0x69, 0x9d, 0xac, 0x33, 0x9d, + 0x93, 0x00, 0xde, 0x3a, 0xe6, 0x59, 0xec, 0xe9, 0x63, 0x52, 0x4d, 0x98, 0x8e, 0x40, 0x1b, 0x91, + 0x32, 0x03, 0x5e, 0x05, 0x7d, 0xb9, 0x09, 0xd3, 0x87, 0x05, 0x44, 0x5f, 0x93, 0x87, 0x73, 0x79, + 0x94, 0x41, 0xaa, 0x0c, 0x44, 0x8c, 0xf3, 0x0c, 0xb4, 0xf6, 0x08, 0x16, 0xdb, 0x9e, 0xd3, 0x21, + 0xb2, 0x07, 0x96, 0x6c, 0xfd, 0x72, 0x08, 0xbd, 0x7d, 0x99, 0x74, 0x83, 0x2c, 0x09, 0x5e, 0xb4, + 0x73, 0x49, 0x70, 0xfa, 0x80, 0xac, 0x6a, 0x90, 0x1c, 0x32, 0xec, 0x5f, 0x25, 0x2c, 0x76, 0xb9, + 0x33, 0x0e, 0xda, 0x2c, 0x6a, 0x95, 0x91, 0x75, 0x73, 0xac, 0xa8, 0x40, 0xdf, 0x10, 0x17, 0xb2, + 0xb8, 0xb3, 0x1f, 0xe1, 0x9d, 0x63, 0x03, 0xdc, 0xce, 0xde, 0x3f, 0x7a, 0x7b, 0x18, 0xf6, 0x3a, + 0xfb, 0x83, 0x5c, 0x5c, 0xf4, 0x94, 0x60, 0x3c, 0x22, 0xb4, 0x4f, 0xee, 0x0f, 0x33, 0xc1, 0x13, + 0x88, 0x0c, 0x9b, 0x46, 0x2c, 0x55, 0x13, 0x69, 0xb0, 0x4f, 0x95, 0xee, 0xa3, 0x5c, 0xfc, 0xe3, + 0x62, 0x77, 0x3b, 0x56, 0x3a, 0x55, 0x5a, 0xf3, 0xb1, 0x2f, 0x54, 0x90, 0x32, 0x33, 0xf2, 0xfb, + 0xd2, 0x84, 0x9b, 0x36, 0x6e, 0xc0, 0xa6, 0x07, 0x18, 0xd5, 0xfa, 0xe2, 0x90, 0xfa, 0xe1, 0x29, + 0x48, 0x33, 0x3f, 0x3f, 0x8e, 0x74, 0x8f, 0xc9, 0x18, 0x8e, 0x81, 0xd3, 0x67, 0xa4, 0x88, 0xb8, + 0x1e, 0x1e, 0x07, 0x4f, 0xb7, 0x61, 0xe1, 0xc5, 0xf4, 0x3c, 0xbd, 0x16, 0xe2, 0x48, 0x08, 0x5e, + 0x5c, 0x52, 0xad, 0x10, 0xe6, 0x68, 0x9f, 0xd3, 0x1d, 0xb2, 0x6e, 0x9f, 0x82, 0xe0, 0xc5, 0x3d, + 0xad, 0xe1, 0xbe, 0xcf, 0xe9, 0x16, 0x59, 0xb1, 0x0f, 0xc8, 0x8e, 0xa7, 0xdd, 0xb4, 0xbe, 0x3a, + 0x84, 0xde, 0x36, 0xf8, 0xff, 0x8d, 0xdd, 0x98, 0xd5, 0x95, 0x9b, 0xb3, 0xda, 0xed, 0x9f, 0x5d, + 0x36, 0x9c, 0xf3, 0xcb, 0x86, 0xf3, 0xf3, 0xb2, 0xe1, 0x7c, 0xbe, 0x6a, 0x94, 0xce, 0xaf, 0x1a, + 0xa5, 0xef, 0x57, 0x8d, 0xd2, 0xc7, 0x20, 0x11, 0x66, 0x34, 0x19, 0xfa, 0xb1, 0x4a, 0x83, 0xbf, + 0xfc, 0x3b, 0xa7, 0x9d, 0x60, 0x3a, 0xff, 0x7c, 0xcc, 0xec, 0x04, 0xf4, 0x70, 0x15, 0xff, 0x9d, + 0x57, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x47, 0x7f, 0x92, 0xfe, 0x04, 0x00, 0x00, } func (m *OutgoingTxBatch) Marshal() (dAtA []byte, err error) { @@ -685,6 +708,7 @@ func encodeVarintBatch(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *OutgoingTxBatch) Size() (n int) { if m == nil { return 0 @@ -813,9 +837,11 @@ func (m *EventOutgoingBatch) Size() (n int) { func sovBatch(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozBatch(x uint64) (n int) { return sovBatch(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *OutgoingTxBatch) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1140,6 +1166,7 @@ func (m *OutgoingTxBatch) Unmarshal(dAtA []byte) error { } return nil } + func (m *OutgoingTransferTx) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1340,6 +1367,7 @@ func (m *OutgoingTransferTx) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventOutgoingBatchCanceled) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1518,6 +1546,7 @@ func (m *EventOutgoingBatchCanceled) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventOutgoingBatch) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1728,6 +1757,7 @@ func (m *EventOutgoingBatch) Unmarshal(dAtA []byte) error { } return nil } + func skipBatch(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/bridge_tax.pb.go b/x/skyway/types/bridge_tax.pb.go index 6a50e2db..fd472e06 100644 --- a/x/skyway/types/bridge_tax.pb.go +++ b/x/skyway/types/bridge_tax.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-proto" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*BridgeTax) ProtoMessage() {} func (*BridgeTax) Descriptor() ([]byte, []int) { return fileDescriptor_71e7abf611c8b94d, []int{0} } + func (m *BridgeTax) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *BridgeTax) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BridgeTax.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *BridgeTax) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *BridgeTax) XXX_Merge(src proto.Message) { xxx_messageInfo_BridgeTax.Merge(m, src) } + func (m *BridgeTax) XXX_Size() int { return m.Size() } + func (m *BridgeTax) XXX_DiscardUnknown() { xxx_messageInfo_BridgeTax.DiscardUnknown(m) } @@ -94,7 +102,7 @@ func init() { } var fileDescriptor_71e7abf611c8b94d = []byte{ - // 290 bytes of a gzipped FileDescriptorProto + // 293 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x8b, 0xb3, 0x2b, 0xcb, 0x13, 0x2b, 0xf5, 0x93, 0x8a, 0x32, 0x53, 0xd2, 0x53, 0xe3, 0x4b, 0x12, 0x2b, 0xf4, 0x0a, 0x8a, 0xf2, @@ -109,11 +117,11 @@ var fileDescriptor_71e7abf611c8b94d = []byte{ 0xb6, 0x7e, 0x49, 0x65, 0x41, 0x6a, 0xb1, 0x9e, 0x63, 0x72, 0xb2, 0x23, 0x44, 0x6b, 0x10, 0x3f, 0xc4, 0x28, 0x47, 0x98, 0x49, 0x42, 0x22, 0x5c, 0xac, 0x25, 0xf9, 0xd9, 0xa9, 0x79, 0x12, 0x2c, 0x20, 0x27, 0x04, 0x41, 0x38, 0x5e, 0x2c, 0x1c, 0x4c, 0x02, 0xcc, 0x20, 0xc5, 0xc9, 0x39, 0xa5, - 0x29, 0xa9, 0x29, 0xf1, 0x60, 0xd1, 0x62, 0x27, 0xb7, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, + 0x29, 0xa9, 0x29, 0xf1, 0x60, 0xd1, 0x62, 0x27, 0xcf, 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, 0x41, 0x72, 0x06, 0x96, 0x90, 0xad, 0x80, 0x85, 0x2d, 0xd8, 0x41, 0x49, - 0x6c, 0xe0, 0xb0, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xcf, 0x92, 0xa2, 0xc8, 0x85, 0x01, - 0x00, 0x00, + 0x96, 0x63, 0x88, 0xd2, 0x47, 0x72, 0x06, 0x96, 0x90, 0x2d, 0x33, 0xd2, 0xaf, 0x80, 0x05, 0x2f, + 0xd8, 0x4d, 0x49, 0x6c, 0xe0, 0xe0, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x85, 0xd1, 0x4c, + 0xe3, 0x88, 0x01, 0x00, 0x00, } func (m *BridgeTax) Marshal() (dAtA []byte, err error) { @@ -173,6 +181,7 @@ func encodeVarintBridgeTax(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *BridgeTax) Size() (n int) { if m == nil { return 0 @@ -199,9 +208,11 @@ func (m *BridgeTax) Size() (n int) { func sovBridgeTax(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozBridgeTax(x uint64) (n int) { return sovBridgeTax(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *BridgeTax) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -348,6 +359,7 @@ func (m *BridgeTax) Unmarshal(dAtA []byte) error { } return nil } + func skipBridgeTax(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/bridge_tax_proposal.pb.go b/x/skyway/types/bridge_tax_proposal.pb.go index 17c32636..7a5bb4db 100644 --- a/x/skyway/types/bridge_tax_proposal.pb.go +++ b/x/skyway/types/bridge_tax_proposal.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*SetBridgeTaxProposal) ProtoMessage() {} func (*SetBridgeTaxProposal) Descriptor() ([]byte, []int) { return fileDescriptor_2d240d8fd882781b, []int{0} } + func (m *SetBridgeTaxProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetBridgeTaxProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetBridgeTaxProposal.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *SetBridgeTaxProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *SetBridgeTaxProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetBridgeTaxProposal.Merge(m, src) } + func (m *SetBridgeTaxProposal) XXX_Size() int { return m.Size() } + func (m *SetBridgeTaxProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetBridgeTaxProposal.DiscardUnknown(m) } @@ -108,26 +116,26 @@ func init() { } var fileDescriptor_2d240d8fd882781b = []byte{ - // 298 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x50, 0xbd, 0x4e, 0xf3, 0x30, - 0x14, 0xad, 0xbf, 0xfe, 0xe8, 0xab, 0x91, 0xa0, 0x8a, 0x3a, 0xa4, 0x0c, 0x56, 0xd5, 0xa9, 0x48, - 0x90, 0x0c, 0x7d, 0x02, 0x2a, 0xc4, 0xc0, 0x84, 0x0a, 0x13, 0x4b, 0xe4, 0xda, 0x57, 0xad, 0xd5, - 0x24, 0xb6, 0x6c, 0x57, 0x24, 0x6f, 0xc1, 0xc3, 0xf0, 0x10, 0x88, 0xa9, 0x62, 0x62, 0x44, 0xc9, - 0x8b, 0xa0, 0xd8, 0xa9, 0xd4, 0x81, 0xed, 0x9e, 0x73, 0xee, 0xb9, 0xf7, 0xe8, 0xe0, 0x85, 0xa2, - 0xa9, 0xcc, 0x28, 0xdb, 0x52, 0x91, 0xc7, 0x7e, 0x8e, 0xcd, 0xae, 0x7c, 0xa5, 0x65, 0xbc, 0xd6, - 0x82, 0x6f, 0x20, 0xb1, 0xb4, 0x48, 0x94, 0x96, 0x4a, 0x1a, 0x9a, 0x46, 0x4a, 0x4b, 0x2b, 0x83, - 0xc9, 0x89, 0x29, 0xf2, 0x73, 0xe4, 0x4d, 0x97, 0x13, 0x26, 0x4d, 0x26, 0x4d, 0xe2, 0x16, 0x63, - 0x0f, 0xbc, 0x6b, 0xf6, 0x89, 0xf0, 0xf8, 0x09, 0xec, 0xd2, 0x9d, 0x7d, 0xa6, 0xc5, 0x63, 0x7b, - 0x34, 0x18, 0xe3, 0xbe, 0x15, 0x36, 0x85, 0x10, 0x4d, 0xd1, 0x7c, 0xb8, 0xf2, 0x20, 0x98, 0xe2, - 0x33, 0x0e, 0x86, 0x69, 0xa1, 0xac, 0x90, 0x79, 0xf8, 0xcf, 0x69, 0xa7, 0x54, 0x30, 0xc3, 0x3d, - 0x4d, 0x2d, 0x84, 0xdd, 0x46, 0x5a, 0x9e, 0x7f, 0xbd, 0xdf, 0xe0, 0xf6, 0xe1, 0x1d, 0xb0, 0x95, - 0xd3, 0x82, 0x2b, 0x3c, 0x82, 0x02, 0x32, 0x65, 0x13, 0xca, 0xb9, 0x06, 0x63, 0xc0, 0x84, 0xfd, - 0x69, 0x77, 0x3e, 0x5c, 0x5d, 0x78, 0xfe, 0xf6, 0x48, 0xbb, 0x18, 0x72, 0x07, 0x79, 0x38, 0x68, - 0x63, 0x34, 0xe0, 0xa1, 0xf7, 0xbf, 0x37, 0xea, 0x37, 0xcb, 0x2c, 0xdd, 0x73, 0xe0, 0x89, 0x63, - 0xcd, 0xf2, 0xfe, 0xa3, 0x22, 0xe8, 0x50, 0x11, 0xf4, 0x53, 0x11, 0xf4, 0x56, 0x93, 0xce, 0xa1, - 0x26, 0x9d, 0xef, 0x9a, 0x74, 0x5e, 0xae, 0x37, 0xc2, 0x6e, 0xf7, 0xeb, 0x88, 0xc9, 0x2c, 0xfe, - 0xa3, 0xdc, 0xe2, 0x58, 0xaf, 0x2d, 0x15, 0x98, 0xf5, 0xc0, 0x75, 0xb3, 0xf8, 0x0d, 0x00, 0x00, - 0xff, 0xff, 0x64, 0xd1, 0x17, 0xa7, 0x88, 0x01, 0x00, 0x00, + // 299 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x50, 0x3b, 0x4e, 0x03, 0x31, + 0x14, 0x8c, 0xc9, 0x47, 0xc4, 0x48, 0x10, 0xad, 0x52, 0x6c, 0x28, 0xac, 0x28, 0x55, 0x28, 0x58, + 0x4b, 0xe4, 0x04, 0x44, 0x34, 0x50, 0xa1, 0x40, 0x45, 0xb3, 0x72, 0xec, 0xa7, 0xc4, 0xca, 0x6e, + 0x6c, 0xd9, 0x0e, 0x6c, 0x6e, 0xc1, 0x61, 0x38, 0x04, 0xa2, 0x8a, 0xa8, 0x28, 0x51, 0xf6, 0x22, + 0x68, 0xed, 0x8d, 0x94, 0x82, 0xee, 0xcd, 0xcc, 0x9b, 0xf7, 0x46, 0x83, 0x27, 0x9a, 0x65, 0x2a, + 0x67, 0x7c, 0xc9, 0xe4, 0x9a, 0x86, 0x99, 0xda, 0xd5, 0xf6, 0x8d, 0x6d, 0xe9, 0xdc, 0x48, 0xb1, + 0x80, 0xd4, 0xb1, 0x22, 0xd5, 0x46, 0x69, 0x65, 0x59, 0x96, 0x68, 0xa3, 0x9c, 0x8a, 0x06, 0x47, + 0xa6, 0x24, 0xcc, 0x49, 0x30, 0x5d, 0x0e, 0xb8, 0xb2, 0xb9, 0xb2, 0xa9, 0x5f, 0xa4, 0x01, 0x04, + 0xd7, 0xe8, 0x0b, 0xe1, 0xfe, 0x13, 0xb8, 0xa9, 0x3f, 0xfb, 0xcc, 0x8a, 0xc7, 0xfa, 0x68, 0xd4, + 0xc7, 0x6d, 0x27, 0x5d, 0x06, 0x31, 0x1a, 0xa2, 0x71, 0x77, 0x16, 0x40, 0x34, 0xc4, 0x67, 0x02, + 0x2c, 0x37, 0x52, 0x3b, 0xa9, 0xd6, 0xf1, 0x89, 0xd7, 0x8e, 0xa9, 0x68, 0x84, 0x5b, 0x86, 0x39, + 0x88, 0x9b, 0x95, 0x34, 0x3d, 0xff, 0xfe, 0xb8, 0xc6, 0xf5, 0xc3, 0x3b, 0xe0, 0x33, 0xaf, 0x45, + 0x57, 0xb8, 0x07, 0x05, 0xe4, 0xda, 0xa5, 0x4c, 0x08, 0x03, 0xd6, 0x82, 0x8d, 0xdb, 0xc3, 0xe6, + 0xb8, 0x3b, 0xbb, 0x08, 0xfc, 0xed, 0x81, 0xf6, 0x31, 0xd4, 0x0a, 0xd6, 0x71, 0xa7, 0x8e, 0x51, + 0x81, 0x87, 0xd6, 0x69, 0xab, 0xd7, 0xae, 0x96, 0x79, 0xb6, 0x11, 0x20, 0x52, 0xcf, 0xda, 0xe9, + 0xfd, 0xe7, 0x9e, 0xa0, 0xdd, 0x9e, 0xa0, 0xdf, 0x3d, 0x41, 0xef, 0x25, 0x69, 0xec, 0x4a, 0xd2, + 0xf8, 0x29, 0x49, 0xe3, 0x85, 0x2e, 0xa4, 0x5b, 0x6e, 0xe6, 0x09, 0x57, 0x39, 0xfd, 0xa7, 0xdc, + 0xd7, 0x1b, 0x5a, 0x1c, 0x1a, 0x76, 0x5b, 0x0d, 0x76, 0xde, 0xf1, 0xf5, 0x4c, 0xfe, 0x02, 0x00, + 0x00, 0xff, 0xff, 0xae, 0x38, 0x3e, 0x56, 0x8b, 0x01, 0x00, 0x00, } func (m *SetBridgeTaxProposal) Marshal() (dAtA []byte, err error) { @@ -201,6 +209,7 @@ func encodeVarintBridgeTaxProposal(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *SetBridgeTaxProposal) Size() (n int) { if m == nil { return 0 @@ -235,9 +244,11 @@ func (m *SetBridgeTaxProposal) Size() (n int) { func sovBridgeTaxProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozBridgeTaxProposal(x uint64) (n int) { return sovBridgeTaxProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetBridgeTaxProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -448,6 +459,7 @@ func (m *SetBridgeTaxProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipBridgeTaxProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/bridge_transfer_limit.pb.go b/x/skyway/types/bridge_transfer_limit.pb.go index cff2b773..3fd980e9 100644 --- a/x/skyway/types/bridge_transfer_limit.pb.go +++ b/x/skyway/types/bridge_transfer_limit.pb.go @@ -4,20 +4,23 @@ package types import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + cosmossdk_io_math "cosmossdk.io/math" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -78,9 +81,11 @@ func (*BridgeTransferLimit) ProtoMessage() {} func (*BridgeTransferLimit) Descriptor() ([]byte, []int) { return fileDescriptor_30c19b73abd7126a, []int{0} } + func (m *BridgeTransferLimit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *BridgeTransferLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BridgeTransferLimit.Marshal(b, m, deterministic) @@ -93,12 +98,15 @@ func (m *BridgeTransferLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *BridgeTransferLimit) XXX_Merge(src proto.Message) { xxx_messageInfo_BridgeTransferLimit.Merge(m, src) } + func (m *BridgeTransferLimit) XXX_Size() int { return m.Size() } + func (m *BridgeTransferLimit) XXX_DiscardUnknown() { xxx_messageInfo_BridgeTransferLimit.DiscardUnknown(m) } @@ -141,9 +149,11 @@ func (*BridgeTransferUsage) ProtoMessage() {} func (*BridgeTransferUsage) Descriptor() ([]byte, []int) { return fileDescriptor_30c19b73abd7126a, []int{1} } + func (m *BridgeTransferUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *BridgeTransferUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BridgeTransferUsage.Marshal(b, m, deterministic) @@ -156,12 +166,15 @@ func (m *BridgeTransferUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *BridgeTransferUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_BridgeTransferUsage.Merge(m, src) } + func (m *BridgeTransferUsage) XXX_Size() int { return m.Size() } + func (m *BridgeTransferUsage) XXX_DiscardUnknown() { xxx_messageInfo_BridgeTransferUsage.DiscardUnknown(m) } @@ -186,35 +199,35 @@ func init() { } var fileDescriptor_30c19b73abd7126a = []byte{ - // 435 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x5d, 0x6b, 0xd4, 0x40, - 0x14, 0x4d, 0xf6, 0xa3, 0xda, 0xd9, 0xa2, 0x61, 0xac, 0x10, 0x05, 0xb3, 0x4b, 0x1f, 0x64, 0x91, - 0x76, 0x82, 0x16, 0x7f, 0x40, 0x82, 0xd1, 0x2e, 0xc6, 0xad, 0x84, 0x8a, 0x44, 0x84, 0x30, 0x49, - 0xc6, 0x64, 0xc8, 0xc7, 0x84, 0xcc, 0x88, 0xbb, 0x3f, 0xc1, 0x37, 0x7f, 0x56, 0x1f, 0xfb, 0x28, - 0x3e, 0x2c, 0xb2, 0xfb, 0x2f, 0x7c, 0x92, 0xcc, 0x74, 0x71, 0x11, 0xa5, 0x4f, 0x39, 0x73, 0xef, - 0x39, 0x27, 0xf7, 0x1e, 0x2e, 0x78, 0xde, 0xe0, 0x92, 0x55, 0x38, 0xc9, 0x31, 0xad, 0x6d, 0x85, - 0x6d, 0x5e, 0x2c, 0xbf, 0xe0, 0xa5, 0x1d, 0xb7, 0x34, 0xcd, 0x48, 0x24, 0x5a, 0x5c, 0xf3, 0x4f, - 0xa4, 0x8d, 0x4a, 0x5a, 0x51, 0x81, 0x9a, 0x96, 0x09, 0x06, 0x1f, 0xec, 0xc8, 0x90, 0xc2, 0x48, - 0xc9, 0x1e, 0x1e, 0x66, 0x2c, 0x63, 0x92, 0x65, 0x77, 0x48, 0x09, 0x8e, 0xbe, 0xf6, 0xc0, 0x3d, - 0x57, 0x1a, 0x5e, 0x5c, 0xfb, 0xf9, 0x9d, 0x1d, 0x3c, 0x04, 0x43, 0xc1, 0x0a, 0x52, 0x9b, 0xfa, - 0x44, 0x9f, 0xee, 0x07, 0xea, 0x01, 0x4f, 0xc1, 0x50, 0xfe, 0xcd, 0xec, 0x75, 0x55, 0xf7, 0xd1, - 0xe5, 0x6a, 0xac, 0xfd, 0x58, 0x8d, 0xef, 0x27, 0x8c, 0x57, 0x8c, 0xf3, 0xb4, 0x40, 0x94, 0xd9, - 0x15, 0x16, 0x39, 0x9a, 0xd5, 0x22, 0x50, 0x5c, 0x38, 0x03, 0x07, 0x12, 0x44, 0x0d, 0x69, 0x29, - 0x4b, 0xcd, 0xfe, 0x44, 0x9f, 0xde, 0x79, 0xf6, 0x18, 0xfd, 0x77, 0x54, 0x24, 0x47, 0x78, 0x2b, - 0xd9, 0xc1, 0xa8, 0xfc, 0xf3, 0x80, 0x1f, 0x81, 0x41, 0x16, 0xa4, 0x6a, 0x44, 0x84, 0xd3, 0xb4, - 0x25, 0x9c, 0x13, 0x6e, 0x0e, 0x26, 0xfd, 0xe9, 0x81, 0xfb, 0xf4, 0xd7, 0x6a, 0x7c, 0x92, 0x51, - 0x91, 0x7f, 0x8e, 0x51, 0xc2, 0x2a, 0x5b, 0x4d, 0x74, 0xfd, 0x39, 0xe1, 0x69, 0x61, 0x8b, 0x65, - 0x43, 0x38, 0x72, 0x92, 0xc4, 0x51, 0xd2, 0xe0, 0xae, 0xb2, 0x72, 0xb6, 0x4e, 0x47, 0x8b, 0xbf, - 0xa3, 0x78, 0xc7, 0x71, 0x46, 0xba, 0xa5, 0x05, 0x13, 0xb8, 0x54, 0x51, 0xdc, 0xb8, 0xb4, 0xe4, - 0xc2, 0x63, 0x00, 0xb9, 0xc0, 0xad, 0x88, 0xe2, 0x92, 0x25, 0x45, 0x94, 0x13, 0x9a, 0xe5, 0x2a, - 0xb6, 0x7e, 0x60, 0xc8, 0x8e, 0xdb, 0x35, 0xce, 0x64, 0xfd, 0xc9, 0x2b, 0x30, 0xda, 0xd9, 0x19, - 0xde, 0x06, 0x83, 0xf9, 0xf9, 0xdc, 0x33, 0x34, 0xb8, 0x0f, 0x86, 0x2f, 0x9c, 0x99, 0x1f, 0x1a, - 0x3a, 0x04, 0x60, 0xef, 0xbd, 0xe7, 0xbd, 0xf6, 0x43, 0xa3, 0x07, 0x47, 0xe0, 0xd6, 0x9b, 0xf3, - 0xf9, 0xc5, 0x99, 0x1f, 0x1a, 0xfd, 0xae, 0x11, 0x7a, 0x4e, 0xe0, 0x87, 0xc6, 0xc0, 0x7d, 0x79, - 0xb9, 0xb6, 0xf4, 0xab, 0xb5, 0xa5, 0xff, 0x5c, 0x5b, 0xfa, 0xb7, 0x8d, 0xa5, 0x5d, 0x6d, 0x2c, - 0xed, 0xfb, 0xc6, 0xd2, 0x3e, 0x1c, 0xef, 0x84, 0xf3, 0x8f, 0xdb, 0x5a, 0x6c, 0xaf, 0x4b, 0xc6, - 0x14, 0xef, 0xc9, 0xeb, 0x38, 0xfd, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x08, 0x6f, 0x45, 0xb9, 0x87, - 0x02, 0x00, 0x00, + // 438 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x5d, 0x8b, 0xd3, 0x40, + 0x14, 0x4d, 0xfa, 0xb1, 0xba, 0xd3, 0x45, 0xc3, 0xb8, 0x42, 0x15, 0x4c, 0xcb, 0x3e, 0x48, 0x11, + 0x77, 0x06, 0x77, 0xf1, 0x07, 0x24, 0x58, 0xdc, 0x62, 0xec, 0x4a, 0x58, 0x91, 0x88, 0x10, 0x26, + 0xc9, 0x98, 0x0c, 0xf9, 0x98, 0x90, 0x19, 0xb5, 0xfd, 0x09, 0xbe, 0xf9, 0xb3, 0xf6, 0x71, 0x1f, + 0xc5, 0x87, 0x22, 0xed, 0xbf, 0xf0, 0x49, 0x32, 0xb3, 0xc5, 0x22, 0xca, 0x3e, 0xe5, 0xcc, 0xbd, + 0xe7, 0x9c, 0xdc, 0x7b, 0xb8, 0xe0, 0x79, 0x4d, 0x0a, 0x5e, 0x92, 0x38, 0x23, 0xac, 0xc2, 0x1a, + 0x63, 0x91, 0x2f, 0xbf, 0x90, 0x25, 0x8e, 0x1a, 0x96, 0xa4, 0x34, 0x94, 0x0d, 0xa9, 0xc4, 0x47, + 0xda, 0x84, 0x05, 0x2b, 0x99, 0x44, 0x75, 0xc3, 0x25, 0x87, 0x0f, 0x76, 0x64, 0x48, 0x63, 0xa4, + 0x65, 0x0f, 0x0f, 0x53, 0x9e, 0x72, 0xc5, 0xc2, 0x2d, 0xd2, 0x82, 0xa3, 0xaf, 0x1d, 0x70, 0xcf, + 0x55, 0x86, 0x17, 0xd7, 0x7e, 0x5e, 0x6b, 0x07, 0x0f, 0x41, 0x5f, 0xf2, 0x9c, 0x56, 0x43, 0x73, + 0x6c, 0x4e, 0xf6, 0x7d, 0xfd, 0x80, 0xa7, 0xa0, 0xaf, 0xfe, 0x36, 0xec, 0xb4, 0x55, 0xf7, 0xd1, + 0xe5, 0x6a, 0x64, 0xfc, 0x58, 0x8d, 0xee, 0xc7, 0x5c, 0x94, 0x5c, 0x88, 0x24, 0x47, 0x8c, 0xe3, + 0x92, 0xc8, 0x0c, 0xcd, 0x2a, 0xe9, 0x6b, 0x2e, 0x9c, 0x81, 0x03, 0x05, 0xc2, 0x9a, 0x36, 0x8c, + 0x27, 0xc3, 0xee, 0xd8, 0x9c, 0xdc, 0x39, 0x79, 0x8c, 0xfe, 0x3b, 0x2a, 0x52, 0x23, 0xbc, 0x51, + 0x6c, 0x7f, 0x50, 0xfc, 0x79, 0xc0, 0x0f, 0xc0, 0xa2, 0x0b, 0x5a, 0xd6, 0x32, 0x24, 0x49, 0xd2, + 0x50, 0x21, 0xa8, 0x18, 0xf6, 0xc6, 0xdd, 0xc9, 0x81, 0xfb, 0xec, 0xd7, 0x6a, 0x74, 0x9c, 0x32, + 0x99, 0x7d, 0x8a, 0x50, 0xcc, 0x4b, 0xac, 0x27, 0xba, 0xfe, 0x1c, 0x8b, 0x24, 0xc7, 0x72, 0x59, + 0x53, 0x81, 0x9c, 0x38, 0x76, 0xb4, 0xd4, 0xbf, 0xab, 0xad, 0x9c, 0xad, 0xd3, 0xd1, 0xe2, 0xef, + 0x28, 0xde, 0x0a, 0x92, 0xd2, 0x76, 0x69, 0xc9, 0x25, 0x29, 0x74, 0x14, 0x37, 0x2e, 0xad, 0xb8, + 0xf0, 0x29, 0x80, 0x42, 0x92, 0x46, 0x86, 0x51, 0xc1, 0xe3, 0x3c, 0xcc, 0x28, 0x4b, 0x33, 0x1d, + 0x5b, 0xd7, 0xb7, 0x54, 0xc7, 0x6d, 0x1b, 0x67, 0xaa, 0xfe, 0xe4, 0x25, 0x18, 0xec, 0xec, 0x0c, + 0x6f, 0x83, 0xde, 0xfc, 0x7c, 0x3e, 0xb5, 0x0c, 0xb8, 0x0f, 0xfa, 0x2f, 0x9c, 0x99, 0x17, 0x58, + 0x26, 0x04, 0x60, 0xef, 0xdd, 0x74, 0xfa, 0xca, 0x0b, 0xac, 0x0e, 0x1c, 0x80, 0x5b, 0xaf, 0xcf, + 0xe7, 0x17, 0x67, 0x5e, 0x60, 0x75, 0xdb, 0x46, 0x30, 0x75, 0x7c, 0x2f, 0xb0, 0x7a, 0xee, 0xec, + 0x72, 0x6d, 0x9b, 0x57, 0x6b, 0xdb, 0xfc, 0xb9, 0xb6, 0xcd, 0x6f, 0x1b, 0xdb, 0xb8, 0xda, 0xd8, + 0xc6, 0xf7, 0x8d, 0x6d, 0xbc, 0xc7, 0x3b, 0xe1, 0xfc, 0xe3, 0xb6, 0x3e, 0x9f, 0xe0, 0xc5, 0xf6, + 0xc0, 0x54, 0x52, 0xd1, 0x9e, 0x3a, 0x90, 0xd3, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1a, 0xb9, + 0xd0, 0xe8, 0x8a, 0x02, 0x00, 0x00, } func (m *BridgeTransferLimit) Marshal() (dAtA []byte, err error) { @@ -320,6 +333,7 @@ func encodeVarintBridgeTransferLimit(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *BridgeTransferLimit) Size() (n int) { if m == nil { return 0 @@ -361,9 +375,11 @@ func (m *BridgeTransferUsage) Size() (n int) { func sovBridgeTransferLimit(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozBridgeTransferLimit(x uint64) (n int) { return sovBridgeTransferLimit(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *BridgeTransferLimit) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -531,6 +547,7 @@ func (m *BridgeTransferLimit) Unmarshal(dAtA []byte) error { } return nil } + func (m *BridgeTransferUsage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -634,6 +651,7 @@ func (m *BridgeTransferUsage) Unmarshal(dAtA []byte) error { } return nil } + func skipBridgeTransferLimit(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/bridge_transfer_limit_proposal.pb.go b/x/skyway/types/bridge_transfer_limit_proposal.pb.go index 183aad38..2bed39d7 100644 --- a/x/skyway/types/bridge_transfer_limit_proposal.pb.go +++ b/x/skyway/types/bridge_transfer_limit_proposal.pb.go @@ -4,19 +4,22 @@ package types import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + cosmossdk_io_math "cosmossdk.io/math" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -39,9 +42,11 @@ func (*SetBridgeTransferLimitProposal) ProtoMessage() {} func (*SetBridgeTransferLimitProposal) Descriptor() ([]byte, []int) { return fileDescriptor_e913872479061690, []int{0} } + func (m *SetBridgeTransferLimitProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetBridgeTransferLimitProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetBridgeTransferLimitProposal.Marshal(b, m, deterministic) @@ -54,12 +59,15 @@ func (m *SetBridgeTransferLimitProposal) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *SetBridgeTransferLimitProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetBridgeTransferLimitProposal.Merge(m, src) } + func (m *SetBridgeTransferLimitProposal) XXX_Size() int { return m.Size() } + func (m *SetBridgeTransferLimitProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetBridgeTransferLimitProposal.DiscardUnknown(m) } @@ -110,29 +118,29 @@ func init() { } var fileDescriptor_e913872479061690 = []byte{ - // 342 bytes of a gzipped FileDescriptorProto + // 344 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x90, 0x31, 0x4b, 0xf3, 0x40, - 0x18, 0xc7, 0x93, 0xf6, 0x6d, 0xa1, 0xe9, 0x8b, 0x4a, 0xa8, 0x10, 0x0b, 0x5e, 0x83, 0x83, 0x54, - 0x90, 0x0b, 0x58, 0x5c, 0x05, 0x3b, 0x08, 0x05, 0x07, 0x89, 0x4e, 0x2e, 0xe1, 0x9a, 0x9c, 0xe9, - 0xd1, 0x24, 0xcf, 0x71, 0x77, 0x62, 0xfb, 0x2d, 0x5c, 0xfd, 0x46, 0x1d, 0x3b, 0x8a, 0x43, 0x91, - 0xf6, 0x8b, 0x48, 0xee, 0x52, 0xec, 0xa0, 0x83, 0xdb, 0xf3, 0xfc, 0xf3, 0xfb, 0xf1, 0xe4, 0xfe, - 0xce, 0x15, 0x27, 0x19, 0xe4, 0x24, 0x9e, 0x10, 0x56, 0x04, 0x66, 0x0e, 0xe4, 0x74, 0xfe, 0x42, - 0xe6, 0xc1, 0x58, 0xb0, 0x24, 0xa5, 0x91, 0x12, 0xa4, 0x90, 0x4f, 0x54, 0x44, 0x19, 0xcb, 0x99, - 0x8a, 0xb8, 0x00, 0x0e, 0x92, 0x64, 0x98, 0x0b, 0x50, 0xe0, 0x1e, 0xed, 0xf8, 0xd8, 0xcc, 0xd8, - 0xf8, 0xdd, 0x4e, 0x0a, 0x29, 0x68, 0x2a, 0x28, 0x27, 0x23, 0x74, 0x2f, 0xff, 0x78, 0xd0, 0x68, - 0x27, 0x6f, 0x35, 0x07, 0xdd, 0x53, 0x35, 0xd4, 0xc8, 0x43, 0x45, 0xdc, 0x96, 0xc0, 0x5d, 0xf5, - 0x43, 0x6e, 0xc7, 0x69, 0x28, 0xa6, 0x32, 0xea, 0xd9, 0xbe, 0xdd, 0x6f, 0x85, 0x66, 0x71, 0x7d, - 0xa7, 0x9d, 0x50, 0x19, 0x0b, 0xc6, 0x15, 0x83, 0xc2, 0xab, 0xe9, 0x6f, 0xbb, 0x91, 0xf6, 0x60, - 0x4a, 0x0b, 0xaf, 0x5e, 0x79, 0xe5, 0xe2, 0x0e, 0x9c, 0x86, 0xbe, 0xef, 0xfd, 0x2b, 0xd3, 0xe1, - 0xf1, 0x62, 0xd5, 0xb3, 0x3e, 0x56, 0xbd, 0xc3, 0x18, 0x64, 0x0e, 0x52, 0x26, 0x53, 0xcc, 0x20, - 0xc8, 0x89, 0x9a, 0xe0, 0x51, 0xa1, 0x42, 0xc3, 0xba, 0x23, 0xe7, 0x7f, 0xd5, 0x12, 0x15, 0x0c, - 0x12, 0xaf, 0xe1, 0xdb, 0xfd, 0xbd, 0x8b, 0x53, 0xfc, 0x6b, 0x49, 0xd8, 0x3c, 0x41, 0xd3, 0x61, - 0x3b, 0xfb, 0x5e, 0xdc, 0x33, 0xe7, 0x80, 0xce, 0x68, 0xce, 0x55, 0x44, 0x92, 0x44, 0x50, 0x29, - 0xa9, 0xf4, 0x9a, 0x7e, 0xbd, 0xdf, 0x0a, 0xf7, 0x4d, 0x7e, 0xbd, 0x8d, 0x87, 0x37, 0x8b, 0x35, - 0xb2, 0x97, 0x6b, 0x64, 0x7f, 0xae, 0x91, 0xfd, 0xba, 0x41, 0xd6, 0x72, 0x83, 0xac, 0xf7, 0x0d, - 0xb2, 0x1e, 0xcf, 0x53, 0xa6, 0x26, 0xcf, 0x63, 0x1c, 0x43, 0x1e, 0xfc, 0xd0, 0xfb, 0x6c, 0xdb, - 0xbc, 0x9a, 0x73, 0x2a, 0xc7, 0x4d, 0x5d, 0xf5, 0xe0, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x75, 0x71, - 0x55, 0x8e, 0x14, 0x02, 0x00, 0x00, + 0x18, 0xc7, 0x93, 0xf6, 0x6d, 0xa1, 0xe9, 0x8b, 0x4a, 0xa8, 0x10, 0x0b, 0xa6, 0xc1, 0x41, 0xea, + 0x72, 0x07, 0x2d, 0xae, 0x82, 0xdd, 0x0a, 0x0e, 0x12, 0x9d, 0x5c, 0xc2, 0x35, 0x39, 0xd3, 0xa3, + 0x49, 0x9e, 0xe3, 0xee, 0xd4, 0xf6, 0x5b, 0xb8, 0xfa, 0x8d, 0x3a, 0x76, 0x14, 0x87, 0x22, 0xed, + 0x17, 0x91, 0xdc, 0xa5, 0xd8, 0x41, 0x07, 0xb7, 0xe7, 0xf9, 0xe7, 0xf7, 0xe3, 0xc9, 0xfd, 0x9d, + 0x2b, 0x4e, 0x32, 0xc8, 0x49, 0x3c, 0x25, 0xac, 0xc0, 0x66, 0xc6, 0x72, 0xb6, 0x78, 0x21, 0x0b, + 0x3c, 0x11, 0x2c, 0x49, 0x69, 0xa4, 0x04, 0x29, 0xe4, 0x23, 0x15, 0x51, 0xc6, 0x72, 0xa6, 0x22, + 0x2e, 0x80, 0x83, 0x24, 0x19, 0xe2, 0x02, 0x14, 0xb8, 0x27, 0x7b, 0x3e, 0x32, 0x33, 0x32, 0x7e, + 0xb7, 0x93, 0x42, 0x0a, 0x9a, 0xc2, 0xe5, 0x64, 0x84, 0xee, 0xe5, 0x1f, 0x0f, 0x1a, 0xed, 0xec, + 0xad, 0xe6, 0xf8, 0x77, 0x54, 0x8d, 0x34, 0x72, 0x5f, 0x11, 0x37, 0x25, 0x70, 0x5b, 0xfd, 0x90, + 0xdb, 0x71, 0x1a, 0x8a, 0xa9, 0x8c, 0x7a, 0x76, 0x60, 0xf7, 0x5b, 0xa1, 0x59, 0xdc, 0xc0, 0x69, + 0x27, 0x54, 0xc6, 0x82, 0x71, 0xc5, 0xa0, 0xf0, 0x6a, 0xfa, 0xdb, 0x7e, 0xa4, 0x3d, 0x98, 0xd1, + 0xc2, 0xab, 0x57, 0x5e, 0xb9, 0xb8, 0x43, 0xa7, 0xa1, 0xef, 0x7b, 0xff, 0xca, 0x74, 0x74, 0xba, + 0x5c, 0xf7, 0xac, 0x8f, 0x75, 0xef, 0x38, 0x06, 0x99, 0x83, 0x94, 0xc9, 0x0c, 0x31, 0xc0, 0x39, + 0x51, 0x53, 0x34, 0x2e, 0x54, 0x68, 0x58, 0x77, 0xec, 0xfc, 0xaf, 0x5a, 0xa2, 0x82, 0x41, 0xe2, + 0x35, 0x02, 0xbb, 0x7f, 0x30, 0x38, 0x47, 0xbf, 0x96, 0x84, 0xcc, 0x13, 0x34, 0x1d, 0xb6, 0xb3, + 0xef, 0xc5, 0xbd, 0x70, 0x8e, 0xe8, 0x9c, 0xe6, 0x5c, 0x45, 0x24, 0x49, 0x04, 0x95, 0x92, 0x4a, + 0xaf, 0x19, 0xd4, 0xfb, 0xad, 0xf0, 0xd0, 0xe4, 0xd7, 0xbb, 0x78, 0x34, 0x5e, 0x6e, 0x7c, 0x7b, + 0xb5, 0xf1, 0xed, 0xcf, 0x8d, 0x6f, 0xbf, 0x6e, 0x7d, 0x6b, 0xb5, 0xf5, 0xad, 0xf7, 0xad, 0x6f, + 0x3d, 0xe0, 0x94, 0xa9, 0xe9, 0xd3, 0x04, 0xc5, 0x90, 0xe3, 0x1f, 0x7a, 0x7f, 0x1e, 0xe0, 0xf9, + 0xae, 0x7c, 0xb5, 0xe0, 0x54, 0x4e, 0x9a, 0xba, 0xed, 0xe1, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x95, 0x6d, 0x0f, 0x7d, 0x17, 0x02, 0x00, 0x00, } func (m *SetBridgeTransferLimitProposal) Marshal() (dAtA []byte, err error) { @@ -214,6 +222,7 @@ func encodeVarintBridgeTransferLimitProposal(dAtA []byte, offset int, v uint64) dAtA[offset] = uint8(v) return base } + func (m *SetBridgeTransferLimitProposal) Size() (n int) { if m == nil { return 0 @@ -249,9 +258,11 @@ func (m *SetBridgeTransferLimitProposal) Size() (n int) { func sovBridgeTransferLimitProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozBridgeTransferLimitProposal(x uint64) (n int) { return sovBridgeTransferLimitProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetBridgeTransferLimitProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -483,6 +494,7 @@ func (m *SetBridgeTransferLimitProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipBridgeTransferLimitProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/codec.go b/x/skyway/types/codec.go index 75a6c396..0b7e3f3d 100644 --- a/x/skyway/types/codec.go +++ b/x/skyway/types/codec.go @@ -31,6 +31,7 @@ func RegisterInterfaces(registry types.InterfaceRegistry) { &MsgSubmitBadSignatureEvidence{}, &MsgLightNodeSaleClaim{}, &MsgNonceOverrideProposal{}, + &MsgSetERC20ToTokenDenom{}, ) registry.RegisterInterface( @@ -85,4 +86,5 @@ func RegisterCodec(cdc *codec.LegacyAmino) { cdc.RegisterConcrete(&MsgLightNodeSaleClaim{}, "skyway/MsgLightNodeSaleClaim", nil) cdc.RegisterConcrete(&SetLightNodeSaleContractsProposal{}, "skyway/SetLightNodeSaleContractsProposal", nil) cdc.RegisterConcrete(&MsgNonceOverrideProposal{}, "skyway/MsgNonceOverrideProposal", nil) + cdc.RegisterConcrete(&MsgSetERC20ToTokenDenom{}, "skyway/MsgSetERC20ToTokenDenom", nil) } diff --git a/x/skyway/types/erc20_to_denom_proposal.pb.go b/x/skyway/types/erc20_to_denom_proposal.pb.go index 37420af0..e1736987 100644 --- a/x/skyway/types/erc20_to_denom_proposal.pb.go +++ b/x/skyway/types/erc20_to_denom_proposal.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*SetERC20ToDenomProposal) ProtoMessage() {} func (*SetERC20ToDenomProposal) Descriptor() ([]byte, []int) { return fileDescriptor_dab216e927aff81c, []int{0} } + func (m *SetERC20ToDenomProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetERC20ToDenomProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetERC20ToDenomProposal.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *SetERC20ToDenomProposal) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *SetERC20ToDenomProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetERC20ToDenomProposal.Merge(m, src) } + func (m *SetERC20ToDenomProposal) XXX_Size() int { return m.Size() } + func (m *SetERC20ToDenomProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetERC20ToDenomProposal.DiscardUnknown(m) } @@ -108,24 +116,25 @@ func init() { } var fileDescriptor_dab216e927aff81c = []byte{ - // 270 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2f, 0x48, 0xcc, 0xc9, - 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x8b, 0xb3, 0x2b, 0xcb, 0x13, - 0x2b, 0xf5, 0x53, 0x8b, 0x92, 0x8d, 0x0c, 0xe2, 0x4b, 0xf2, 0xe3, 0x53, 0x52, 0xf3, 0xf2, 0x73, - 0xe3, 0x0b, 0x8a, 0xf2, 0x0b, 0xf2, 0x8b, 0x13, 0x73, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, - 0x24, 0x91, 0x34, 0xea, 0x41, 0xd8, 0x7a, 0x10, 0x8d, 0x52, 0x92, 0xc9, 0xf9, 0xc5, 0xb9, 0xf9, - 0xc5, 0xf1, 0x60, 0x85, 0xfa, 0x10, 0x0e, 0x44, 0x97, 0xd2, 0x6a, 0x46, 0x2e, 0xf1, 0xe0, 0xd4, - 0x12, 0xd7, 0x20, 0x67, 0x23, 0x83, 0x90, 0x7c, 0x17, 0x90, 0xc1, 0x01, 0x50, 0x73, 0x85, 0x44, - 0xb8, 0x58, 0x4b, 0x32, 0x4b, 0x72, 0x52, 0x25, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x20, 0x1c, - 0x21, 0x05, 0x2e, 0xee, 0x94, 0xd4, 0xe2, 0xe4, 0xa2, 0xcc, 0x82, 0x92, 0xcc, 0xfc, 0x3c, 0x09, - 0x26, 0xb0, 0x1c, 0xb2, 0x90, 0x90, 0x0e, 0x97, 0x10, 0xd8, 0x15, 0xf1, 0x45, 0xa9, 0x69, 0xa9, - 0x45, 0xa9, 0x79, 0xc9, 0xa9, 0xf1, 0x99, 0x29, 0x12, 0xcc, 0x60, 0x85, 0x02, 0x60, 0x99, 0x20, - 0x98, 0x84, 0x67, 0x0a, 0xc8, 0x16, 0xb0, 0xc7, 0x24, 0x58, 0x20, 0xb6, 0x80, 0x39, 0x20, 0x51, - 0xb0, 0x2f, 0x25, 0x58, 0x21, 0xa2, 0x60, 0x8e, 0x93, 0xdb, 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, 0xe9, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, - 0x63, 0x09, 0xc1, 0x0a, 0x58, 0x18, 0x96, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x3d, 0x6f, - 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xb3, 0x48, 0x9f, 0x29, 0x6d, 0x01, 0x00, 0x00, + // 273 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x50, 0x3d, 0x4f, 0xc3, 0x30, + 0x10, 0xad, 0x81, 0x22, 0x11, 0x16, 0x14, 0x21, 0x91, 0x32, 0x58, 0x15, 0x13, 0x03, 0x8a, 0xab, + 0x30, 0xb0, 0xf3, 0x31, 0x74, 0x43, 0x81, 0x89, 0xc5, 0x4a, 0x9d, 0x83, 0x5a, 0x24, 0x39, 0xcb, + 0x36, 0x1f, 0xf9, 0x17, 0xfc, 0x0f, 0xfe, 0x08, 0x63, 0x47, 0x46, 0x94, 0xfc, 0x11, 0x94, 0x33, + 0x95, 0x3a, 0xb0, 0xdd, 0x7b, 0xef, 0xde, 0xdd, 0xbd, 0x8b, 0x2e, 0x4c, 0x51, 0x61, 0x5d, 0xa8, + 0x65, 0xa1, 0x1b, 0x11, 0x6a, 0xe1, 0x9e, 0xdb, 0xb7, 0xa2, 0x15, 0x60, 0x55, 0x36, 0x93, 0x1e, + 0x65, 0x09, 0x0d, 0xd6, 0xd2, 0x58, 0x34, 0xe8, 0x8a, 0x2a, 0x35, 0x16, 0x3d, 0xc6, 0x93, 0x0d, + 0x63, 0x1a, 0xea, 0x34, 0x18, 0x8f, 0x27, 0x0a, 0x5d, 0x8d, 0x4e, 0x52, 0xa3, 0x08, 0x20, 0xb8, + 0x4e, 0x3e, 0x59, 0x74, 0x74, 0x07, 0xfe, 0x26, 0xbf, 0xca, 0x66, 0xf7, 0x78, 0x3d, 0x0c, 0xbe, + 0xfd, 0x9b, 0x1b, 0x1f, 0x46, 0x63, 0xaf, 0x7d, 0x05, 0x09, 0x9b, 0xb2, 0xd3, 0xbd, 0x3c, 0x80, + 0x78, 0x1a, 0xed, 0x97, 0xe0, 0x94, 0xd5, 0xc6, 0x6b, 0x6c, 0x92, 0x2d, 0xd2, 0x36, 0xa9, 0xf8, + 0x2c, 0x8a, 0xe9, 0x0a, 0x69, 0xe1, 0x11, 0x2c, 0x34, 0x0a, 0xa4, 0x2e, 0x93, 0x6d, 0x6a, 0x3c, + 0x20, 0x25, 0x5f, 0x0b, 0xf3, 0x72, 0xd8, 0x42, 0xc1, 0x92, 0x9d, 0xb0, 0x85, 0xc0, 0xc0, 0x52, + 0xca, 0x64, 0x1c, 0x58, 0x02, 0x97, 0xf3, 0xaf, 0x8e, 0xb3, 0x55, 0xc7, 0xd9, 0x4f, 0xc7, 0xd9, + 0x47, 0xcf, 0x47, 0xab, 0x9e, 0x8f, 0xbe, 0x7b, 0x3e, 0x7a, 0x10, 0x4f, 0xda, 0x2f, 0x5f, 0x16, + 0xa9, 0xc2, 0x5a, 0xfc, 0xf3, 0xc1, 0xd7, 0x4c, 0xbc, 0xaf, 0xdf, 0xe8, 0x5b, 0x03, 0x6e, 0xb1, + 0x4b, 0xf9, 0xcf, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x21, 0x18, 0x9d, 0x70, 0x01, 0x00, + 0x00, } func (m *SetERC20ToDenomProposal) Marshal() (dAtA []byte, err error) { @@ -197,6 +206,7 @@ func encodeVarintErc20ToDenomProposal(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *SetERC20ToDenomProposal) Size() (n int) { if m == nil { return 0 @@ -229,9 +239,11 @@ func (m *SetERC20ToDenomProposal) Size() (n int) { func sovErc20ToDenomProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozErc20ToDenomProposal(x uint64) (n int) { return sovErc20ToDenomProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetERC20ToDenomProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -442,6 +454,7 @@ func (m *SetERC20ToDenomProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipErc20ToDenomProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/errors.go b/x/skyway/types/errors.go index 2c729141..753c8af9 100644 --- a/x/skyway/types/errors.go +++ b/x/skyway/types/errors.go @@ -23,4 +23,5 @@ var ( ErrInvalidClaim = sdkerrors.Register(ModuleName, 19, "invalid claim submitted") ErrDenomNotFound = sdkerrors.Register(ModuleName, 21, "denom not found") ErrERC20NotFound = sdkerrors.Register(ModuleName, 22, "erc20 not found") + ErrUnauthorized = sdkerrors.Register(ModuleName, 23, "unauthorized") ) diff --git a/x/skyway/types/ethereum_signer.pb.go b/x/skyway/types/ethereum_signer.pb.go index bd17c486..2da0bd4c 100644 --- a/x/skyway/types/ethereum_signer.pb.go +++ b/x/skyway/types/ethereum_signer.pb.go @@ -5,15 +5,18 @@ package types import ( fmt "fmt" + math "math" + _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" - math "math" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -58,7 +61,7 @@ func init() { } var fileDescriptor_b7a59dec35d73c73 = []byte{ - // 258 bytes of a gzipped FileDescriptorProto + // 261 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2f, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0x83, 0xb2, 0xf5, 0x8b, 0xb3, 0x2b, 0xcb, 0x13, 0x2b, 0xf5, 0x53, 0x4b, 0x32, 0x52, 0x8b, 0x52, 0x4b, 0x73, 0xe3, 0x8b, 0x33, 0xd3, 0xf3, 0x52, 0x8b, @@ -70,10 +73,10 @@ var fileDescriptor_b7a59dec35d73c73 = []byte{ 0x70, 0x48, 0x90, 0x63, 0x88, 0x7f, 0x50, 0x3c, 0x48, 0xd8, 0xd5, 0x25, 0xde, 0x37, 0xd4, 0x27, 0xc4, 0x13, 0xc4, 0x89, 0x0f, 0x0d, 0x70, 0x71, 0x0c, 0x71, 0x15, 0x60, 0x14, 0x32, 0xe0, 0xd2, 0xc1, 0xaf, 0x27, 0xdc, 0x33, 0xc4, 0xc3, 0x25, 0xc8, 0x31, 0x3c, 0xde, 0xc9, 0x31, 0xc4, 0xd9, - 0x43, 0x80, 0x49, 0x8a, 0xa3, 0x63, 0xb1, 0x1c, 0xc3, 0x8a, 0x25, 0x72, 0x0c, 0x4e, 0x6e, 0x27, + 0x43, 0x80, 0x49, 0x8a, 0xa3, 0x63, 0xb1, 0x1c, 0xc3, 0x8a, 0x25, 0x72, 0x0c, 0x4e, 0x9e, 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, 0x93, 0x9e, 0x59, 0x92, 0x51, 0x9a, - 0xa4, 0x97, 0x9c, 0x9f, 0x8b, 0x2d, 0x78, 0x2a, 0x60, 0x01, 0x54, 0x52, 0x59, 0x90, 0x5a, 0x9c, - 0xc4, 0x06, 0xf6, 0xa6, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x31, 0x0a, 0xa4, 0x02, 0x4a, 0x01, - 0x00, 0x00, + 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x9f, 0x9e, 0x59, 0x92, 0x51, 0x9a, + 0xa4, 0x97, 0x9c, 0x9f, 0x8b, 0x2d, 0x78, 0xca, 0x8c, 0xf4, 0x2b, 0x60, 0x61, 0x54, 0x52, 0x59, + 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xf6, 0xa9, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xb2, 0x2a, 0xed, + 0x0c, 0x4d, 0x01, 0x00, 0x00, } diff --git a/x/skyway/types/events.go b/x/skyway/types/events.go index a131f6fa..694cc111 100644 --- a/x/skyway/types/events.go +++ b/x/skyway/types/events.go @@ -9,6 +9,7 @@ const ( EventTypeBridgeDepositReceived = "deposit_received" EventTypeBridgeWithdrawCanceled = "withdraw_canceled" EventTypeInvalidSendToPalomaReceiver = "invalid_send_to_paloma_receiver" + EventTypeSetERC20ToTokenDenom = "set_erc20_to_token_denom" AttributeKeyAttestationID = "attestation_id" AttributeKeyBatchConfirmKey = "batch_confirm_key" @@ -30,4 +31,8 @@ const ( AttributeKeySendToPalomaSender = "msg_send_to_cosmsos_sender" AttributeKeyBatchSignatureSlashing = "batch_signature_slashing" + + AttributeKeyChainReferenceID = "chain_reference_id" + AttributeKeyERC20Address = "erc20_address" + AttributeKeyTokenDenom = "token_denom" ) diff --git a/x/skyway/types/expected_keepers.go b/x/skyway/types/expected_keepers.go index d7cb7ada..db87b5bf 100644 --- a/x/skyway/types/expected_keepers.go +++ b/x/skyway/types/expected_keepers.go @@ -13,6 +13,7 @@ import ( xchain "github.com/palomachain/paloma/v2/internal/x-chain" consensustypes "github.com/palomachain/paloma/v2/x/consensus/types" evmtypes "github.com/palomachain/paloma/v2/x/evm/types" + tokenfactorytypes "github.com/palomachain/paloma/v2/x/tokenfactory/types" ) // StakingKeeper defines the expected staking keeper methods @@ -82,3 +83,7 @@ type EVMKeeper interface { type PalomaKeeper interface { CreateSaleLightNodeClientLicense(ctx context.Context, clientAddr string, amount math.Int) error } + +type TokenFactoryKeeper interface { + GetAuthorityMetadata(ctx context.Context, denom string) (tokenfactorytypes.DenomAuthorityMetadata, error) +} diff --git a/x/skyway/types/genesis.pb.go b/x/skyway/types/genesis.pb.go index 1f3e78f2..02f2d9b1 100644 --- a/x/skyway/types/genesis.pb.go +++ b/x/skyway/types/genesis.pb.go @@ -5,18 +5,21 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -46,9 +49,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_e20fa6374f01ce45, []int{0} } + 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) @@ -61,12 +66,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) 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) } @@ -175,9 +183,11 @@ func (*SkywayNonces) ProtoMessage() {} func (*SkywayNonces) Descriptor() ([]byte, []int) { return fileDescriptor_e20fa6374f01ce45, []int{1} } + func (m *SkywayNonces) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SkywayNonces) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SkywayNonces.Marshal(b, m, deterministic) @@ -190,12 +200,15 @@ func (m *SkywayNonces) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *SkywayNonces) XXX_Merge(src proto.Message) { xxx_messageInfo_SkywayNonces.Merge(m, src) } + func (m *SkywayNonces) XXX_Size() int { return m.Size() } + func (m *SkywayNonces) XXX_DiscardUnknown() { xxx_messageInfo_SkywayNonces.DiscardUnknown(m) } @@ -247,53 +260,53 @@ func init() { } var fileDescriptor_e20fa6374f01ce45 = []byte{ - // 732 bytes of a gzipped FileDescriptorProto + // 734 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xcf, 0x4e, 0xdb, 0x4a, 0x14, 0xc6, 0x13, 0x08, 0x70, 0x99, 0x38, 0xfc, 0x19, 0xb8, 0x68, 0x60, 0x91, 0xcb, 0x45, 0xfc, - 0x13, 0x97, 0x6b, 0x43, 0xaa, 0xaa, 0xed, 0xb2, 0xa1, 0x14, 0x81, 0x28, 0x20, 0x27, 0x55, 0xa5, - 0x6e, 0xac, 0xb1, 0x3d, 0x38, 0x16, 0xb6, 0x27, 0xf2, 0x19, 0x68, 0x78, 0x8b, 0x3e, 0x16, 0x4b, - 0x96, 0x5d, 0x55, 0x15, 0xa8, 0xfb, 0x3e, 0x42, 0x35, 0xe3, 0x31, 0xa4, 0x2a, 0x4e, 0xba, 0x62, - 0x38, 0xdf, 0xf7, 0xfd, 0x26, 0x3a, 0xc7, 0x67, 0xd0, 0x46, 0x97, 0x46, 0x3c, 0xa6, 0x5e, 0x87, - 0x86, 0x89, 0x95, 0x9d, 0x2d, 0xb8, 0xb8, 0xfe, 0x44, 0xaf, 0xad, 0x80, 0x25, 0x0c, 0x42, 0x30, - 0xbb, 0x29, 0x17, 0x1c, 0x2f, 0xf6, 0x19, 0xcd, 0xec, 0x6c, 0x66, 0xc6, 0xa5, 0xba, 0xc7, 0x21, - 0xe6, 0x60, 0xb9, 0x14, 0x98, 0x75, 0xb5, 0xeb, 0x32, 0x41, 0x77, 0x2d, 0x8f, 0x4b, 0x9f, 0x8c, - 0x2e, 0xcd, 0x07, 0x3c, 0xe0, 0xea, 0x68, 0xc9, 0x93, 0xae, 0xfe, 0x57, 0x7c, 0x33, 0x15, 0x82, - 0x81, 0xa0, 0x22, 0xe4, 0x39, 0x62, 0xad, 0xd8, 0xec, 0x52, 0xe1, 0x75, 0xb4, 0x6d, 0x6b, 0x80, - 0x2d, 0x0d, 0xfd, 0x80, 0x39, 0x82, 0xf6, 0xb4, 0xf7, 0xf9, 0x70, 0x6f, 0x4a, 0x13, 0x38, 0x67, - 0xa9, 0x13, 0x85, 0x71, 0x28, 0x74, 0xec, 0x65, 0x71, 0x2c, 0x0a, 0x83, 0x8e, 0x70, 0x12, 0xee, - 0x33, 0x07, 0x68, 0xc4, 0x1c, 0x8f, 0x27, 0x22, 0xa5, 0x5e, 0x9e, 0x5c, 0x2d, 0x4e, 0xc6, 0x10, - 0xe8, 0x3e, 0x2f, 0xad, 0x17, 0xbb, 0xba, 0x34, 0xa5, 0x31, 0x0c, 0xef, 0x88, 0xb8, 0xee, 0x32, - 0x6d, 0x5b, 0xf9, 0x3e, 0x81, 0x8c, 0x83, 0x6c, 0x90, 0x2d, 0x41, 0x05, 0xc3, 0xaf, 0xd0, 0x78, - 0xc6, 0x21, 0xe5, 0xe5, 0xf2, 0x66, 0xb5, 0xf1, 0xaf, 0x59, 0x38, 0x58, 0xf3, 0x4c, 0x19, 0x6d, - 0x1d, 0xc0, 0x36, 0xaa, 0x65, 0x82, 0x93, 0xf0, 0xc4, 0x63, 0x40, 0x46, 0x96, 0x47, 0x37, 0xab, - 0x8d, 0x8d, 0x01, 0x84, 0x96, 0xfa, 0x73, 0xa2, 0xec, 0xcd, 0xca, 0xcd, 0xd7, 0x7f, 0x4a, 0xb6, - 0x01, 0x7d, 0x35, 0x7c, 0x84, 0x26, 0xd4, 0x00, 0x19, 0x90, 0x51, 0x45, 0xdb, 0x1a, 0x40, 0x3b, - 0xbd, 0x14, 0x01, 0x0f, 0x93, 0xa0, 0xdd, 0x6b, 0xca, 0x8c, 0x06, 0xe6, 0x00, 0xfc, 0x01, 0x4d, - 0xa9, 0xa3, 0x6c, 0xfc, 0x79, 0x98, 0xc6, 0x40, 0x2a, 0x43, 0x91, 0xef, 0x20, 0xd8, 0xcb, 0xdc, - 0xfd, 0xc8, 0x9a, 0xe2, 0x68, 0x01, 0xb0, 0x8f, 0xe6, 0x32, 0x70, 0x40, 0xc1, 0x61, 0x20, 0xc2, - 0x98, 0x0a, 0x06, 0x64, 0x4c, 0xd1, 0xcd, 0xc1, 0xf4, 0x7d, 0x6d, 0x57, 0xf8, 0x03, 0x9a, 0x77, - 0x61, 0xd6, 0xd5, 0xff, 0xe7, 0x3a, 0xe0, 0x33, 0x64, 0xf4, 0x7d, 0xf8, 0x40, 0x26, 0x14, 0x7e, - 0x7d, 0x00, 0xfe, 0xf5, 0xa3, 0x3d, 0x6f, 0x6e, 0x3f, 0x01, 0xbf, 0x47, 0xd3, 0x2c, 0xf5, 0x1a, - 0x3b, 0x8e, 0xe0, 0x8e, 0xcf, 0x12, 0x1e, 0x03, 0x99, 0x1c, 0x3a, 0xb2, 0x7d, 0x7b, 0xaf, 0xb1, - 0xd3, 0xe6, 0x6f, 0xa4, 0x3f, 0x6f, 0x87, 0xa2, 0xe8, 0x9a, 0x6a, 0xc7, 0x65, 0x92, 0x35, 0xdd, - 0x7f, 0x58, 0x12, 0x20, 0x48, 0xa1, 0xff, 0xff, 0x93, 0xf9, 0xe9, 0x4c, 0xbb, 0xa7, 0x2f, 0xc0, - 0x0f, 0xbc, 0x5c, 0x92, 0xb7, 0x2c, 0x3c, 0xb9, 0x87, 0x40, 0x8c, 0xa1, 0x7d, 0x6f, 0xaa, 0x60, - 0xce, 0x3a, 0x96, 0x31, 0x7b, 0xde, 0xfd, 0xbd, 0x08, 0xf8, 0x00, 0x19, 0x8f, 0x2f, 0x03, 0x03, - 0x52, 0x53, 0xec, 0xd5, 0xe1, 0x6c, 0xda, 0xb3, 0xab, 0x6e, 0x7e, 0x64, 0x80, 0x2f, 0xd0, 0x62, - 0xd1, 0xfe, 0x03, 0x99, 0x52, 0xd4, 0x9d, 0x01, 0xd4, 0x63, 0x99, 0x3d, 0xe1, 0x3e, 0x6b, 0xd1, - 0x88, 0xed, 0xe9, 0xa0, 0xbd, 0x10, 0x3d, 0x55, 0x86, 0xa3, 0xca, 0x5f, 0xd5, 0x19, 0xc3, 0x46, - 0x8f, 0xbf, 0x7c, 0xe5, 0x47, 0x19, 0x19, 0xfd, 0xcb, 0x86, 0x4d, 0x34, 0x17, 0x51, 0x10, 0x0e, - 0x77, 0x81, 0xa5, 0x57, 0xcc, 0xcf, 0x76, 0x56, 0x2d, 0x7d, 0xc5, 0x9e, 0x95, 0xd2, 0xa9, 0x56, - 0x54, 0x00, 0xbf, 0x40, 0x44, 0xf9, 0x21, 0xa2, 0x20, 0xe7, 0x9a, 0x7d, 0xf0, 0x6e, 0xc4, 0xbd, - 0x0b, 0x32, 0xa2, 0x42, 0x7f, 0x4b, 0xbd, 0x95, 0xc9, 0xd9, 0xb2, 0x48, 0x11, 0xaf, 0xa1, 0x69, - 0x15, 0x14, 0x3d, 0xa7, 0xcb, 0x79, 0xe4, 0x84, 0x3e, 0x19, 0x55, 0x7e, 0x43, 0x96, 0xdb, 0xbd, - 0x33, 0xce, 0xa3, 0x43, 0x1f, 0xaf, 0xa0, 0x9a, 0xb2, 0x65, 0xdc, 0xd0, 0x27, 0x15, 0x65, 0xaa, - 0xca, 0xa2, 0xa2, 0x1d, 0xfa, 0x78, 0x1b, 0x61, 0xd5, 0x1b, 0x27, 0x65, 0xe7, 0x2c, 0x65, 0x89, - 0xc7, 0xa4, 0x71, 0x6c, 0xb9, 0xbc, 0x39, 0x69, 0xcf, 0x28, 0xc5, 0xce, 0x85, 0x43, 0xbf, 0xf9, - 0xf6, 0xe6, 0xae, 0x5e, 0xbe, 0xbd, 0xab, 0x97, 0xbf, 0xdd, 0xd5, 0xcb, 0x9f, 0xef, 0xeb, 0xa5, - 0xdb, 0xfb, 0x7a, 0xe9, 0xcb, 0x7d, 0xbd, 0xf4, 0x71, 0x3b, 0x08, 0x45, 0xe7, 0xd2, 0x35, 0x3d, - 0x1e, 0x5b, 0x4f, 0x3c, 0x93, 0xbd, 0x5f, 0x1e, 0x4a, 0x77, 0x5c, 0xbd, 0x94, 0xcf, 0x7e, 0x06, - 0x00, 0x00, 0xff, 0xff, 0x33, 0x67, 0x8f, 0x56, 0x0b, 0x07, 0x00, 0x00, + 0x13, 0xf7, 0xd6, 0x86, 0x54, 0x55, 0xdb, 0x65, 0x43, 0x11, 0x0a, 0xa2, 0x80, 0x9c, 0x54, 0x95, + 0xba, 0xb1, 0xc6, 0xf6, 0xe0, 0x58, 0xd8, 0x9e, 0xc8, 0x67, 0xa0, 0xe1, 0x2d, 0xfa, 0x58, 0x2c, + 0x59, 0x76, 0x55, 0x55, 0xa0, 0xee, 0xfb, 0x08, 0xd5, 0x8c, 0xc7, 0x90, 0xaa, 0x38, 0xe9, 0x8a, + 0xe1, 0x7c, 0xdf, 0xf7, 0x9b, 0xe8, 0x1c, 0x9f, 0x41, 0x5b, 0x3d, 0x1a, 0xf1, 0x98, 0x7a, 0x5d, + 0x1a, 0x26, 0x56, 0x76, 0xb6, 0xe0, 0xe2, 0xfa, 0x13, 0xbd, 0xb6, 0x02, 0x96, 0x30, 0x08, 0xc1, + 0xec, 0xa5, 0x5c, 0x70, 0xbc, 0x3c, 0x60, 0x34, 0xb3, 0xb3, 0x99, 0x19, 0x57, 0xea, 0x1e, 0x87, + 0x98, 0x83, 0xe5, 0x52, 0x60, 0xd6, 0xd5, 0x9e, 0xcb, 0x04, 0xdd, 0xb3, 0x3c, 0x2e, 0x7d, 0x32, + 0xba, 0xb2, 0x18, 0xf0, 0x80, 0xab, 0xa3, 0x25, 0x4f, 0xba, 0xfa, 0x5f, 0xf1, 0xcd, 0x54, 0x08, + 0x06, 0x82, 0x8a, 0x90, 0xe7, 0x88, 0x8d, 0x62, 0xb3, 0x4b, 0x85, 0xd7, 0xd5, 0xb6, 0x9d, 0x21, + 0xb6, 0x34, 0xf4, 0x03, 0xe6, 0x08, 0xda, 0xd7, 0xde, 0x17, 0xa3, 0xbd, 0x29, 0x4d, 0xe0, 0x9c, + 0xa5, 0x4e, 0x14, 0xc6, 0xa1, 0xd0, 0xb1, 0x57, 0xc5, 0xb1, 0x28, 0x0c, 0xba, 0xc2, 0x49, 0xb8, + 0xcf, 0x1c, 0xa0, 0x11, 0x73, 0x3c, 0x9e, 0x88, 0x94, 0x7a, 0x79, 0x72, 0xbd, 0x38, 0x19, 0x43, + 0xa0, 0xfb, 0xbc, 0xb2, 0x59, 0xec, 0xea, 0xd1, 0x94, 0xc6, 0x30, 0xba, 0x23, 0xe2, 0xba, 0xc7, + 0xb4, 0x6d, 0xed, 0xfb, 0x14, 0x32, 0x0e, 0xb3, 0x41, 0xb6, 0x05, 0x15, 0x0c, 0xbf, 0x46, 0x93, + 0x19, 0x87, 0x94, 0x57, 0xcb, 0xdb, 0xd5, 0xc6, 0xbf, 0x66, 0xe1, 0x60, 0xcd, 0x33, 0x65, 0xb4, + 0x75, 0x00, 0xdb, 0xa8, 0x96, 0x09, 0x4e, 0xc2, 0x13, 0x8f, 0x01, 0x19, 0x5b, 0x1d, 0xdf, 0xae, + 0x36, 0xb6, 0x86, 0x10, 0xda, 0xea, 0xcf, 0x89, 0xb2, 0x37, 0x2b, 0x37, 0x5f, 0xff, 0x29, 0xd9, + 0x06, 0x0c, 0xd4, 0xf0, 0x11, 0x9a, 0x52, 0x03, 0x64, 0x40, 0xc6, 0x15, 0x6d, 0x67, 0x08, 0xed, + 0xf4, 0x52, 0x04, 0x3c, 0x4c, 0x82, 0x4e, 0xbf, 0x29, 0x33, 0x1a, 0x98, 0x03, 0xf0, 0x07, 0x34, + 0xa3, 0x8e, 0xb2, 0xf1, 0xe7, 0x61, 0x1a, 0x03, 0xa9, 0x8c, 0x44, 0xbe, 0x83, 0x60, 0x3f, 0x73, + 0x0f, 0x22, 0x6b, 0x8a, 0xa3, 0x05, 0xc0, 0x3e, 0x5a, 0xc8, 0xc0, 0x01, 0x05, 0x87, 0x81, 0x08, + 0x63, 0x2a, 0x18, 0x90, 0x09, 0x45, 0x37, 0x87, 0xd3, 0x0f, 0xb4, 0x5d, 0xe1, 0x0f, 0x69, 0xde, + 0x85, 0x79, 0x57, 0xff, 0x9f, 0xeb, 0x80, 0xcf, 0x90, 0x31, 0xf0, 0xe1, 0x03, 0x99, 0x52, 0xf8, + 0xcd, 0x21, 0xf8, 0x37, 0x8f, 0xf6, 0xbc, 0xb9, 0x83, 0x04, 0xfc, 0x1e, 0xcd, 0xb2, 0xd4, 0x6b, + 0xec, 0x3a, 0x82, 0x3b, 0x3e, 0x4b, 0x78, 0x0c, 0x64, 0x7a, 0xe4, 0xc8, 0x0e, 0xec, 0xfd, 0xc6, + 0x6e, 0x87, 0xbf, 0x95, 0xfe, 0xbc, 0x1d, 0x8a, 0xa2, 0x6b, 0xaa, 0x1d, 0x97, 0x49, 0xd6, 0x74, + 0xff, 0x61, 0x49, 0x80, 0x20, 0x85, 0x7e, 0xf6, 0x27, 0xf3, 0xd3, 0x99, 0x4e, 0x5f, 0x5f, 0x80, + 0x1f, 0x78, 0xb9, 0x24, 0x6f, 0x59, 0x7a, 0x72, 0x0f, 0x81, 0x18, 0x23, 0xfb, 0xde, 0x54, 0xc1, + 0x9c, 0x75, 0x2c, 0x63, 0xf6, 0xa2, 0xfb, 0x7b, 0x11, 0xf0, 0x21, 0x32, 0x1e, 0x5f, 0x06, 0x06, + 0xa4, 0xa6, 0xd8, 0xeb, 0xa3, 0xd9, 0xb4, 0x6f, 0x57, 0xdd, 0xfc, 0xc8, 0x00, 0x5f, 0xa0, 0xe5, + 0xa2, 0xfd, 0x07, 0x32, 0xa3, 0xa8, 0xbb, 0x43, 0xa8, 0xc7, 0x32, 0x7b, 0xc2, 0x7d, 0xd6, 0xa6, + 0x11, 0xdb, 0xd7, 0x41, 0x7b, 0x29, 0x7a, 0xaa, 0x0c, 0x47, 0x95, 0xbf, 0xaa, 0x73, 0x86, 0x8d, + 0x1e, 0x7f, 0xf9, 0xda, 0x8f, 0x32, 0x32, 0x06, 0x97, 0x0d, 0x9b, 0x68, 0x21, 0xa2, 0x20, 0x1c, + 0xee, 0x02, 0x4b, 0xaf, 0x98, 0x9f, 0xed, 0xac, 0x5a, 0xfa, 0x8a, 0x3d, 0x2f, 0xa5, 0x53, 0xad, + 0xa8, 0x00, 0x7e, 0x89, 0x88, 0xf2, 0x43, 0x44, 0x41, 0xce, 0x35, 0xfb, 0xe0, 0xdd, 0x88, 0x7b, + 0x17, 0x64, 0x4c, 0x85, 0xfe, 0x96, 0x7a, 0x3b, 0x93, 0xb3, 0x65, 0x91, 0x22, 0xde, 0x40, 0xb3, + 0x2a, 0x28, 0xfa, 0x4e, 0x8f, 0xf3, 0xc8, 0x09, 0x7d, 0x32, 0xae, 0xfc, 0x86, 0x2c, 0x77, 0xfa, + 0x67, 0x9c, 0x47, 0x2d, 0x1f, 0xaf, 0xa1, 0x9a, 0xb2, 0x65, 0xdc, 0xd0, 0x27, 0x15, 0x65, 0xaa, + 0xca, 0xa2, 0xa2, 0xb5, 0x7c, 0xfc, 0x3f, 0xc2, 0xaa, 0x37, 0x4e, 0xca, 0xce, 0x59, 0xca, 0x12, + 0x8f, 0x49, 0xe3, 0xc4, 0x6a, 0x79, 0x7b, 0xda, 0x9e, 0x53, 0x8a, 0x9d, 0x0b, 0x2d, 0xbf, 0xd9, + 0xba, 0xb9, 0xab, 0x97, 0x6f, 0xef, 0xea, 0xe5, 0x6f, 0x77, 0xf5, 0xf2, 0xe7, 0xfb, 0x7a, 0xe9, + 0xf6, 0xbe, 0x5e, 0xfa, 0x72, 0x5f, 0x2f, 0x7d, 0xb4, 0x82, 0x50, 0x74, 0x2f, 0x5d, 0xd3, 0xe3, + 0xb1, 0xf5, 0xc4, 0x33, 0x79, 0xd5, 0xb0, 0xfa, 0xbf, 0xbc, 0x95, 0xee, 0xa4, 0x7a, 0x2c, 0x9f, + 0xff, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x22, 0x12, 0x86, 0x73, 0x0e, 0x07, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -532,6 +545,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -633,9 +647,11 @@ func (m *SkywayNonces) Size() (n int) { 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 *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1062,6 +1078,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func (m *SkywayNonces) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1220,6 +1237,7 @@ func (m *SkywayNonces) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/gravity/bridge_tax_proposal.pb.go b/x/skyway/types/gravity/bridge_tax_proposal.pb.go index a816b196..940a78ca 100644 --- a/x/skyway/types/gravity/bridge_tax_proposal.pb.go +++ b/x/skyway/types/gravity/bridge_tax_proposal.pb.go @@ -5,17 +5,20 @@ package gravity import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*SetBridgeTaxProposal) ProtoMessage() {} func (*SetBridgeTaxProposal) Descriptor() ([]byte, []int) { return fileDescriptor_7b15146dd277be39, []int{0} } + func (m *SetBridgeTaxProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetBridgeTaxProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetBridgeTaxProposal.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *SetBridgeTaxProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *SetBridgeTaxProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetBridgeTaxProposal.Merge(m, src) } + func (m *SetBridgeTaxProposal) XXX_Size() int { return m.Size() } + func (m *SetBridgeTaxProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetBridgeTaxProposal.DiscardUnknown(m) } @@ -108,26 +116,27 @@ func init() { } var fileDescriptor_7b15146dd277be39 = []byte{ - // 302 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0x32, 0x41, - 0x14, 0x85, 0xd9, 0x1f, 0xf8, 0x13, 0xc6, 0x04, 0xcc, 0x86, 0x62, 0xa5, 0x98, 0x10, 0x1a, 0xb1, - 0x70, 0xa7, 0x90, 0x17, 0x90, 0x58, 0x1b, 0x83, 0x54, 0x36, 0x9b, 0x61, 0xe6, 0x06, 0x26, 0xec, - 0x32, 0x93, 0x99, 0x8b, 0xee, 0xbe, 0x85, 0x0f, 0xe3, 0x33, 0x18, 0x4b, 0x62, 0x65, 0x69, 0xe0, - 0x45, 0x8c, 0x33, 0x6c, 0x42, 0x61, 0x77, 0xef, 0x77, 0xee, 0x39, 0x37, 0x39, 0x64, 0x62, 0x78, - 0xae, 0x0b, 0x2e, 0x56, 0x5c, 0x6d, 0x58, 0x98, 0xd9, 0xd2, 0xf2, 0x67, 0x85, 0x15, 0x5b, 0x58, - 0x25, 0x97, 0x90, 0x21, 0x2f, 0x33, 0x63, 0xb5, 0xd1, 0x8e, 0xe7, 0xa9, 0xb1, 0x1a, 0x75, 0x3c, - 0x38, 0x71, 0xa5, 0x61, 0x4e, 0x8f, 0xae, 0xc1, 0x85, 0xd0, 0xae, 0xd0, 0x2e, 0xf3, 0x97, 0x2c, - 0x2c, 0xc1, 0x36, 0x7a, 0x8f, 0x48, 0xff, 0x11, 0x70, 0xea, 0x73, 0xe7, 0xbc, 0x7c, 0x38, 0xa6, - 0xc6, 0x7d, 0xd2, 0x46, 0x85, 0x39, 0x24, 0xd1, 0x30, 0x1a, 0x77, 0x66, 0x61, 0x89, 0x87, 0xe4, - 0x4c, 0x82, 0x13, 0x56, 0x19, 0x54, 0x7a, 0x93, 0xfc, 0xf3, 0xda, 0x29, 0x8a, 0x47, 0xa4, 0x65, - 0x39, 0x42, 0xd2, 0xfc, 0x95, 0xa6, 0xdd, 0xcf, 0xb7, 0x6b, 0x72, 0x7c, 0x78, 0x07, 0x62, 0xe6, - 0xb5, 0xf8, 0x92, 0xf4, 0xa0, 0x14, 0xf9, 0x56, 0x82, 0xcc, 0x50, 0xaf, 0x61, 0xe3, 0x92, 0xd6, - 0xb0, 0x39, 0xee, 0xcc, 0xba, 0x35, 0x9e, 0x7b, 0x1a, 0x5f, 0x91, 0x73, 0x28, 0xa1, 0x30, 0x98, - 0x71, 0x29, 0x2d, 0x38, 0x07, 0x2e, 0x69, 0xfb, 0xcb, 0x5e, 0xe0, 0xb7, 0x35, 0x9e, 0xde, 0x7f, - 0xec, 0x69, 0xb4, 0xdb, 0xd3, 0xe8, 0x7b, 0x4f, 0xa3, 0xd7, 0x03, 0x6d, 0xec, 0x0e, 0xb4, 0xf1, - 0x75, 0xa0, 0x8d, 0xa7, 0xc9, 0x52, 0xe1, 0x6a, 0xbb, 0x48, 0x85, 0x2e, 0xd8, 0x1f, 0xd5, 0x96, - 0xcc, 0xad, 0xab, 0x17, 0x5e, 0x31, 0xac, 0x0c, 0xb8, 0xba, 0xe9, 0xc5, 0x7f, 0xdf, 0xcf, 0xcd, - 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc6, 0xc6, 0x11, 0x2b, 0x8e, 0x01, 0x00, 0x00, + // 305 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4e, 0x32, 0x31, + 0x14, 0x85, 0x99, 0x1f, 0xf8, 0x13, 0x6a, 0x02, 0x66, 0xc2, 0x62, 0x64, 0xd1, 0x10, 0x36, 0xe2, + 0xc2, 0x69, 0xa2, 0x26, 0xae, 0x25, 0x3e, 0x80, 0x22, 0x2b, 0x37, 0x93, 0xd2, 0xde, 0x40, 0xc3, + 0x0c, 0x6d, 0xda, 0x0b, 0xce, 0xbc, 0x85, 0x0f, 0xe3, 0x33, 0x18, 0x97, 0xc4, 0x95, 0x4b, 0x03, + 0x2f, 0x62, 0x6c, 0x21, 0x61, 0xe1, 0xee, 0xde, 0xef, 0xdc, 0x73, 0x6e, 0x72, 0xc8, 0x8d, 0xe1, + 0xb9, 0x2e, 0xb8, 0x98, 0x73, 0xb5, 0x64, 0x61, 0x66, 0x33, 0xcb, 0xd7, 0x0a, 0x2b, 0x36, 0xb5, + 0x4a, 0xce, 0x20, 0x43, 0x5e, 0x66, 0xc6, 0x6a, 0xa3, 0x1d, 0xcf, 0x53, 0x63, 0x35, 0xea, 0xb8, + 0x77, 0xe4, 0x4a, 0xc3, 0x9c, 0xee, 0x5d, 0xbd, 0x33, 0xa1, 0x5d, 0xa1, 0x5d, 0xe6, 0x2f, 0x59, + 0x58, 0x82, 0x6d, 0xf0, 0x1e, 0x91, 0xee, 0x13, 0xe0, 0xc8, 0xe7, 0x4e, 0x78, 0xf9, 0xb0, 0x4f, + 0x8d, 0xbb, 0xa4, 0x89, 0x0a, 0x73, 0x48, 0xa2, 0x7e, 0x34, 0x6c, 0x8d, 0xc3, 0x12, 0xf7, 0xc9, + 0x89, 0x04, 0x27, 0xac, 0x32, 0xa8, 0xf4, 0x32, 0xf9, 0xe7, 0xb5, 0x63, 0x14, 0x0f, 0x48, 0xc3, + 0x72, 0x84, 0xa4, 0xfe, 0x2b, 0x8d, 0xda, 0x9f, 0x6f, 0x97, 0x64, 0xff, 0xf0, 0x1e, 0xc4, 0xd8, + 0x6b, 0xf1, 0x39, 0xe9, 0x40, 0x29, 0xf2, 0x95, 0x04, 0x99, 0xa1, 0x5e, 0xc0, 0xd2, 0x25, 0x8d, + 0x7e, 0x7d, 0xd8, 0x1a, 0xb7, 0x0f, 0x78, 0xe2, 0x69, 0x7c, 0x41, 0x4e, 0xa1, 0x84, 0xc2, 0x60, + 0xc6, 0xa5, 0xb4, 0xe0, 0x1c, 0xb8, 0xa4, 0xe9, 0x2f, 0x3b, 0x81, 0xdf, 0x1d, 0xf0, 0xe8, 0xf1, + 0x63, 0x4b, 0xa3, 0xcd, 0x96, 0x46, 0xdf, 0x5b, 0x1a, 0xbd, 0xee, 0x68, 0x6d, 0xb3, 0xa3, 0xb5, + 0xaf, 0x1d, 0xad, 0x3d, 0xdf, 0xce, 0x14, 0xce, 0x57, 0xd3, 0x54, 0xe8, 0x82, 0xfd, 0x51, 0xed, + 0xfa, 0x8a, 0x95, 0xcc, 0x2d, 0xaa, 0x17, 0x5e, 0x31, 0xac, 0x0c, 0xb8, 0x43, 0xd9, 0xd3, 0xff, + 0xbe, 0xa2, 0xeb, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2e, 0x0a, 0x8d, 0xa1, 0x91, 0x01, 0x00, + 0x00, } func (m *SetBridgeTaxProposal) Marshal() (dAtA []byte, err error) { @@ -203,6 +212,7 @@ func encodeVarintBridgeTaxProposal(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *SetBridgeTaxProposal) Size() (n int) { if m == nil { return 0 @@ -239,9 +249,11 @@ func (m *SetBridgeTaxProposal) Size() (n int) { func sovBridgeTaxProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozBridgeTaxProposal(x uint64) (n int) { return sovBridgeTaxProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetBridgeTaxProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -452,6 +464,7 @@ func (m *SetBridgeTaxProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipBridgeTaxProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/gravity/bridge_transfer_limit_proposal.pb.go b/x/skyway/types/gravity/bridge_transfer_limit_proposal.pb.go index 2dab83e0..5d20fd48 100644 --- a/x/skyway/types/gravity/bridge_transfer_limit_proposal.pb.go +++ b/x/skyway/types/gravity/bridge_transfer_limit_proposal.pb.go @@ -4,19 +4,22 @@ package gravity import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + cosmossdk_io_math "cosmossdk.io/math" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -73,9 +76,11 @@ func (*SetBridgeTransferLimitProposal) ProtoMessage() {} func (*SetBridgeTransferLimitProposal) Descriptor() ([]byte, []int) { return fileDescriptor_decc4855205ef000, []int{0} } + func (m *SetBridgeTransferLimitProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetBridgeTransferLimitProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetBridgeTransferLimitProposal.Marshal(b, m, deterministic) @@ -88,12 +93,15 @@ func (m *SetBridgeTransferLimitProposal) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *SetBridgeTransferLimitProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetBridgeTransferLimitProposal.Merge(m, src) } + func (m *SetBridgeTransferLimitProposal) XXX_Size() int { return m.Size() } + func (m *SetBridgeTransferLimitProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetBridgeTransferLimitProposal.DiscardUnknown(m) } @@ -145,33 +153,33 @@ func init() { } var fileDescriptor_decc4855205ef000 = []byte{ - // 403 bytes of a gzipped FileDescriptorProto + // 407 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x4f, 0x8b, 0xd3, 0x40, 0x18, 0xc6, 0x93, 0xb6, 0xa9, 0x76, 0x22, 0x1a, 0x86, 0x15, 0xc2, 0x82, 0xd9, 0xe0, 0xc5, 0xea, - 0x61, 0x06, 0x5c, 0xef, 0xd2, 0x62, 0xd0, 0xd5, 0x98, 0x95, 0xb8, 0x20, 0xf1, 0x12, 0xa6, 0xc9, - 0x98, 0x0e, 0x4d, 0x32, 0x61, 0x66, 0xd4, 0xe6, 0x5b, 0x78, 0xf6, 0x13, 0xf5, 0xd8, 0xa3, 0x78, - 0x28, 0xd2, 0x7e, 0x11, 0xc9, 0x9f, 0x62, 0x0f, 0xee, 0xed, 0x7d, 0x9f, 0xf7, 0x7d, 0x7e, 0xcc, - 0xc3, 0x3b, 0xe0, 0x65, 0x45, 0x72, 0x5e, 0x90, 0x64, 0x49, 0x58, 0x89, 0xbb, 0x1a, 0x67, 0x82, - 0x7c, 0x63, 0xaa, 0xc6, 0x0b, 0xc1, 0xd2, 0x8c, 0xc6, 0x4a, 0x90, 0x52, 0x7e, 0xa1, 0x22, 0xce, - 0x59, 0xc1, 0x54, 0x5c, 0x09, 0x5e, 0x71, 0x49, 0x72, 0x54, 0x09, 0xae, 0x38, 0x3c, 0x3f, 0x01, - 0xa0, 0xae, 0x46, 0x3d, 0xe0, 0xfc, 0x2c, 0xe3, 0x19, 0x6f, 0xd7, 0x70, 0x53, 0x75, 0x8e, 0xc7, - 0x3f, 0x07, 0xc0, 0xf9, 0x48, 0xd5, 0xbc, 0xa5, 0xdf, 0xf4, 0x70, 0xbf, 0x61, 0x7f, 0xe8, 0xd1, - 0xf0, 0x0c, 0x18, 0x8a, 0xa9, 0x9c, 0xda, 0xba, 0xab, 0x4f, 0x27, 0x61, 0xd7, 0x40, 0x17, 0x98, - 0x29, 0x95, 0x89, 0x60, 0x95, 0x62, 0xbc, 0xb4, 0x07, 0xed, 0xec, 0x54, 0x6a, 0x7d, 0x7c, 0x45, - 0x4b, 0x7b, 0xd8, 0xfb, 0x9a, 0x06, 0x5e, 0x02, 0xa3, 0x7d, 0xba, 0x3d, 0x6a, 0xd4, 0xf9, 0xa3, - 0xcd, 0xee, 0x42, 0xfb, 0xbd, 0xbb, 0x78, 0x98, 0x70, 0x59, 0x70, 0x29, 0xd3, 0x15, 0x62, 0x1c, - 0x17, 0x44, 0x2d, 0xd1, 0x55, 0xa9, 0xc2, 0x6e, 0x17, 0xbe, 0x05, 0xf7, 0xfa, 0xbc, 0x54, 0x30, - 0x9e, 0xda, 0x86, 0xab, 0x4f, 0xef, 0x3f, 0x7f, 0x82, 0x6e, 0x8f, 0x8b, 0xba, 0x0c, 0xed, 0x7a, - 0x68, 0xe6, 0xff, 0x1a, 0xf8, 0x14, 0x58, 0x74, 0x4d, 0x8b, 0x4a, 0xc5, 0x24, 0x4d, 0x05, 0x95, - 0x92, 0x4a, 0x7b, 0xec, 0x0e, 0xa7, 0x93, 0xf0, 0x41, 0xa7, 0xcf, 0x8e, 0xf2, 0xb3, 0xd7, 0xc0, - 0x3c, 0xc1, 0xc0, 0xbb, 0x60, 0x14, 0x5c, 0x07, 0x9e, 0xa5, 0xc1, 0x09, 0x30, 0x5e, 0xcd, 0xae, - 0xfc, 0xc8, 0xd2, 0x21, 0x00, 0xe3, 0x4f, 0x9e, 0xf7, 0xce, 0x8f, 0xac, 0x01, 0x34, 0xc1, 0x9d, - 0xf7, 0xd7, 0xc1, 0xcd, 0x1b, 0x3f, 0xb2, 0x86, 0xcd, 0x20, 0xf2, 0x66, 0xa1, 0x1f, 0x59, 0xa3, - 0x79, 0xb0, 0xd9, 0x3b, 0xfa, 0x76, 0xef, 0xe8, 0x7f, 0xf6, 0x8e, 0xfe, 0xe3, 0xe0, 0x68, 0xdb, - 0x83, 0xa3, 0xfd, 0x3a, 0x38, 0xda, 0xe7, 0x17, 0x19, 0x53, 0xcb, 0xaf, 0x0b, 0x94, 0xf0, 0x02, - 0xff, 0xe7, 0xfa, 0x6b, 0x2c, 0x57, 0xf5, 0x77, 0x52, 0x63, 0x55, 0x57, 0x54, 0x1e, 0x3f, 0xc3, - 0x62, 0xdc, 0x1e, 0xef, 0xf2, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x3a, 0x32, 0x17, 0x31, - 0x02, 0x00, 0x00, + 0x61, 0x06, 0x76, 0x0f, 0x1e, 0xa5, 0xc5, 0xa0, 0xab, 0xb1, 0xab, 0x71, 0x41, 0xe2, 0x25, 0x4c, + 0x93, 0x31, 0x1d, 0x9a, 0x64, 0xc2, 0xcc, 0x58, 0x9b, 0x6f, 0xe1, 0xd9, 0x4f, 0xd4, 0x63, 0x8f, + 0xe2, 0xa1, 0x48, 0xfb, 0x45, 0x24, 0x7f, 0x8a, 0x3d, 0xe8, 0xed, 0x7d, 0x9f, 0xf7, 0x7d, 0x7e, + 0xcc, 0xc3, 0x3b, 0xe0, 0x45, 0x49, 0x32, 0x9e, 0x93, 0x78, 0x41, 0x58, 0x81, 0xdb, 0x1a, 0xa7, + 0x82, 0xac, 0x98, 0xaa, 0xf0, 0x5c, 0xb0, 0x24, 0xa5, 0x91, 0x12, 0xa4, 0x90, 0x5f, 0xa8, 0x88, + 0x32, 0x96, 0x33, 0x15, 0x95, 0x82, 0x97, 0x5c, 0x92, 0x0c, 0x95, 0x82, 0x2b, 0x0e, 0xcf, 0x4f, + 0x00, 0xa8, 0xad, 0x51, 0x07, 0x38, 0x3f, 0x4b, 0x79, 0xca, 0x9b, 0x35, 0x5c, 0x57, 0xad, 0xe3, + 0xf1, 0x8f, 0x1e, 0x70, 0x3e, 0x52, 0x35, 0x6d, 0xe8, 0xb7, 0x1d, 0xdc, 0xaf, 0xd9, 0xef, 0x3b, + 0x34, 0x3c, 0x03, 0x86, 0x62, 0x2a, 0xa3, 0xb6, 0xee, 0xea, 0xe3, 0x51, 0xd0, 0x36, 0xd0, 0x05, + 0x66, 0x42, 0x65, 0x2c, 0x58, 0xa9, 0x18, 0x2f, 0xec, 0x5e, 0x33, 0x3b, 0x95, 0x1a, 0x1f, 0x5f, + 0xd2, 0xc2, 0xee, 0x77, 0xbe, 0xba, 0x81, 0x57, 0xc0, 0x68, 0x9e, 0x6e, 0x0f, 0x6a, 0x75, 0xfa, + 0x68, 0xb3, 0xbb, 0xd0, 0x7e, 0xed, 0x2e, 0x1e, 0xc6, 0x5c, 0xe6, 0x5c, 0xca, 0x64, 0x89, 0x18, + 0xc7, 0x39, 0x51, 0x0b, 0x74, 0x5d, 0xa8, 0xa0, 0xdd, 0x85, 0x6f, 0xc0, 0xbd, 0x2e, 0x2f, 0x15, + 0x8c, 0x27, 0xb6, 0xe1, 0xea, 0xe3, 0xfb, 0x97, 0x4f, 0xd0, 0xff, 0xe3, 0xa2, 0x36, 0x43, 0xb3, + 0x1e, 0x98, 0xd9, 0xdf, 0x06, 0x3e, 0x05, 0x16, 0x5d, 0xd3, 0xbc, 0x54, 0x11, 0x49, 0x12, 0x41, + 0xa5, 0xa4, 0xd2, 0x1e, 0xba, 0xfd, 0xf1, 0x28, 0x78, 0xd0, 0xea, 0x93, 0xa3, 0xfc, 0xec, 0x15, + 0x30, 0x4f, 0x30, 0xf0, 0x2e, 0x18, 0xcc, 0x6e, 0x66, 0x9e, 0xa5, 0xc1, 0x11, 0x30, 0x5e, 0x4e, + 0xae, 0xfd, 0xd0, 0xd2, 0x21, 0x00, 0xc3, 0x4f, 0x9e, 0xf7, 0xd6, 0x0f, 0xad, 0x1e, 0x34, 0xc1, + 0x9d, 0x77, 0x37, 0xb3, 0xdb, 0xd7, 0x7e, 0x68, 0xf5, 0xeb, 0x41, 0xe8, 0x4d, 0x02, 0x3f, 0xb4, + 0x06, 0xd3, 0x0f, 0x9b, 0xbd, 0xa3, 0x6f, 0xf7, 0x8e, 0xfe, 0x7b, 0xef, 0xe8, 0xdf, 0x0f, 0x8e, + 0xb6, 0x3d, 0x38, 0xda, 0xcf, 0x83, 0xa3, 0x7d, 0x7e, 0x9e, 0x32, 0xb5, 0xf8, 0x3a, 0x47, 0x31, + 0xcf, 0xf1, 0x3f, 0xae, 0xbf, 0xba, 0xc4, 0x6b, 0x2c, 0x97, 0xd5, 0x37, 0x52, 0x61, 0x55, 0x95, + 0x54, 0x1e, 0xff, 0xc3, 0x7c, 0xd8, 0xdc, 0xef, 0xea, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x25, + 0xc9, 0x92, 0x96, 0x34, 0x02, 0x00, 0x00, } func (m *SetBridgeTransferLimitProposal) Marshal() (dAtA []byte, err error) { @@ -253,6 +261,7 @@ func encodeVarintBridgeTransferLimitProposal(dAtA []byte, offset int, v uint64) dAtA[offset] = uint8(v) return base } + func (m *SetBridgeTransferLimitProposal) Size() (n int) { if m == nil { return 0 @@ -288,9 +297,11 @@ func (m *SetBridgeTransferLimitProposal) Size() (n int) { func sovBridgeTransferLimitProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozBridgeTransferLimitProposal(x uint64) (n int) { return sovBridgeTransferLimitProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetBridgeTransferLimitProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -522,6 +533,7 @@ func (m *SetBridgeTransferLimitProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipBridgeTransferLimitProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/gravity/erc20_to_denom_proposal.pb.go b/x/skyway/types/gravity/erc20_to_denom_proposal.pb.go index 4f8f161e..d0651023 100644 --- a/x/skyway/types/gravity/erc20_to_denom_proposal.pb.go +++ b/x/skyway/types/gravity/erc20_to_denom_proposal.pb.go @@ -5,17 +5,20 @@ package gravity import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*SetERC20ToDenomProposal) ProtoMessage() {} func (*SetERC20ToDenomProposal) Descriptor() ([]byte, []int) { return fileDescriptor_aedb9a8b0e7c953e, []int{0} } + func (m *SetERC20ToDenomProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetERC20ToDenomProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetERC20ToDenomProposal.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *SetERC20ToDenomProposal) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *SetERC20ToDenomProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetERC20ToDenomProposal.Merge(m, src) } + func (m *SetERC20ToDenomProposal) XXX_Size() int { return m.Size() } + func (m *SetERC20ToDenomProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetERC20ToDenomProposal.DiscardUnknown(m) } @@ -108,25 +116,25 @@ func init() { } var fileDescriptor_aedb9a8b0e7c953e = []byte{ - // 278 bytes of a gzipped FileDescriptorProto + // 280 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x50, 0xbb, 0x4e, 0xc3, 0x30, - 0x14, 0x8d, 0x81, 0x22, 0x11, 0x16, 0x14, 0x21, 0x11, 0x3a, 0x58, 0x15, 0x13, 0x03, 0x8a, 0xab, - 0xc2, 0xc0, 0xcc, 0x63, 0x60, 0x41, 0x28, 0x30, 0xb1, 0x58, 0xae, 0x63, 0x5a, 0x8b, 0x24, 0xd7, - 0xb2, 0xcd, 0x23, 0x7f, 0xc1, 0x7f, 0xf0, 0x23, 0x8c, 0x1d, 0x19, 0x51, 0xf2, 0x23, 0x28, 0xd7, - 0xad, 0xd4, 0xa1, 0xdb, 0x3d, 0xe7, 0xdc, 0x73, 0x1f, 0x27, 0xbe, 0x34, 0xa2, 0x84, 0x4a, 0xc8, - 0xb9, 0xd0, 0x35, 0x0b, 0x35, 0x9b, 0x59, 0xf1, 0xae, 0x7d, 0xc3, 0x94, 0x95, 0x93, 0x31, 0xf7, - 0xc0, 0x0b, 0x55, 0x43, 0xc5, 0x8d, 0x05, 0x03, 0x4e, 0x94, 0x99, 0xb1, 0xe0, 0x21, 0x19, 0xae, - 0x39, 0xb3, 0x50, 0x67, 0x4b, 0xe7, 0xf0, 0x58, 0x82, 0xab, 0xc0, 0x71, 0xec, 0x64, 0x01, 0x04, - 0xdb, 0xc9, 0x37, 0x89, 0x8f, 0x1e, 0x95, 0xbf, 0xcd, 0xaf, 0x27, 0xe3, 0x27, 0xb8, 0xe9, 0x27, - 0x3f, 0x2c, 0x07, 0x27, 0x87, 0xf1, 0xc0, 0x6b, 0x5f, 0xaa, 0x94, 0x8c, 0xc8, 0xe9, 0x5e, 0x1e, - 0x40, 0x32, 0x8a, 0xf7, 0x0b, 0xe5, 0xa4, 0xd5, 0xc6, 0x6b, 0xa8, 0xd3, 0x2d, 0xd4, 0xd6, 0xa9, - 0xe4, 0x2c, 0x4e, 0xf0, 0x0c, 0x6e, 0xd5, 0x8b, 0xb2, 0xaa, 0x96, 0x8a, 0xeb, 0x22, 0xdd, 0xc6, - 0xc6, 0x03, 0x54, 0xf2, 0x95, 0x70, 0x57, 0xf4, 0x5b, 0xf0, 0xb3, 0x74, 0x27, 0x6c, 0x41, 0xd0, - 0xb3, 0xf8, 0x66, 0x3a, 0x08, 0x2c, 0x82, 0xab, 0xfb, 0x9f, 0x96, 0x92, 0x45, 0x4b, 0xc9, 0x5f, - 0x4b, 0xc9, 0x57, 0x47, 0xa3, 0x45, 0x47, 0xa3, 0xdf, 0x8e, 0x46, 0xcf, 0x17, 0x33, 0xed, 0xe7, - 0x6f, 0xd3, 0x4c, 0x42, 0xc5, 0x36, 0x64, 0xf8, 0xc9, 0xdc, 0x6b, 0xf3, 0x21, 0x1a, 0xe6, 0x1b, - 0xa3, 0xdc, 0x2a, 0xd2, 0xe9, 0x2e, 0x86, 0x70, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xd5, 0x79, - 0x41, 0x36, 0x77, 0x01, 0x00, 0x00, + 0x14, 0xad, 0x81, 0x22, 0x11, 0x16, 0x14, 0x21, 0x11, 0x3a, 0x58, 0x15, 0x13, 0x03, 0x8a, 0xab, + 0x30, 0xc0, 0xcc, 0x63, 0x60, 0x83, 0xc0, 0xc4, 0x62, 0xb9, 0x8e, 0x69, 0x2d, 0x92, 0x5c, 0xcb, + 0x36, 0x85, 0xfc, 0x05, 0xff, 0xc1, 0x8f, 0x30, 0x76, 0x64, 0x44, 0xc9, 0x8f, 0xa0, 0x5c, 0xb7, + 0x52, 0x07, 0xb6, 0x7b, 0xce, 0xb9, 0xe7, 0x3e, 0x4e, 0x74, 0x69, 0x44, 0x09, 0x95, 0x90, 0x73, + 0xa1, 0x6b, 0x16, 0x6a, 0x36, 0xb3, 0x62, 0xa1, 0x7d, 0xc3, 0x94, 0x95, 0xd9, 0x84, 0x7b, 0xe0, + 0x85, 0xaa, 0xa1, 0xe2, 0xc6, 0x82, 0x01, 0x27, 0xca, 0xd4, 0x58, 0xf0, 0x10, 0x8f, 0x36, 0x9c, + 0x69, 0xa8, 0xd3, 0x95, 0x73, 0x74, 0x2c, 0xc1, 0x55, 0xe0, 0x38, 0x76, 0xb2, 0x00, 0x82, 0xed, + 0xe4, 0x8b, 0x44, 0x47, 0x8f, 0xca, 0xdf, 0xe6, 0xd7, 0xd9, 0xe4, 0x09, 0x6e, 0xfa, 0xc9, 0xf7, + 0xab, 0xc1, 0xf1, 0x61, 0x34, 0xf4, 0xda, 0x97, 0x2a, 0x21, 0x63, 0x72, 0xba, 0x97, 0x07, 0x10, + 0x8f, 0xa3, 0xfd, 0x42, 0x39, 0x69, 0xb5, 0xf1, 0x1a, 0xea, 0x64, 0x0b, 0xb5, 0x4d, 0x2a, 0x3e, + 0x8b, 0x62, 0x3c, 0x83, 0x5b, 0xf5, 0xa2, 0xac, 0xaa, 0xa5, 0xe2, 0xba, 0x48, 0xb6, 0xb1, 0xf1, + 0x00, 0x95, 0x7c, 0x2d, 0xdc, 0x15, 0xfd, 0x16, 0xfc, 0x2c, 0xd9, 0x09, 0x5b, 0x10, 0xf4, 0x2c, + 0xbe, 0x99, 0x0c, 0x03, 0x8b, 0xe0, 0xea, 0xe1, 0xbb, 0xa5, 0x64, 0xd9, 0x52, 0xf2, 0xdb, 0x52, + 0xf2, 0xd9, 0xd1, 0xc1, 0xb2, 0xa3, 0x83, 0x9f, 0x8e, 0x0e, 0x9e, 0x2f, 0x66, 0xda, 0xcf, 0xdf, + 0xa6, 0xa9, 0x84, 0x8a, 0xfd, 0x93, 0xe1, 0x22, 0x63, 0x1f, 0xcc, 0xbd, 0x36, 0xef, 0xa2, 0x61, + 0xbe, 0x31, 0xca, 0xad, 0x53, 0x9d, 0xee, 0x62, 0x0e, 0xe7, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, + 0x99, 0xf4, 0xdb, 0xb7, 0x7a, 0x01, 0x00, 0x00, } func (m *SetERC20ToDenomProposal) Marshal() (dAtA []byte, err error) { @@ -198,6 +206,7 @@ func encodeVarintErc20ToDenomProposal(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *SetERC20ToDenomProposal) Size() (n int) { if m == nil { return 0 @@ -230,9 +239,11 @@ func (m *SetERC20ToDenomProposal) Size() (n int) { func sovErc20ToDenomProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozErc20ToDenomProposal(x uint64) (n int) { return sovErc20ToDenomProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetERC20ToDenomProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -443,6 +454,7 @@ func (m *SetERC20ToDenomProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipErc20ToDenomProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/legacy_msgs.pb.go b/x/skyway/types/legacy_msgs.pb.go index 1c985e09..0bd7c209 100644 --- a/x/skyway/types/legacy_msgs.pb.go +++ b/x/skyway/types/legacy_msgs.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" types "github.com/palomachain/paloma/v2/x/valset/types" - 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -47,9 +50,11 @@ func (*MsgBatchSendToEthClaim) ProtoMessage() {} func (*MsgBatchSendToEthClaim) Descriptor() ([]byte, []int) { return fileDescriptor_1ec51423b5f9718d, []int{0} } + func (m *MsgBatchSendToEthClaim) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgBatchSendToEthClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgBatchSendToEthClaim.Marshal(b, m, deterministic) @@ -62,12 +67,15 @@ func (m *MsgBatchSendToEthClaim) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *MsgBatchSendToEthClaim) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgBatchSendToEthClaim.Merge(m, src) } + func (m *MsgBatchSendToEthClaim) XXX_Size() int { return m.Size() } + func (m *MsgBatchSendToEthClaim) XXX_DiscardUnknown() { xxx_messageInfo_MsgBatchSendToEthClaim.DiscardUnknown(m) } @@ -139,33 +147,33 @@ func init() { } var fileDescriptor_1ec51423b5f9718d = []byte{ - // 415 bytes of a gzipped FileDescriptorProto + // 416 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x31, 0x6f, 0x13, 0x31, 0x14, 0xc7, 0x73, 0x25, 0x94, 0xe2, 0xb4, 0x55, 0x65, 0x21, 0x38, 0x3a, 0x5c, 0x43, 0x25, 0xaa, - 0x08, 0xaa, 0xb3, 0x80, 0x8d, 0x31, 0x15, 0xa8, 0x0c, 0x61, 0x08, 0x4c, 0x2c, 0x27, 0xc7, 0x79, - 0xd8, 0xa7, 0x9c, 0xfd, 0xa2, 0xf3, 0x23, 0x90, 0x95, 0x4f, 0xc0, 0x47, 0xe1, 0x63, 0x74, 0xec, - 0xc8, 0x84, 0x50, 0x32, 0xf0, 0x19, 0xd8, 0xd0, 0xd9, 0xd7, 0x08, 0xa4, 0x4c, 0xf7, 0xf4, 0xf3, - 0xff, 0xfd, 0xad, 0xff, 0xfd, 0xcd, 0x9e, 0xce, 0x65, 0x85, 0x56, 0x2a, 0x23, 0x4b, 0x27, 0xe2, - 0x2c, 0xfc, 0x6c, 0xf9, 0x59, 0x2e, 0x45, 0x05, 0x5a, 0xaa, 0x65, 0x61, 0xbd, 0xf6, 0xf9, 0xbc, - 0x46, 0x42, 0xfe, 0xf0, 0x1f, 0x71, 0x1e, 0xe7, 0x3c, 0x8a, 0x8f, 0x1f, 0x28, 0xf4, 0x16, 0xbd, - 0xb0, 0x5e, 0x8b, 0xc5, 0xb3, 0xe6, 0x13, 0x77, 0x8e, 0xef, 0x69, 0xd4, 0x18, 0x46, 0xd1, 0x4c, - 0x2d, 0x3d, 0xdb, 0x72, 0xed, 0x42, 0x56, 0x1e, 0x48, 0x28, 0xb4, 0x16, 0x5d, 0xd4, 0x9d, 0xfe, - 0xd9, 0x61, 0xf7, 0x47, 0x5e, 0x0f, 0x25, 0x29, 0xf3, 0x0e, 0xdc, 0xf4, 0x3d, 0xbe, 0x22, 0x73, - 0x51, 0xc9, 0xd2, 0xf2, 0x13, 0xd6, 0x83, 0x05, 0x38, 0x2a, 0x1c, 0x3a, 0x05, 0x69, 0xd2, 0x4f, - 0x06, 0xdd, 0x31, 0x0b, 0xe8, 0x6d, 0x43, 0xf8, 0x80, 0x1d, 0x01, 0x99, 0x62, 0x52, 0xa1, 0x9a, - 0x15, 0x06, 0x4a, 0x6d, 0x28, 0xdd, 0x09, 0xaa, 0x43, 0x20, 0x33, 0x6c, 0xf0, 0x65, 0xa0, 0x8d, - 0xd5, 0xa4, 0xb9, 0xa1, 0xb5, 0xba, 0x15, 0xad, 0x02, 0x8a, 0x56, 0x8f, 0xd9, 0x21, 0xe1, 0x0c, - 0x5c, 0xa1, 0xd0, 0x51, 0x2d, 0x15, 0xa5, 0xdd, 0x7e, 0x32, 0xb8, 0x3b, 0x3e, 0x08, 0xf4, 0xa2, - 0x85, 0xfc, 0x9c, 0xf1, 0x90, 0xa8, 0xa8, 0xe1, 0x23, 0xd4, 0xe0, 0x14, 0x14, 0xe5, 0x34, 0xbd, - 0x1d, 0xa4, 0x47, 0xe1, 0x64, 0x7c, 0x73, 0xf0, 0x66, 0xca, 0x4f, 0xd9, 0x3e, 0xd6, 0xca, 0x80, - 0xa7, 0x5a, 0x12, 0xd6, 0xe9, 0x6e, 0xd0, 0xfd, 0xc7, 0xf8, 0x25, 0xdb, 0xb3, 0x40, 0x72, 0x2a, - 0x49, 0xa6, 0x77, 0xfa, 0xc9, 0xa0, 0xf7, 0xfc, 0x2c, 0xdf, 0x52, 0x42, 0xfc, 0x75, 0xf9, 0xc8, - 0xeb, 0x51, 0xab, 0x1e, 0x76, 0xaf, 0x7e, 0x9e, 0x74, 0xc6, 0x9b, 0x6d, 0xfe, 0x88, 0xed, 0xc7, - 0xaa, 0xda, 0x90, 0x7b, 0x21, 0x64, 0x2f, 0xb2, 0x90, 0xf2, 0xe5, 0xc1, 0xd7, 0xdf, 0xdf, 0x9f, - 0x6c, 0x36, 0x86, 0xaf, 0xaf, 0x56, 0x59, 0x72, 0xbd, 0xca, 0x92, 0x5f, 0xab, 0x2c, 0xf9, 0xb6, - 0xce, 0x3a, 0xd7, 0xeb, 0xac, 0xf3, 0x63, 0x9d, 0x75, 0x3e, 0x9c, 0xeb, 0x92, 0xcc, 0xa7, 0x49, - 0xae, 0xd0, 0x8a, 0x2d, 0x45, 0x7e, 0xb9, 0x79, 0x41, 0xb4, 0x9c, 0x83, 0x9f, 0xec, 0x86, 0x2a, - 0x5f, 0xfc, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xb3, 0x05, 0x75, 0x87, 0x6b, 0x02, 0x00, 0x00, + 0x08, 0xd0, 0x59, 0x94, 0x8d, 0x31, 0x15, 0x52, 0x3b, 0x84, 0x21, 0x30, 0xb1, 0x9c, 0x1c, 0xe7, + 0x61, 0x9f, 0x72, 0xf6, 0x8b, 0xce, 0x8f, 0x40, 0x56, 0x3e, 0x01, 0x1f, 0x85, 0x8f, 0xd1, 0xb1, + 0x23, 0x13, 0x42, 0xc9, 0xc0, 0x67, 0x60, 0x43, 0x67, 0x5f, 0x23, 0x90, 0x32, 0xdd, 0xd3, 0xcf, + 0xff, 0xf7, 0xb7, 0xfe, 0xf7, 0x37, 0x7b, 0x3e, 0x97, 0x15, 0x5a, 0xa9, 0x8c, 0x2c, 0x9d, 0x88, + 0xb3, 0xf0, 0xb3, 0xe5, 0x67, 0xb9, 0x14, 0x15, 0x68, 0xa9, 0x96, 0x85, 0xf5, 0xda, 0xe7, 0xf3, + 0x1a, 0x09, 0xf9, 0xe3, 0x7f, 0xc4, 0x79, 0x9c, 0xf3, 0x28, 0x3e, 0x7e, 0xa4, 0xd0, 0x5b, 0xf4, + 0xc2, 0x7a, 0x2d, 0x16, 0x2f, 0x9b, 0x4f, 0xdc, 0x39, 0x7e, 0xa0, 0x51, 0x63, 0x18, 0x45, 0x33, + 0xb5, 0xf4, 0x6c, 0xcb, 0xb5, 0x0b, 0x59, 0x79, 0x20, 0xa1, 0xd0, 0x5a, 0x74, 0x51, 0x77, 0xfa, + 0x67, 0x87, 0x3d, 0x1c, 0x79, 0x3d, 0x94, 0xa4, 0xcc, 0x3b, 0x70, 0xd3, 0xf7, 0xf8, 0x86, 0xcc, + 0x45, 0x25, 0x4b, 0xcb, 0x4f, 0x58, 0x0f, 0x16, 0xe0, 0xa8, 0x70, 0xe8, 0x14, 0xa4, 0x49, 0x3f, + 0x19, 0x74, 0xc7, 0x2c, 0xa0, 0xb7, 0x0d, 0xe1, 0x03, 0x76, 0x04, 0x64, 0x8a, 0x49, 0x85, 0x6a, + 0x56, 0x18, 0x28, 0xb5, 0xa1, 0x74, 0x27, 0xa8, 0x0e, 0x81, 0xcc, 0xb0, 0xc1, 0x97, 0x81, 0x36, + 0x56, 0x93, 0xe6, 0x86, 0xd6, 0xea, 0x4e, 0xb4, 0x0a, 0x28, 0x5a, 0x3d, 0x65, 0x87, 0x84, 0x33, + 0x70, 0x85, 0x42, 0x47, 0xb5, 0x54, 0x94, 0x76, 0xfb, 0xc9, 0xe0, 0xfe, 0xf8, 0x20, 0xd0, 0x8b, + 0x16, 0xf2, 0x17, 0x8c, 0x87, 0x44, 0x45, 0x0d, 0x1f, 0xa1, 0x06, 0xa7, 0xa0, 0x28, 0xa7, 0xe9, + 0xdd, 0x20, 0x3d, 0x0a, 0x27, 0xe3, 0xdb, 0x83, 0xab, 0x29, 0x3f, 0x65, 0xfb, 0x58, 0x2b, 0x03, + 0x9e, 0x6a, 0x49, 0x58, 0xa7, 0xbb, 0x41, 0xf7, 0x1f, 0xe3, 0x97, 0x6c, 0xcf, 0x02, 0xc9, 0xa9, + 0x24, 0x99, 0xde, 0xeb, 0x27, 0x83, 0xde, 0xf9, 0x59, 0xbe, 0xa5, 0x84, 0xf8, 0xeb, 0xf2, 0x91, + 0xd7, 0xa3, 0x56, 0x3d, 0xec, 0x5e, 0xff, 0x3c, 0xe9, 0x8c, 0x37, 0xdb, 0xfc, 0x09, 0xdb, 0x8f, + 0x55, 0xb5, 0x21, 0xf7, 0x42, 0xc8, 0x5e, 0x64, 0x21, 0xe5, 0xeb, 0x83, 0xaf, 0xbf, 0xbf, 0x3f, + 0xdb, 0x6c, 0x0c, 0xaf, 0xae, 0x57, 0x59, 0x72, 0xb3, 0xca, 0x92, 0x5f, 0xab, 0x2c, 0xf9, 0xb6, + 0xce, 0x3a, 0x37, 0xeb, 0xac, 0xf3, 0x63, 0x9d, 0x75, 0x3e, 0x08, 0x5d, 0x92, 0xf9, 0x34, 0xc9, + 0x15, 0x5a, 0xb1, 0xad, 0xc8, 0x73, 0xf1, 0xe5, 0xf6, 0x11, 0xd1, 0x72, 0x0e, 0x7e, 0xb2, 0x1b, + 0xda, 0x7c, 0xf5, 0x37, 0x00, 0x00, 0xff, 0xff, 0x54, 0x1b, 0x10, 0x98, 0x6e, 0x02, 0x00, 0x00, } func (m *MsgBatchSendToEthClaim) Marshal() (dAtA []byte, err error) { @@ -253,6 +261,7 @@ func encodeVarintLegacyMsgs(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgBatchSendToEthClaim) Size() (n int) { if m == nil { return 0 @@ -291,9 +300,11 @@ func (m *MsgBatchSendToEthClaim) Size() (n int) { func sovLegacyMsgs(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozLegacyMsgs(x uint64) (n int) { return sovLegacyMsgs(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *MsgBatchSendToEthClaim) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -549,6 +560,7 @@ func (m *MsgBatchSendToEthClaim) Unmarshal(dAtA []byte) error { } return nil } + func skipLegacyMsgs(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/light_node_sale_contract.pb.go b/x/skyway/types/light_node_sale_contract.pb.go index 94566237..15503100 100644 --- a/x/skyway/types/light_node_sale_contract.pb.go +++ b/x/skyway/types/light_node_sale_contract.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -36,9 +39,11 @@ func (*LightNodeSaleContract) ProtoMessage() {} func (*LightNodeSaleContract) Descriptor() ([]byte, []int) { return fileDescriptor_c24364f3379af24c, []int{0} } + func (m *LightNodeSaleContract) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *LightNodeSaleContract) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LightNodeSaleContract.Marshal(b, m, deterministic) @@ -51,12 +56,15 @@ func (m *LightNodeSaleContract) XXX_Marshal(b []byte, deterministic bool) ([]byt return b[:n], nil } } + func (m *LightNodeSaleContract) XXX_Merge(src proto.Message) { xxx_messageInfo_LightNodeSaleContract.Merge(m, src) } + func (m *LightNodeSaleContract) XXX_Size() int { return m.Size() } + func (m *LightNodeSaleContract) XXX_DiscardUnknown() { xxx_messageInfo_LightNodeSaleContract.DiscardUnknown(m) } @@ -86,7 +94,7 @@ func init() { } var fileDescriptor_c24364f3379af24c = []byte{ - // 220 bytes of a gzipped FileDescriptorProto + // 223 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x28, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x8b, 0xb3, 0x2b, 0xcb, 0x13, 0x2b, 0xf5, 0x73, 0x32, 0xd3, 0x33, 0x4a, 0xe2, 0xf3, 0xf2, 0x53, 0x52, 0xe3, 0x8b, 0x13, 0x73, @@ -96,11 +104,11 @@ var fileDescriptor_c24364f3379af24c = []byte{ 0x60, 0xf5, 0xf1, 0x45, 0xa9, 0x69, 0xa9, 0x45, 0xa9, 0x79, 0xc9, 0xa9, 0xf1, 0x99, 0x29, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x02, 0x60, 0x99, 0x20, 0x98, 0x84, 0x67, 0x8a, 0x90, 0x26, 0x97, 0x00, 0xcc, 0xce, 0xf8, 0xc4, 0x94, 0x94, 0xa2, 0xd4, 0xe2, 0x62, 0x09, 0x26, 0xb0, 0x5a, - 0x7e, 0x98, 0xb8, 0x23, 0x44, 0xd8, 0xc9, 0xed, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, + 0x7e, 0x98, 0xb8, 0x23, 0x44, 0xd8, 0xc9, 0xf3, 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, 0x74, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0xf8, - 0xb5, 0x02, 0xe6, 0xdb, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0xdf, 0x8c, 0x01, 0x01, - 0x00, 0x00, 0xff, 0xff, 0xc9, 0x39, 0xe4, 0xa9, 0x17, 0x01, 0x00, 0x00, + 0x18, 0xa2, 0xf4, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xb1, 0xf8, + 0xb5, 0xcc, 0x48, 0xbf, 0x02, 0xe6, 0xe1, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0xf7, + 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd1, 0x2c, 0x8d, 0x35, 0x1a, 0x01, 0x00, 0x00, } func (m *LightNodeSaleContract) Marshal() (dAtA []byte, err error) { @@ -151,6 +159,7 @@ func encodeVarintLightNodeSaleContract(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *LightNodeSaleContract) Size() (n int) { if m == nil { return 0 @@ -171,9 +180,11 @@ func (m *LightNodeSaleContract) Size() (n int) { func sovLightNodeSaleContract(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozLightNodeSaleContract(x uint64) (n int) { return sovLightNodeSaleContract(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *LightNodeSaleContract) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -288,6 +299,7 @@ func (m *LightNodeSaleContract) Unmarshal(dAtA []byte) error { } return nil } + func skipLightNodeSaleContract(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/light_node_sale_contracts_proposal.pb.go b/x/skyway/types/light_node_sale_contracts_proposal.pb.go index f09f2918..2115ed94 100644 --- a/x/skyway/types/light_node_sale_contracts_proposal.pb.go +++ b/x/skyway/types/light_node_sale_contracts_proposal.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -34,9 +37,11 @@ func (*SetLightNodeSaleContractsProposal) ProtoMessage() {} func (*SetLightNodeSaleContractsProposal) Descriptor() ([]byte, []int) { return fileDescriptor_bcf7977a19185ea8, []int{0} } + func (m *SetLightNodeSaleContractsProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetLightNodeSaleContractsProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetLightNodeSaleContractsProposal.Marshal(b, m, deterministic) @@ -49,12 +54,15 @@ func (m *SetLightNodeSaleContractsProposal) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *SetLightNodeSaleContractsProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetLightNodeSaleContractsProposal.Merge(m, src) } + func (m *SetLightNodeSaleContractsProposal) XXX_Size() int { return m.Size() } + func (m *SetLightNodeSaleContractsProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetLightNodeSaleContractsProposal.DiscardUnknown(m) } @@ -91,7 +99,7 @@ func init() { } var fileDescriptor_bcf7977a19185ea8 = []byte{ - // 253 bytes of a gzipped FileDescriptorProto + // 256 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x8b, 0xb3, 0x2b, 0xcb, 0x13, 0x2b, 0xf5, 0x73, 0x32, 0xd3, 0x33, 0x4a, 0xe2, 0xf3, 0xf2, 0x53, 0x52, 0xe3, 0x8b, 0x13, 0x73, @@ -103,11 +111,11 @@ var fileDescriptor_bcf7977a19185ea8 = []byte{ 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0xe1, 0x08, 0x29, 0x70, 0x71, 0xa7, 0xa4, 0x16, 0x27, 0x17, 0x65, 0x16, 0x94, 0x64, 0xe6, 0xe7, 0x49, 0x30, 0x81, 0xe5, 0x90, 0x85, 0x84, 0xb2, 0xb9, 0x24, 0x71, 0x7a, 0x4f, 0x82, 0x59, 0x81, 0x59, 0x83, 0xdb, 0xc8, 0x40, 0x0f, 0xa7, 0xb7, 0xf4, 0xb0, 0xba, - 0x2a, 0x48, 0x2c, 0x07, 0xab, 0x63, 0x9d, 0xdc, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, + 0x2a, 0x48, 0x2c, 0x07, 0xab, 0x63, 0x9d, 0x3c, 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, 0x27, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x4b, - 0x48, 0x55, 0xc0, 0xc2, 0xaa, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c, 0x32, 0xc6, 0x80, - 0x00, 0x00, 0x00, 0xff, 0xff, 0x95, 0xbc, 0x9c, 0x28, 0xb4, 0x01, 0x00, 0x00, + 0x8e, 0x21, 0x4a, 0x3f, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x4b, + 0x48, 0x95, 0x19, 0xe9, 0x57, 0xc0, 0x82, 0xab, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c, + 0x38, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x84, 0x6e, 0x01, 0x48, 0xb7, 0x01, 0x00, 0x00, } func (m *SetLightNodeSaleContractsProposal) Marshal() (dAtA []byte, err error) { @@ -172,6 +180,7 @@ func encodeVarintLightNodeSaleContractsProposal(dAtA []byte, offset int, v uint6 dAtA[offset] = uint8(v) return base } + func (m *SetLightNodeSaleContractsProposal) Size() (n int) { if m == nil { return 0 @@ -198,9 +207,11 @@ func (m *SetLightNodeSaleContractsProposal) Size() (n int) { func sovLightNodeSaleContractsProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozLightNodeSaleContractsProposal(x uint64) (n int) { return sovLightNodeSaleContractsProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetLightNodeSaleContractsProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -349,6 +360,7 @@ func (m *SetLightNodeSaleContractsProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipLightNodeSaleContractsProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/msgs.go b/x/skyway/types/msgs.go index e7d19943..474445f5 100644 --- a/x/skyway/types/msgs.go +++ b/x/skyway/types/msgs.go @@ -9,6 +9,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" errorsmod "github.com/cosmos/cosmos-sdk/types/errors" "github.com/palomachain/paloma/v2/util/libmeta" + tokenfactorytypes "github.com/palomachain/paloma/v2/x/tokenfactory/types" "github.com/palomachain/paloma/v2/x/valset/types" ) @@ -22,6 +23,7 @@ var ( _ sdk.Msg = &MsgSubmitBadSignatureEvidence{} _ sdk.Msg = &MsgUpdateParams{} _ sdk.Msg = &MsgLightNodeSaleClaim{} + _ sdk.Msg = &MsgSetERC20ToTokenDenom{} ) // NewMsgSendToRemote returns a new msgSendToRemote @@ -446,3 +448,36 @@ func (msg *MsgLightNodeSaleClaim) GetType() ClaimType { func (msg *MsgLightNodeSaleClaim) SetOrchestrator(orchestrator sdk.AccAddress) { msg.Orchestrator = orchestrator.String() } + +func NewMsgSetERC20ToTokenDenom(sender sdk.AccAddress, erc20 EthAddress, chainReferenceID string, denom string) *MsgSetERC20ToTokenDenom { + return &MsgSetERC20ToTokenDenom{ + Metadata: types.MsgMetadata{Creator: sender.String(), Signers: []string{sender.String()}}, + Denom: denom, + ChainReferenceId: chainReferenceID, + Erc20: erc20.address.Hex(), + } +} + +func (msg *MsgSetERC20ToTokenDenom) ValidateBasic() error { + _, _, err := tokenfactorytypes.DeconstructDenom(msg.Denom) + if err != nil { + return sdkerrors.Wrap(ErrInvalid, "no tokenfactory denom") + } + + if err := ValidateEthAddress(msg.Erc20); err != nil { + return sdkerrors.Wrap(err, "invalid erc20 address") + } + + if msg.ChainReferenceId == "" { + return sdkerrors.Wrap(ErrInvalid, "chain reference id cannot be empty") + } + + return libmeta.ValidateBasic(msg) +} + +func (msg *MsgSetERC20ToTokenDenom) GetSigners() []sdk.AccAddress { + return libmeta.GetSigners(msg) +} + +func (msg MsgSetERC20ToTokenDenom) Type() string { return "set-erc20-to-denom" } +func (msg MsgSetERC20ToTokenDenom) Route() string { return RouterKey } diff --git a/x/skyway/types/msgs.pb.go b/x/skyway/types/msgs.pb.go index 69717ca8..79e5c5c5 100644 --- a/x/skyway/types/msgs.pb.go +++ b/x/skyway/types/msgs.pb.go @@ -1762,6 +1762,82 @@ func (m *MsgEstimateBatchGas) GetEstimate() uint64 { return 0 } +// MsgSetERC20ToTokenDenom is a message to set the mapping between an ERC20 token +// and a denom created by the token factory. +// Needs admin rights on the token to set the mapping. +type MsgSetERC20ToTokenDenom struct { + Metadata types.MsgMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata" yaml:"metadata"` + Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"` + ChainReferenceId string `protobuf:"bytes,3,opt,name=chain_reference_id,json=chainReferenceId,proto3" json:"chain_reference_id,omitempty" yaml:"chain_reference_id"` + Erc20 string `protobuf:"bytes,4,opt,name=erc20,proto3" json:"erc20,omitempty" yaml:"erc20"` +} + +func (m *MsgSetERC20ToTokenDenom) Reset() { *m = MsgSetERC20ToTokenDenom{} } +func (m *MsgSetERC20ToTokenDenom) String() string { return proto.CompactTextString(m) } +func (*MsgSetERC20ToTokenDenom) ProtoMessage() {} +func (*MsgSetERC20ToTokenDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_857e0e6098045c7c, []int{26} +} + +func (m *MsgSetERC20ToTokenDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgSetERC20ToTokenDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSetERC20ToTokenDenom.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 *MsgSetERC20ToTokenDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSetERC20ToTokenDenom.Merge(m, src) +} + +func (m *MsgSetERC20ToTokenDenom) XXX_Size() int { + return m.Size() +} + +func (m *MsgSetERC20ToTokenDenom) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSetERC20ToTokenDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSetERC20ToTokenDenom proto.InternalMessageInfo + +func (m *MsgSetERC20ToTokenDenom) GetMetadata() types.MsgMetadata { + if m != nil { + return m.Metadata + } + return types.MsgMetadata{} +} + +func (m *MsgSetERC20ToTokenDenom) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +func (m *MsgSetERC20ToTokenDenom) GetChainReferenceId() string { + if m != nil { + return m.ChainReferenceId + } + return "" +} + +func (m *MsgSetERC20ToTokenDenom) GetErc20() string { + if m != nil { + return m.Erc20 + } + return "" +} + func init() { proto.RegisterType((*MsgNonceOverrideProposal)(nil), "palomachain.paloma.skyway.MsgNonceOverrideProposal") proto.RegisterType((*MsgSendToRemote)(nil), "palomachain.paloma.skyway.MsgSendToRemote") @@ -1789,6 +1865,7 @@ func init() { proto.RegisterType((*MsgUpdateParamsResponse)(nil), "palomachain.paloma.skyway.MsgUpdateParamsResponse") proto.RegisterType((*MsgLightNodeSaleClaim)(nil), "palomachain.paloma.skyway.MsgLightNodeSaleClaim") proto.RegisterType((*MsgEstimateBatchGas)(nil), "palomachain.paloma.skyway.MsgEstimateBatchGas") + proto.RegisterType((*MsgSetERC20ToTokenDenom)(nil), "palomachain.paloma.skyway.MsgSetERC20ToTokenDenom") } func init() { @@ -1796,122 +1873,130 @@ func init() { } var fileDescriptor_857e0e6098045c7c = []byte{ - // 1835 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x8f, 0x1b, 0x49, - 0x15, 0x4f, 0xdb, 0xce, 0xcc, 0xf8, 0xcd, 0x67, 0x7a, 0x27, 0x93, 0xb1, 0x37, 0x99, 0x49, 0x1a, - 0x92, 0x0c, 0x61, 0xdd, 0x9d, 0x99, 0xec, 0x92, 0x10, 0x21, 0x6d, 0xd6, 0xc3, 0x2c, 0x19, 0xc0, - 0x49, 0x64, 0x2f, 0x17, 0x84, 0x64, 0x95, 0xbb, 0x2b, 0xdd, 0xcd, 0xb8, 0xbb, 0x4c, 0x57, 0x79, - 0x88, 0xaf, 0x7b, 0xe2, 0x08, 0xe2, 0x82, 0x04, 0x12, 0x1f, 0x82, 0x3b, 0x87, 0x15, 0x12, 0xdc, - 0x91, 0x56, 0x9c, 0x56, 0x70, 0x41, 0x7b, 0x58, 0xa1, 0x64, 0x05, 0xff, 0x03, 0x12, 0x08, 0xd5, - 0x47, 0xb7, 0xdb, 0x76, 0xbb, 0xed, 0xd9, 0x9d, 0x03, 0x27, 0xbb, 0x5f, 0xbd, 0xf7, 0xfa, 0xd5, - 0xef, 0x7d, 0xd4, 0xaf, 0x1a, 0xbe, 0xd8, 0x43, 0x5d, 0x12, 0x20, 0xdb, 0x43, 0x7e, 0x68, 0xc9, - 0xff, 0x16, 0x3d, 0x19, 0xfc, 0x10, 0x0d, 0xac, 0x80, 0xba, 0xd4, 0xec, 0x45, 0x84, 0x11, 0xbd, - 0x92, 0xd2, 0x32, 0xe5, 0x7f, 0x53, 0x6a, 0x55, 0x77, 0x6c, 0x42, 0x03, 0x42, 0xad, 0x0e, 0xa2, - 0xd8, 0x3a, 0xdd, 0xef, 0x60, 0x86, 0xf6, 0x2d, 0x9b, 0x70, 0x3d, 0x6e, 0x5a, 0xbd, 0xa2, 0xd6, - 0x03, 0xea, 0x5a, 0xa7, 0xfb, 0xfc, 0x47, 0x2d, 0x54, 0xe4, 0x42, 0x5b, 0x3c, 0x59, 0xf2, 0x41, - 0x2d, 0x6d, 0xba, 0xc4, 0x25, 0x52, 0xce, 0xff, 0x29, 0xe9, 0x55, 0x97, 0x10, 0xb7, 0x8b, 0x2d, - 0xd4, 0xf3, 0x2d, 0x14, 0x86, 0x84, 0x21, 0xe6, 0x93, 0x30, 0xb6, 0xa9, 0xa8, 0x55, 0xf1, 0xd4, - 0xe9, 0x3f, 0xb7, 0x50, 0x38, 0x50, 0x4b, 0xaf, 0x8f, 0x2f, 0xe1, 0xa0, 0xc7, 0xe2, 0xc5, 0x5b, - 0xd3, 0x01, 0xe8, 0xa1, 0x08, 0x05, 0xb1, 0xff, 0x9b, 0xd3, 0xf5, 0xd8, 0xa0, 0x87, 0x69, 0x8e, - 0xbb, 0x53, 0xd4, 0xa5, 0x98, 0x59, 0x36, 0x09, 0x02, 0xa2, 0x60, 0x31, 0xfe, 0xa8, 0xc1, 0x76, - 0x83, 0xba, 0x4f, 0x48, 0x68, 0xe3, 0xa7, 0xa7, 0x38, 0x8a, 0x7c, 0x07, 0x3f, 0x8b, 0x48, 0x8f, - 0x50, 0xd4, 0xd5, 0x1f, 0xc3, 0x52, 0x80, 0x19, 0x72, 0x10, 0x43, 0xdb, 0xda, 0x75, 0x6d, 0x6f, - 0xf9, 0xe0, 0x96, 0x99, 0x91, 0x01, 0xe9, 0xd7, 0x6c, 0x50, 0xb7, 0xa1, 0xb4, 0xeb, 0xa5, 0x0f, - 0x3f, 0xd9, 0xbd, 0xd0, 0x4c, 0xac, 0xf5, 0x37, 0x40, 0x17, 0x26, 0xed, 0x08, 0x3f, 0xc7, 0x11, - 0x0e, 0x6d, 0xdc, 0xf6, 0x9d, 0xed, 0xc2, 0x75, 0x6d, 0xaf, 0xdc, 0xdc, 0x10, 0x2b, 0xcd, 0x78, - 0xe1, 0xd8, 0xd1, 0x37, 0xe1, 0x62, 0xc8, 0x03, 0xda, 0x2e, 0x5e, 0xd7, 0xf6, 0x4a, 0x4d, 0xf9, - 0xf0, 0x70, 0xfd, 0xfd, 0x7f, 0xfd, 0xfe, 0x4e, 0x2a, 0x20, 0xe3, 0xdf, 0x1a, 0xac, 0x37, 0xa8, - 0xdb, 0xc2, 0xa1, 0xf3, 0x1e, 0x69, 0xe2, 0x80, 0x30, 0xac, 0x57, 0x60, 0x09, 0x33, 0xaf, 0xed, - 0x60, 0xca, 0x94, 0xfb, 0x45, 0xcc, 0xbc, 0xaf, 0x63, 0xca, 0xf4, 0xfb, 0xb0, 0x80, 0x02, 0xd2, - 0x0f, 0x99, 0x70, 0xbb, 0x7c, 0x50, 0x31, 0x55, 0xb2, 0x79, 0xc9, 0x98, 0xaa, 0x64, 0xcc, 0x43, - 0xe2, 0x87, 0x2a, 0x7c, 0xa5, 0x3e, 0x25, 0xf8, 0xd2, 0x94, 0xe0, 0xd3, 0xa0, 0x5d, 0xfc, 0x3c, - 0xa0, 0x3d, 0x5c, 0x1d, 0xd9, 0xf0, 0x37, 0x4b, 0x4b, 0xda, 0x46, 0xa1, 0xb9, 0x40, 0x71, 0xe8, - 0xe0, 0xc8, 0xa8, 0xc0, 0x95, 0xb1, 0xbd, 0x37, 0x31, 0xed, 0x91, 0x90, 0x62, 0xe3, 0x47, 0x05, - 0x81, 0xcb, 0x21, 0x09, 0x9f, 0xfb, 0x51, 0x50, 0x47, 0xcc, 0xf6, 0x86, 0x90, 0x6a, 0x29, 0x48, - 0xf5, 0x9b, 0xb0, 0xc6, 0xc8, 0x09, 0x0e, 0xdb, 0x36, 0x09, 0x59, 0x84, 0xec, 0x18, 0xb3, 0x55, - 0x21, 0x3d, 0x54, 0x42, 0xfd, 0x1a, 0x00, 0x07, 0x95, 0xfa, 0x6e, 0x88, 0x23, 0x81, 0x5e, 0xb9, - 0x59, 0xc6, 0xcc, 0x6b, 0x09, 0x81, 0x6e, 0xc0, 0x0a, 0x89, 0x6c, 0x0f, 0x53, 0x16, 0x21, 0x46, - 0x22, 0x85, 0xcc, 0x88, 0x4c, 0xbf, 0x0a, 0x65, 0x6e, 0x8e, 0x58, 0x3f, 0xc2, 0x02, 0x96, 0x72, - 0x73, 0x28, 0x18, 0xc1, 0x6c, 0xe1, 0x1c, 0x31, 0x53, 0x28, 0xa5, 0x91, 0x48, 0x50, 0xfa, 0x6f, - 0x11, 0x36, 0x13, 0x04, 0x9f, 0x89, 0x17, 0x1c, 0x76, 0x91, 0x1f, 0xe8, 0xbb, 0xb0, 0x8c, 0x4f, - 0x71, 0xc8, 0xda, 0x69, 0xc0, 0x40, 0x88, 0x44, 0x9b, 0xe8, 0x7b, 0xb0, 0xc1, 0xe1, 0xe8, 0x74, - 0x89, 0x7d, 0xd2, 0xf6, 0xb0, 0xef, 0x7a, 0x12, 0xb7, 0x52, 0x73, 0x0d, 0x33, 0xaf, 0xce, 0xc5, - 0x8f, 0x85, 0x34, 0x03, 0xdf, 0x62, 0x16, 0xbe, 0x6f, 0x25, 0x95, 0x29, 0xa0, 0xab, 0x5f, 0xe3, - 0x9b, 0xfa, 0xf8, 0x93, 0xdd, 0xcb, 0xb2, 0x40, 0xa9, 0x73, 0x62, 0xfa, 0xc4, 0x0a, 0x10, 0xf3, - 0xcc, 0xe3, 0x90, 0x25, 0x75, 0x79, 0x1b, 0xd6, 0x31, 0xf3, 0x70, 0x84, 0xfb, 0x41, 0x5b, 0x56, - 0x85, 0x42, 0x76, 0x2d, 0x16, 0xb7, 0x84, 0x94, 0x2b, 0x4a, 0x04, 0xdb, 0x11, 0xb6, 0xb1, 0x7f, - 0x8a, 0x23, 0x81, 0x72, 0xb9, 0xb9, 0x26, 0xc5, 0x4d, 0x25, 0x9d, 0xc8, 0xe4, 0x62, 0x46, 0x26, - 0xb3, 0xbb, 0x61, 0x69, 0x8e, 0x6e, 0x28, 0x7f, 0xae, 0x11, 0x72, 0x03, 0x56, 0xe4, 0x9c, 0x53, - 0x79, 0x01, 0x81, 0xf8, 0xb2, 0x94, 0xc9, 0xc4, 0x5c, 0x03, 0xb0, 0x49, 0xd0, 0x43, 0x94, 0xf2, - 0x90, 0x96, 0x65, 0x95, 0x29, 0xc9, 0xb1, 0x33, 0x5e, 0x1b, 0x3b, 0x70, 0x35, 0x2b, 0xff, 0x49, - 0x81, 0xfc, 0xbc, 0x08, 0x95, 0x06, 0x75, 0x45, 0xd5, 0xa4, 0xfb, 0xec, 0xdc, 0xab, 0x64, 0x17, - 0x96, 0x3b, 0xfc, 0x25, 0xed, 0xf4, 0xd0, 0x03, 0x21, 0x7a, 0x32, 0xa5, 0x4d, 0x4b, 0x59, 0x65, - 0x94, 0x9d, 0x99, 0x8b, 0x53, 0x32, 0x33, 0x9e, 0xeb, 0x85, 0x8c, 0x5c, 0xa7, 0xb3, 0xb7, 0x78, - 0xae, 0xd9, 0x5b, 0x9a, 0x95, 0xbd, 0xf2, 0x8c, 0xec, 0x7d, 0x01, 0x6e, 0x4c, 0x4d, 0x4e, 0x92, - 0xc2, 0xdf, 0x69, 0x70, 0x99, 0xf7, 0x3f, 0x0a, 0x6d, 0xdc, 0x1d, 0x39, 0x27, 0x38, 0xa4, 0x11, - 0x0a, 0x29, 0xb2, 0xf9, 0xe1, 0xcd, 0x5f, 0x28, 0x33, 0xb8, 0x9a, 0x92, 0x8e, 0x95, 0x6f, 0xf1, - 0x7c, 0x87, 0x79, 0x61, 0xa3, 0x98, 0x0c, 0xf3, 0x5d, 0xb8, 0x96, 0x19, 0x66, 0xb2, 0x91, 0xdf, - 0x14, 0x84, 0x46, 0xab, 0xdf, 0x09, 0x7c, 0x56, 0x47, 0x4e, 0x2b, 0x1e, 0x9d, 0x47, 0xa7, 0xbe, - 0xc3, 0x13, 0xaa, 0x3f, 0x82, 0x45, 0xda, 0xef, 0x7c, 0x1f, 0xdb, 0x4c, 0x1d, 0xd5, 0x9b, 0xa6, - 0xa4, 0x1b, 0x66, 0x4c, 0x37, 0xcc, 0x77, 0xc2, 0x41, 0x7d, 0xe3, 0x2f, 0x1f, 0xd4, 0x56, 0xa4, - 0x73, 0x31, 0xbd, 0x9d, 0x66, 0x6c, 0x36, 0x3a, 0xa2, 0x0b, 0xe3, 0x23, 0xba, 0x0a, 0x2a, 0x58, - 0x39, 0xc2, 0xea, 0x85, 0x6d, 0x2d, 0x0e, 0xff, 0xff, 0xe4, 0x80, 0x34, 0x6e, 0xc3, 0xcd, 0x5c, - 0x8c, 0x12, 0x34, 0x1b, 0x70, 0xe5, 0x88, 0x37, 0x6a, 0x0b, 0xb3, 0xa7, 0x3d, 0x2c, 0x4a, 0xfd, - 0x1d, 0xc7, 0x89, 0x30, 0xa5, 0xfa, 0x36, 0x2c, 0x06, 0x98, 0x52, 0xe4, 0xca, 0x96, 0x2e, 0x37, - 0xe3, 0x47, 0xbe, 0x82, 0xa4, 0x52, 0x4c, 0x2c, 0xd4, 0xa3, 0xf1, 0x04, 0x2e, 0x09, 0x77, 0xa2, - 0x18, 0x0f, 0x23, 0x8c, 0x18, 0x76, 0x72, 0x1c, 0x8d, 0xb5, 0xbb, 0x74, 0x96, 0x6a, 0x77, 0xe3, - 0x7b, 0xb0, 0x99, 0xf2, 0x27, 0xcf, 0xae, 0x6f, 0xe1, 0x41, 0x8e, 0xcb, 0x3b, 0x70, 0x49, 0xba, - 0xb4, 0xa5, 0x76, 0xfb, 0x04, 0x0f, 0x94, 0xe3, 0xf5, 0xce, 0xa8, 0x17, 0xe3, 0x1e, 0xbc, 0x3e, - 0xf4, 0x3e, 0x39, 0xd7, 0x46, 0x88, 0x42, 0x59, 0x11, 0x05, 0xa3, 0x0b, 0x20, 0x8c, 0xa4, 0xce, - 0xf4, 0x40, 0x78, 0x0f, 0x73, 0x95, 0xb6, 0x87, 0xa8, 0x17, 0x17, 0x91, 0x90, 0x3c, 0x46, 0xd4, - 0xe3, 0x5d, 0x87, 0x18, 0xc3, 0x54, 0x52, 0x66, 0x5e, 0x24, 0xea, 0x3c, 0x4c, 0x49, 0x8f, 0x1d, - 0xe3, 0x17, 0x1a, 0x54, 0x54, 0x8c, 0x19, 0x95, 0x3e, 0x03, 0x06, 0xa7, 0x1d, 0x73, 0x95, 0x74, - 0x25, 0xaf, 0x77, 0x90, 0x73, 0x24, 0x19, 0x8b, 0xac, 0xe7, 0xaf, 0x42, 0x65, 0x42, 0xb7, 0x1d, - 0x77, 0x90, 0x8c, 0x6a, 0x6b, 0xcc, 0xa6, 0x25, 0x57, 0x8d, 0xdf, 0x6a, 0x50, 0x15, 0xe1, 0x35, - 0xfa, 0x5d, 0xe6, 0x53, 0xdf, 0xfd, 0x4e, 0xcf, 0x41, 0xbc, 0x59, 0x7f, 0xd0, 0xe7, 0x3c, 0xf3, - 0x36, 0xac, 0x77, 0x22, 0xdf, 0x71, 0xf1, 0x70, 0x5c, 0xcb, 0x38, 0xd7, 0xa4, 0x38, 0x99, 0xd7, - 0xb7, 0x86, 0x8a, 0xa2, 0x7b, 0x12, 0x46, 0xbc, 0xaa, 0x14, 0xb9, 0xf4, 0xd8, 0xe1, 0x05, 0x13, - 0xa8, 0x37, 0x0d, 0x21, 0x83, 0x58, 0x94, 0xe6, 0xcb, 0xa5, 0x74, 0xce, 0xde, 0x85, 0x2d, 0x59, - 0xe5, 0x49, 0xfc, 0x5d, 0x44, 0x3d, 0x3f, 0x74, 0x75, 0x1d, 0x4a, 0xfc, 0xae, 0xa0, 0xc2, 0x12, - 0xff, 0x73, 0xca, 0xbb, 0xae, 0xca, 0xfb, 0x69, 0x9f, 0xb9, 0xc4, 0x0f, 0xdd, 0xf7, 0x5e, 0x1c, - 0xe7, 0x95, 0xf7, 0x6b, 0x70, 0x91, 0xbd, 0x18, 0xee, 0xa5, 0xc4, 0x5e, 0x1c, 0x3b, 0xc6, 0xa7, - 0x92, 0xaa, 0x4b, 0xa0, 0x9e, 0x89, 0xfb, 0x8c, 0xfe, 0x15, 0x28, 0xa3, 0x3e, 0xf3, 0x48, 0xe4, - 0xb3, 0x81, 0x74, 0x52, 0xdf, 0xfe, 0xeb, 0x07, 0xb5, 0x4d, 0xc5, 0xca, 0x55, 0x47, 0xb6, 0x58, - 0xe4, 0x87, 0x6e, 0x73, 0xa8, 0xaa, 0xbf, 0x0d, 0x0b, 0xf2, 0x46, 0x24, 0xde, 0xb0, 0x7c, 0x70, - 0xc3, 0x9c, 0x7a, 0x2b, 0x34, 0xe5, 0xab, 0x62, 0x3e, 0x2f, 0xcd, 0xce, 0x71, 0xa8, 0xaf, 0xf1, - 0x01, 0x34, 0x0c, 0x4d, 0xd1, 0xcd, 0xf4, 0x2e, 0x93, 0x99, 0xf3, 0x9f, 0xa2, 0x38, 0x8a, 0xbe, - 0xcd, 0x4f, 0xfc, 0x27, 0xc4, 0xc1, 0x2d, 0xd4, 0x55, 0x1d, 0x77, 0x7e, 0xb7, 0xac, 0x31, 0x4e, - 0x52, 0x98, 0x8b, 0x93, 0x14, 0x33, 0x39, 0xc9, 0x3c, 0x9c, 0xfe, 0x6c, 0x7c, 0x63, 0x9c, 0x01, - 0x2c, 0x4c, 0x32, 0x80, 0xb7, 0x61, 0xcd, 0xee, 0xfa, 0x7c, 0x03, 0x71, 0x29, 0x2e, 0xce, 0x28, - 0x8b, 0x55, 0xa9, 0x1f, 0x4f, 0xef, 0x21, 0x91, 0x5e, 0x3a, 0x0b, 0x91, 0x7e, 0x13, 0xb6, 0x68, - 0x80, 0x22, 0x96, 0x34, 0x6c, 0xf2, 0x7e, 0xc9, 0x42, 0x36, 0xc5, 0x6a, 0xdc, 0xb7, 0xf1, 0xcb, - 0x46, 0xf9, 0x0a, 0xcc, 0xe0, 0x2b, 0xff, 0xd4, 0xe0, 0xb5, 0x06, 0x75, 0x8f, 0x28, 0xf3, 0x03, - 0xc4, 0xb0, 0x98, 0xbe, 0xdf, 0x40, 0xf4, 0x1c, 0xb3, 0x9f, 0x4c, 0x81, 0x42, 0xfe, 0x15, 0xaf, - 0x38, 0xfb, 0x8a, 0x57, 0x1a, 0xbf, 0xe2, 0x55, 0x61, 0x09, 0xab, 0xc8, 0x45, 0x82, 0x4b, 0xcd, - 0xe4, 0x79, 0x6c, 0xa3, 0x07, 0xbf, 0x5c, 0x85, 0x62, 0x83, 0xba, 0xfa, 0xaf, 0x35, 0x58, 0x19, - 0xa1, 0x5c, 0x77, 0x72, 0xfa, 0x74, 0xec, 0x2a, 0x5b, 0x3d, 0x98, 0x5f, 0x37, 0xe9, 0xb0, 0xfd, - 0xf7, 0xff, 0xf6, 0xe9, 0x4f, 0x0b, 0x5f, 0x36, 0xbe, 0x64, 0x4d, 0xff, 0x44, 0xc2, 0x09, 0x4b, - 0x8d, 0x91, 0x5a, 0x24, 0x43, 0xfa, 0x95, 0x06, 0x2b, 0x23, 0xd7, 0xe4, 0x19, 0x31, 0xa6, 0x75, - 0x67, 0xc5, 0x98, 0x79, 0xe9, 0xbc, 0x2b, 0x62, 0xbc, 0x63, 0xec, 0xe5, 0xc4, 0xa8, 0xce, 0xf0, - 0x9a, 0x38, 0xb8, 0xf5, 0x9f, 0x68, 0xb0, 0x31, 0x51, 0x34, 0x66, 0xfe, 0xab, 0xc7, 0xf5, 0xab, - 0x5b, 0x13, 0x5c, 0xf0, 0x28, 0xe8, 0xb1, 0x81, 0xf1, 0x96, 0x08, 0xc7, 0x32, 0x6a, 0x39, 0xe1, - 0xc4, 0x79, 0x96, 0xf1, 0xd4, 0x5c, 0x44, 0xf5, 0x3f, 0x68, 0x70, 0x69, 0xf2, 0xde, 0x6c, 0xcd, - 0x93, 0xb3, 0x94, 0x41, 0xf5, 0xfe, 0x19, 0x0d, 0x12, 0x14, 0xef, 0x8b, 0xb0, 0xf7, 0x0d, 0x6b, - 0x8e, 0x4c, 0x4b, 0x69, 0x4d, 0x70, 0x10, 0xfd, 0xcf, 0x1a, 0x6c, 0x4d, 0xe1, 0x3d, 0x6f, 0xe6, - 0x07, 0x93, 0x6d, 0x55, 0xfd, 0xda, 0x67, 0xb1, 0x3a, 0xd3, 0x3e, 0x24, 0xea, 0x63, 0x75, 0xfb, - 0x27, 0x0d, 0xf4, 0x8c, 0x4b, 0xcd, 0xdd, 0x19, 0x15, 0x39, 0x61, 0x51, 0x7d, 0x70, 0x56, 0x8b, - 0x24, 0xf6, 0x07, 0x22, 0xf6, 0x03, 0xe3, 0x6e, 0x5e, 0x25, 0x0b, 0xf3, 0xf1, 0xe0, 0x3f, 0xd6, - 0xa0, 0x9a, 0x73, 0x91, 0x99, 0x11, 0xd2, 0x74, 0xcb, 0xea, 0xa3, 0xcf, 0x6a, 0x99, 0x6c, 0xea, - 0x91, 0xd8, 0xd4, 0x43, 0xe3, 0x41, 0x5e, 0x61, 0x09, 0x37, 0xb5, 0x0e, 0x72, 0x6a, 0x09, 0x71, - 0xac, 0xe1, 0x38, 0x7a, 0x3e, 0x51, 0x46, 0x58, 0xce, 0x8c, 0x89, 0x92, 0xd6, 0x9d, 0x35, 0x51, - 0x32, 0x79, 0xc5, 0x3c, 0x13, 0xa5, 0x2f, 0x0c, 0x6b, 0x8a, 0xfe, 0xfc, 0x4c, 0x03, 0x3d, 0x83, - 0x86, 0xcc, 0x28, 0x9e, 0x49, 0x8b, 0xa9, 0x53, 0x65, 0x9e, 0xd2, 0xe8, 0x72, 0x77, 0xb5, 0x90, - 0x38, 0xb8, 0x46, 0x51, 0x17, 0xab, 0xfe, 0x74, 0xe0, 0x72, 0xfc, 0x11, 0x5a, 0x30, 0x82, 0xe4, - 0x4b, 0xf4, 0xbd, 0xfc, 0xe0, 0x32, 0x3f, 0x5f, 0x4f, 0x8b, 0xaf, 0xfe, 0xee, 0x87, 0x2f, 0x77, - 0xb4, 0x8f, 0x5e, 0xee, 0x68, 0xff, 0x78, 0xb9, 0xa3, 0xfd, 0xf8, 0xd5, 0xce, 0x85, 0x8f, 0x5e, - 0xed, 0x5c, 0xf8, 0xfb, 0xab, 0x9d, 0x0b, 0xdf, 0x7d, 0xc3, 0xf5, 0x99, 0xd7, 0xef, 0x98, 0x36, - 0x09, 0xb2, 0x62, 0x7f, 0x31, 0xf2, 0xa5, 0xbd, 0xb3, 0x20, 0xfc, 0xde, 0xfb, 0x5f, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x42, 0x79, 0x35, 0xc7, 0xbc, 0x18, 0x00, 0x00, + // 1965 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x4d, 0x8c, 0x1b, 0x49, + 0xf5, 0x4f, 0xdb, 0x9e, 0x0f, 0xbf, 0xf9, 0x4c, 0xef, 0x64, 0x32, 0xf6, 0x66, 0x66, 0x92, 0xfe, + 0xff, 0x33, 0x19, 0x02, 0x76, 0xcf, 0x4c, 0x76, 0x49, 0x88, 0x90, 0x36, 0xeb, 0xd9, 0x81, 0x0c, + 0x8b, 0x93, 0xa8, 0x1d, 0x2e, 0x80, 0x64, 0x95, 0xbb, 0x2b, 0xed, 0x66, 0xdc, 0x5d, 0xa6, 0xab, + 0x3c, 0xc4, 0xd7, 0x3d, 0x71, 0x04, 0x71, 0x41, 0x5a, 0x0e, 0xb0, 0x82, 0x3b, 0x87, 0x15, 0x12, + 0x48, 0x1c, 0x91, 0x56, 0x9c, 0x56, 0x70, 0x41, 0x7b, 0x18, 0xa1, 0x64, 0x05, 0xf7, 0x1c, 0x91, + 0x40, 0xa8, 0x3e, 0xba, 0xdd, 0xb6, 0xdb, 0x1f, 0x93, 0x9d, 0x03, 0xa7, 0xb1, 0x5f, 0xbd, 0xf7, + 0xea, 0xd5, 0xef, 0x7d, 0xd4, 0xaf, 0xc6, 0xf0, 0xff, 0x6d, 0xd4, 0x22, 0x3e, 0xb2, 0x9b, 0xc8, + 0x0b, 0x4c, 0xf9, 0xd9, 0xa4, 0x27, 0xdd, 0x1f, 0xa1, 0xae, 0xe9, 0x53, 0x97, 0x96, 0xdb, 0x21, + 0x61, 0x44, 0x2f, 0x24, 0xb4, 0xca, 0xf2, 0x73, 0x59, 0x6a, 0x15, 0xb7, 0x6c, 0x42, 0x7d, 0x42, + 0xcd, 0x06, 0xa2, 0xd8, 0x3c, 0xdd, 0x6f, 0x60, 0x86, 0xf6, 0x4d, 0x9b, 0x70, 0x3d, 0x6e, 0x5a, + 0xbc, 0xaa, 0xd6, 0x7d, 0xea, 0x9a, 0xa7, 0xfb, 0xfc, 0x8f, 0x5a, 0x28, 0xc8, 0x85, 0xba, 0xf8, + 0x66, 0xca, 0x2f, 0x6a, 0x69, 0xcd, 0x25, 0x2e, 0x91, 0x72, 0xfe, 0x49, 0x49, 0xaf, 0xb9, 0x84, + 0xb8, 0x2d, 0x6c, 0xa2, 0xb6, 0x67, 0xa2, 0x20, 0x20, 0x0c, 0x31, 0x8f, 0x04, 0x91, 0x4d, 0x41, + 0xad, 0x8a, 0x6f, 0x8d, 0xce, 0x33, 0x13, 0x05, 0x5d, 0xb5, 0xf4, 0xe6, 0xe0, 0x12, 0xf6, 0xdb, + 0x2c, 0x5a, 0xdc, 0x19, 0x0d, 0x40, 0x1b, 0x85, 0xc8, 0x8f, 0xfc, 0xdf, 0x1c, 0xad, 0xc7, 0xba, + 0x6d, 0x4c, 0xc7, 0xb8, 0x3b, 0x45, 0x2d, 0x8a, 0x99, 0x69, 0x13, 0xdf, 0x27, 0x0a, 0x16, 0xe3, + 0xf7, 0x1a, 0x6c, 0x54, 0xa9, 0xfb, 0x88, 0x04, 0x36, 0x7e, 0x7c, 0x8a, 0xc3, 0xd0, 0x73, 0xf0, + 0x93, 0x90, 0xb4, 0x09, 0x45, 0x2d, 0xfd, 0x21, 0xcc, 0xfb, 0x98, 0x21, 0x07, 0x31, 0xb4, 0xa1, + 0x5d, 0xd7, 0x76, 0x17, 0x0e, 0x76, 0xca, 0x29, 0x19, 0x90, 0x7e, 0xcb, 0x55, 0xea, 0x56, 0x95, + 0x76, 0x25, 0xf7, 0xc9, 0xd9, 0xf6, 0x25, 0x2b, 0xb6, 0xd6, 0xbf, 0x02, 0xba, 0x30, 0xa9, 0x87, + 0xf8, 0x19, 0x0e, 0x71, 0x60, 0xe3, 0xba, 0xe7, 0x6c, 0x64, 0xae, 0x6b, 0xbb, 0x79, 0x6b, 0x55, + 0xac, 0x58, 0xd1, 0xc2, 0xb1, 0xa3, 0xaf, 0xc1, 0x4c, 0xc0, 0x03, 0xda, 0xc8, 0x5e, 0xd7, 0x76, + 0x73, 0x96, 0xfc, 0x72, 0x7f, 0xe5, 0x83, 0x7f, 0xfe, 0xf6, 0x76, 0x22, 0x20, 0xe3, 0x5f, 0x1a, + 0xac, 0x54, 0xa9, 0x5b, 0xc3, 0x81, 0xf3, 0x94, 0x58, 0xd8, 0x27, 0x0c, 0xeb, 0x05, 0x98, 0xc7, + 0xac, 0x59, 0x77, 0x30, 0x65, 0xca, 0xfd, 0x1c, 0x66, 0xcd, 0xf7, 0x30, 0x65, 0xfa, 0x5d, 0x98, + 0x45, 0x3e, 0xe9, 0x04, 0x4c, 0xb8, 0x5d, 0x38, 0x28, 0x94, 0x55, 0xb2, 0x79, 0xc9, 0x94, 0x55, + 0xc9, 0x94, 0x0f, 0x89, 0x17, 0xa8, 0xf0, 0x95, 0xfa, 0x88, 0xe0, 0x73, 0x23, 0x82, 0x4f, 0x82, + 0x36, 0xf3, 0x45, 0x40, 0xbb, 0xbf, 0xd4, 0x77, 0xe0, 0x6f, 0xe5, 0xe6, 0xb5, 0xd5, 0x8c, 0x35, + 0x4b, 0x71, 0xe0, 0xe0, 0xd0, 0x28, 0xc0, 0xd5, 0x81, 0xb3, 0x5b, 0x98, 0xb6, 0x49, 0x40, 0xb1, + 0xf1, 0xe3, 0x8c, 0xc0, 0xe5, 0x90, 0x04, 0xcf, 0xbc, 0xd0, 0xaf, 0x20, 0x66, 0x37, 0x7b, 0x90, + 0x6a, 0x09, 0x48, 0xf5, 0x9b, 0xb0, 0xcc, 0xc8, 0x09, 0x0e, 0xea, 0x36, 0x09, 0x58, 0x88, 0xec, + 0x08, 0xb3, 0x25, 0x21, 0x3d, 0x54, 0x42, 0x7d, 0x13, 0x80, 0x83, 0x4a, 0x3d, 0x37, 0xc0, 0xa1, + 0x40, 0x2f, 0x6f, 0xe5, 0x31, 0x6b, 0xd6, 0x84, 0x40, 0x37, 0x60, 0x91, 0x84, 0x76, 0x13, 0x53, + 0x16, 0x22, 0x46, 0x42, 0x85, 0x4c, 0x9f, 0x4c, 0xbf, 0x06, 0x79, 0x6e, 0x8e, 0x58, 0x27, 0xc4, + 0x02, 0x96, 0xbc, 0xd5, 0x13, 0xf4, 0x61, 0x36, 0x7b, 0x81, 0x98, 0x29, 0x94, 0x92, 0x48, 0xc4, + 0x28, 0xfd, 0x27, 0x0b, 0x6b, 0x31, 0x82, 0x4f, 0xc4, 0x06, 0x87, 0x2d, 0xe4, 0xf9, 0xfa, 0x36, + 0x2c, 0xe0, 0x53, 0x1c, 0xb0, 0x7a, 0x12, 0x30, 0x10, 0x22, 0xd1, 0x26, 0xfa, 0x2e, 0xac, 0x72, + 0x38, 0x1a, 0x2d, 0x62, 0x9f, 0xd4, 0x9b, 0xd8, 0x73, 0x9b, 0x12, 0xb7, 0x9c, 0xb5, 0x8c, 0x59, + 0xb3, 0xc2, 0xc5, 0x0f, 0x85, 0x34, 0x05, 0xdf, 0x6c, 0x1a, 0xbe, 0x6f, 0xc7, 0x95, 0x29, 0xa0, + 0xab, 0x6c, 0xf2, 0x43, 0x7d, 0x76, 0xb6, 0x7d, 0x45, 0x16, 0x28, 0x75, 0x4e, 0xca, 0x1e, 0x31, + 0x7d, 0xc4, 0x9a, 0xe5, 0xe3, 0x80, 0xc5, 0x75, 0x79, 0x0b, 0x56, 0x30, 0x6b, 0xe2, 0x10, 0x77, + 0xfc, 0xba, 0xac, 0x0a, 0x85, 0xec, 0x72, 0x24, 0xae, 0x09, 0x29, 0x57, 0x94, 0x08, 0xd6, 0x43, + 0x6c, 0x63, 0xef, 0x14, 0x87, 0x02, 0xe5, 0xbc, 0xb5, 0x2c, 0xc5, 0x96, 0x92, 0x0e, 0x65, 0x72, + 0x2e, 0x25, 0x93, 0xe9, 0xdd, 0x30, 0x3f, 0x45, 0x37, 0xe4, 0xbf, 0xd0, 0x08, 0xb9, 0x01, 0x8b, + 0x72, 0xce, 0xa9, 0xbc, 0x80, 0x40, 0x7c, 0x41, 0xca, 0x64, 0x62, 0x36, 0x01, 0x6c, 0xe2, 0xb7, + 0x11, 0xa5, 0x3c, 0xa4, 0x05, 0x59, 0x65, 0x4a, 0x72, 0xec, 0x0c, 0xd6, 0xc6, 0x16, 0x5c, 0x4b, + 0xcb, 0x7f, 0x5c, 0x20, 0x1f, 0x66, 0xa1, 0x50, 0xa5, 0xae, 0xa8, 0x9a, 0x64, 0x9f, 0x5d, 0x78, + 0x95, 0x6c, 0xc3, 0x42, 0x83, 0x6f, 0x52, 0x4f, 0x0e, 0x3d, 0x10, 0xa2, 0x47, 0x23, 0xda, 0x34, + 0x97, 0x56, 0x46, 0xe9, 0x99, 0x99, 0x19, 0x91, 0x99, 0xc1, 0x5c, 0xcf, 0xa6, 0xe4, 0x3a, 0x99, + 0xbd, 0xb9, 0x0b, 0xcd, 0xde, 0xfc, 0xa4, 0xec, 0xe5, 0x27, 0x64, 0xef, 0xff, 0xe0, 0xc6, 0xc8, + 0xe4, 0xc4, 0x29, 0xfc, 0x8d, 0x06, 0x57, 0x78, 0xff, 0xa3, 0xc0, 0xc6, 0xad, 0xbe, 0x7b, 0x82, + 0x43, 0x1a, 0xa2, 0x80, 0x22, 0x9b, 0x5f, 0xde, 0x7c, 0x43, 0x99, 0xc1, 0xa5, 0x84, 0x74, 0xa0, + 0x7c, 0xb3, 0x17, 0x3b, 0xcc, 0x33, 0xab, 0xd9, 0x78, 0x98, 0x6f, 0xc3, 0x66, 0x6a, 0x98, 0xf1, + 0x41, 0x3e, 0xca, 0x08, 0x8d, 0x5a, 0xa7, 0xe1, 0x7b, 0xac, 0x82, 0x9c, 0x5a, 0x34, 0x3a, 0x8f, + 0x4e, 0x3d, 0x87, 0x27, 0x54, 0x7f, 0x00, 0x73, 0xb4, 0xd3, 0xf8, 0x01, 0xb6, 0x99, 0xba, 0xaa, + 0xd7, 0xca, 0x92, 0x6e, 0x94, 0x23, 0xba, 0x51, 0x7e, 0x37, 0xe8, 0x56, 0x56, 0xff, 0xfc, 0x71, + 0x69, 0x51, 0x3a, 0x17, 0xd3, 0xdb, 0xb1, 0x22, 0xb3, 0xfe, 0x11, 0x9d, 0x19, 0x1c, 0xd1, 0x45, + 0x50, 0xc1, 0xca, 0x11, 0x56, 0xc9, 0x6c, 0x68, 0x51, 0xf8, 0xff, 0x23, 0x17, 0xa4, 0x71, 0x0b, + 0x6e, 0x8e, 0xc5, 0x28, 0x46, 0xb3, 0x0a, 0x57, 0x8f, 0x78, 0xa3, 0xd6, 0x30, 0x7b, 0xdc, 0xc6, + 0xa2, 0xd4, 0xdf, 0x75, 0x9c, 0x10, 0x53, 0xaa, 0x6f, 0xc0, 0x9c, 0x8f, 0x29, 0x45, 0xae, 0x6c, + 0xe9, 0xbc, 0x15, 0x7d, 0xe5, 0x2b, 0x48, 0x2a, 0x45, 0xc4, 0x42, 0x7d, 0x35, 0x1e, 0xc1, 0x65, + 0xe1, 0x4e, 0x14, 0xe3, 0x61, 0x88, 0x11, 0xc3, 0xce, 0x18, 0x47, 0x03, 0xed, 0x2e, 0x9d, 0x25, + 0xda, 0xdd, 0xf8, 0x3e, 0xac, 0x25, 0xfc, 0xc9, 0xbb, 0xeb, 0x7d, 0xdc, 0x1d, 0xe3, 0xf2, 0x36, + 0x5c, 0x96, 0x2e, 0x6d, 0xa9, 0x5d, 0x3f, 0xc1, 0x5d, 0xe5, 0x78, 0xa5, 0xd1, 0xef, 0xc5, 0xb8, + 0x03, 0x6f, 0xf6, 0xbc, 0x0f, 0xcf, 0xb5, 0x3e, 0xa2, 0x90, 0x57, 0x44, 0xc1, 0x68, 0x01, 0x08, + 0x23, 0xa9, 0x33, 0x3a, 0x10, 0xde, 0xc3, 0x5c, 0xa5, 0xde, 0x44, 0xb4, 0x19, 0x15, 0x91, 0x90, + 0x3c, 0x44, 0xb4, 0xc9, 0xbb, 0x0e, 0x31, 0x86, 0xa9, 0xa4, 0xcc, 0xbc, 0x48, 0xd4, 0x7d, 0x98, + 0x90, 0x1e, 0x3b, 0xc6, 0x2f, 0x34, 0x28, 0xa8, 0x18, 0x53, 0x2a, 0x7d, 0x02, 0x0c, 0x4e, 0x3d, + 0xe2, 0x2a, 0xc9, 0x4a, 0x5e, 0x69, 0x20, 0xe7, 0x48, 0x32, 0x16, 0x59, 0xcf, 0x5f, 0x83, 0xc2, + 0x90, 0x6e, 0x3d, 0xea, 0x20, 0x19, 0xd5, 0xfa, 0x80, 0x4d, 0x4d, 0xae, 0x1a, 0xbf, 0xd6, 0xa0, + 0x28, 0xc2, 0xab, 0x76, 0x5a, 0xcc, 0xa3, 0x9e, 0xfb, 0x9d, 0xb6, 0x83, 0x78, 0xb3, 0xfe, 0xb0, + 0xc3, 0x79, 0xe6, 0x2d, 0x58, 0x69, 0x84, 0x9e, 0xe3, 0xe2, 0xde, 0xb8, 0x96, 0x71, 0x2e, 0x4b, + 0x71, 0x3c, 0xaf, 0x77, 0x7a, 0x8a, 0xa2, 0x7b, 0x62, 0x46, 0xbc, 0xa4, 0x14, 0xb9, 0xf4, 0xd8, + 0xe1, 0x05, 0xe3, 0xab, 0x9d, 0x7a, 0x90, 0x41, 0x24, 0x4a, 0xf2, 0xe5, 0x5c, 0x32, 0x67, 0xdf, + 0x80, 0x75, 0x59, 0xe5, 0x71, 0xfc, 0x2d, 0x44, 0x9b, 0x5e, 0xe0, 0xea, 0x3a, 0xe4, 0xf8, 0x5b, + 0x41, 0x85, 0x25, 0x3e, 0x8f, 0x29, 0xef, 0x8a, 0x2a, 0xef, 0xc7, 0x1d, 0xe6, 0x12, 0x2f, 0x70, + 0x9f, 0x3e, 0x3f, 0x1e, 0x57, 0xde, 0x6f, 0xc0, 0x0c, 0x7b, 0xde, 0x3b, 0x4b, 0x8e, 0x3d, 0x3f, + 0x76, 0x8c, 0xcf, 0x25, 0x55, 0x97, 0x40, 0x3d, 0x11, 0xef, 0x19, 0xfd, 0xab, 0x90, 0x47, 0x1d, + 0xd6, 0x24, 0xa1, 0xc7, 0xba, 0xd2, 0x49, 0x65, 0xe3, 0x2f, 0x1f, 0x97, 0xd6, 0x14, 0x2b, 0x57, + 0x1d, 0x59, 0x63, 0xa1, 0x17, 0xb8, 0x56, 0x4f, 0x55, 0x7f, 0x07, 0x66, 0xe5, 0x8b, 0x48, 0xec, + 0xb0, 0x70, 0x70, 0xa3, 0x3c, 0xf2, 0x55, 0x58, 0x96, 0x5b, 0x45, 0x7c, 0x5e, 0x9a, 0x5d, 0xe0, + 0x50, 0x5f, 0xe6, 0x03, 0xa8, 0x17, 0x9a, 0xa2, 0x9b, 0xc9, 0x53, 0xc6, 0x33, 0xe7, 0xdf, 0x59, + 0x71, 0x15, 0x7d, 0x9b, 0xdf, 0xf8, 0x8f, 0x88, 0x83, 0x6b, 0xa8, 0xa5, 0x3a, 0xee, 0xe2, 0x5e, + 0x59, 0x03, 0x9c, 0x24, 0x33, 0x15, 0x27, 0xc9, 0xa6, 0x72, 0x92, 0x69, 0x38, 0xfd, 0xf9, 0xf8, + 0xc6, 0x20, 0x03, 0x98, 0x1d, 0x66, 0x00, 0xef, 0xc0, 0xb2, 0xdd, 0xf2, 0xf8, 0x01, 0xa2, 0x52, + 0x9c, 0x9b, 0x50, 0x16, 0x4b, 0x52, 0x3f, 0x9a, 0xde, 0x3d, 0x22, 0x3d, 0x7f, 0x1e, 0x22, 0xfd, + 0x16, 0xac, 0x53, 0x1f, 0x85, 0x2c, 0x6e, 0xd8, 0x78, 0x7f, 0xc9, 0x42, 0xd6, 0xc4, 0x6a, 0xd4, + 0xb7, 0xd1, 0x66, 0xfd, 0x7c, 0x05, 0x26, 0xf0, 0x95, 0x7f, 0x68, 0xf0, 0x46, 0x95, 0xba, 0x47, + 0x94, 0x79, 0x3e, 0x62, 0x58, 0x4c, 0xdf, 0x6f, 0x22, 0x7a, 0x81, 0xd9, 0x8f, 0xa7, 0x40, 0x66, + 0xfc, 0x13, 0x2f, 0x3b, 0xf9, 0x89, 0x97, 0x1b, 0x7c, 0xe2, 0x15, 0x61, 0x1e, 0xab, 0xc8, 0x45, + 0x82, 0x73, 0x56, 0xfc, 0x7d, 0xf0, 0xa0, 0x1f, 0x65, 0xd4, 0xcb, 0x94, 0x1d, 0x59, 0x87, 0x07, + 0x7b, 0x4f, 0xc9, 0x53, 0xbe, 0xd1, 0x7b, 0x38, 0x20, 0xbe, 0xfe, 0xbd, 0xd7, 0x3e, 0xec, 0x55, + 0x7e, 0xd8, 0x57, 0x67, 0xdb, 0x2b, 0x5d, 0xe4, 0xb7, 0xee, 0x1b, 0xf1, 0x6e, 0x89, 0xf3, 0xef, + 0xc0, 0x8c, 0xc3, 0x77, 0x91, 0x83, 0xa7, 0xb2, 0xfa, 0xea, 0x6c, 0x7b, 0x51, 0x6a, 0x0b, 0xb1, + 0x61, 0xc9, 0x65, 0xfd, 0xfd, 0xd4, 0xb2, 0x95, 0xac, 0x66, 0xf3, 0xd5, 0xd9, 0x76, 0x41, 0x1a, + 0x0d, 0xeb, 0x18, 0x29, 0x55, 0xbd, 0x03, 0x33, 0x38, 0xb4, 0x0f, 0xf6, 0xd4, 0xcb, 0x2d, 0xb1, + 0xa9, 0x10, 0x1b, 0x96, 0x5c, 0x1e, 0x00, 0xe9, 0xe0, 0x8f, 0xcb, 0x90, 0xad, 0x52, 0x57, 0xff, + 0x95, 0x06, 0x8b, 0x7d, 0xbc, 0xf4, 0xf6, 0x98, 0x61, 0x36, 0xf0, 0xde, 0x2f, 0x1e, 0x4c, 0xaf, + 0x1b, 0x8f, 0xa1, 0xfd, 0x0f, 0xfe, 0xfa, 0xf9, 0xcf, 0x32, 0x5f, 0x36, 0xbe, 0x64, 0x8e, 0xfe, + 0x3f, 0x12, 0x67, 0x75, 0x25, 0x46, 0x4a, 0xa1, 0x0c, 0xe9, 0x97, 0x1a, 0x2c, 0xf6, 0xfd, 0x2f, + 0x61, 0x42, 0x8c, 0x49, 0xdd, 0x49, 0x31, 0xa6, 0xbe, 0xcc, 0xf7, 0x44, 0x8c, 0xb7, 0x8d, 0xdd, + 0x31, 0x31, 0x2a, 0xa2, 0x53, 0x12, 0xec, 0x46, 0xff, 0xa9, 0x06, 0xab, 0x43, 0x9d, 0x55, 0x1e, + 0xbf, 0xf5, 0xa0, 0x7e, 0x71, 0x7d, 0x88, 0x30, 0x1f, 0xf9, 0x6d, 0xd6, 0x35, 0xde, 0x16, 0xe1, + 0x98, 0x46, 0x69, 0x4c, 0x38, 0x51, 0x33, 0xc8, 0x78, 0x4a, 0x2e, 0xa2, 0xfa, 0xef, 0x34, 0xb8, + 0x3c, 0xfc, 0xcf, 0x05, 0x73, 0x9a, 0x9c, 0x25, 0x0c, 0x8a, 0x77, 0xcf, 0x69, 0x10, 0xa3, 0x78, + 0x57, 0x84, 0xbd, 0x6f, 0x98, 0x53, 0x64, 0x5a, 0x4a, 0x4b, 0x82, 0xa8, 0xe9, 0x7f, 0xd2, 0x60, + 0x7d, 0x04, 0x39, 0x7c, 0x6b, 0x7c, 0x30, 0xe9, 0x56, 0xc5, 0xaf, 0xbf, 0x8e, 0xd5, 0xb9, 0xce, + 0x21, 0x51, 0x1f, 0xa8, 0xdb, 0x3f, 0x68, 0xa0, 0xa7, 0xbc, 0xfc, 0xf6, 0x26, 0x54, 0xe4, 0x90, + 0x45, 0xf1, 0xde, 0x79, 0x2d, 0xe2, 0xd8, 0xef, 0x89, 0xd8, 0x0f, 0x8c, 0xbd, 0x71, 0x95, 0x2c, + 0xcc, 0x07, 0x83, 0xff, 0x4c, 0x83, 0xe2, 0x98, 0xd7, 0xde, 0x84, 0x90, 0x46, 0x5b, 0x16, 0x1f, + 0xbc, 0xae, 0x65, 0x7c, 0xa8, 0x07, 0xe2, 0x50, 0xf7, 0x8d, 0x7b, 0xe3, 0x0a, 0x4b, 0xb8, 0x29, + 0x35, 0x90, 0x53, 0x8a, 0xd9, 0x75, 0x09, 0x47, 0xd1, 0xf3, 0x89, 0xd2, 0x47, 0x05, 0x27, 0x4c, + 0x94, 0xa4, 0xee, 0xa4, 0x89, 0x92, 0x4a, 0xbe, 0xa6, 0x99, 0x28, 0x1d, 0x61, 0x58, 0x52, 0x1c, + 0xf1, 0xe7, 0x1a, 0xe8, 0x29, 0x5c, 0x6d, 0x42, 0xf1, 0x0c, 0x5b, 0x8c, 0x9c, 0x2a, 0xd3, 0x94, + 0x46, 0x8b, 0xbb, 0x2b, 0x05, 0xc4, 0xc1, 0x25, 0x8a, 0x5a, 0x58, 0xf5, 0xe7, 0x87, 0x1a, 0xac, + 0xa5, 0xde, 0xae, 0x13, 0xef, 0x83, 0x61, 0x9b, 0x91, 0xe1, 0x4d, 0xd3, 0x75, 0xe2, 0x66, 0xe3, + 0x35, 0x2b, 0xa8, 0x44, 0x49, 0xde, 0xae, 0x0e, 0x5c, 0x89, 0x7e, 0x47, 0x10, 0xa4, 0x2e, 0xfe, + 0x31, 0xe1, 0xce, 0xf8, 0xe8, 0x52, 0x7f, 0x81, 0x18, 0x15, 0x5e, 0xe5, 0xf8, 0x93, 0x17, 0x5b, + 0xda, 0xa7, 0x2f, 0xb6, 0xb4, 0xbf, 0xbf, 0xd8, 0xd2, 0x7e, 0xf2, 0x72, 0xeb, 0xd2, 0xa7, 0x2f, + 0xb7, 0x2e, 0xfd, 0xed, 0xe5, 0xd6, 0xa5, 0xef, 0x9a, 0xae, 0xc7, 0x9a, 0x9d, 0x46, 0xd9, 0x26, + 0x7e, 0x5a, 0xe8, 0xa7, 0x07, 0xe6, 0xf3, 0xbe, 0xdf, 0x4b, 0x1a, 0xb3, 0xc2, 0xf5, 0x9d, 0xff, + 0x06, 0x00, 0x00, 0xff, 0xff, 0x21, 0x5b, 0xb9, 0xfc, 0x82, 0x1a, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1937,6 +2022,7 @@ type MsgClient interface { SubmitBadSignatureEvidence(ctx context.Context, in *MsgSubmitBadSignatureEvidence, opts ...grpc.CallOption) (*MsgSubmitBadSignatureEvidenceResponse, error) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) LightNodeSaleClaim(ctx context.Context, in *MsgLightNodeSaleClaim, opts ...grpc.CallOption) (*emptypb.Empty, error) + SetERC20ToTokenDenom(ctx context.Context, in *MsgSetERC20ToTokenDenom, opts ...grpc.CallOption) (*emptypb.Empty, error) OverrideNonceProposal(ctx context.Context, in *MsgNonceOverrideProposal, opts ...grpc.CallOption) (*emptypb.Empty, error) } @@ -2029,6 +2115,15 @@ func (c *msgClient) LightNodeSaleClaim(ctx context.Context, in *MsgLightNodeSale return out, nil } +func (c *msgClient) SetERC20ToTokenDenom(ctx context.Context, in *MsgSetERC20ToTokenDenom, opts ...grpc.CallOption) (*emptypb.Empty, error) { + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, "/palomachain.paloma.skyway.Msg/SetERC20ToTokenDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *msgClient) OverrideNonceProposal(ctx context.Context, in *MsgNonceOverrideProposal, opts ...grpc.CallOption) (*emptypb.Empty, error) { out := new(emptypb.Empty) err := c.cc.Invoke(ctx, "/palomachain.paloma.skyway.Msg/OverrideNonceProposal", in, out, opts...) @@ -2049,6 +2144,7 @@ type MsgServer interface { SubmitBadSignatureEvidence(context.Context, *MsgSubmitBadSignatureEvidence) (*MsgSubmitBadSignatureEvidenceResponse, error) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) LightNodeSaleClaim(context.Context, *MsgLightNodeSaleClaim) (*emptypb.Empty, error) + SetERC20ToTokenDenom(context.Context, *MsgSetERC20ToTokenDenom) (*emptypb.Empty, error) OverrideNonceProposal(context.Context, *MsgNonceOverrideProposal) (*emptypb.Empty, error) } @@ -2091,6 +2187,10 @@ func (*UnimplementedMsgServer) LightNodeSaleClaim(ctx context.Context, req *MsgL return nil, status.Errorf(codes.Unimplemented, "method LightNodeSaleClaim not implemented") } +func (*UnimplementedMsgServer) SetERC20ToTokenDenom(ctx context.Context, req *MsgSetERC20ToTokenDenom) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetERC20ToTokenDenom not implemented") +} + func (*UnimplementedMsgServer) OverrideNonceProposal(ctx context.Context, req *MsgNonceOverrideProposal) (*emptypb.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method OverrideNonceProposal not implemented") } @@ -2261,6 +2361,24 @@ func _Msg_LightNodeSaleClaim_Handler(srv interface{}, ctx context.Context, dec f return interceptor(ctx, in, info, handler) } +func _Msg_SetERC20ToTokenDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSetERC20ToTokenDenom) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).SetERC20ToTokenDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/palomachain.paloma.skyway.Msg/SetERC20ToTokenDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).SetERC20ToTokenDenom(ctx, req.(*MsgSetERC20ToTokenDenom)) + } + return interceptor(ctx, in, info, handler) +} + func _Msg_OverrideNonceProposal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(MsgNonceOverrideProposal) if err := dec(in); err != nil { @@ -2319,6 +2437,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "LightNodeSaleClaim", Handler: _Msg_LightNodeSaleClaim_Handler, }, + { + MethodName: "SetERC20ToTokenDenom", + Handler: _Msg_SetERC20ToTokenDenom_Handler, + }, { MethodName: "OverrideNonceProposal", Handler: _Msg_OverrideNonceProposal_Handler, @@ -3496,6 +3618,60 @@ func (m *MsgEstimateBatchGas) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *MsgSetERC20ToTokenDenom) 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 *MsgSetERC20ToTokenDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSetERC20ToTokenDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Erc20) > 0 { + i -= len(m.Erc20) + copy(dAtA[i:], m.Erc20) + i = encodeVarintMsgs(dAtA, i, uint64(len(m.Erc20))) + i-- + dAtA[i] = 0x22 + } + if len(m.ChainReferenceId) > 0 { + i -= len(m.ChainReferenceId) + copy(dAtA[i:], m.ChainReferenceId) + i = encodeVarintMsgs(dAtA, i, uint64(len(m.ChainReferenceId))) + i-- + dAtA[i] = 0x1a + } + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintMsgs(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0x12 + } + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintMsgs(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func encodeVarintMsgs(dAtA []byte, offset int, v uint64) int { offset -= sovMsgs(v) base := offset @@ -4015,6 +4191,29 @@ func (m *MsgEstimateBatchGas) Size() (n int) { return n } +func (m *MsgSetERC20ToTokenDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metadata.Size() + n += 1 + l + sovMsgs(uint64(l)) + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovMsgs(uint64(l)) + } + l = len(m.ChainReferenceId) + if l > 0 { + n += 1 + l + sovMsgs(uint64(l)) + } + l = len(m.Erc20) + if l > 0 { + n += 1 + l + sovMsgs(uint64(l)) + } + return n +} + func sovMsgs(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -7702,6 +7901,186 @@ func (m *MsgEstimateBatchGas) Unmarshal(dAtA []byte) error { return nil } +func (m *MsgSetERC20ToTokenDenom) 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 ErrIntOverflowMsgs + } + 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: MsgSetERC20ToTokenDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSetERC20ToTokenDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMsgs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMsgs + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthMsgs + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMsgs + } + 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 ErrInvalidLengthMsgs + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMsgs + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainReferenceId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMsgs + } + 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 ErrInvalidLengthMsgs + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMsgs + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainReferenceId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Erc20", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMsgs + } + 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 ErrInvalidLengthMsgs + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMsgs + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Erc20 = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMsgs(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMsgs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + func skipMsgs(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/msgs.pb.gw.go b/x/skyway/types/msgs.pb.gw.go index 6c5b66ad..92c9886c 100644 --- a/x/skyway/types/msgs.pb.gw.go +++ b/x/skyway/types/msgs.pb.gw.go @@ -25,18 +25,18 @@ import ( ) // 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 - var ( - filter_Msg_SendToRemote_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + _ codes.Code + _ io.Reader + _ status.Status + _ = runtime.String + _ = utilities.NewDoubleArray + _ = descriptor.ForMessage + _ = metadata.Join ) +var filter_Msg_SendToRemote_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + func request_Msg_SendToRemote_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgSendToRemote var metadata runtime.ServerMetadata @@ -50,7 +50,6 @@ func request_Msg_SendToRemote_0(ctx context.Context, marshaler runtime.Marshaler msg, err := client.SendToRemote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_SendToRemote_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -66,12 +65,9 @@ func local_request_Msg_SendToRemote_0(ctx context.Context, marshaler runtime.Mar msg, err := server.SendToRemote(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Msg_ConfirmBatch_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Msg_ConfirmBatch_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Msg_ConfirmBatch_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgConfirmBatch @@ -86,7 +82,6 @@ func request_Msg_ConfirmBatch_0(ctx context.Context, marshaler runtime.Marshaler msg, err := client.ConfirmBatch(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_ConfirmBatch_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -102,12 +97,9 @@ func local_request_Msg_ConfirmBatch_0(ctx context.Context, marshaler runtime.Mar msg, err := server.ConfirmBatch(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Msg_EstimateBatchGas_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Msg_EstimateBatchGas_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Msg_EstimateBatchGas_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgEstimateBatchGas @@ -122,7 +114,6 @@ func request_Msg_EstimateBatchGas_0(ctx context.Context, marshaler runtime.Marsh msg, err := client.EstimateBatchGas(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_EstimateBatchGas_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -138,12 +129,9 @@ func local_request_Msg_EstimateBatchGas_0(ctx context.Context, marshaler runtime msg, err := server.EstimateBatchGas(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Msg_SendToPalomaClaim_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Msg_SendToPalomaClaim_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Msg_SendToPalomaClaim_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgSendToPalomaClaim @@ -158,7 +146,6 @@ func request_Msg_SendToPalomaClaim_0(ctx context.Context, marshaler runtime.Mars msg, err := client.SendToPalomaClaim(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_SendToPalomaClaim_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -174,12 +161,9 @@ func local_request_Msg_SendToPalomaClaim_0(ctx context.Context, marshaler runtim msg, err := server.SendToPalomaClaim(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Msg_BatchSendToRemoteClaim_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Msg_BatchSendToRemoteClaim_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Msg_BatchSendToRemoteClaim_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgBatchSendToRemoteClaim @@ -194,7 +178,6 @@ func request_Msg_BatchSendToRemoteClaim_0(ctx context.Context, marshaler runtime msg, err := client.BatchSendToRemoteClaim(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_BatchSendToRemoteClaim_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -210,12 +193,9 @@ func local_request_Msg_BatchSendToRemoteClaim_0(ctx context.Context, marshaler r msg, err := server.BatchSendToRemoteClaim(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Msg_CancelSendToRemote_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Msg_CancelSendToRemote_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Msg_CancelSendToRemote_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgCancelSendToRemote @@ -230,7 +210,6 @@ func request_Msg_CancelSendToRemote_0(ctx context.Context, marshaler runtime.Mar msg, err := client.CancelSendToRemote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_CancelSendToRemote_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -246,12 +225,9 @@ func local_request_Msg_CancelSendToRemote_0(ctx context.Context, marshaler runti msg, err := server.CancelSendToRemote(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Msg_SubmitBadSignatureEvidence_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Msg_SubmitBadSignatureEvidence_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Msg_SubmitBadSignatureEvidence_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgSubmitBadSignatureEvidence @@ -266,7 +242,6 @@ func request_Msg_SubmitBadSignatureEvidence_0(ctx context.Context, marshaler run msg, err := client.SubmitBadSignatureEvidence(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_SubmitBadSignatureEvidence_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -282,12 +257,9 @@ func local_request_Msg_SubmitBadSignatureEvidence_0(ctx context.Context, marshal msg, err := server.SubmitBadSignatureEvidence(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Msg_UpdateParams_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Msg_UpdateParams_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Msg_UpdateParams_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgUpdateParams @@ -302,7 +274,6 @@ func request_Msg_UpdateParams_0(ctx context.Context, marshaler runtime.Marshaler msg, err := client.UpdateParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_UpdateParams_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -318,12 +289,9 @@ func local_request_Msg_UpdateParams_0(ctx context.Context, marshaler runtime.Mar msg, err := server.UpdateParams(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Msg_LightNodeSaleClaim_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Msg_LightNodeSaleClaim_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Msg_LightNodeSaleClaim_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgLightNodeSaleClaim @@ -338,7 +306,6 @@ func request_Msg_LightNodeSaleClaim_0(ctx context.Context, marshaler runtime.Mar msg, err := client.LightNodeSaleClaim(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Msg_LightNodeSaleClaim_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -354,7 +321,38 @@ func local_request_Msg_LightNodeSaleClaim_0(ctx context.Context, marshaler runti msg, err := server.LightNodeSaleClaim(ctx, &protoReq) return msg, metadata, err +} + +var filter_Msg_SetERC20ToTokenDenom_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_SetERC20ToTokenDenom_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgSetERC20ToTokenDenom + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_SetERC20ToTokenDenom_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.SetERC20ToTokenDenom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_SetERC20ToTokenDenom_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgSetERC20ToTokenDenom + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_SetERC20ToTokenDenom_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := server.SetERC20ToTokenDenom(ctx, &protoReq) + return msg, metadata, err } // RegisterMsgHandlerServer registers the http handlers for service Msg to "mux". @@ -362,7 +360,6 @@ func local_request_Msg_LightNodeSaleClaim_0(ctx context.Context, marshaler runti // 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 RegisterMsgHandlerFromEndpoint instead. func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MsgServer) error { - mux.Handle("POST", pattern_Msg_SendToRemote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -383,7 +380,6 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_SendToRemote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_ConfirmBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -406,7 +402,6 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_ConfirmBatch_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_EstimateBatchGas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -429,7 +424,6 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_EstimateBatchGas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_SendToPalomaClaim_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -452,7 +446,6 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_SendToPalomaClaim_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_BatchSendToRemoteClaim_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -475,7 +468,6 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_BatchSendToRemoteClaim_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_CancelSendToRemote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -498,7 +490,6 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_CancelSendToRemote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_SubmitBadSignatureEvidence_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -521,7 +512,6 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_SubmitBadSignatureEvidence_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_UpdateParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -544,7 +534,6 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_UpdateParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_LightNodeSaleClaim_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -567,7 +556,28 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server } forward_Msg_LightNodeSaleClaim_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle("POST", pattern_Msg_SetERC20ToTokenDenom_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_Msg_SetERC20ToTokenDenom_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_Msg_SetERC20ToTokenDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) return nil @@ -610,7 +620,6 @@ func RegisterMsgHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.C // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in // "MsgClient" to call the correct interceptors. func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MsgClient) error { - mux.Handle("POST", pattern_Msg_SendToRemote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -628,7 +637,6 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_SendToRemote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_ConfirmBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -648,7 +656,6 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_ConfirmBatch_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_EstimateBatchGas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -668,7 +675,6 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_EstimateBatchGas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_SendToPalomaClaim_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -688,7 +694,6 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_SendToPalomaClaim_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_BatchSendToRemoteClaim_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -708,7 +713,6 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_BatchSendToRemoteClaim_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_CancelSendToRemote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -728,7 +732,6 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_CancelSendToRemote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_SubmitBadSignatureEvidence_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -748,7 +751,6 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_SubmitBadSignatureEvidence_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_UpdateParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -768,7 +770,6 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_UpdateParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("POST", pattern_Msg_LightNodeSaleClaim_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -788,7 +789,25 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client } forward_Msg_LightNodeSaleClaim_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle("POST", pattern_Msg_SetERC20ToTokenDenom_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_Msg_SetERC20ToTokenDenom_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_SetERC20ToTokenDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) return nil @@ -812,6 +831,8 @@ var ( pattern_Msg_UpdateParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "skyway", "update-params"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Msg_LightNodeSaleClaim_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "skyway", "light-node-sale-claim"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Msg_SetERC20ToTokenDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"palomachain", "paloma", "skyway", "erc20-to-token-denom"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( @@ -832,4 +853,6 @@ var ( forward_Msg_UpdateParams_0 = runtime.ForwardResponseMessage forward_Msg_LightNodeSaleClaim_0 = runtime.ForwardResponseMessage + + forward_Msg_SetERC20ToTokenDenom_0 = runtime.ForwardResponseMessage ) diff --git a/x/skyway/types/params.pb.go b/x/skyway/types/params.pb.go index b41d62ed..88d67e9e 100644 --- a/x/skyway/types/params.pb.go +++ b/x/skyway/types/params.pb.go @@ -5,18 +5,21 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -27,8 +30,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // The slashing fractions for the various skyway related slashing conditions. // The first three refer to not submitting a particular message, the third for // submitting a different claim for the same ethereum event -type Params struct { -} +type Params struct{} func (m *Params) Reset() { *m = Params{} } func (m *Params) String() string { return proto.CompactTextString(m) } @@ -36,9 +38,11 @@ func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_9ec5e4b3ac5cfb2a, []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) @@ -51,12 +55,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 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) } @@ -72,27 +79,27 @@ func init() { } var fileDescriptor_9ec5e4b3ac5cfb2a = []byte{ - // 305 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0xb1, 0x4a, 0x03, 0x41, - 0x10, 0xbd, 0x83, 0x10, 0x24, 0x8d, 0x21, 0x44, 0x24, 0x11, 0x8e, 0x60, 0x61, 0x25, 0x77, 0x85, - 0x9d, 0xa5, 0x85, 0x85, 0x95, 0x6c, 0x69, 0xb3, 0xcc, 0xed, 0x8e, 0xb7, 0x4b, 0x72, 0x37, 0xc7, - 0xce, 0x9e, 0x31, 0x9d, 0x9f, 0xe0, 0x67, 0x59, 0xa6, 0xb4, 0xb0, 0x90, 0x1c, 0xf8, 0x1d, 0x72, - 0xb7, 0x46, 0x02, 0xda, 0xbd, 0x7d, 0xef, 0xcd, 0xce, 0x63, 0xde, 0xe8, 0xa2, 0x86, 0x15, 0x95, - 0xa0, 0x0c, 0xd8, 0x2a, 0x0b, 0x38, 0xe3, 0xe5, 0x66, 0x0d, 0x9b, 0xac, 0x06, 0x07, 0x25, 0xa7, - 0xb5, 0x23, 0x4f, 0x93, 0xd9, 0x81, 0x2f, 0x0d, 0x38, 0x0d, 0xbe, 0xf9, 0xb4, 0xa0, 0x82, 0x7a, - 0x57, 0xd6, 0xa1, 0x30, 0x30, 0x9f, 0x29, 0xe2, 0x92, 0x58, 0x06, 0x21, 0x3c, 0x82, 0x74, 0xfe, - 0x15, 0x8f, 0x86, 0xf7, 0xfd, 0xe7, 0xd7, 0x83, 0x97, 0x8f, 0x45, 0x74, 0x37, 0x38, 0x8a, 0xc7, - 0x23, 0x31, 0x55, 0x54, 0x79, 0x07, 0xca, 0x4b, 0xa6, 0xc6, 0x29, 0x94, 0x06, 0xd8, 0x88, 0xd3, - 0xdc, 0x59, 0x5d, 0xa0, 0x44, 0x6f, 0xd0, 0x61, 0x53, 0x4a, 0xd0, 0xda, 0x21, 0xb3, 0x38, 0xfe, - 0x11, 0xfa, 0x48, 0xd2, 0x6a, 0x71, 0xc2, 0xb6, 0xa8, 0x50, 0xcb, 0x1c, 0xbc, 0x32, 0xc8, 0x72, - 0x6d, 0x2b, 0x4d, 0x6b, 0x31, 0xf6, 0xe0, 0x7a, 0x4a, 0x7a, 0x5b, 0x22, 0x35, 0x5e, 0x4c, 0xe0, - 0x09, 0x1d, 0x14, 0x28, 0xf3, 0x15, 0xa9, 0x65, 0x4f, 0x8b, 0xb3, 0x3d, 0xf7, 0xbb, 0xe7, 0x40, - 0x9c, 0xf2, 0x0a, 0xd8, 0xc8, 0xc7, 0x2e, 0x9c, 0xa5, 0x2a, 0x6c, 0x10, 0x8b, 0x3f, 0xac, 0xee, - 0xa6, 0x65, 0x17, 0x03, 0x7c, 0xe3, 0xf0, 0xe6, 0xf6, 0x6d, 0x97, 0xc4, 0xdb, 0x5d, 0x12, 0x7f, - 0xee, 0x92, 0xf8, 0xb5, 0x4d, 0xa2, 0x6d, 0x9b, 0x44, 0xef, 0x6d, 0x12, 0x3d, 0x5c, 0x16, 0xd6, - 0x9b, 0x26, 0x4f, 0x15, 0x95, 0xd9, 0x3f, 0x0d, 0x3c, 0xef, 0x3b, 0xf0, 0x9b, 0x1a, 0x39, 0x1f, - 0xf6, 0x77, 0xbb, 0xfa, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xee, 0x32, 0xc7, 0x14, 0xad, 0x01, 0x00, - 0x00, + // 309 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0xb1, 0x6a, 0xe3, 0x40, + 0x10, 0x95, 0xc0, 0x98, 0xc3, 0xcd, 0x19, 0xe3, 0xe3, 0xb0, 0x0f, 0x84, 0xb9, 0x22, 0xa5, 0x16, + 0x92, 0x2e, 0x65, 0xba, 0xa4, 0x0a, 0x5b, 0xa6, 0x59, 0x46, 0xbb, 0x13, 0xed, 0x62, 0x4b, 0x23, + 0x76, 0x56, 0x76, 0xdc, 0xe5, 0x13, 0xf2, 0x59, 0x29, 0x5d, 0xa6, 0x48, 0x11, 0x6c, 0xc8, 0x77, + 0x04, 0x69, 0xe3, 0x60, 0x48, 0xba, 0xb7, 0xef, 0xbd, 0xd9, 0x79, 0xcc, 0x1b, 0x9d, 0x35, 0xb0, + 0xa2, 0x0a, 0xb4, 0x05, 0x57, 0x8b, 0x88, 0x05, 0x2f, 0xb7, 0x1b, 0xd8, 0x8a, 0x06, 0x3c, 0x54, + 0x9c, 0x37, 0x9e, 0x02, 0x4d, 0x66, 0x27, 0xbe, 0x3c, 0xe2, 0x3c, 0xfa, 0xe6, 0xd3, 0x92, 0x4a, + 0xea, 0x5d, 0xa2, 0x43, 0x71, 0x60, 0x3e, 0xd3, 0xc4, 0x15, 0xb1, 0x8a, 0x42, 0x7c, 0x44, 0xe9, + 0xff, 0x7b, 0x3a, 0x1a, 0xde, 0xf6, 0x9f, 0x5f, 0x0e, 0x1e, 0x5f, 0x17, 0xc9, 0xcd, 0xe0, 0x57, + 0x3a, 0x1e, 0xc9, 0xa9, 0xa6, 0x3a, 0x78, 0xd0, 0x41, 0x31, 0xb5, 0x5e, 0xa3, 0xb2, 0xc0, 0x56, + 0xfe, 0x2d, 0xbc, 0x33, 0x25, 0x2a, 0x0c, 0x16, 0x3d, 0xb6, 0x95, 0x02, 0x63, 0x3c, 0x32, 0xcb, + 0xdf, 0x9f, 0x42, 0x1f, 0x49, 0x39, 0x23, 0xff, 0xb0, 0x2b, 0x6b, 0x34, 0xaa, 0x80, 0xa0, 0x2d, + 0xb2, 0xda, 0xb8, 0xda, 0xd0, 0x46, 0x8e, 0x03, 0xf8, 0x9e, 0x52, 0xc1, 0x55, 0x48, 0x6d, 0x90, + 0x13, 0x58, 0xa3, 0x87, 0x12, 0x55, 0xb1, 0x22, 0xbd, 0xec, 0x69, 0xf9, 0xef, 0xc8, 0x7d, 0xed, + 0x39, 0x11, 0xa7, 0xbc, 0x02, 0xb6, 0xea, 0xbe, 0x0b, 0xe7, 0xa8, 0x8e, 0x1b, 0xe4, 0xe2, 0x1b, + 0x6b, 0xba, 0x69, 0xd5, 0xc5, 0x80, 0xd0, 0x7a, 0xbc, 0xba, 0x7e, 0xde, 0x67, 0xe9, 0x6e, 0x9f, + 0xa5, 0x6f, 0xfb, 0x2c, 0x7d, 0x3a, 0x64, 0xc9, 0xee, 0x90, 0x25, 0x2f, 0x87, 0x2c, 0xb9, 0x13, + 0xa5, 0x0b, 0xb6, 0x2d, 0x72, 0x4d, 0x95, 0xf8, 0xa1, 0x81, 0xf5, 0xb9, 0x78, 0x38, 0xd6, 0x10, + 0xb6, 0x0d, 0x72, 0x31, 0xec, 0x4f, 0x77, 0xf1, 0x11, 0x00, 0x00, 0xff, 0xff, 0xb0, 0xd4, 0x1c, + 0x49, 0xb0, 0x01, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -129,6 +136,7 @@ func encodeVarintParams(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -141,9 +149,11 @@ func (m *Params) Size() (n int) { func sovParams(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozParams(x uint64) (n int) { return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -194,6 +204,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func skipParams(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/pool.pb.go b/x/skyway/types/pool.pb.go index ef9a57b3..d5f71748 100644 --- a/x/skyway/types/pool.pb.go +++ b/x/skyway/types/pool.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -34,9 +37,11 @@ func (*IDSet) ProtoMessage() {} func (*IDSet) Descriptor() ([]byte, []int) { return fileDescriptor_991a1dbac3810c79, []int{0} } + func (m *IDSet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *IDSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IDSet.Marshal(b, m, deterministic) @@ -49,12 +54,15 @@ func (m *IDSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *IDSet) XXX_Merge(src proto.Message) { xxx_messageInfo_IDSet.Merge(m, src) } + func (m *IDSet) XXX_Size() int { return m.Size() } + func (m *IDSet) XXX_DiscardUnknown() { xxx_messageInfo_IDSet.DiscardUnknown(m) } @@ -81,9 +89,11 @@ func (*EventWithdrawalReceived) ProtoMessage() {} func (*EventWithdrawalReceived) Descriptor() ([]byte, []int) { return fileDescriptor_991a1dbac3810c79, []int{1} } + func (m *EventWithdrawalReceived) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventWithdrawalReceived) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventWithdrawalReceived.Marshal(b, m, deterministic) @@ -96,12 +106,15 @@ func (m *EventWithdrawalReceived) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *EventWithdrawalReceived) XXX_Merge(src proto.Message) { xxx_messageInfo_EventWithdrawalReceived.Merge(m, src) } + func (m *EventWithdrawalReceived) XXX_Size() int { return m.Size() } + func (m *EventWithdrawalReceived) XXX_DiscardUnknown() { xxx_messageInfo_EventWithdrawalReceived.DiscardUnknown(m) } @@ -149,9 +162,11 @@ func (*EventWithdrawCanceled) ProtoMessage() {} func (*EventWithdrawCanceled) Descriptor() ([]byte, []int) { return fileDescriptor_991a1dbac3810c79, []int{2} } + func (m *EventWithdrawCanceled) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EventWithdrawCanceled) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EventWithdrawCanceled.Marshal(b, m, deterministic) @@ -164,12 +179,15 @@ func (m *EventWithdrawCanceled) XXX_Marshal(b []byte, deterministic bool) ([]byt return b[:n], nil } } + func (m *EventWithdrawCanceled) XXX_Merge(src proto.Message) { xxx_messageInfo_EventWithdrawCanceled.Merge(m, src) } + func (m *EventWithdrawCanceled) XXX_Size() int { return m.Size() } + func (m *EventWithdrawCanceled) XXX_DiscardUnknown() { xxx_messageInfo_EventWithdrawCanceled.DiscardUnknown(m) } @@ -215,28 +233,28 @@ func init() { } var fileDescriptor_991a1dbac3810c79 = []byte{ - // 331 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x91, 0xcf, 0x4a, 0xf3, 0x40, - 0x14, 0xc5, 0x3b, 0x5f, 0xd2, 0xc2, 0x37, 0x68, 0x95, 0xb1, 0x6a, 0xea, 0x22, 0x94, 0x52, 0xb4, - 0x0b, 0x49, 0x16, 0xbe, 0x81, 0x55, 0xa1, 0xdb, 0x2a, 0x08, 0x6e, 0xca, 0x74, 0xe6, 0x92, 0x0e, - 0xa6, 0x73, 0x43, 0x32, 0xfd, 0xf7, 0x16, 0x6e, 0x7c, 0x05, 0x9f, 0xc5, 0x65, 0x97, 0x2e, 0xa5, - 0x7d, 0x11, 0x49, 0x26, 0x45, 0x85, 0x2e, 0xdc, 0x9d, 0x7b, 0xe6, 0x37, 0x33, 0xe7, 0x72, 0x68, - 0x27, 0xe1, 0x31, 0x4e, 0xb8, 0x18, 0x73, 0xa5, 0x43, 0xab, 0xc3, 0xec, 0x79, 0x39, 0xe7, 0xcb, - 0x30, 0x41, 0x8c, 0x83, 0x24, 0x45, 0x83, 0xac, 0xf9, 0x83, 0x0a, 0xac, 0x0e, 0x2c, 0x75, 0xd6, - 0x88, 0x30, 0xc2, 0x82, 0x0a, 0x73, 0x65, 0x2f, 0xb4, 0x9b, 0xb4, 0xda, 0xbf, 0xb9, 0x07, 0xc3, - 0x0e, 0xa9, 0xa3, 0x64, 0xe6, 0x91, 0x96, 0xd3, 0x75, 0x07, 0xb9, 0x6c, 0xbf, 0x11, 0x7a, 0x7a, - 0x3b, 0x03, 0x6d, 0x1e, 0x95, 0x19, 0xcb, 0x94, 0xcf, 0x79, 0x3c, 0x00, 0x01, 0x6a, 0x06, 0x92, - 0x5d, 0xd0, 0x83, 0x51, 0xaa, 0x64, 0x04, 0x43, 0x81, 0xda, 0xa4, 0x5c, 0x18, 0x8f, 0xb4, 0x48, - 0xf7, 0xff, 0xa0, 0x6e, 0xed, 0x5e, 0xe9, 0xb2, 0xf3, 0x6f, 0x30, 0xcf, 0x34, 0x54, 0xd2, 0xfb, - 0x57, 0x80, 0xfb, 0x25, 0x98, 0xbb, 0x7d, 0xc9, 0x3a, 0xb4, 0x8e, 0x53, 0x13, 0xa1, 0xd2, 0xd1, - 0xd0, 0x2c, 0x72, 0xcc, 0x29, 0xb0, 0xbd, 0xad, 0xfb, 0xb0, 0xe8, 0x4b, 0xd6, 0xa0, 0x55, 0x8d, - 0x5a, 0x80, 0xe7, 0x16, 0x87, 0x76, 0x68, 0xbf, 0x12, 0x7a, 0xfc, 0x2b, 0x68, 0x8f, 0x6b, 0x01, - 0x31, 0x48, 0x76, 0x42, 0x6b, 0x19, 0x68, 0x09, 0x69, 0x99, 0xae, 0x9c, 0xd8, 0x11, 0xad, 0xda, - 0x4f, 0x6c, 0x16, 0xd7, 0xe4, 0x8f, 0xef, 0xd8, 0xc9, 0xf9, 0xeb, 0x4e, 0xee, 0x8e, 0x9d, 0xae, - 0xef, 0xde, 0xd7, 0x3e, 0x59, 0xad, 0x7d, 0xf2, 0xb9, 0xf6, 0xc9, 0xcb, 0xc6, 0xaf, 0xac, 0x36, - 0x7e, 0xe5, 0x63, 0xe3, 0x57, 0x9e, 0x2e, 0x23, 0x65, 0xc6, 0xd3, 0x51, 0x20, 0x70, 0x12, 0xee, - 0xe8, 0x75, 0xb1, 0x6d, 0xd6, 0x2c, 0x13, 0xc8, 0x46, 0xb5, 0xa2, 0xaa, 0xab, 0xaf, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x21, 0xe8, 0x38, 0xf9, 0x03, 0x02, 0x00, 0x00, + // 330 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x91, 0x3f, 0x4e, 0xc3, 0x30, + 0x18, 0xc5, 0x6b, 0x92, 0x56, 0xc2, 0x82, 0x82, 0x4c, 0x81, 0x94, 0x21, 0xaa, 0xaa, 0x0a, 0x3a, + 0xc5, 0x12, 0xdc, 0x80, 0xc2, 0x90, 0xb5, 0x20, 0x21, 0xb1, 0x54, 0xae, 0x6d, 0xa5, 0x16, 0xa9, + 0xbf, 0x28, 0x71, 0xff, 0xdd, 0x82, 0x85, 0x2b, 0x70, 0x16, 0xc6, 0x8e, 0x8c, 0xa8, 0xbd, 0x08, + 0x4a, 0x9c, 0x0a, 0x90, 0x32, 0xb0, 0xbd, 0xef, 0xf9, 0x67, 0xfb, 0x7d, 0x7a, 0xb8, 0x97, 0xb0, + 0x18, 0xa6, 0x8c, 0x4f, 0x98, 0xd2, 0xd4, 0x6a, 0x9a, 0xbd, 0xac, 0x16, 0x6c, 0x45, 0x13, 0x80, + 0x38, 0x48, 0x52, 0x30, 0x40, 0xda, 0xbf, 0xa8, 0xc0, 0xea, 0xc0, 0x52, 0x17, 0xad, 0x08, 0x22, + 0x28, 0x28, 0x9a, 0x2b, 0x7b, 0xa1, 0xdb, 0xc6, 0xf5, 0xf0, 0xee, 0x41, 0x1a, 0x72, 0x8c, 0x1d, + 0x25, 0x32, 0x0f, 0x75, 0x9c, 0xbe, 0x3b, 0xcc, 0x65, 0xf7, 0x1d, 0xe1, 0xf3, 0xfb, 0xb9, 0xd4, + 0xe6, 0x49, 0x99, 0x89, 0x48, 0xd9, 0x82, 0xc5, 0x43, 0xc9, 0xa5, 0x9a, 0x4b, 0x41, 0xae, 0xf0, + 0xd1, 0x38, 0x55, 0x22, 0x92, 0x23, 0x0e, 0xda, 0xa4, 0x8c, 0x1b, 0x0f, 0x75, 0x50, 0x7f, 0x7f, + 0xd8, 0xb4, 0xf6, 0xa0, 0x74, 0xc9, 0xe5, 0x0f, 0x98, 0x67, 0x1a, 0x29, 0xe1, 0xed, 0x15, 0xe0, + 0x61, 0x09, 0xe6, 0x6e, 0x28, 0x48, 0x0f, 0x37, 0x61, 0x66, 0x22, 0x50, 0x3a, 0x1a, 0x99, 0x65, + 0x8e, 0x39, 0x05, 0x76, 0xb0, 0x73, 0x1f, 0x97, 0xa1, 0x20, 0x2d, 0x5c, 0xd7, 0xa0, 0xb9, 0xf4, + 0xdc, 0xe2, 0xd0, 0x0e, 0xdd, 0x37, 0x84, 0x4f, 0xff, 0x04, 0x1d, 0x30, 0xcd, 0x65, 0x2c, 0x05, + 0x39, 0xc3, 0x8d, 0x4c, 0x6a, 0x21, 0xd3, 0x32, 0x5d, 0x39, 0x91, 0x13, 0x5c, 0xb7, 0x9f, 0xd8, + 0x2c, 0xae, 0xc9, 0x1f, 0xaf, 0xd8, 0xc9, 0xf9, 0xef, 0x4e, 0x6e, 0xc5, 0x4e, 0xb7, 0xe1, 0xc7, + 0xc6, 0x47, 0xeb, 0x8d, 0x8f, 0xbe, 0x36, 0x3e, 0x7a, 0xdd, 0xfa, 0xb5, 0xf5, 0xd6, 0xaf, 0x7d, + 0x6e, 0xfd, 0xda, 0x33, 0x8d, 0x94, 0x99, 0xcc, 0xc6, 0x01, 0x87, 0x29, 0xad, 0xe8, 0x75, 0x7e, + 0x4d, 0x97, 0xbb, 0x72, 0xcd, 0x2a, 0x91, 0xd9, 0xb8, 0x51, 0xb4, 0x75, 0xf3, 0x1d, 0x00, 0x00, + 0xff, 0xff, 0x38, 0xc7, 0x3a, 0x85, 0x06, 0x02, 0x00, 0x00, } func (m *IDSet) Marshal() (dAtA []byte, err error) { @@ -393,6 +411,7 @@ func encodeVarintPool(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *IDSet) Size() (n int) { if m == nil { return 0 @@ -462,9 +481,11 @@ func (m *EventWithdrawCanceled) Size() (n int) { func sovPool(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozPool(x uint64) (n int) { return sovPool(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *IDSet) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -591,6 +612,7 @@ func (m *IDSet) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventWithdrawalReceived) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -769,6 +791,7 @@ func (m *EventWithdrawalReceived) Unmarshal(dAtA []byte) error { } return nil } + func (m *EventWithdrawCanceled) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -947,6 +970,7 @@ func (m *EventWithdrawCanceled) Unmarshal(dAtA []byte) error { } return nil } + func skipPool(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/query.pb.go b/x/skyway/types/query.pb.go index afc60b91..87498c7b 100644 --- a/x/skyway/types/query.pb.go +++ b/x/skyway/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" @@ -15,15 +19,14 @@ import ( codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" emptypb "google.golang.org/protobuf/types/known/emptypb" - 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -31,8 +34,7 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -40,9 +42,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{0} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -55,12 +59,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -77,9 +84,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{1} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -92,12 +101,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -118,6 +130,7 @@ type QueryLastPendingBatchRequestByAddrRequest struct { func (m *QueryLastPendingBatchRequestByAddrRequest) Reset() { *m = QueryLastPendingBatchRequestByAddrRequest{} } + func (m *QueryLastPendingBatchRequestByAddrRequest) String() string { return proto.CompactTextString(m) } @@ -125,9 +138,11 @@ func (*QueryLastPendingBatchRequestByAddrRequest) ProtoMessage() {} func (*QueryLastPendingBatchRequestByAddrRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{2} } + func (m *QueryLastPendingBatchRequestByAddrRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastPendingBatchRequestByAddrRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastPendingBatchRequestByAddrRequest.Marshal(b, m, deterministic) @@ -140,12 +155,15 @@ func (m *QueryLastPendingBatchRequestByAddrRequest) XXX_Marshal(b []byte, determ return b[:n], nil } } + func (m *QueryLastPendingBatchRequestByAddrRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastPendingBatchRequestByAddrRequest.Merge(m, src) } + func (m *QueryLastPendingBatchRequestByAddrRequest) XXX_Size() int { return m.Size() } + func (m *QueryLastPendingBatchRequestByAddrRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastPendingBatchRequestByAddrRequest.DiscardUnknown(m) } @@ -166,6 +184,7 @@ type QueryLastPendingBatchRequestByAddrResponse struct { func (m *QueryLastPendingBatchRequestByAddrResponse) Reset() { *m = QueryLastPendingBatchRequestByAddrResponse{} } + func (m *QueryLastPendingBatchRequestByAddrResponse) String() string { return proto.CompactTextString(m) } @@ -173,9 +192,11 @@ func (*QueryLastPendingBatchRequestByAddrResponse) ProtoMessage() {} func (*QueryLastPendingBatchRequestByAddrResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{3} } + func (m *QueryLastPendingBatchRequestByAddrResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastPendingBatchRequestByAddrResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastPendingBatchRequestByAddrResponse.Marshal(b, m, deterministic) @@ -188,12 +209,15 @@ func (m *QueryLastPendingBatchRequestByAddrResponse) XXX_Marshal(b []byte, deter return b[:n], nil } } + func (m *QueryLastPendingBatchRequestByAddrResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastPendingBatchRequestByAddrResponse.Merge(m, src) } + func (m *QueryLastPendingBatchRequestByAddrResponse) XXX_Size() int { return m.Size() } + func (m *QueryLastPendingBatchRequestByAddrResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastPendingBatchRequestByAddrResponse.DiscardUnknown(m) } @@ -218,9 +242,11 @@ func (*QueryOutgoingTxBatchesRequest) ProtoMessage() {} func (*QueryOutgoingTxBatchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{4} } + func (m *QueryOutgoingTxBatchesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryOutgoingTxBatchesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryOutgoingTxBatchesRequest.Marshal(b, m, deterministic) @@ -233,12 +259,15 @@ func (m *QueryOutgoingTxBatchesRequest) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } + func (m *QueryOutgoingTxBatchesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryOutgoingTxBatchesRequest.Merge(m, src) } + func (m *QueryOutgoingTxBatchesRequest) XXX_Size() int { return m.Size() } + func (m *QueryOutgoingTxBatchesRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryOutgoingTxBatchesRequest.DiscardUnknown(m) } @@ -269,9 +298,11 @@ func (*QueryOutgoingTxBatchesResponse) ProtoMessage() {} func (*QueryOutgoingTxBatchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{5} } + func (m *QueryOutgoingTxBatchesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryOutgoingTxBatchesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryOutgoingTxBatchesResponse.Marshal(b, m, deterministic) @@ -284,12 +315,15 @@ func (m *QueryOutgoingTxBatchesResponse) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *QueryOutgoingTxBatchesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryOutgoingTxBatchesResponse.Merge(m, src) } + func (m *QueryOutgoingTxBatchesResponse) XXX_Size() int { return m.Size() } + func (m *QueryOutgoingTxBatchesResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryOutgoingTxBatchesResponse.DiscardUnknown(m) } @@ -314,9 +348,11 @@ func (*QueryBatchRequestByNonceRequest) ProtoMessage() {} func (*QueryBatchRequestByNonceRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{6} } + func (m *QueryBatchRequestByNonceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBatchRequestByNonceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBatchRequestByNonceRequest.Marshal(b, m, deterministic) @@ -329,12 +365,15 @@ func (m *QueryBatchRequestByNonceRequest) XXX_Marshal(b []byte, deterministic bo return b[:n], nil } } + func (m *QueryBatchRequestByNonceRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBatchRequestByNonceRequest.Merge(m, src) } + func (m *QueryBatchRequestByNonceRequest) XXX_Size() int { return m.Size() } + func (m *QueryBatchRequestByNonceRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryBatchRequestByNonceRequest.DiscardUnknown(m) } @@ -365,9 +404,11 @@ func (*QueryBatchRequestByNonceResponse) ProtoMessage() {} func (*QueryBatchRequestByNonceResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{7} } + func (m *QueryBatchRequestByNonceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBatchRequestByNonceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBatchRequestByNonceResponse.Marshal(b, m, deterministic) @@ -380,12 +421,15 @@ func (m *QueryBatchRequestByNonceResponse) XXX_Marshal(b []byte, deterministic b return b[:n], nil } } + func (m *QueryBatchRequestByNonceResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBatchRequestByNonceResponse.Merge(m, src) } + func (m *QueryBatchRequestByNonceResponse) XXX_Size() int { return m.Size() } + func (m *QueryBatchRequestByNonceResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryBatchRequestByNonceResponse.DiscardUnknown(m) } @@ -410,9 +454,11 @@ func (*QueryBatchConfirmsRequest) ProtoMessage() {} func (*QueryBatchConfirmsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{8} } + func (m *QueryBatchConfirmsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBatchConfirmsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBatchConfirmsRequest.Marshal(b, m, deterministic) @@ -425,12 +471,15 @@ func (m *QueryBatchConfirmsRequest) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryBatchConfirmsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBatchConfirmsRequest.Merge(m, src) } + func (m *QueryBatchConfirmsRequest) XXX_Size() int { return m.Size() } + func (m *QueryBatchConfirmsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryBatchConfirmsRequest.DiscardUnknown(m) } @@ -461,9 +510,11 @@ func (*QueryBatchConfirmsResponse) ProtoMessage() {} func (*QueryBatchConfirmsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{9} } + func (m *QueryBatchConfirmsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBatchConfirmsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBatchConfirmsResponse.Marshal(b, m, deterministic) @@ -476,12 +527,15 @@ func (m *QueryBatchConfirmsResponse) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *QueryBatchConfirmsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBatchConfirmsResponse.Merge(m, src) } + func (m *QueryBatchConfirmsResponse) XXX_Size() int { return m.Size() } + func (m *QueryBatchConfirmsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryBatchConfirmsResponse.DiscardUnknown(m) } @@ -505,9 +559,11 @@ func (*QueryLastObservedSkywayNonceRequest) ProtoMessage() {} func (*QueryLastObservedSkywayNonceRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{10} } + func (m *QueryLastObservedSkywayNonceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastObservedSkywayNonceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastObservedSkywayNonceRequest.Marshal(b, m, deterministic) @@ -520,12 +576,15 @@ func (m *QueryLastObservedSkywayNonceRequest) XXX_Marshal(b []byte, deterministi return b[:n], nil } } + func (m *QueryLastObservedSkywayNonceRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastObservedSkywayNonceRequest.Merge(m, src) } + func (m *QueryLastObservedSkywayNonceRequest) XXX_Size() int { return m.Size() } + func (m *QueryLastObservedSkywayNonceRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastObservedSkywayNonceRequest.DiscardUnknown(m) } @@ -547,6 +606,7 @@ type QueryLastObservedSkywayNonceByAddrRequest struct { func (m *QueryLastObservedSkywayNonceByAddrRequest) Reset() { *m = QueryLastObservedSkywayNonceByAddrRequest{} } + func (m *QueryLastObservedSkywayNonceByAddrRequest) String() string { return proto.CompactTextString(m) } @@ -554,9 +614,11 @@ func (*QueryLastObservedSkywayNonceByAddrRequest) ProtoMessage() {} func (*QueryLastObservedSkywayNonceByAddrRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{11} } + func (m *QueryLastObservedSkywayNonceByAddrRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastObservedSkywayNonceByAddrRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastObservedSkywayNonceByAddrRequest.Marshal(b, m, deterministic) @@ -569,12 +631,15 @@ func (m *QueryLastObservedSkywayNonceByAddrRequest) XXX_Marshal(b []byte, determ return b[:n], nil } } + func (m *QueryLastObservedSkywayNonceByAddrRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastObservedSkywayNonceByAddrRequest.Merge(m, src) } + func (m *QueryLastObservedSkywayNonceByAddrRequest) XXX_Size() int { return m.Size() } + func (m *QueryLastObservedSkywayNonceByAddrRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastObservedSkywayNonceByAddrRequest.DiscardUnknown(m) } @@ -605,9 +670,11 @@ func (*QueryLastObservedSkywayNonceResponse) ProtoMessage() {} func (*QueryLastObservedSkywayNonceResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{12} } + func (m *QueryLastObservedSkywayNonceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastObservedSkywayNonceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastObservedSkywayNonceResponse.Marshal(b, m, deterministic) @@ -620,12 +687,15 @@ func (m *QueryLastObservedSkywayNonceResponse) XXX_Marshal(b []byte, determinist return b[:n], nil } } + func (m *QueryLastObservedSkywayNonceResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastObservedSkywayNonceResponse.Merge(m, src) } + func (m *QueryLastObservedSkywayNonceResponse) XXX_Size() int { return m.Size() } + func (m *QueryLastObservedSkywayNonceResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastObservedSkywayNonceResponse.DiscardUnknown(m) } @@ -649,9 +719,11 @@ func (*QueryLastObservedSkywayBlockRequest) ProtoMessage() {} func (*QueryLastObservedSkywayBlockRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{13} } + func (m *QueryLastObservedSkywayBlockRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastObservedSkywayBlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastObservedSkywayBlockRequest.Marshal(b, m, deterministic) @@ -664,12 +736,15 @@ func (m *QueryLastObservedSkywayBlockRequest) XXX_Marshal(b []byte, deterministi return b[:n], nil } } + func (m *QueryLastObservedSkywayBlockRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastObservedSkywayBlockRequest.Merge(m, src) } + func (m *QueryLastObservedSkywayBlockRequest) XXX_Size() int { return m.Size() } + func (m *QueryLastObservedSkywayBlockRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastObservedSkywayBlockRequest.DiscardUnknown(m) } @@ -693,9 +768,11 @@ func (*QueryLastObservedSkywayBlockResponse) ProtoMessage() {} func (*QueryLastObservedSkywayBlockResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{14} } + func (m *QueryLastObservedSkywayBlockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastObservedSkywayBlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastObservedSkywayBlockResponse.Marshal(b, m, deterministic) @@ -708,12 +785,15 @@ func (m *QueryLastObservedSkywayBlockResponse) XXX_Marshal(b []byte, determinist return b[:n], nil } } + func (m *QueryLastObservedSkywayBlockResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastObservedSkywayBlockResponse.Merge(m, src) } + func (m *QueryLastObservedSkywayBlockResponse) XXX_Size() int { return m.Size() } + func (m *QueryLastObservedSkywayBlockResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastObservedSkywayBlockResponse.DiscardUnknown(m) } @@ -738,9 +818,11 @@ func (*QueryERC20ToDenomRequest) ProtoMessage() {} func (*QueryERC20ToDenomRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{15} } + func (m *QueryERC20ToDenomRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryERC20ToDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryERC20ToDenomRequest.Marshal(b, m, deterministic) @@ -753,12 +835,15 @@ func (m *QueryERC20ToDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryERC20ToDenomRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryERC20ToDenomRequest.Merge(m, src) } + func (m *QueryERC20ToDenomRequest) XXX_Size() int { return m.Size() } + func (m *QueryERC20ToDenomRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryERC20ToDenomRequest.DiscardUnknown(m) } @@ -789,9 +874,11 @@ func (*QueryERC20ToDenomResponse) ProtoMessage() {} func (*QueryERC20ToDenomResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{16} } + func (m *QueryERC20ToDenomResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryERC20ToDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryERC20ToDenomResponse.Marshal(b, m, deterministic) @@ -804,12 +891,15 @@ func (m *QueryERC20ToDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryERC20ToDenomResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryERC20ToDenomResponse.Merge(m, src) } + func (m *QueryERC20ToDenomResponse) XXX_Size() int { return m.Size() } + func (m *QueryERC20ToDenomResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryERC20ToDenomResponse.DiscardUnknown(m) } @@ -834,9 +924,11 @@ func (*QueryDenomToERC20Request) ProtoMessage() {} func (*QueryDenomToERC20Request) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{17} } + func (m *QueryDenomToERC20Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryDenomToERC20Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryDenomToERC20Request.Marshal(b, m, deterministic) @@ -849,12 +941,15 @@ func (m *QueryDenomToERC20Request) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryDenomToERC20Request) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryDenomToERC20Request.Merge(m, src) } + func (m *QueryDenomToERC20Request) XXX_Size() int { return m.Size() } + func (m *QueryDenomToERC20Request) XXX_DiscardUnknown() { xxx_messageInfo_QueryDenomToERC20Request.DiscardUnknown(m) } @@ -885,9 +980,11 @@ func (*QueryDenomToERC20Response) ProtoMessage() {} func (*QueryDenomToERC20Response) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{18} } + func (m *QueryDenomToERC20Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryDenomToERC20Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryDenomToERC20Response.Marshal(b, m, deterministic) @@ -900,12 +997,15 @@ func (m *QueryDenomToERC20Response) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryDenomToERC20Response) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryDenomToERC20Response.Merge(m, src) } + func (m *QueryDenomToERC20Response) XXX_Size() int { return m.Size() } + func (m *QueryDenomToERC20Response) XXX_DiscardUnknown() { xxx_messageInfo_QueryDenomToERC20Response.DiscardUnknown(m) } @@ -949,9 +1049,11 @@ func (*QueryAttestationsRequest) ProtoMessage() {} func (*QueryAttestationsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{19} } + func (m *QueryAttestationsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAttestationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAttestationsRequest.Marshal(b, m, deterministic) @@ -964,12 +1066,15 @@ func (m *QueryAttestationsRequest) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryAttestationsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAttestationsRequest.Merge(m, src) } + func (m *QueryAttestationsRequest) XXX_Size() int { return m.Size() } + func (m *QueryAttestationsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryAttestationsRequest.DiscardUnknown(m) } @@ -1028,9 +1133,11 @@ func (*QueryAttestationsResponse) ProtoMessage() {} func (*QueryAttestationsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{20} } + func (m *QueryAttestationsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAttestationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAttestationsResponse.Marshal(b, m, deterministic) @@ -1043,12 +1150,15 @@ func (m *QueryAttestationsResponse) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryAttestationsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAttestationsResponse.Merge(m, src) } + func (m *QueryAttestationsResponse) XXX_Size() int { return m.Size() } + func (m *QueryAttestationsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryAttestationsResponse.DiscardUnknown(m) } @@ -1062,8 +1172,7 @@ func (m *QueryAttestationsResponse) GetAttestations() []Attestation { return nil } -type QueryErc20ToDenoms struct { -} +type QueryErc20ToDenoms struct{} func (m *QueryErc20ToDenoms) Reset() { *m = QueryErc20ToDenoms{} } func (m *QueryErc20ToDenoms) String() string { return proto.CompactTextString(m) } @@ -1071,9 +1180,11 @@ func (*QueryErc20ToDenoms) ProtoMessage() {} func (*QueryErc20ToDenoms) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{21} } + func (m *QueryErc20ToDenoms) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryErc20ToDenoms) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryErc20ToDenoms.Marshal(b, m, deterministic) @@ -1086,12 +1197,15 @@ func (m *QueryErc20ToDenoms) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryErc20ToDenoms) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryErc20ToDenoms.Merge(m, src) } + func (m *QueryErc20ToDenoms) XXX_Size() int { return m.Size() } + func (m *QueryErc20ToDenoms) XXX_DiscardUnknown() { xxx_messageInfo_QueryErc20ToDenoms.DiscardUnknown(m) } @@ -1108,9 +1222,11 @@ func (*QueryErc20ToDenomsResponse) ProtoMessage() {} func (*QueryErc20ToDenomsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{22} } + func (m *QueryErc20ToDenomsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryErc20ToDenomsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryErc20ToDenomsResponse.Marshal(b, m, deterministic) @@ -1123,12 +1239,15 @@ func (m *QueryErc20ToDenomsResponse) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *QueryErc20ToDenomsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryErc20ToDenomsResponse.Merge(m, src) } + func (m *QueryErc20ToDenomsResponse) XXX_Size() int { return m.Size() } + func (m *QueryErc20ToDenomsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryErc20ToDenomsResponse.DiscardUnknown(m) } @@ -1152,9 +1271,11 @@ func (*QueryPendingSendToRemote) ProtoMessage() {} func (*QueryPendingSendToRemote) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{23} } + func (m *QueryPendingSendToRemote) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryPendingSendToRemote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryPendingSendToRemote.Marshal(b, m, deterministic) @@ -1167,12 +1288,15 @@ func (m *QueryPendingSendToRemote) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryPendingSendToRemote) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryPendingSendToRemote.Merge(m, src) } + func (m *QueryPendingSendToRemote) XXX_Size() int { return m.Size() } + func (m *QueryPendingSendToRemote) XXX_DiscardUnknown() { xxx_messageInfo_QueryPendingSendToRemote.DiscardUnknown(m) } @@ -1197,9 +1321,11 @@ func (*QueryPendingSendToRemoteResponse) ProtoMessage() {} func (*QueryPendingSendToRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{24} } + func (m *QueryPendingSendToRemoteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryPendingSendToRemoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryPendingSendToRemoteResponse.Marshal(b, m, deterministic) @@ -1212,12 +1338,15 @@ func (m *QueryPendingSendToRemoteResponse) XXX_Marshal(b []byte, deterministic b return b[:n], nil } } + func (m *QueryPendingSendToRemoteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryPendingSendToRemoteResponse.Merge(m, src) } + func (m *QueryPendingSendToRemoteResponse) XXX_Size() int { return m.Size() } + func (m *QueryPendingSendToRemoteResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryPendingSendToRemoteResponse.DiscardUnknown(m) } @@ -1248,9 +1377,11 @@ func (*QueryBridgeTaxesResponse) ProtoMessage() {} func (*QueryBridgeTaxesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{25} } + func (m *QueryBridgeTaxesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBridgeTaxesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBridgeTaxesResponse.Marshal(b, m, deterministic) @@ -1263,12 +1394,15 @@ func (m *QueryBridgeTaxesResponse) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryBridgeTaxesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBridgeTaxesResponse.Merge(m, src) } + func (m *QueryBridgeTaxesResponse) XXX_Size() int { return m.Size() } + func (m *QueryBridgeTaxesResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryBridgeTaxesResponse.DiscardUnknown(m) } @@ -1292,9 +1426,11 @@ func (*QueryBridgeTransferLimitsResponse) ProtoMessage() {} func (*QueryBridgeTransferLimitsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{26} } + func (m *QueryBridgeTransferLimitsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBridgeTransferLimitsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBridgeTransferLimitsResponse.Marshal(b, m, deterministic) @@ -1307,12 +1443,15 @@ func (m *QueryBridgeTransferLimitsResponse) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *QueryBridgeTransferLimitsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBridgeTransferLimitsResponse.Merge(m, src) } + func (m *QueryBridgeTransferLimitsResponse) XXX_Size() int { return m.Size() } + func (m *QueryBridgeTransferLimitsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryBridgeTransferLimitsResponse.DiscardUnknown(m) } @@ -1334,6 +1473,7 @@ type QueryBridgeTransferLimitsResponse_LimitUsage struct { func (m *QueryBridgeTransferLimitsResponse_LimitUsage) Reset() { *m = QueryBridgeTransferLimitsResponse_LimitUsage{} } + func (m *QueryBridgeTransferLimitsResponse_LimitUsage) String() string { return proto.CompactTextString(m) } @@ -1341,9 +1481,11 @@ func (*QueryBridgeTransferLimitsResponse_LimitUsage) ProtoMessage() {} func (*QueryBridgeTransferLimitsResponse_LimitUsage) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{26, 0} } + func (m *QueryBridgeTransferLimitsResponse_LimitUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBridgeTransferLimitsResponse_LimitUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBridgeTransferLimitsResponse_LimitUsage.Marshal(b, m, deterministic) @@ -1356,12 +1498,15 @@ func (m *QueryBridgeTransferLimitsResponse_LimitUsage) XXX_Marshal(b []byte, det return b[:n], nil } } + func (m *QueryBridgeTransferLimitsResponse_LimitUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBridgeTransferLimitsResponse_LimitUsage.Merge(m, src) } + func (m *QueryBridgeTransferLimitsResponse_LimitUsage) XXX_Size() int { return m.Size() } + func (m *QueryBridgeTransferLimitsResponse_LimitUsage) XXX_DiscardUnknown() { xxx_messageInfo_QueryBridgeTransferLimitsResponse_LimitUsage.DiscardUnknown(m) } @@ -1392,9 +1537,11 @@ func (*QueryLightNodeSaleContractsResponse) ProtoMessage() {} func (*QueryLightNodeSaleContractsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{27} } + func (m *QueryLightNodeSaleContractsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLightNodeSaleContractsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLightNodeSaleContractsResponse.Marshal(b, m, deterministic) @@ -1407,12 +1554,15 @@ func (m *QueryLightNodeSaleContractsResponse) XXX_Marshal(b []byte, deterministi return b[:n], nil } } + func (m *QueryLightNodeSaleContractsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLightNodeSaleContractsResponse.Merge(m, src) } + func (m *QueryLightNodeSaleContractsResponse) XXX_Size() int { return m.Size() } + func (m *QueryLightNodeSaleContractsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryLightNodeSaleContractsResponse.DiscardUnknown(m) } @@ -1436,6 +1586,7 @@ type QueryLastPendingBatchForGasEstimationRequest struct { func (m *QueryLastPendingBatchForGasEstimationRequest) Reset() { *m = QueryLastPendingBatchForGasEstimationRequest{} } + func (m *QueryLastPendingBatchForGasEstimationRequest) String() string { return proto.CompactTextString(m) } @@ -1443,9 +1594,11 @@ func (*QueryLastPendingBatchForGasEstimationRequest) ProtoMessage() {} func (*QueryLastPendingBatchForGasEstimationRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{28} } + func (m *QueryLastPendingBatchForGasEstimationRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastPendingBatchForGasEstimationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastPendingBatchForGasEstimationRequest.Marshal(b, m, deterministic) @@ -1458,12 +1611,15 @@ func (m *QueryLastPendingBatchForGasEstimationRequest) XXX_Marshal(b []byte, det return b[:n], nil } } + func (m *QueryLastPendingBatchForGasEstimationRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastPendingBatchForGasEstimationRequest.Merge(m, src) } + func (m *QueryLastPendingBatchForGasEstimationRequest) XXX_Size() int { return m.Size() } + func (m *QueryLastPendingBatchForGasEstimationRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastPendingBatchForGasEstimationRequest.DiscardUnknown(m) } @@ -1491,6 +1647,7 @@ type QueryLastPendingBatchForGasEstimationResponse struct { func (m *QueryLastPendingBatchForGasEstimationResponse) Reset() { *m = QueryLastPendingBatchForGasEstimationResponse{} } + func (m *QueryLastPendingBatchForGasEstimationResponse) String() string { return proto.CompactTextString(m) } @@ -1498,9 +1655,11 @@ func (*QueryLastPendingBatchForGasEstimationResponse) ProtoMessage() {} func (*QueryLastPendingBatchForGasEstimationResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{29} } + func (m *QueryLastPendingBatchForGasEstimationResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryLastPendingBatchForGasEstimationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryLastPendingBatchForGasEstimationResponse.Marshal(b, m, deterministic) @@ -1513,12 +1672,15 @@ func (m *QueryLastPendingBatchForGasEstimationResponse) XXX_Marshal(b []byte, de return b[:n], nil } } + func (m *QueryLastPendingBatchForGasEstimationResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryLastPendingBatchForGasEstimationResponse.Merge(m, src) } + func (m *QueryLastPendingBatchForGasEstimationResponse) XXX_Size() int { return m.Size() } + func (m *QueryLastPendingBatchForGasEstimationResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryLastPendingBatchForGasEstimationResponse.DiscardUnknown(m) } @@ -1543,9 +1705,11 @@ func (*QueryUnobservedBlocksByAddrRequest) ProtoMessage() {} func (*QueryUnobservedBlocksByAddrRequest) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{30} } + func (m *QueryUnobservedBlocksByAddrRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryUnobservedBlocksByAddrRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryUnobservedBlocksByAddrRequest.Marshal(b, m, deterministic) @@ -1558,12 +1722,15 @@ func (m *QueryUnobservedBlocksByAddrRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *QueryUnobservedBlocksByAddrRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryUnobservedBlocksByAddrRequest.Merge(m, src) } + func (m *QueryUnobservedBlocksByAddrRequest) XXX_Size() int { return m.Size() } + func (m *QueryUnobservedBlocksByAddrRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryUnobservedBlocksByAddrRequest.DiscardUnknown(m) } @@ -1594,9 +1761,11 @@ func (*QueryUnobservedBlocksByAddrResponse) ProtoMessage() {} func (*QueryUnobservedBlocksByAddrResponse) Descriptor() ([]byte, []int) { return fileDescriptor_933fccfef6a08c1d, []int{31} } + func (m *QueryUnobservedBlocksByAddrResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryUnobservedBlocksByAddrResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryUnobservedBlocksByAddrResponse.Marshal(b, m, deterministic) @@ -1609,12 +1778,15 @@ func (m *QueryUnobservedBlocksByAddrResponse) XXX_Marshal(b []byte, deterministi return b[:n], nil } } + func (m *QueryUnobservedBlocksByAddrResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryUnobservedBlocksByAddrResponse.Merge(m, src) } + func (m *QueryUnobservedBlocksByAddrResponse) XXX_Size() int { return m.Size() } + func (m *QueryUnobservedBlocksByAddrResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryUnobservedBlocksByAddrResponse.DiscardUnknown(m) } @@ -1669,129 +1841,131 @@ func init() { } var fileDescriptor_933fccfef6a08c1d = []byte{ - // 1868 bytes of a gzipped FileDescriptorProto + // 1870 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xcd, 0x6f, 0x14, 0xc9, - 0x15, 0x77, 0x1b, 0x7f, 0x51, 0x36, 0xe0, 0x14, 0x96, 0xb1, 0x27, 0xb1, 0x31, 0xcd, 0xa7, 0x8d, - 0x7b, 0x1a, 0xdb, 0x90, 0x40, 0x62, 0x20, 0x1e, 0x7f, 0x4c, 0x6c, 0x1c, 0x30, 0x63, 0x83, 0xa2, + 0x15, 0x77, 0x1b, 0x7f, 0x51, 0x36, 0xe0, 0x14, 0x96, 0xb1, 0x27, 0xb1, 0x31, 0xcd, 0xa7, 0x0d, + 0x3d, 0x8d, 0xc7, 0x90, 0x40, 0x62, 0x20, 0x1e, 0xdb, 0x4c, 0x6c, 0x1c, 0x30, 0x63, 0x83, 0xa2, 0x28, 0x4a, 0xab, 0x67, 0xba, 0xdc, 0xee, 0xb8, 0xa7, 0x6b, 0xe8, 0xea, 0x01, 0x8f, 0x10, 0x97, 0xfc, 0x01, 0x49, 0x44, 0x2e, 0x39, 0x25, 0xe7, 0x48, 0xab, 0x5d, 0xed, 0x9f, 0xb0, 0x7b, 0x62, 0x6f, 0x48, 0xab, 0x5d, 0x71, 0x42, 0x2b, 0xd8, 0xeb, 0xee, 0xde, 0x91, 0x56, 0x5a, 0x75, 0xf5, 0xeb, 0x9e, 0x6e, 0xdc, 0x1f, 0xe3, 0x31, 0x87, 0x3d, 0xd9, 0x55, 0x5d, 0xef, 0xbd, 0xdf, 0xaf, - 0xea, 0x55, 0xd5, 0xfb, 0xd5, 0xa0, 0xf3, 0x35, 0xd5, 0xa4, 0x55, 0xb5, 0xb2, 0xa3, 0x1a, 0x96, - 0xec, 0xfd, 0x2f, 0xb3, 0xdd, 0xc6, 0x13, 0xb5, 0x21, 0x3f, 0xaa, 0x13, 0xbb, 0x91, 0xaf, 0xd9, - 0xd4, 0xa1, 0x78, 0x34, 0x34, 0x2c, 0xef, 0xfd, 0x9f, 0xf7, 0x86, 0xe5, 0x86, 0x74, 0xaa, 0x53, - 0x3e, 0x4a, 0x76, 0xff, 0xf3, 0x0c, 0x72, 0xbf, 0xd2, 0x29, 0xd5, 0x4d, 0x22, 0xab, 0x35, 0x43, - 0x56, 0x2d, 0x8b, 0x3a, 0xaa, 0x63, 0x50, 0x8b, 0xc1, 0xd7, 0x5f, 0xc2, 0x57, 0xde, 0x2a, 0xd7, - 0xb7, 0x65, 0x52, 0xad, 0x39, 0x10, 0x2b, 0x77, 0x39, 0x19, 0x92, 0xea, 0x38, 0x84, 0x79, 0xae, - 0x60, 0x70, 0x0a, 0xfe, 0xb2, 0xea, 0x54, 0x76, 0x60, 0xd8, 0x54, 0xca, 0x30, 0xdb, 0xd0, 0x74, - 0xa2, 0x38, 0xea, 0x1e, 0x8c, 0xbd, 0x96, 0x3d, 0xd6, 0x56, 0x2d, 0xb6, 0x4d, 0x6c, 0xc5, 0x34, - 0xaa, 0x86, 0x03, 0x66, 0x17, 0x93, 0xcd, 0x74, 0x62, 0x11, 0x66, 0xf8, 0xe4, 0xaf, 0x27, 0x0f, - 0x34, 0x0d, 0x7d, 0xc7, 0x51, 0x2c, 0xaa, 0x11, 0x85, 0xa9, 0x26, 0x51, 0x2a, 0xd4, 0x72, 0x6c, - 0xb5, 0xe2, 0x87, 0x38, 0x97, 0x6c, 0x59, 0x65, 0xba, 0xef, 0xff, 0x42, 0xf2, 0xa8, 0x9a, 0x6a, - 0xab, 0x55, 0x96, 0xed, 0xad, 0x46, 0xa9, 0x99, 0x3d, 0xc1, 0x4e, 0xa3, 0x46, 0xc0, 0x99, 0x38, - 0x84, 0xf0, 0x7d, 0x37, 0x5f, 0x36, 0x78, 0x84, 0x12, 0x79, 0x54, 0x27, 0xcc, 0x11, 0x1f, 0xa2, - 0x93, 0x91, 0x5e, 0x56, 0xa3, 0x16, 0x23, 0xf8, 0x36, 0xea, 0xf1, 0x90, 0x8c, 0x08, 0x13, 0xc2, - 0xa5, 0xfe, 0xd9, 0x33, 0xf9, 0xc4, 0xf4, 0xca, 0x7b, 0xa6, 0x85, 0xae, 0x17, 0xaf, 0x4f, 0x77, - 0x94, 0xc0, 0x4c, 0x5c, 0x46, 0x93, 0xdc, 0xef, 0xba, 0xca, 0x9c, 0x0d, 0x62, 0x69, 0x86, 0xa5, - 0x17, 0xdc, 0xd5, 0x86, 0xb8, 0x85, 0xc6, 0x82, 0xa6, 0xd9, 0xd0, 0xc0, 0x23, 0xa8, 0x57, 0xd5, - 0x34, 0x9b, 0x30, 0x2f, 0xdc, 0xd1, 0x92, 0xdf, 0x14, 0x1d, 0x34, 0xd5, 0x8a, 0x1b, 0x40, 0xbd, - 0x82, 0xba, 0x79, 0x4a, 0x8d, 0x08, 0x13, 0x47, 0x2e, 0xf5, 0xcf, 0x4e, 0xa5, 0x80, 0xbe, 0x57, - 0x77, 0x74, 0x6a, 0x58, 0xfa, 0xd6, 0x1e, 0xf7, 0x07, 0xe8, 0x3d, 0x73, 0xd1, 0x40, 0x63, 0x3c, - 0xea, 0x7b, 0x83, 0x88, 0x3f, 0x6b, 0x78, 0x1a, 0x61, 0xee, 0x54, 0xb1, 0xc9, 0x36, 0xb1, 0x89, - 0x55, 0x21, 0x8a, 0xa1, 0x01, 0xf6, 0x41, 0xfe, 0xa5, 0xe4, 0x7f, 0x58, 0xd5, 0x70, 0x0e, 0xf5, - 0xa9, 0x8c, 0x19, 0xba, 0x45, 0xc8, 0x48, 0x27, 0x1f, 0x13, 0xb4, 0x45, 0x13, 0x8d, 0x27, 0x85, - 0x02, 0x52, 0x6b, 0xa8, 0xb7, 0xec, 0x75, 0xb5, 0x4d, 0xcb, 0x77, 0x20, 0x96, 0xd1, 0x69, 0x1e, - 0x2d, 0x3a, 0x87, 0x77, 0xa9, 0x55, 0x21, 0x3e, 0xb5, 0x21, 0xd4, 0x6d, 0xb9, 0x6d, 0xce, 0xa6, - 0xab, 0xe4, 0x35, 0xf0, 0x24, 0x1a, 0xf4, 0x33, 0x5d, 0xf1, 0x97, 0xca, 0xa3, 0x72, 0xc2, 0xef, - 0x5f, 0x80, 0x25, 0xfb, 0x1b, 0x9a, 0x48, 0x8e, 0xb1, 0x7f, 0xa1, 0x84, 0xc3, 0x2c, 0xd4, 0x5f, - 0xd0, 0x68, 0x33, 0xd6, 0x22, 0xb5, 0xb6, 0x0d, 0x3b, 0x48, 0xed, 0x0f, 0xc1, 0x24, 0x17, 0xe7, - 0x1d, 0x38, 0xac, 0xa3, 0xbe, 0x0a, 0xf4, 0xb5, 0xb0, 0x30, 0x7f, 0x64, 0x3a, 0x78, 0x08, 0xd3, - 0x08, 0x3c, 0x88, 0x9b, 0xe8, 0x6c, 0x90, 0xe8, 0xf7, 0xca, 0x8c, 0xd8, 0x8f, 0x89, 0xb6, 0xc9, - 0x4d, 0x23, 0xab, 0x73, 0xa0, 0xc4, 0x13, 0x59, 0x68, 0x13, 0xc6, 0x38, 0x6d, 0x71, 0x13, 0x26, - 0x04, 0xed, 0x4c, 0x08, 0x3a, 0x8f, 0xce, 0xa5, 0x33, 0x81, 0xf9, 0x8b, 0x5d, 0x9e, 0x94, 0x79, - 0x28, 0x98, 0xb4, 0xb2, 0xdb, 0xde, 0x3c, 0x24, 0x43, 0x02, 0xa7, 0x4d, 0x48, 0x65, 0xb7, 0xc3, - 0x87, 0xc4, 0x1b, 0xe2, 0x5f, 0xd1, 0x08, 0xb7, 0x5e, 0x2e, 0x2d, 0xce, 0x5e, 0xd9, 0xa2, 0x4b, - 0xc4, 0xa2, 0xd5, 0x50, 0x8e, 0x11, 0xbb, 0x32, 0x7b, 0x05, 0x42, 0x7b, 0x8d, 0x03, 0x4e, 0xd8, - 0x0c, 0x24, 0x71, 0xd4, 0x7f, 0x13, 0x92, 0xe6, 0x76, 0xf8, 0x01, 0x78, 0x23, 0x80, 0xc4, 0xc7, - 0x6e, 0x51, 0x6e, 0x19, 0x82, 0xb4, 0xdf, 0xa2, 0x4d, 0x48, 0x51, 0xff, 0x4d, 0x48, 0xfb, 0x39, - 0x8b, 0xaf, 0x04, 0xc0, 0xb4, 0xd0, 0xac, 0x00, 0xc2, 0x5b, 0x91, 0x5f, 0xc4, 0xfe, 0xc4, 0xf2, - 0x06, 0x1e, 0x45, 0x7d, 0xd4, 0xd6, 0x88, 0xad, 0x94, 0x1b, 0x80, 0xa4, 0x97, 0xb7, 0x0b, 0x0d, - 0x3c, 0x86, 0x50, 0xc5, 0x54, 0x8d, 0xaa, 0xe2, 0xde, 0x60, 0x23, 0x47, 0xf8, 0xc7, 0xa3, 0xbc, - 0x67, 0xab, 0x51, 0x0b, 0xe5, 0x4e, 0x57, 0x78, 0x6b, 0x0f, 0xa3, 0x9e, 0x1d, 0xe2, 0xde, 0xcf, - 0x23, 0xdd, 0xbc, 0x1b, 0x5a, 0x09, 0xdc, 0x7b, 0xe3, 0xb9, 0xaf, 0x75, 0xf5, 0xf5, 0x0c, 0xf6, - 0x96, 0x50, 0x9d, 0x11, 0xe5, 0xf1, 0x8c, 0xb2, 0x4b, 0x1a, 0x62, 0x15, 0x66, 0x23, 0xca, 0x0c, - 0x66, 0x63, 0x03, 0x0d, 0x84, 0x6a, 0x1e, 0xff, 0x28, 0xb8, 0x90, 0x72, 0x14, 0x84, 0xdc, 0xc0, - 0x31, 0x10, 0xf1, 0x10, 0x5c, 0xd4, 0xcb, 0xee, 0xbc, 0x42, 0x3e, 0x30, 0xf1, 0x11, 0x1c, 0x46, - 0x91, 0xde, 0x00, 0xc5, 0x26, 0x3a, 0xce, 0x97, 0x41, 0x71, 0xa8, 0xe2, 0xaf, 0xbe, 0x8b, 0xe3, - 0x62, 0x0a, 0x8e, 0x70, 0xbe, 0xf9, 0x40, 0x48, 0xc8, 0xbb, 0xb8, 0x00, 0x2b, 0x0a, 0x17, 0xef, - 0x26, 0xb1, 0xb4, 0x2d, 0x5a, 0x22, 0x55, 0xea, 0x10, 0x7c, 0x1e, 0x1d, 0x67, 0xc4, 0x72, 0x17, - 0x2f, 0x7a, 0x68, 0x1c, 0xf3, 0x7a, 0xfd, 0x23, 0xf4, 0x07, 0x01, 0x6e, 0x83, 0x18, 0x1f, 0x01, - 0x78, 0x82, 0x86, 0xfc, 0x7a, 0x8d, 0x29, 0x86, 0xa5, 0x44, 0xaf, 0x3b, 0xa9, 0x95, 0xcb, 0x01, - 0xcc, 0xb7, 0xf6, 0x80, 0x08, 0x0e, 0x1c, 0xae, 0x5a, 0x70, 0xa1, 0x62, 0x0d, 0x9d, 0xac, 0x5b, - 0x9e, 0x6f, 0x2d, 0x28, 0x10, 0xdd, 0xc3, 0xbf, 0xfd, 0x28, 0x81, 0x3f, 0xff, 0x13, 0x13, 0x2b, - 0x30, 0x69, 0x05, 0x5e, 0x88, 0x6e, 0xa9, 0x7b, 0xa1, 0xab, 0xbc, 0x88, 0x06, 0x9a, 0xb5, 0x6c, - 0x40, 0xf0, 0x5c, 0x4a, 0xe8, 0xc0, 0x4b, 0xa9, 0xbf, 0xdc, 0x74, 0x28, 0xfe, 0xaf, 0x13, 0x9d, - 0x09, 0x47, 0x81, 0xe8, 0xeb, 0xee, 0xb6, 0x6a, 0x86, 0x53, 0x50, 0x0f, 0xdf, 0x68, 0x7e, 0xa0, - 0x62, 0x4a, 0xa0, 0x4c, 0x6f, 0x79, 0xde, 0x7c, 0xc0, 0x54, 0x9d, 0x94, 0xc0, 0x6d, 0xee, 0x3f, - 0x02, 0x42, 0xcd, 0x6e, 0xbc, 0x14, 0xde, 0xe5, 0xfd, 0xb3, 0xf9, 0x6c, 0x5e, 0xe1, 0x48, 0xfe, - 0xa9, 0xb0, 0x84, 0xba, 0xeb, 0xae, 0x3b, 0x7e, 0x24, 0x1c, 0xc4, 0x8b, 0x87, 0xcd, 0x33, 0x16, - 0x9f, 0x0b, 0xfe, 0x45, 0xe2, 0x1e, 0x01, 0x77, 0xa9, 0x46, 0x36, 0x55, 0x93, 0x2c, 0xc2, 0x0d, - 0xdf, 0x9c, 0xa3, 0x5d, 0x34, 0x9a, 0x54, 0xd2, 0xfb, 0xd3, 0x76, 0x25, 0x05, 0x41, 0xac, 0xf7, - 0xd2, 0xb0, 0x19, 0x1b, 0x54, 0xfc, 0xbf, 0x80, 0xa6, 0x63, 0xcb, 0xd9, 0x15, 0x6a, 0x17, 0x55, - 0xb6, 0xcc, 0x1c, 0xa3, 0xca, 0x0f, 0x01, 0xff, 0xdc, 0xbc, 0x13, 0xbd, 0x93, 0x07, 0x0a, 0x33, - 0xef, 0x5e, 0x9f, 0x96, 0x74, 0xc3, 0xd9, 0xa9, 0x97, 0xf3, 0x15, 0x5a, 0x95, 0x2b, 0x94, 0x55, - 0x29, 0x83, 0x3f, 0x12, 0xd3, 0x76, 0xa1, 0xe4, 0x7f, 0xa8, 0x9a, 0xb0, 0x05, 0xdb, 0xbd, 0xc6, - 0x9f, 0x20, 0xa9, 0x45, 0xa8, 0x1f, 0xb8, 0xf8, 0x36, 0x91, 0xc8, 0x03, 0x3f, 0xb0, 0x28, 0x5c, - 0xd5, 0xfc, 0x92, 0x66, 0xd1, 0x6a, 0xe5, 0x60, 0x15, 0x78, 0xa8, 0xb6, 0xe9, 0x8c, 0x0a, 0x8c, - 0x9b, 0x90, 0x26, 0x49, 0xd1, 0x80, 0xdc, 0x30, 0xea, 0xe1, 0xc5, 0x80, 0x97, 0x13, 0x5d, 0x25, - 0x68, 0xcd, 0xfe, 0x77, 0x0c, 0x75, 0x73, 0x7b, 0xfc, 0x5c, 0x40, 0x3d, 0x9e, 0x12, 0xc2, 0x52, - 0xd6, 0x3e, 0x8b, 0x48, 0xb0, 0x5c, 0xbe, 0xd5, 0xe1, 0x1e, 0x16, 0x71, 0xf2, 0xef, 0x5f, 0x7e, - 0xfb, 0xef, 0xce, 0xb3, 0xf8, 0x8c, 0x9c, 0x25, 0x23, 0xf1, 0x8f, 0x02, 0x1a, 0x4b, 0x95, 0x4e, - 0x78, 0x29, 0x2b, 0x78, 0x2b, 0x02, 0x2e, 0xb7, 0x7c, 0x48, 0x2f, 0xc0, 0xec, 0x1e, 0x67, 0xb6, - 0x8a, 0x8b, 0x29, 0xcc, 0x4c, 0x95, 0x39, 0x52, 0xcd, 0x73, 0x25, 0xf1, 0x8c, 0x91, 0x6c, 0xcf, - 0x99, 0x54, 0x6e, 0x48, 0xee, 0xb2, 0xca, 0x4f, 0x61, 0x71, 0x9f, 0xe1, 0xef, 0x05, 0x74, 0x2a, - 0xa1, 0x0e, 0xc5, 0xb7, 0x5a, 0xc1, 0x9c, 0x5c, 0x8a, 0xe7, 0x6e, 0xb7, 0x6d, 0x0f, 0x6c, 0x4b, - 0x9c, 0xed, 0x3a, 0x5e, 0xcb, 0x62, 0xeb, 0x67, 0xa6, 0xe4, 0x75, 0x4a, 0xbc, 0xda, 0x91, 0x9f, - 0xee, 0xcf, 0xff, 0x67, 0xf8, 0x1d, 0x2c, 0x78, 0x62, 0xb5, 0xdf, 0xda, 0x82, 0x67, 0x89, 0x85, - 0x9f, 0x27, 0xf9, 0xf8, 0xd5, 0xe6, 0xfb, 0xb9, 0x9d, 0xd5, 0x0e, 0x0b, 0x8e, 0x76, 0x08, 0x47, - 0xb4, 0x45, 0xfb, 0x84, 0xf9, 0x49, 0x13, 0x4f, 0xf8, 0x2b, 0x01, 0xfd, 0x62, 0xdf, 0xc3, 0x01, - 0xbe, 0x9e, 0x05, 0x35, 0xe9, 0x59, 0x23, 0x77, 0xa3, 0x0d, 0x4b, 0xa0, 0x77, 0x87, 0xd3, 0x5b, - 0xc6, 0x8b, 0x29, 0xf4, 0x28, 0x58, 0x4b, 0xce, 0x9e, 0x04, 0x35, 0x5e, 0x3c, 0xaf, 0x2f, 0x04, - 0x74, 0x32, 0xe6, 0xf9, 0x00, 0xff, 0x36, 0xb3, 0x80, 0x49, 0x7c, 0xd7, 0xc8, 0xfd, 0xae, 0x2d, - 0x5b, 0x60, 0x77, 0x83, 0xb3, 0x9b, 0xc3, 0x33, 0x72, 0xc6, 0x63, 0x66, 0xf8, 0x2c, 0xf2, 0x44, - 0xc9, 0x27, 0x02, 0x3a, 0x16, 0x79, 0x40, 0xc0, 0x57, 0x5b, 0x42, 0xf2, 0xde, 0x6b, 0x46, 0xee, - 0xda, 0x01, 0xad, 0x00, 0xf9, 0x0c, 0x47, 0x7e, 0x19, 0x4f, 0x66, 0x22, 0xf7, 0x9f, 0x22, 0xf0, - 0x67, 0x02, 0x1a, 0x08, 0x6b, 0x03, 0x3c, 0x97, 0x15, 0x3a, 0x46, 0x19, 0xe7, 0xae, 0x1e, 0xcc, - 0x08, 0xe0, 0xae, 0x70, 0xb8, 0xbf, 0xc7, 0xb7, 0x52, 0xe0, 0x72, 0x8d, 0x22, 0x39, 0x54, 0xe2, - 0x42, 0x27, 0x3e, 0x83, 0x5c, 0x0e, 0x61, 0xf1, 0x9a, 0xcd, 0x21, 0x46, 0x4a, 0x67, 0x73, 0x88, - 0xd3, 0xc7, 0x2d, 0x71, 0xe0, 0xd0, 0x5d, 0x0e, 0x9c, 0x4c, 0x3c, 0x87, 0xcf, 0x05, 0x74, 0xa2, - 0x48, 0x9c, 0xb0, 0xea, 0xcc, 0xa6, 0x11, 0xa3, 0xbe, 0xb3, 0x69, 0xc4, 0x09, 0x5b, 0x71, 0x89, - 0xd3, 0xb8, 0x85, 0xe7, 0xe5, 0x96, 0x5e, 0xfb, 0x13, 0xb6, 0xf2, 0x47, 0x02, 0x1a, 0x2c, 0x12, - 0x27, 0xa2, 0x5a, 0xb3, 0x0b, 0xa4, 0xc8, 0xf0, 0xec, 0xd4, 0x8f, 0xd5, 0xc4, 0xe2, 0x2c, 0x27, - 0x30, 0x8d, 0xa7, 0x5a, 0xce, 0x25, 0x86, 0xbf, 0x16, 0xd0, 0x70, 0x91, 0x38, 0x71, 0x8a, 0x37, - 0x73, 0xea, 0x63, 0x8c, 0xb2, 0x4f, 0x9d, 0x14, 0x5d, 0x2c, 0xae, 0x71, 0x02, 0x4b, 0xb8, 0x90, - 0x56, 0xe8, 0x41, 0x25, 0xe4, 0xca, 0x6e, 0x97, 0x87, 0xcd, 0x5d, 0xc8, 0x4f, 0xa3, 0xe2, 0xfc, - 0x19, 0xfe, 0x87, 0x80, 0x8e, 0x17, 0x89, 0x13, 0x52, 0xa5, 0x78, 0x38, 0xef, 0xfd, 0xc6, 0x93, - 0xf7, 0x7f, 0xe3, 0xc9, 0x2f, 0x57, 0x6b, 0x4e, 0x23, 0x37, 0xd7, 0xa2, 0x4c, 0x0c, 0x4b, 0x5b, - 0x51, 0xe6, 0x58, 0x27, 0xf1, 0x45, 0x39, 0xeb, 0xb7, 0x19, 0x89, 0x6b, 0x5f, 0xfc, 0xb1, 0x80, - 0x4e, 0x35, 0x01, 0x45, 0x24, 0x67, 0x22, 0xb2, 0xf9, 0xc3, 0x08, 0x58, 0xf1, 0x26, 0x87, 0xf8, - 0x1b, 0x7c, 0x2d, 0x2d, 0xa1, 0x4d, 0x53, 0xf2, 0x61, 0x82, 0x17, 0xc9, 0x13, 0xbb, 0xf8, 0x53, - 0x01, 0x8d, 0x16, 0x89, 0x13, 0xaf, 0x27, 0x13, 0x21, 0x67, 0xd7, 0x1d, 0xa9, 0xfa, 0x54, 0x9c, - 0xe7, 0xa0, 0x7f, 0x8d, 0xaf, 0xca, 0x19, 0xbf, 0x49, 0x49, 0xae, 0x80, 0x95, 0x5c, 0x01, 0x2b, - 0x05, 0x02, 0x16, 0xff, 0xb3, 0x13, 0x4d, 0x64, 0x09, 0x38, 0x5c, 0x3c, 0x68, 0xf1, 0x9e, 0xa0, - 0x56, 0x73, 0x7f, 0x38, 0xbc, 0x23, 0x60, 0xfd, 0x27, 0xce, 0xba, 0x84, 0x37, 0x5a, 0xc8, 0x7c, - 0xef, 0xf6, 0xda, 0xa6, 0xb6, 0xa4, 0xab, 0x4c, 0x22, 0x81, 0xb3, 0xf8, 0xf3, 0xe8, 0x3b, 0x6f, - 0x15, 0xe3, 0xe5, 0x1e, 0xbe, 0x99, 0xc5, 0x20, 0x55, 0x94, 0x66, 0x2f, 0x76, 0xba, 0xca, 0x14, - 0xef, 0x73, 0xda, 0x77, 0xf0, 0x6a, 0x0a, 0xed, 0x7a, 0xe0, 0xc2, 0xab, 0x0c, 0x59, 0x53, 0xf6, - 0xc4, 0xf0, 0x2d, 0xac, 0xbc, 0x78, 0x33, 0x2e, 0xbc, 0x7c, 0x33, 0x2e, 0x7c, 0xf3, 0x66, 0x5c, - 0xf8, 0xd7, 0xdb, 0xf1, 0x8e, 0x97, 0x6f, 0xc7, 0x3b, 0x5e, 0xbd, 0x1d, 0xef, 0xf8, 0xf3, 0x74, - 0xe8, 0x19, 0x21, 0x26, 0xdc, 0x5e, 0xe4, 0x37, 0xc4, 0x72, 0x0f, 0xcf, 0xeb, 0xb9, 0x9f, 0x02, - 0x00, 0x00, 0xff, 0xff, 0xdf, 0x88, 0x94, 0x7b, 0x8e, 0x1e, 0x00, 0x00, + 0xea, 0x55, 0xd5, 0xfb, 0xd5, 0xa0, 0xb3, 0x75, 0xd5, 0xa4, 0x35, 0xb5, 0xba, 0xad, 0x1a, 0x96, + 0xec, 0xfd, 0x2f, 0xb3, 0x9d, 0xe6, 0x13, 0xb5, 0x29, 0x3f, 0x6a, 0x10, 0xbb, 0x99, 0xaf, 0xdb, + 0xd4, 0xa1, 0x78, 0x3c, 0x34, 0x2c, 0xef, 0xfd, 0x9f, 0xf7, 0x86, 0xe5, 0x46, 0x74, 0xaa, 0x53, + 0x3e, 0x4a, 0x76, 0xff, 0xf3, 0x0c, 0x72, 0xbf, 0xd2, 0x29, 0xd5, 0x4d, 0x22, 0xab, 0x75, 0x43, + 0x56, 0x2d, 0x8b, 0x3a, 0xaa, 0x63, 0x50, 0x8b, 0xc1, 0xd7, 0x5f, 0xc2, 0x57, 0xde, 0xaa, 0x34, + 0xb6, 0x64, 0x52, 0xab, 0x3b, 0x10, 0x2b, 0x77, 0x31, 0x19, 0x92, 0xea, 0x38, 0x84, 0x79, 0xae, + 0x60, 0x70, 0x0a, 0xfe, 0x8a, 0xea, 0x54, 0xb7, 0x61, 0xd8, 0x4c, 0xca, 0x30, 0xdb, 0xd0, 0x74, + 0xa2, 0x38, 0xea, 0x2e, 0x8c, 0xbd, 0x9a, 0x3d, 0xd6, 0x56, 0x2d, 0xb6, 0x45, 0x6c, 0xc5, 0x34, + 0x6a, 0x86, 0x03, 0x66, 0xe7, 0x93, 0xcd, 0x74, 0x62, 0x11, 0x66, 0xf8, 0xe4, 0xaf, 0x25, 0x0f, + 0x34, 0x0d, 0x7d, 0xdb, 0x51, 0x2c, 0xaa, 0x11, 0x85, 0xa9, 0x26, 0x51, 0xaa, 0xd4, 0x72, 0x6c, + 0xb5, 0xea, 0x87, 0x38, 0x93, 0x6c, 0x59, 0x63, 0xba, 0xef, 0xff, 0x5c, 0xf2, 0xa8, 0xba, 0x6a, + 0xab, 0x35, 0x96, 0xed, 0xad, 0x4e, 0xa9, 0x99, 0x3d, 0xc1, 0x4e, 0xb3, 0x4e, 0xc0, 0x99, 0x38, + 0x82, 0xf0, 0x7d, 0x37, 0x5f, 0xd6, 0x79, 0x84, 0x32, 0x79, 0xd4, 0x20, 0xcc, 0x11, 0x1f, 0xa2, + 0xe3, 0x91, 0x5e, 0x56, 0xa7, 0x16, 0x23, 0xf8, 0x16, 0xea, 0xf3, 0x90, 0x8c, 0x09, 0x53, 0xc2, + 0x85, 0xc1, 0xc2, 0xa9, 0x7c, 0x62, 0x7a, 0xe5, 0x3d, 0xd3, 0x62, 0xcf, 0x8b, 0xd7, 0x27, 0xbb, + 0xca, 0x60, 0x26, 0x2e, 0xa3, 0x69, 0xee, 0x77, 0x4d, 0x65, 0xce, 0x3a, 0xb1, 0x34, 0xc3, 0xd2, + 0x8b, 0xee, 0x6a, 0x43, 0xdc, 0x62, 0x73, 0x41, 0xd3, 0x6c, 0x68, 0xe0, 0x31, 0xd4, 0xaf, 0x6a, + 0x9a, 0x4d, 0x98, 0x17, 0xee, 0x70, 0xd9, 0x6f, 0x8a, 0x0e, 0x9a, 0x69, 0xc7, 0x0d, 0xa0, 0xbe, + 0x8d, 0x7a, 0x79, 0x4a, 0x8d, 0x09, 0x53, 0x87, 0x2e, 0x0c, 0x16, 0x66, 0x52, 0x40, 0xdf, 0x6b, + 0x38, 0x3a, 0x35, 0x2c, 0x7d, 0x73, 0x97, 0xfb, 0x03, 0xf4, 0x9e, 0xb9, 0x68, 0xa0, 0x09, 0x1e, + 0xf5, 0xbd, 0x41, 0xc4, 0x9f, 0x35, 0x7c, 0x09, 0x61, 0xee, 0x54, 0xb1, 0xc9, 0x16, 0xb1, 0x89, + 0x55, 0x25, 0x8a, 0xa1, 0x01, 0xf6, 0x61, 0xfe, 0xa5, 0xec, 0x7f, 0x58, 0xd1, 0x70, 0x0e, 0x0d, + 0xa8, 0x8c, 0x19, 0xba, 0x45, 0xc8, 0x58, 0x37, 0x1f, 0x13, 0xb4, 0x45, 0x13, 0x4d, 0x26, 0x85, + 0x02, 0x52, 0xab, 0xa8, 0xbf, 0xe2, 0x75, 0x75, 0x4c, 0xcb, 0x77, 0x20, 0x56, 0xd0, 0x49, 0x1e, + 0x2d, 0x3a, 0x87, 0x77, 0xa9, 0x55, 0x25, 0x3e, 0xb5, 0x11, 0xd4, 0x6b, 0xb9, 0x6d, 0xce, 0xa6, + 0xa7, 0xec, 0x35, 0xf0, 0x34, 0x1a, 0xf6, 0x33, 0x5d, 0xf1, 0x97, 0xca, 0xa3, 0x72, 0xcc, 0xef, + 0x5f, 0x80, 0x25, 0xfb, 0x1b, 0x9a, 0x4a, 0x8e, 0xb1, 0x77, 0xa1, 0x84, 0x83, 0x2c, 0xd4, 0x5f, + 0xd0, 0x78, 0x2b, 0xd6, 0x22, 0xb5, 0xb6, 0x0c, 0x3b, 0x48, 0xed, 0x0f, 0xc1, 0x24, 0x17, 0xe7, + 0x1d, 0x38, 0xac, 0xa1, 0x81, 0x2a, 0xf4, 0xb5, 0xb1, 0x30, 0x7f, 0x64, 0x3a, 0x78, 0x08, 0xd3, + 0x08, 0x3c, 0x88, 0x1b, 0xe8, 0x74, 0x90, 0xe8, 0xf7, 0x2a, 0x8c, 0xd8, 0x8f, 0x89, 0xb6, 0xc1, + 0x4d, 0x23, 0xab, 0xb3, 0xaf, 0xc4, 0x13, 0x59, 0x68, 0x13, 0xc6, 0x38, 0x6d, 0x73, 0x13, 0x26, + 0x04, 0xed, 0x4e, 0x08, 0x3a, 0x8f, 0xce, 0xa4, 0x33, 0x81, 0xf9, 0x8b, 0x5d, 0x9e, 0x94, 0x79, + 0x28, 0x9a, 0xb4, 0xba, 0xd3, 0xd9, 0x3c, 0x24, 0x43, 0x02, 0xa7, 0x2d, 0x48, 0x15, 0xb7, 0xc3, + 0x87, 0xc4, 0x1b, 0xe2, 0x5f, 0xd1, 0x18, 0xb7, 0x5e, 0x2e, 0x2f, 0x16, 0x2e, 0x6f, 0xd2, 0x25, + 0x62, 0xd1, 0x5a, 0x28, 0xc7, 0x88, 0x5d, 0x2d, 0x5c, 0x86, 0xd0, 0x5e, 0x63, 0x9f, 0x13, 0x36, + 0x0b, 0x49, 0x1c, 0xf5, 0xdf, 0x82, 0xa4, 0xb9, 0x1d, 0x7e, 0x00, 0xde, 0x08, 0x20, 0xf1, 0xb1, + 0x9b, 0x94, 0x5b, 0x86, 0x20, 0xed, 0xb5, 0xe8, 0x10, 0x52, 0xd4, 0x7f, 0x0b, 0xd2, 0x5e, 0xce, + 0xe2, 0x2b, 0x01, 0x30, 0x2d, 0xb4, 0x2a, 0x80, 0xf0, 0x56, 0xe4, 0x17, 0xb1, 0x3f, 0xb1, 0xbc, + 0x81, 0xc7, 0xd1, 0x00, 0xb5, 0x35, 0x62, 0x2b, 0x95, 0x26, 0x20, 0xe9, 0xe7, 0xed, 0x62, 0x13, + 0x4f, 0x20, 0x54, 0x35, 0x55, 0xa3, 0xa6, 0xb8, 0x37, 0xd8, 0xd8, 0x21, 0xfe, 0xf1, 0x30, 0xef, + 0xd9, 0x6c, 0xd6, 0x43, 0xb9, 0xd3, 0x13, 0xde, 0xda, 0xa3, 0xa8, 0x6f, 0x9b, 0xb8, 0xf7, 0xf3, + 0x58, 0x2f, 0xef, 0x86, 0x56, 0x02, 0xf7, 0xfe, 0x78, 0xee, 0xab, 0x3d, 0x03, 0x7d, 0xc3, 0xfd, + 0x65, 0xd4, 0x60, 0x44, 0x79, 0x3c, 0xab, 0xec, 0x90, 0xa6, 0x58, 0x83, 0xd9, 0x88, 0x32, 0x83, + 0xd9, 0x58, 0x47, 0x43, 0xa1, 0x9a, 0xc7, 0x3f, 0x0a, 0xce, 0xa5, 0x1c, 0x05, 0x21, 0x37, 0x70, + 0x0c, 0x44, 0x3c, 0x04, 0x17, 0xf5, 0xb2, 0x3b, 0xaf, 0x90, 0x0f, 0x4c, 0x7c, 0x04, 0x87, 0x51, + 0xa4, 0x37, 0x40, 0xb1, 0x81, 0x8e, 0xf2, 0x65, 0x50, 0x1c, 0xaa, 0xf8, 0xab, 0xef, 0xe2, 0x38, + 0x9f, 0x82, 0x23, 0x9c, 0x6f, 0x3e, 0x10, 0x12, 0xf2, 0x2e, 0x2e, 0xc0, 0x8a, 0xc2, 0xc5, 0xbb, + 0x41, 0x2c, 0x6d, 0x93, 0x96, 0x49, 0x8d, 0x3a, 0x04, 0x9f, 0x45, 0x47, 0x19, 0xb1, 0xdc, 0xc5, + 0x8b, 0x1e, 0x1a, 0x47, 0xbc, 0x5e, 0xff, 0x08, 0xfd, 0x41, 0x80, 0xdb, 0x20, 0xc6, 0x47, 0x00, + 0x9e, 0xa0, 0x11, 0xbf, 0x5e, 0x63, 0x8a, 0x61, 0x29, 0xd1, 0xeb, 0x4e, 0x6a, 0xe7, 0x72, 0x00, + 0xf3, 0xcd, 0x5d, 0x20, 0x82, 0x03, 0x87, 0x2b, 0x16, 0x5c, 0xa8, 0x58, 0x43, 0xc7, 0x1b, 0x96, + 0xe7, 0x5b, 0x0b, 0x0a, 0x44, 0xf7, 0xf0, 0xef, 0x3c, 0x4a, 0xe0, 0xcf, 0xff, 0xc4, 0xc4, 0x2a, + 0x4c, 0x5a, 0x91, 0x17, 0xa2, 0x9b, 0xea, 0x6e, 0xe8, 0x2a, 0x2f, 0xa1, 0xa1, 0x56, 0x2d, 0x1b, + 0x10, 0x3c, 0x93, 0x12, 0x3a, 0xf0, 0x52, 0x1e, 0xac, 0xb4, 0x1c, 0x8a, 0xff, 0xeb, 0x46, 0xa7, + 0xc2, 0x51, 0x20, 0xfa, 0x9a, 0xbb, 0xad, 0x5a, 0xe1, 0x14, 0xd4, 0xc7, 0x37, 0x9a, 0x1f, 0xa8, + 0x94, 0x12, 0x28, 0xd3, 0x5b, 0x9e, 0x37, 0x1f, 0x30, 0x55, 0x27, 0x65, 0x70, 0x9b, 0xfb, 0x8f, + 0x80, 0x50, 0xab, 0x1b, 0x2f, 0x85, 0x77, 0xf9, 0x60, 0x21, 0x9f, 0xcd, 0x2b, 0x1c, 0xc9, 0x3f, + 0x15, 0x96, 0x50, 0x6f, 0xc3, 0x75, 0xc7, 0x8f, 0x84, 0xfd, 0x78, 0xf1, 0xb0, 0x79, 0xc6, 0xe2, + 0x73, 0xc1, 0xbf, 0x48, 0xdc, 0x23, 0xe0, 0x2e, 0xd5, 0xc8, 0x86, 0x6a, 0x92, 0x45, 0xb8, 0xe1, + 0x5b, 0x73, 0xb4, 0x83, 0xc6, 0x93, 0x4a, 0x7a, 0x7f, 0xda, 0x2e, 0xa7, 0x20, 0x88, 0xf5, 0x5e, + 0x1e, 0x35, 0x63, 0x83, 0x8a, 0xff, 0x17, 0xd0, 0xa5, 0xd8, 0x72, 0xf6, 0x36, 0xb5, 0x4b, 0x2a, + 0x5b, 0x66, 0x8e, 0x51, 0xe3, 0x87, 0x80, 0x7f, 0x6e, 0xde, 0x89, 0xde, 0xc9, 0x43, 0xc5, 0xd9, + 0x77, 0xaf, 0x4f, 0x4a, 0xba, 0xe1, 0x6c, 0x37, 0x2a, 0xf9, 0x2a, 0xad, 0xc9, 0x55, 0xca, 0x6a, + 0x94, 0xc1, 0x1f, 0x89, 0x69, 0x3b, 0x50, 0xf2, 0x3f, 0x54, 0x4d, 0xd8, 0x82, 0x9d, 0x5e, 0xe3, + 0x4f, 0x90, 0xd4, 0x26, 0xd4, 0x0f, 0x5c, 0x7c, 0x9b, 0x48, 0xe4, 0x81, 0x1f, 0x58, 0x14, 0xae, + 0x6a, 0x7e, 0x49, 0xb3, 0x68, 0xb5, 0xb2, 0xbf, 0x0a, 0x3c, 0x54, 0xdb, 0x74, 0x47, 0x05, 0xc6, + 0x0d, 0x48, 0x93, 0xa4, 0x68, 0x40, 0x6e, 0x14, 0xf5, 0xf1, 0x62, 0xc0, 0xcb, 0x89, 0x9e, 0x32, + 0xb4, 0x0a, 0xff, 0x9d, 0x40, 0xbd, 0xdc, 0x1e, 0x3f, 0x17, 0x50, 0x9f, 0xa7, 0x84, 0xb0, 0x94, + 0xb5, 0xcf, 0x22, 0x12, 0x2c, 0x97, 0x6f, 0x77, 0xb8, 0x87, 0x45, 0x9c, 0xfe, 0xfb, 0x97, 0xdf, + 0xfe, 0xbb, 0xfb, 0x34, 0x3e, 0x25, 0x67, 0xc9, 0x48, 0xfc, 0xa3, 0x80, 0x26, 0x52, 0xa5, 0x13, + 0x5e, 0xca, 0x0a, 0xde, 0x8e, 0x80, 0xcb, 0x2d, 0x1f, 0xd0, 0x0b, 0x30, 0xbb, 0xc7, 0x99, 0xad, + 0xe0, 0x52, 0x0a, 0x33, 0x53, 0x65, 0x8e, 0x54, 0xf7, 0x5c, 0x49, 0x3c, 0x63, 0x24, 0xdb, 0x73, + 0x26, 0x55, 0x9a, 0x92, 0xbb, 0xac, 0xf2, 0x53, 0x58, 0xdc, 0x67, 0xf8, 0x7b, 0x01, 0x9d, 0x48, + 0xa8, 0x43, 0xf1, 0xcd, 0x76, 0x30, 0x27, 0x97, 0xe2, 0xb9, 0x5b, 0x1d, 0xdb, 0x03, 0xdb, 0x32, + 0x67, 0xbb, 0x86, 0x57, 0xb3, 0xd8, 0xfa, 0x99, 0x29, 0x79, 0x9d, 0x12, 0xaf, 0x76, 0xe4, 0xa7, + 0x7b, 0xf3, 0xff, 0x19, 0x7e, 0x07, 0x0b, 0x9e, 0x58, 0xed, 0xb7, 0xb7, 0xe0, 0x59, 0x62, 0xe1, + 0xe7, 0x49, 0x3e, 0x7e, 0xb5, 0xf9, 0x7e, 0xee, 0x64, 0xb5, 0xc3, 0x82, 0xa3, 0x13, 0xc2, 0x11, + 0x6d, 0xd1, 0x39, 0x61, 0x7e, 0xd2, 0xc4, 0x13, 0xfe, 0x4a, 0x40, 0xbf, 0xd8, 0xf3, 0x70, 0x80, + 0xaf, 0x65, 0x41, 0x4d, 0x7a, 0xd6, 0xc8, 0x5d, 0xef, 0xc0, 0x12, 0xe8, 0xdd, 0xe1, 0xf4, 0x96, + 0xf1, 0x62, 0x0a, 0x3d, 0x0a, 0xd6, 0x92, 0xb3, 0x2b, 0x41, 0x8d, 0x17, 0xcf, 0xeb, 0x0b, 0x01, + 0x1d, 0x8f, 0x79, 0x3e, 0xc0, 0xbf, 0xcd, 0x2c, 0x60, 0x12, 0xdf, 0x35, 0x72, 0xbf, 0xeb, 0xc8, + 0x16, 0xd8, 0x5d, 0xe7, 0xec, 0xe6, 0xf0, 0xac, 0x9c, 0xf1, 0x98, 0x19, 0x3e, 0x8b, 0x3c, 0x51, + 0xf2, 0x89, 0x80, 0x8e, 0x44, 0x1e, 0x10, 0xf0, 0x95, 0xb6, 0x90, 0xbc, 0xf7, 0x9a, 0x91, 0xbb, + 0xba, 0x4f, 0x2b, 0x40, 0x3e, 0xcb, 0x91, 0x5f, 0xc4, 0xd3, 0x99, 0xc8, 0xfd, 0xa7, 0x08, 0xfc, + 0x99, 0x80, 0x86, 0xc2, 0xda, 0x00, 0xcf, 0x65, 0x85, 0x8e, 0x51, 0xc6, 0xb9, 0x2b, 0xfb, 0x33, + 0x02, 0xb8, 0xb7, 0x39, 0xdc, 0xdf, 0xe3, 0x9b, 0x29, 0x70, 0xb9, 0x46, 0x91, 0x1c, 0x2a, 0x71, + 0xa1, 0x13, 0x9f, 0x41, 0x2e, 0x87, 0xb0, 0x78, 0xcd, 0xe6, 0x10, 0x23, 0xa5, 0xb3, 0x39, 0xc4, + 0xe9, 0xe3, 0xb6, 0x38, 0x70, 0xe8, 0x2e, 0x07, 0x4e, 0x26, 0x9e, 0xc3, 0xe7, 0x02, 0x3a, 0x56, + 0x22, 0x4e, 0x58, 0x75, 0x66, 0xd3, 0x88, 0x51, 0xdf, 0xd9, 0x34, 0xe2, 0x84, 0xad, 0xb8, 0xc4, + 0x69, 0xdc, 0xc4, 0xf3, 0x72, 0x5b, 0xaf, 0xfd, 0x09, 0x5b, 0xf9, 0x23, 0x01, 0x0d, 0x97, 0x88, + 0x13, 0x51, 0xad, 0xd9, 0x05, 0x52, 0x64, 0x78, 0x76, 0xea, 0xc7, 0x6a, 0x62, 0xb1, 0xc0, 0x09, + 0x5c, 0xc2, 0x33, 0x6d, 0xe7, 0x12, 0xc3, 0x5f, 0x0b, 0x68, 0xb4, 0x44, 0x9c, 0x38, 0xc5, 0x9b, + 0x39, 0xf5, 0x31, 0x46, 0xd9, 0xa7, 0x4e, 0x8a, 0x2e, 0x16, 0x57, 0x39, 0x81, 0x25, 0x5c, 0x4c, + 0x2b, 0xf4, 0xa0, 0x12, 0x72, 0x65, 0xb7, 0xcb, 0xc3, 0xe6, 0x2e, 0xe4, 0xa7, 0x51, 0x71, 0xfe, + 0x0c, 0xff, 0x43, 0x40, 0x47, 0x4b, 0xc4, 0x09, 0xa9, 0x52, 0x3c, 0x9a, 0xf7, 0x7e, 0xe3, 0xc9, + 0xfb, 0xbf, 0xf1, 0xe4, 0x97, 0x6b, 0x75, 0xa7, 0x99, 0x9b, 0x6b, 0x53, 0x26, 0x86, 0xa5, 0xad, + 0x28, 0x73, 0xac, 0xd3, 0xf8, 0xbc, 0x9c, 0xf5, 0xdb, 0x8c, 0xc4, 0xb5, 0x2f, 0xfe, 0x58, 0x40, + 0x27, 0x5a, 0x80, 0x22, 0x92, 0x33, 0x11, 0xd9, 0xfc, 0x41, 0x04, 0xac, 0x78, 0x83, 0x43, 0xfc, + 0x0d, 0xbe, 0x9a, 0x96, 0xd0, 0xa6, 0x29, 0xf9, 0x30, 0xc1, 0x8b, 0xe4, 0x89, 0x5d, 0xfc, 0xa9, + 0x80, 0xc6, 0x4b, 0xc4, 0x89, 0xd7, 0x93, 0x89, 0x90, 0xb3, 0xeb, 0x8e, 0x54, 0x7d, 0x2a, 0xce, + 0x73, 0xd0, 0xbf, 0xc6, 0x57, 0xe4, 0x8c, 0xdf, 0xa4, 0x24, 0x57, 0xc0, 0x4a, 0xae, 0x80, 0x95, + 0x02, 0x01, 0x8b, 0xff, 0xd9, 0x8d, 0xa6, 0xb2, 0x04, 0x1c, 0x2e, 0xed, 0xb7, 0x78, 0x4f, 0x50, + 0xab, 0xb9, 0x3f, 0x1c, 0xdc, 0x11, 0xb0, 0xfe, 0x13, 0x67, 0x5d, 0xc6, 0xeb, 0x6d, 0x64, 0xbe, + 0x77, 0x7b, 0x6d, 0x51, 0x5b, 0xd2, 0x55, 0x26, 0x91, 0xc0, 0x59, 0xfc, 0x79, 0xf4, 0x9d, 0xb7, + 0x8a, 0xf1, 0x72, 0x0f, 0xdf, 0xc8, 0x62, 0x90, 0x2a, 0x4a, 0xb3, 0x17, 0x3b, 0x5d, 0x65, 0x8a, + 0xf7, 0x39, 0xed, 0x3b, 0x78, 0x25, 0x85, 0x76, 0x23, 0x70, 0xe1, 0x55, 0x86, 0xac, 0x25, 0x7b, + 0x62, 0xf8, 0x16, 0x57, 0x5e, 0xbc, 0x99, 0x14, 0x5e, 0xbe, 0x99, 0x14, 0xbe, 0x79, 0x33, 0x29, + 0xfc, 0xeb, 0xed, 0x64, 0xd7, 0xcb, 0xb7, 0x93, 0x5d, 0xaf, 0xde, 0x4e, 0x76, 0xfd, 0x59, 0x0e, + 0x3d, 0x23, 0xc4, 0x84, 0x7b, 0x5c, 0x90, 0x77, 0x23, 0x3f, 0x23, 0x56, 0xfa, 0x78, 0x6a, 0xcf, + 0xfd, 0x14, 0x00, 0x00, 0xff, 0xff, 0x04, 0x1d, 0xfd, 0x80, 0x91, 0x1e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -2014,60 +2188,76 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } + func (*UnimplementedQueryServer) LastPendingBatchRequestByAddr(ctx context.Context, req *QueryLastPendingBatchRequestByAddrRequest) (*QueryLastPendingBatchRequestByAddrResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method LastPendingBatchRequestByAddr not implemented") } + func (*UnimplementedQueryServer) LastObservedSkywayNonce(ctx context.Context, req *QueryLastObservedSkywayNonceRequest) (*QueryLastObservedSkywayNonceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method LastObservedSkywayNonce not implemented") } + func (*UnimplementedQueryServer) LastObservedSkywayNonceByAddr(ctx context.Context, req *QueryLastObservedSkywayNonceByAddrRequest) (*QueryLastObservedSkywayNonceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method LastObservedSkywayNonceByAddr not implemented") } + func (*UnimplementedQueryServer) LastObservedSkywayBlock(ctx context.Context, req *QueryLastObservedSkywayBlockRequest) (*QueryLastObservedSkywayBlockResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method LastObservedSkywayBlock not implemented") } + func (*UnimplementedQueryServer) OutgoingTxBatches(ctx context.Context, req *QueryOutgoingTxBatchesRequest) (*QueryOutgoingTxBatchesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method OutgoingTxBatches not implemented") } + func (*UnimplementedQueryServer) BatchRequestByNonce(ctx context.Context, req *QueryBatchRequestByNonceRequest) (*QueryBatchRequestByNonceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method BatchRequestByNonce not implemented") } + func (*UnimplementedQueryServer) BatchConfirms(ctx context.Context, req *QueryBatchConfirmsRequest) (*QueryBatchConfirmsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method BatchConfirms not implemented") } + func (*UnimplementedQueryServer) ERC20ToDenom(ctx context.Context, req *QueryERC20ToDenomRequest) (*QueryERC20ToDenomResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ERC20ToDenom not implemented") } + func (*UnimplementedQueryServer) DenomToERC20(ctx context.Context, req *QueryDenomToERC20Request) (*QueryDenomToERC20Response, error) { return nil, status.Errorf(codes.Unimplemented, "method DenomToERC20 not implemented") } + func (*UnimplementedQueryServer) GetAttestations(ctx context.Context, req *QueryAttestationsRequest) (*QueryAttestationsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetAttestations not implemented") } + func (*UnimplementedQueryServer) GetErc20ToDenoms(ctx context.Context, req *QueryErc20ToDenoms) (*QueryErc20ToDenomsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetErc20ToDenoms not implemented") } + func (*UnimplementedQueryServer) GetPendingSendToRemote(ctx context.Context, req *QueryPendingSendToRemote) (*QueryPendingSendToRemoteResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetPendingSendToRemote not implemented") } + func (*UnimplementedQueryServer) GetBridgeTaxes(ctx context.Context, req *emptypb.Empty) (*QueryBridgeTaxesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetBridgeTaxes not implemented") } + func (*UnimplementedQueryServer) GetBridgeTransferLimits(ctx context.Context, req *emptypb.Empty) (*QueryBridgeTransferLimitsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetBridgeTransferLimits not implemented") } + func (*UnimplementedQueryServer) GetLightNodeSaleContracts(ctx context.Context, req *emptypb.Empty) (*QueryLightNodeSaleContractsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetLightNodeSaleContracts not implemented") } + func (*UnimplementedQueryServer) LastPendingBatchForGasEstimation(ctx context.Context, req *QueryLastPendingBatchForGasEstimationRequest) (*QueryLastPendingBatchForGasEstimationResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method LastPendingBatchForGasEstimation not implemented") } + func (*UnimplementedQueryServer) GetUnobservedBlocksByAddr(ctx context.Context, req *QueryUnobservedBlocksByAddrRequest) (*QueryUnobservedBlocksByAddrResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetUnobservedBlocksByAddr not implemented") } @@ -3663,6 +3853,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QueryParamsRequest) Size() (n int) { if m == nil { return 0 @@ -4161,9 +4352,11 @@ func (m *QueryUnobservedBlocksByAddrResponse) Size() (n int) { 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 *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4214,6 +4407,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4297,6 +4491,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryLastPendingBatchRequestByAddrRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4379,6 +4574,7 @@ func (m *QueryLastPendingBatchRequestByAddrRequest) Unmarshal(dAtA []byte) error } return nil } + func (m *QueryLastPendingBatchRequestByAddrResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4463,6 +4659,7 @@ func (m *QueryLastPendingBatchRequestByAddrResponse) Unmarshal(dAtA []byte) erro } return nil } + func (m *QueryOutgoingTxBatchesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4577,6 +4774,7 @@ func (m *QueryOutgoingTxBatchesRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryOutgoingTxBatchesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4661,6 +4859,7 @@ func (m *QueryOutgoingTxBatchesResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBatchRequestByNonceRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4762,6 +4961,7 @@ func (m *QueryBatchRequestByNonceRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBatchRequestByNonceResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4845,6 +5045,7 @@ func (m *QueryBatchRequestByNonceResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBatchConfirmsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4946,6 +5147,7 @@ func (m *QueryBatchConfirmsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBatchConfirmsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5030,6 +5232,7 @@ func (m *QueryBatchConfirmsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryLastObservedSkywayNonceRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5112,6 +5315,7 @@ func (m *QueryLastObservedSkywayNonceRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryLastObservedSkywayNonceByAddrRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5226,6 +5430,7 @@ func (m *QueryLastObservedSkywayNonceByAddrRequest) Unmarshal(dAtA []byte) error } return nil } + func (m *QueryLastObservedSkywayNonceResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5295,6 +5500,7 @@ func (m *QueryLastObservedSkywayNonceResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryLastObservedSkywayBlockRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5377,6 +5583,7 @@ func (m *QueryLastObservedSkywayBlockRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryLastObservedSkywayBlockResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5446,6 +5653,7 @@ func (m *QueryLastObservedSkywayBlockResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryERC20ToDenomRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5560,6 +5768,7 @@ func (m *QueryERC20ToDenomRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryERC20ToDenomResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5642,6 +5851,7 @@ func (m *QueryERC20ToDenomResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryDenomToERC20Request) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5756,6 +5966,7 @@ func (m *QueryDenomToERC20Request) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryDenomToERC20Response) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5838,6 +6049,7 @@ func (m *QueryDenomToERC20Response) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAttestationsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6041,6 +6253,7 @@ func (m *QueryAttestationsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAttestationsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6125,6 +6338,7 @@ func (m *QueryAttestationsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryErc20ToDenoms) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6175,6 +6389,7 @@ func (m *QueryErc20ToDenoms) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryErc20ToDenomsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6259,6 +6474,7 @@ func (m *QueryErc20ToDenomsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryPendingSendToRemote) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6341,6 +6557,7 @@ func (m *QueryPendingSendToRemote) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryPendingSendToRemoteResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6459,6 +6676,7 @@ func (m *QueryPendingSendToRemoteResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBridgeTaxesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6543,6 +6761,7 @@ func (m *QueryBridgeTaxesResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBridgeTransferLimitsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6627,6 +6846,7 @@ func (m *QueryBridgeTransferLimitsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBridgeTransferLimitsResponse_LimitUsage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6749,6 +6969,7 @@ func (m *QueryBridgeTransferLimitsResponse_LimitUsage) Unmarshal(dAtA []byte) er } return nil } + func (m *QueryLightNodeSaleContractsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6833,6 +7054,7 @@ func (m *QueryLightNodeSaleContractsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryLastPendingBatchForGasEstimationRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -6949,6 +7171,7 @@ func (m *QueryLastPendingBatchForGasEstimationRequest) Unmarshal(dAtA []byte) er } return nil } + func (m *QueryLastPendingBatchForGasEstimationResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -7033,6 +7256,7 @@ func (m *QueryLastPendingBatchForGasEstimationResponse) Unmarshal(dAtA []byte) e } return nil } + func (m *QueryUnobservedBlocksByAddrRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -7147,6 +7371,7 @@ func (m *QueryUnobservedBlocksByAddrRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryUnobservedBlocksByAddrResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -7273,6 +7498,7 @@ func (m *QueryUnobservedBlocksByAddrResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/skyway/types/types.pb.go b/x/skyway/types/types.pb.go index 98a97802..19f9a370 100644 --- a/x/skyway/types/types.pb.go +++ b/x/skyway/types/types.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/cosmos-sdk/x/bank/types" _ "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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*BridgeValidator) ProtoMessage() {} func (*BridgeValidator) Descriptor() ([]byte, []int) { return fileDescriptor_612aaf09f1f80ffb, []int{0} } + func (m *BridgeValidator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *BridgeValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BridgeValidator.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *BridgeValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } + func (m *BridgeValidator) XXX_Merge(src proto.Message) { xxx_messageInfo_BridgeValidator.Merge(m, src) } + func (m *BridgeValidator) XXX_Size() int { return m.Size() } + func (m *BridgeValidator) XXX_DiscardUnknown() { xxx_messageInfo_BridgeValidator.DiscardUnknown(m) } @@ -94,9 +102,11 @@ func (*LastObservedEthereumBlockHeight) ProtoMessage() {} func (*LastObservedEthereumBlockHeight) Descriptor() ([]byte, []int) { return fileDescriptor_612aaf09f1f80ffb, []int{1} } + func (m *LastObservedEthereumBlockHeight) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *LastObservedEthereumBlockHeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LastObservedEthereumBlockHeight.Marshal(b, m, deterministic) @@ -109,12 +119,15 @@ func (m *LastObservedEthereumBlockHeight) XXX_Marshal(b []byte, deterministic bo return b[:n], nil } } + func (m *LastObservedEthereumBlockHeight) XXX_Merge(src proto.Message) { xxx_messageInfo_LastObservedEthereumBlockHeight.Merge(m, src) } + func (m *LastObservedEthereumBlockHeight) XXX_Size() int { return m.Size() } + func (m *LastObservedEthereumBlockHeight) XXX_DiscardUnknown() { xxx_messageInfo_LastObservedEthereumBlockHeight.DiscardUnknown(m) } @@ -149,9 +162,11 @@ func (*ERC20ToDenom) ProtoMessage() {} func (*ERC20ToDenom) Descriptor() ([]byte, []int) { return fileDescriptor_612aaf09f1f80ffb, []int{2} } + func (m *ERC20ToDenom) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ERC20ToDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ERC20ToDenom.Marshal(b, m, deterministic) @@ -164,12 +179,15 @@ func (m *ERC20ToDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *ERC20ToDenom) XXX_Merge(src proto.Message) { xxx_messageInfo_ERC20ToDenom.Merge(m, src) } + func (m *ERC20ToDenom) XXX_Size() int { return m.Size() } + func (m *ERC20ToDenom) XXX_DiscardUnknown() { xxx_messageInfo_ERC20ToDenom.DiscardUnknown(m) } @@ -208,30 +226,30 @@ func init() { } var fileDescriptor_612aaf09f1f80ffb = []byte{ - // 361 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0xcd, 0x4a, 0xfb, 0x40, - 0x14, 0xc5, 0x9b, 0xfe, 0x3f, 0xa0, 0x83, 0xd0, 0x9a, 0x56, 0xa8, 0x2e, 0x62, 0x29, 0x08, 0x15, - 0x4a, 0xa6, 0xad, 0x4f, 0x60, 0xb5, 0xa2, 0x20, 0x08, 0x41, 0x5c, 0xb8, 0x09, 0x93, 0xcc, 0x35, - 0x09, 0x6d, 0x32, 0x61, 0x66, 0xda, 0xda, 0x07, 0x70, 0xef, 0x63, 0xb9, 0xec, 0xd2, 0xa5, 0xb4, - 0x2f, 0x22, 0x33, 0x93, 0x96, 0x16, 0xdd, 0xdd, 0x73, 0x7e, 0xe7, 0x72, 0xb8, 0xcc, 0xa0, 0xb3, - 0x9c, 0x4c, 0x58, 0x4a, 0xc2, 0x98, 0x24, 0x19, 0x36, 0x33, 0x16, 0xe3, 0xc5, 0x9c, 0x2c, 0xb0, - 0x5c, 0xe4, 0x20, 0xdc, 0x9c, 0x33, 0xc9, 0xec, 0xe3, 0x9d, 0x98, 0x6b, 0x66, 0xd7, 0xc4, 0x4e, - 0x9c, 0x90, 0x89, 0x94, 0x09, 0x1c, 0x10, 0x01, 0x78, 0xd6, 0x0f, 0x40, 0x92, 0x3e, 0x0e, 0x99, - 0xca, 0xa9, 0xd5, 0x1d, 0x9e, 0x8d, 0xb7, 0x5c, 0x89, 0x82, 0x37, 0x22, 0x16, 0x31, 0x3d, 0x62, - 0x35, 0x19, 0xb7, 0xed, 0xa1, 0xea, 0x90, 0x27, 0x34, 0x82, 0x27, 0x32, 0x49, 0x28, 0x91, 0x8c, - 0xdb, 0x0d, 0xf4, 0x2f, 0x67, 0x73, 0xe0, 0x4d, 0xab, 0x65, 0x75, 0xfe, 0x7a, 0x46, 0xd8, 0xe7, - 0xa8, 0x06, 0x32, 0x06, 0x0e, 0xd3, 0xd4, 0x27, 0x94, 0x72, 0x10, 0xa2, 0x59, 0x6e, 0x59, 0x9d, - 0x8a, 0x57, 0xdd, 0xf8, 0x97, 0xc6, 0x6e, 0xbf, 0x59, 0xe8, 0xf4, 0x9e, 0x08, 0xf9, 0x10, 0x08, - 0xe0, 0x33, 0xa0, 0xa3, 0x82, 0x0f, 0x27, 0x2c, 0x1c, 0xdf, 0x42, 0x12, 0xc5, 0xd2, 0x76, 0x51, - 0xdd, 0x9c, 0xe7, 0x07, 0xca, 0xf5, 0x63, 0x6d, 0x17, 0x95, 0x87, 0x06, 0xed, 0xe6, 0x07, 0xe8, - 0x68, 0x5b, 0xbf, 0xb7, 0x51, 0xd6, 0x1b, 0x75, 0xf8, 0xd9, 0xd1, 0x8e, 0xd1, 0xc1, 0xc8, 0xbb, - 0x1a, 0xf4, 0x1e, 0xd9, 0x35, 0x64, 0x2c, 0x55, 0x87, 0x01, 0x0f, 0x07, 0x3d, 0xdd, 0x52, 0xf1, - 0x8c, 0x50, 0x2e, 0x55, 0xb8, 0xb8, 0xc6, 0x08, 0xbb, 0x8b, 0x6c, 0xfd, 0x08, 0x3e, 0x87, 0x17, - 0xe0, 0x90, 0x85, 0xe0, 0x27, 0xb4, 0xf9, 0x47, 0x47, 0x6a, 0x9a, 0x78, 0x1b, 0x70, 0x47, 0x87, - 0x37, 0x1f, 0x2b, 0xc7, 0x5a, 0xae, 0x1c, 0xeb, 0x6b, 0xe5, 0x58, 0xef, 0x6b, 0xa7, 0xb4, 0x5c, - 0x3b, 0xa5, 0xcf, 0xb5, 0x53, 0x7a, 0xee, 0x46, 0x89, 0x8c, 0xa7, 0x81, 0x1b, 0xb2, 0x14, 0xff, - 0xf2, 0x05, 0x5e, 0xf7, 0x3e, 0x41, 0xf0, 0x5f, 0x3f, 0xca, 0xc5, 0x77, 0x00, 0x00, 0x00, 0xff, - 0xff, 0xf2, 0x38, 0x79, 0x46, 0x2e, 0x02, 0x00, 0x00, + // 363 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0xcf, 0x6a, 0xf2, 0x40, + 0x14, 0xc5, 0x8d, 0xdf, 0x1f, 0x70, 0xf8, 0x40, 0xbf, 0x68, 0xc1, 0x76, 0x91, 0x8a, 0x50, 0xb0, + 0x50, 0x32, 0x9a, 0x3e, 0x41, 0x6d, 0x85, 0x0a, 0x85, 0x42, 0x28, 0x5d, 0x74, 0x13, 0x26, 0x99, + 0xdb, 0x24, 0x68, 0x32, 0x61, 0x66, 0xd4, 0xfa, 0x00, 0xdd, 0xf7, 0xb1, 0xba, 0x74, 0xd9, 0x65, + 0xd1, 0x17, 0x29, 0x33, 0x13, 0x45, 0x69, 0x77, 0xf7, 0x9c, 0xdf, 0xb9, 0x1c, 0x2e, 0x33, 0xe8, + 0xac, 0x20, 0x53, 0x96, 0x91, 0x28, 0x21, 0x69, 0x8e, 0xcd, 0x8c, 0xc5, 0x64, 0xb9, 0x20, 0x4b, + 0x2c, 0x97, 0x05, 0x08, 0xb7, 0xe0, 0x4c, 0x32, 0xfb, 0x78, 0x2f, 0xe6, 0x9a, 0xd9, 0x35, 0xb1, + 0x13, 0x27, 0x62, 0x22, 0x63, 0x02, 0x87, 0x44, 0x00, 0x9e, 0x0f, 0x42, 0x90, 0x64, 0x80, 0x23, + 0xa6, 0x72, 0x6a, 0x75, 0x8f, 0xe7, 0x93, 0x1d, 0x57, 0xa2, 0xe4, 0xad, 0x98, 0xc5, 0x4c, 0x8f, + 0x58, 0x4d, 0xc6, 0xed, 0xfa, 0xa8, 0x3e, 0xe4, 0x29, 0x8d, 0xe1, 0x91, 0x4c, 0x53, 0x4a, 0x24, + 0xe3, 0x76, 0x0b, 0xfd, 0x29, 0xd8, 0x02, 0x78, 0xdb, 0xea, 0x58, 0xbd, 0xdf, 0xbe, 0x11, 0xf6, + 0x39, 0x6a, 0x80, 0x4c, 0x80, 0xc3, 0x2c, 0x0b, 0x08, 0xa5, 0x1c, 0x84, 0x68, 0x57, 0x3b, 0x56, + 0xaf, 0xe6, 0xd7, 0xb7, 0xfe, 0x95, 0xb1, 0xbb, 0xaf, 0x16, 0x3a, 0xbd, 0x23, 0x42, 0xde, 0x87, + 0x02, 0xf8, 0x1c, 0xe8, 0xa8, 0xe4, 0xc3, 0x29, 0x8b, 0x26, 0xb7, 0x90, 0xc6, 0x89, 0xb4, 0x5d, + 0xd4, 0x34, 0xe7, 0x05, 0xa1, 0x72, 0x83, 0x44, 0xdb, 0x65, 0xe5, 0x7f, 0x83, 0xf6, 0xf3, 0x1e, + 0x3a, 0xda, 0xd5, 0x1f, 0x6c, 0x54, 0xf5, 0x46, 0x13, 0xbe, 0x77, 0x74, 0x13, 0xf4, 0x6f, 0xe4, + 0x5f, 0x7b, 0xfd, 0x07, 0x76, 0x03, 0x39, 0xcb, 0xd4, 0x61, 0xc0, 0x23, 0xaf, 0xaf, 0x5b, 0x6a, + 0xbe, 0x11, 0xca, 0xa5, 0x0a, 0x97, 0xd7, 0x18, 0x61, 0x5f, 0x20, 0x5b, 0x3f, 0x42, 0xc0, 0xe1, + 0x19, 0x38, 0xe4, 0x11, 0x04, 0x29, 0x6d, 0xff, 0xd2, 0x91, 0x86, 0x26, 0xfe, 0x16, 0x8c, 0xe9, + 0x70, 0xfc, 0xbe, 0x76, 0xac, 0xd5, 0xda, 0xb1, 0x3e, 0xd7, 0x8e, 0xf5, 0xb6, 0x71, 0x2a, 0xab, + 0x8d, 0x53, 0xf9, 0xd8, 0x38, 0x95, 0x27, 0x1c, 0xa7, 0x32, 0x99, 0x85, 0x6e, 0xc4, 0x32, 0xfc, + 0xc3, 0x17, 0x98, 0x7b, 0xf8, 0xe5, 0xe0, 0x1f, 0x84, 0x7f, 0xf5, 0xbb, 0x5c, 0x7e, 0x05, 0x00, + 0x00, 0xff, 0xff, 0xf7, 0xf8, 0x16, 0x8a, 0x31, 0x02, 0x00, 0x00, } func (m *BridgeValidator) Marshal() (dAtA []byte, err error) { @@ -357,6 +375,7 @@ func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *BridgeValidator) Size() (n int) { if m == nil { return 0 @@ -412,9 +431,11 @@ func (m *ERC20ToDenom) Size() (n int) { func sovTypes(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozTypes(x uint64) (n int) { return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *BridgeValidator) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -516,6 +537,7 @@ func (m *BridgeValidator) Unmarshal(dAtA []byte) error { } return nil } + func (m *LastObservedEthereumBlockHeight) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -604,6 +626,7 @@ func (m *LastObservedEthereumBlockHeight) Unmarshal(dAtA []byte) error { } return nil } + func (m *ERC20ToDenom) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -750,6 +773,7 @@ func (m *ERC20ToDenom) Unmarshal(dAtA []byte) error { } return nil } + func skipTypes(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/tokenfactory/types/params.go b/x/tokenfactory/types/params.go index e1b57376..bab9041f 100644 --- a/x/tokenfactory/types/params.go +++ b/x/tokenfactory/types/params.go @@ -7,6 +7,10 @@ import ( paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) +const ( + cDefaultBondDenom string = "ugrain" +) + var KeyDenomCreationFee = []byte("DenomCreationFee") func ParamKeyTable() paramtypes.KeyTable { @@ -21,7 +25,7 @@ func NewParams(denomCreationFee sdk.Coins) Params { func DefaultParams() Params { return Params{ - DenomCreationFee: sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 10_000_000)), // 10 GRAIN + DenomCreationFee: sdk.NewCoins(sdk.NewInt64Coin(cDefaultBondDenom, 10_000_000)), // 10 GRAIN } } diff --git a/x/treasury/types/community_fund_fee_proposal.pb.go b/x/treasury/types/community_fund_fee_proposal.pb.go index 0f78c15f..080beecb 100644 --- a/x/treasury/types/community_fund_fee_proposal.pb.go +++ b/x/treasury/types/community_fund_fee_proposal.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*CommunityFundFeeProposal) ProtoMessage() {} func (*CommunityFundFeeProposal) Descriptor() ([]byte, []int) { return fileDescriptor_c3b9afded0ada472, []int{0} } + func (m *CommunityFundFeeProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *CommunityFundFeeProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommunityFundFeeProposal.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *CommunityFundFeeProposal) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *CommunityFundFeeProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_CommunityFundFeeProposal.Merge(m, src) } + func (m *CommunityFundFeeProposal) XXX_Size() int { return m.Size() } + func (m *CommunityFundFeeProposal) XXX_DiscardUnknown() { xxx_messageInfo_CommunityFundFeeProposal.DiscardUnknown(m) } @@ -92,7 +100,7 @@ func init() { } var fileDescriptor_c3b9afded0ada472 = []byte{ - // 246 bytes of a gzipped FileDescriptorProto + // 249 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x2d, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x4b, 0x8a, 0x52, 0x13, 0x8b, 0x4b, 0x8b, 0x2a, 0xf5, 0x93, 0xf3, 0x73, 0x73, 0x4b, 0xf3, 0x32, 0x4b, 0x2a, 0xe3, 0xd3, 0x4a, @@ -104,11 +112,11 @@ var fileDescriptor_c3b9afded0ada472 = []byte{ 0x10, 0x8e, 0x90, 0x02, 0x17, 0x77, 0x4a, 0x6a, 0x71, 0x72, 0x51, 0x66, 0x41, 0x49, 0x66, 0x7e, 0x9e, 0x04, 0x13, 0x58, 0x0e, 0x59, 0x48, 0x48, 0x81, 0x8b, 0x39, 0x2d, 0x35, 0x55, 0x82, 0x19, 0x24, 0xe3, 0xc4, 0x77, 0x69, 0x8b, 0x2e, 0x17, 0xd4, 0x4a, 0x97, 0xd4, 0xe4, 0x20, 0x90, 0x94, - 0x93, 0xc7, 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, 0xe9, 0xa5, 0x67, 0x96, - 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x63, 0x09, 0x91, 0x0a, 0x44, 0x98, 0x94, 0x54, - 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0xbd, 0x61, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x92, 0xad, - 0x39, 0xee, 0x3f, 0x01, 0x00, 0x00, + 0x93, 0xf7, 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, 0x19, 0xa6, 0x67, 0x96, + 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x63, 0x09, 0x91, 0x32, 0x23, 0xfd, 0x0a, 0x44, + 0xb0, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x7d, 0x62, 0x0c, 0x08, 0x00, 0x00, 0xff, + 0xff, 0x2c, 0x7f, 0xc4, 0x60, 0x42, 0x01, 0x00, 0x00, } func (m *CommunityFundFeeProposal) Marshal() (dAtA []byte, err error) { @@ -166,6 +174,7 @@ func encodeVarintCommunityFundFeeProposal(dAtA []byte, offset int, v uint64) int dAtA[offset] = uint8(v) return base } + func (m *CommunityFundFeeProposal) Size() (n int) { if m == nil { return 0 @@ -190,9 +199,11 @@ func (m *CommunityFundFeeProposal) Size() (n int) { func sovCommunityFundFeeProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozCommunityFundFeeProposal(x uint64) (n int) { return sovCommunityFundFeeProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *CommunityFundFeeProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -339,6 +350,7 @@ func (m *CommunityFundFeeProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipCommunityFundFeeProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/fees.pb.go b/x/treasury/types/fees.pb.go index f15a7241..0f9dd1d0 100644 --- a/x/treasury/types/fees.pb.go +++ b/x/treasury/types/fees.pb.go @@ -4,23 +4,26 @@ package types import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + cosmossdk_io_math "cosmossdk.io/math" _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/types/query" _ "github.com/cosmos/cosmos-sdk/types/tx/amino" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" _ "google.golang.org/genproto/googleapis/api/annotations" - 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -29,8 +32,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Empty represents an empty message -type Empty struct { -} +type Empty struct{} func (m *Empty) Reset() { *m = Empty{} } func (m *Empty) String() string { return proto.CompactTextString(m) } @@ -38,9 +40,11 @@ func (*Empty) ProtoMessage() {} func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor_025e81aa1db4e06a, []int{0} } + func (m *Empty) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Empty.Marshal(b, m, deterministic) @@ -53,12 +57,15 @@ func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Empty) XXX_Merge(src proto.Message) { xxx_messageInfo_Empty.Merge(m, src) } + func (m *Empty) XXX_Size() int { return m.Size() } + func (m *Empty) XXX_DiscardUnknown() { xxx_messageInfo_Empty.DiscardUnknown(m) } @@ -76,9 +83,11 @@ func (*Fees) ProtoMessage() {} func (*Fees) Descriptor() ([]byte, []int) { return fileDescriptor_025e81aa1db4e06a, []int{1} } + func (m *Fees) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Fees) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Fees.Marshal(b, m, deterministic) @@ -91,12 +100,15 @@ func (m *Fees) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Fees) XXX_Merge(src proto.Message) { xxx_messageInfo_Fees.Merge(m, src) } + func (m *Fees) XXX_Size() int { return m.Size() } + func (m *Fees) XXX_DiscardUnknown() { xxx_messageInfo_Fees.DiscardUnknown(m) } @@ -130,9 +142,11 @@ func (*RelayerFeeSetting) ProtoMessage() {} func (*RelayerFeeSetting) Descriptor() ([]byte, []int) { return fileDescriptor_025e81aa1db4e06a, []int{2} } + func (m *RelayerFeeSetting) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *RelayerFeeSetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RelayerFeeSetting.Marshal(b, m, deterministic) @@ -145,12 +159,15 @@ func (m *RelayerFeeSetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *RelayerFeeSetting) XXX_Merge(src proto.Message) { xxx_messageInfo_RelayerFeeSetting.Merge(m, src) } + func (m *RelayerFeeSetting) XXX_Size() int { return m.Size() } + func (m *RelayerFeeSetting) XXX_DiscardUnknown() { xxx_messageInfo_RelayerFeeSetting.DiscardUnknown(m) } @@ -191,9 +208,11 @@ func (*RelayerFeeSetting_FeeSetting) ProtoMessage() {} func (*RelayerFeeSetting_FeeSetting) Descriptor() ([]byte, []int) { return fileDescriptor_025e81aa1db4e06a, []int{2, 0} } + func (m *RelayerFeeSetting_FeeSetting) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *RelayerFeeSetting_FeeSetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RelayerFeeSetting_FeeSetting.Marshal(b, m, deterministic) @@ -206,12 +225,15 @@ func (m *RelayerFeeSetting_FeeSetting) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *RelayerFeeSetting_FeeSetting) XXX_Merge(src proto.Message) { xxx_messageInfo_RelayerFeeSetting_FeeSetting.Merge(m, src) } + func (m *RelayerFeeSetting_FeeSetting) XXX_Size() int { return m.Size() } + func (m *RelayerFeeSetting_FeeSetting) XXX_DiscardUnknown() { xxx_messageInfo_RelayerFeeSetting_FeeSetting.DiscardUnknown(m) } @@ -237,38 +259,38 @@ func init() { } var fileDescriptor_025e81aa1db4e06a = []byte{ - // 483 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0x4f, 0x6b, 0x13, 0x4f, - 0x18, 0xce, 0xf6, 0x97, 0x9f, 0x7f, 0x26, 0x08, 0xed, 0xd2, 0x43, 0x4c, 0x65, 0x13, 0x72, 0x90, - 0x10, 0xec, 0x0e, 0x55, 0x10, 0xea, 0xcd, 0x50, 0x83, 0x82, 0xa7, 0x8d, 0x27, 0x11, 0xc2, 0x9b, - 0xd9, 0xb7, 0x9b, 0xc1, 0x9d, 0x99, 0x75, 0x66, 0x36, 0xb8, 0xdf, 0xc2, 0xa3, 0xc7, 0xe2, 0xc9, - 0xa3, 0x87, 0x7e, 0x88, 0x1e, 0x4b, 0x4e, 0xe2, 0xa1, 0x48, 0x72, 0xd0, 0x8f, 0x21, 0xd9, 0xd9, - 0x90, 0x48, 0xa5, 0x97, 0xe5, 0xd9, 0xe7, 0x79, 0xe6, 0xd9, 0x67, 0xe7, 0x7d, 0xc9, 0xc3, 0x0c, - 0x52, 0x25, 0x80, 0x4d, 0x81, 0x4b, 0xea, 0x30, 0xb5, 0x1a, 0xc1, 0xe4, 0xba, 0xa0, 0xa7, 0x88, - 0x26, 0xcc, 0xb4, 0xb2, 0xca, 0x3f, 0xd8, 0xf2, 0x85, 0x0e, 0x87, 0x6b, 0x5f, 0x6b, 0x3f, 0x51, - 0x89, 0x2a, 0x7d, 0x74, 0x85, 0xdc, 0x91, 0xd6, 0x83, 0x44, 0xa9, 0x24, 0x45, 0x0a, 0x19, 0xa7, - 0x20, 0xa5, 0xb2, 0x60, 0xb9, 0x92, 0x55, 0x60, 0xab, 0xcf, 0x94, 0x11, 0xca, 0xd0, 0x09, 0x18, - 0xa4, 0x1f, 0x72, 0xd4, 0x05, 0x9d, 0x1d, 0x4d, 0xd0, 0xc2, 0x11, 0xcd, 0x20, 0xe1, 0xb2, 0x34, - 0x57, 0xde, 0xde, 0x4d, 0x25, 0x33, 0xd0, 0x20, 0xd6, 0xa9, 0xf7, 0x5d, 0xea, 0xd8, 0x95, 0x71, - 0x2f, 0x95, 0xb4, 0x07, 0x82, 0x4b, 0x45, 0xcb, 0xa7, 0xa3, 0xba, 0xb7, 0xc9, 0xff, 0x2f, 0x44, - 0x66, 0x8b, 0xee, 0x1b, 0x52, 0x1f, 0x22, 0x1a, 0xbf, 0x4f, 0x76, 0x99, 0x12, 0x22, 0x97, 0xdc, - 0x16, 0xc3, 0x5c, 0xc6, 0x43, 0xc4, 0xa6, 0xd7, 0xf1, 0x7a, 0x77, 0xa3, 0x6b, 0xbc, 0xdf, 0x21, - 0x0d, 0x83, 0x2c, 0xd7, 0x2b, 0x0a, 0xb1, 0xb9, 0x53, 0xda, 0xb6, 0xa9, 0xee, 0x7c, 0x87, 0xec, - 0x45, 0x98, 0x42, 0x81, 0x7a, 0x88, 0x38, 0x42, 0x6b, 0xb9, 0x4c, 0xfc, 0x63, 0xd2, 0x98, 0x41, - 0x3a, 0x86, 0x38, 0xd6, 0x68, 0x8c, 0x8b, 0x1f, 0x34, 0xe7, 0xe7, 0x87, 0xfb, 0x55, 0xdd, 0xe7, - 0x4e, 0x19, 0x59, 0xcd, 0x65, 0x12, 0x91, 0x19, 0xa4, 0x15, 0xe3, 0x8f, 0x48, 0x7d, 0x35, 0x92, - 0xe6, 0x4e, 0xe7, 0xbf, 0x5e, 0xe3, 0xf1, 0x71, 0x78, 0xc3, 0x4c, 0xc2, 0x6b, 0x1f, 0x0e, 0x37, - 0x70, 0x50, 0xbf, 0xb8, 0x6a, 0xd7, 0xa2, 0x32, 0xac, 0xf5, 0xc5, 0x23, 0x64, 0xab, 0xde, 0x3b, - 0x72, 0x4f, 0xe4, 0xa9, 0xe5, 0x59, 0xca, 0x19, 0x58, 0xa5, 0xab, 0x82, 0x4f, 0x57, 0x27, 0x7e, - 0x5c, 0xb5, 0x0f, 0x5c, 0x49, 0x13, 0xbf, 0x0f, 0xb9, 0xa2, 0x02, 0xec, 0x34, 0x7c, 0x8d, 0x09, - 0xb0, 0xe2, 0x04, 0xd9, 0xfc, 0xfc, 0x90, 0x54, 0xff, 0x70, 0x82, 0xec, 0xeb, 0xaf, 0x6f, 0x7d, - 0x2f, 0xfa, 0x3b, 0xcc, 0x7f, 0x44, 0xfc, 0xb2, 0xee, 0x58, 0xe3, 0x29, 0x6a, 0x94, 0x0c, 0xc7, - 0x3c, 0xae, 0xee, 0x6e, 0xb7, 0x54, 0xa2, 0xb5, 0xf0, 0x2a, 0x7e, 0x76, 0xe7, 0xf3, 0x59, 0xdb, - 0xfb, 0x7d, 0xd6, 0xf6, 0x36, 0x68, 0xf0, 0xf2, 0x62, 0x11, 0x78, 0x97, 0x8b, 0xc0, 0xfb, 0xb9, - 0x08, 0xbc, 0x4f, 0xcb, 0xa0, 0x76, 0xb9, 0x0c, 0x6a, 0xdf, 0x97, 0x41, 0xed, 0x6d, 0x98, 0x70, - 0x3b, 0xcd, 0x27, 0x21, 0x53, 0x82, 0xfe, 0x63, 0x61, 0x3e, 0x6e, 0x56, 0xc6, 0x16, 0x19, 0x9a, - 0xc9, 0xad, 0x72, 0x09, 0x9e, 0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0xd8, 0x77, 0x27, 0xf8, 0x03, - 0x03, 0x00, 0x00, + // 484 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0xcf, 0x8b, 0xd3, 0x40, + 0x18, 0x6d, 0x6a, 0xfd, 0x35, 0x45, 0xd8, 0x0d, 0x7b, 0xa8, 0x5d, 0x49, 0x4b, 0x0f, 0x52, 0x8a, + 0x9b, 0xa1, 0x2b, 0x08, 0xeb, 0xcd, 0xb2, 0x16, 0x44, 0x4f, 0xa9, 0x27, 0x11, 0xca, 0xd7, 0xe4, + 0xdb, 0x74, 0x30, 0x33, 0x13, 0x67, 0x26, 0xc5, 0xfc, 0x17, 0x1e, 0x3d, 0x2e, 0x9e, 0x3c, 0x7a, + 0xd8, 0x3f, 0x62, 0x8f, 0x4b, 0x4f, 0xe2, 0x61, 0x91, 0xf6, 0xa0, 0x7f, 0x86, 0x34, 0x93, 0xd2, + 0xca, 0x4a, 0x2f, 0xe1, 0xe5, 0xbd, 0x37, 0x2f, 0x2f, 0xf3, 0x7d, 0xe4, 0x71, 0x0a, 0x89, 0xe4, + 0x10, 0x4e, 0x81, 0x09, 0x6a, 0x31, 0x35, 0x0a, 0x41, 0x67, 0x2a, 0xa7, 0x67, 0x88, 0xda, 0x4f, + 0x95, 0x34, 0xd2, 0x3d, 0xdc, 0xf2, 0xf9, 0x16, 0xfb, 0x6b, 0x5f, 0xf3, 0x20, 0x96, 0xb1, 0x2c, + 0x7c, 0x74, 0x85, 0xec, 0x91, 0xe6, 0xa3, 0x58, 0xca, 0x38, 0x41, 0x0a, 0x29, 0xa3, 0x20, 0x84, + 0x34, 0x60, 0x98, 0x14, 0x65, 0x60, 0xb3, 0x17, 0x4a, 0xcd, 0xa5, 0xa6, 0x13, 0xd0, 0x48, 0x3f, + 0x66, 0xa8, 0x72, 0x3a, 0xeb, 0x4f, 0xd0, 0x40, 0x9f, 0xa6, 0x10, 0x33, 0x51, 0x98, 0x4b, 0x6f, + 0x77, 0x57, 0xc9, 0x14, 0x14, 0xf0, 0x75, 0xea, 0x43, 0x9b, 0x3a, 0xb6, 0x65, 0xec, 0x4b, 0x29, + 0xed, 0x03, 0x67, 0x42, 0xd2, 0xe2, 0x69, 0xa9, 0xce, 0x5d, 0x72, 0xfb, 0x25, 0x4f, 0x4d, 0xde, + 0x79, 0x4b, 0x6a, 0x43, 0x44, 0xed, 0xf6, 0xc8, 0x5e, 0x28, 0x39, 0xcf, 0x04, 0x33, 0xf9, 0x30, + 0x13, 0xd1, 0x10, 0xb1, 0xe1, 0xb4, 0x9d, 0xee, 0xfd, 0xe0, 0x06, 0xef, 0xb6, 0x49, 0x5d, 0x63, + 0x98, 0xa9, 0x15, 0x85, 0xd8, 0xa8, 0x16, 0xb6, 0x6d, 0xaa, 0x33, 0xaf, 0x92, 0xfd, 0x00, 0x13, + 0xc8, 0x51, 0x0d, 0x11, 0x47, 0x68, 0x0c, 0x13, 0xb1, 0x7b, 0x42, 0xea, 0x33, 0x48, 0xc6, 0x10, + 0x45, 0x0a, 0xb5, 0xb6, 0xf1, 0x83, 0xc6, 0xfc, 0xe2, 0xe8, 0xa0, 0xac, 0xfb, 0xc2, 0x2a, 0x23, + 0xa3, 0x98, 0x88, 0x03, 0x32, 0x83, 0xa4, 0x64, 0xdc, 0x11, 0xa9, 0xad, 0x46, 0xd2, 0xa8, 0xb6, + 0x6f, 0x75, 0xeb, 0xc7, 0x27, 0xfe, 0x8e, 0x99, 0xf8, 0x37, 0x3e, 0xec, 0x6f, 0xe0, 0xa0, 0x76, + 0x79, 0xdd, 0xaa, 0x04, 0x45, 0x58, 0xf3, 0xab, 0x43, 0xc8, 0x56, 0xbd, 0xf7, 0xe4, 0x01, 0xcf, + 0x12, 0xc3, 0xd2, 0x84, 0x85, 0x60, 0xa4, 0x2a, 0x0b, 0x3e, 0x5b, 0x9d, 0xf8, 0x79, 0xdd, 0x3a, + 0xb4, 0x25, 0x75, 0xf4, 0xc1, 0x67, 0x92, 0x72, 0x30, 0x53, 0xff, 0x0d, 0xc6, 0x10, 0xe6, 0xa7, + 0x18, 0xce, 0x2f, 0x8e, 0x48, 0xf9, 0x0f, 0xa7, 0x18, 0x7e, 0xfb, 0xfd, 0xbd, 0xe7, 0x04, 0xff, + 0x86, 0xb9, 0x4f, 0x88, 0x5b, 0xd4, 0x1d, 0x2b, 0x3c, 0x43, 0x85, 0x22, 0xc4, 0x31, 0x8b, 0xca, + 0xbb, 0xdb, 0x2b, 0x94, 0x60, 0x2d, 0xbc, 0x8a, 0x9e, 0xdf, 0xfb, 0x72, 0xde, 0x72, 0xfe, 0x9c, + 0xb7, 0x9c, 0x0d, 0x1a, 0xbc, 0xbe, 0x5c, 0x78, 0xce, 0xd5, 0xc2, 0x73, 0x7e, 0x2d, 0x3c, 0xe7, + 0xf3, 0xd2, 0xab, 0x5c, 0x2d, 0xbd, 0xca, 0x8f, 0xa5, 0x57, 0x79, 0xd7, 0x8f, 0x99, 0x99, 0x66, + 0x13, 0x3f, 0x94, 0x9c, 0xfe, 0x67, 0x61, 0x66, 0xc7, 0xf4, 0xd3, 0x66, 0x6b, 0x4c, 0x9e, 0xa2, + 0x9e, 0xdc, 0x29, 0xf6, 0xe0, 0xe9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xda, 0x67, 0x11, 0x9c, + 0x06, 0x03, 0x00, 0x00, } func (this *RelayerFeeSetting) Equal(that interface{}) bool { @@ -303,6 +325,7 @@ func (this *RelayerFeeSetting) Equal(that interface{}) bool { } return true } + func (this *RelayerFeeSetting_FeeSetting) Equal(that interface{}) bool { if that == nil { return this == nil @@ -330,6 +353,7 @@ func (this *RelayerFeeSetting_FeeSetting) Equal(that interface{}) bool { } return true } + func (m *Empty) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -485,6 +509,7 @@ func encodeVarintFees(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Empty) Size() (n int) { if m == nil { return 0 @@ -548,9 +573,11 @@ func (m *RelayerFeeSetting_FeeSetting) Size() (n int) { func sovFees(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozFees(x uint64) (n int) { return sovFees(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Empty) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -601,6 +628,7 @@ func (m *Empty) Unmarshal(dAtA []byte) error { } return nil } + func (m *Fees) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -715,6 +743,7 @@ func (m *Fees) Unmarshal(dAtA []byte) error { } return nil } + func (m *RelayerFeeSetting) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -831,6 +860,7 @@ func (m *RelayerFeeSetting) Unmarshal(dAtA []byte) error { } return nil } + func (m *RelayerFeeSetting_FeeSetting) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -947,6 +977,7 @@ func (m *RelayerFeeSetting_FeeSetting) Unmarshal(dAtA []byte) error { } return nil } + func skipFees(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/genesis.pb.go b/x/treasury/types/genesis.pb.go index 85d29185..e11a6430 100644 --- a/x/treasury/types/genesis.pb.go +++ b/x/treasury/types/genesis.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -36,9 +39,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_477152b2c8c909fc, []int{0} } + 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) @@ -51,12 +56,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) 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) } @@ -93,25 +101,25 @@ func init() { } var fileDescriptor_477152b2c8c909fc = []byte{ - // 281 bytes of a gzipped FileDescriptorProto + // 284 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0xbd, 0x6a, 0xc3, 0x30, - 0x14, 0x85, 0xed, 0xa4, 0x64, 0x50, 0x32, 0x89, 0x0c, 0xc6, 0x05, 0x35, 0x6d, 0xa1, 0xb8, 0x8b, - 0x04, 0xe9, 0x13, 0x34, 0x43, 0x5a, 0xe8, 0x52, 0x92, 0xad, 0x4b, 0x50, 0xc2, 0xb5, 0x62, 0x88, - 0x2d, 0x23, 0x29, 0x50, 0xbf, 0x40, 0xe7, 0x3e, 0x56, 0xc6, 0x8c, 0x9d, 0x4a, 0xb1, 0x5f, 0xa4, - 0xc4, 0x52, 0xe8, 0x0f, 0x41, 0xdb, 0x01, 0x7d, 0xe7, 0xd3, 0xe5, 0xa0, 0xdb, 0x92, 0x6f, 0x64, - 0xce, 0x57, 0x6b, 0x9e, 0x15, 0xcc, 0x66, 0x66, 0x14, 0x70, 0xbd, 0x55, 0x15, 0x13, 0x50, 0x80, - 0xce, 0x34, 0x2d, 0x95, 0x34, 0x12, 0x9f, 0xff, 0x42, 0xa9, 0xcd, 0xf4, 0x88, 0xc6, 0x43, 0x21, - 0x85, 0x6c, 0x39, 0x76, 0x48, 0xb6, 0x12, 0x27, 0x3e, 0x7b, 0xc9, 0x15, 0xcf, 0x9d, 0x3c, 0xbe, - 0xf1, 0x91, 0x29, 0x80, 0xe3, 0xae, 0xde, 0x3a, 0x68, 0xf0, 0x60, 0xcf, 0x9a, 0x1b, 0x6e, 0x00, - 0xdf, 0xa3, 0x9e, 0x15, 0x45, 0xe1, 0x28, 0x4c, 0xfa, 0xe3, 0x6b, 0xea, 0x39, 0x93, 0x3e, 0xb7, - 0xe8, 0xe4, 0x6c, 0xf7, 0x79, 0x11, 0xcc, 0x5c, 0x11, 0x3f, 0xa1, 0xc1, 0x11, 0x98, 0x02, 0xe8, - 0xa8, 0xd3, 0x8a, 0x2e, 0xbd, 0xa2, 0x03, 0xe8, 0x34, 0x7f, 0xca, 0x38, 0x45, 0x43, 0x05, 0x1b, - 0x5e, 0x81, 0x5a, 0xa4, 0x00, 0x0b, 0x0d, 0xc6, 0x64, 0x85, 0xd0, 0x51, 0x77, 0xd4, 0x4d, 0xfa, - 0x63, 0xea, 0x95, 0xce, 0x6c, 0x71, 0x0a, 0x30, 0xb7, 0x35, 0xf7, 0x03, 0x56, 0xff, 0x1f, 0xf4, - 0xe4, 0x71, 0x57, 0x93, 0x70, 0x5f, 0x93, 0xf0, 0xab, 0x26, 0xe1, 0x7b, 0x43, 0x82, 0x7d, 0x43, - 0x82, 0x8f, 0x86, 0x04, 0x2f, 0x54, 0x64, 0x66, 0xbd, 0x5d, 0xd2, 0x95, 0xcc, 0xd9, 0x89, 0x55, - 0x5f, 0x7f, 0x76, 0x35, 0x55, 0x09, 0x7a, 0xd9, 0x6b, 0x97, 0xbd, 0xfb, 0x0e, 0x00, 0x00, 0xff, - 0xff, 0x02, 0x15, 0x1e, 0xea, 0x0b, 0x02, 0x00, 0x00, + 0x14, 0x85, 0xed, 0xa4, 0x64, 0x70, 0x32, 0x89, 0x0c, 0xc6, 0x05, 0x35, 0x6d, 0xa1, 0xb8, 0x8b, + 0x44, 0xdd, 0x27, 0x68, 0x86, 0x74, 0xc8, 0x52, 0x92, 0xad, 0x4b, 0x50, 0xc2, 0xb5, 0x62, 0x88, + 0x2d, 0x23, 0x29, 0xa5, 0x7e, 0x81, 0xce, 0x7d, 0xac, 0x8c, 0x19, 0x3b, 0x95, 0x62, 0xbf, 0x48, + 0x89, 0xa5, 0xd0, 0x1f, 0x82, 0xb6, 0x03, 0xfa, 0xce, 0xa7, 0xcb, 0x09, 0x6e, 0x4b, 0xb6, 0x11, + 0x39, 0x5b, 0xad, 0x59, 0x56, 0x50, 0x93, 0xa9, 0x96, 0xc0, 0xd4, 0x56, 0x56, 0x94, 0x43, 0x01, + 0x2a, 0x53, 0xa4, 0x94, 0x42, 0x0b, 0x74, 0xfe, 0x0b, 0x25, 0x26, 0x93, 0x23, 0x1a, 0x0d, 0xb9, + 0xe0, 0xa2, 0xe5, 0xe8, 0x21, 0x99, 0x4a, 0x14, 0xbb, 0xec, 0x25, 0x93, 0x2c, 0xb7, 0xf2, 0xe8, + 0xc6, 0x45, 0xa6, 0x00, 0x96, 0xbb, 0x7a, 0xeb, 0x04, 0x83, 0x47, 0x73, 0xd6, 0x5c, 0x33, 0x0d, + 0xe8, 0x21, 0xe8, 0x19, 0x51, 0xe8, 0x8f, 0xfc, 0xb8, 0x9f, 0x5c, 0x13, 0xc7, 0x99, 0xe4, 0xa9, + 0x45, 0xc7, 0x67, 0xbb, 0xcf, 0x0b, 0x6f, 0x66, 0x8b, 0x68, 0x1a, 0x0c, 0x8e, 0xc0, 0x04, 0x40, + 0x85, 0x9d, 0x56, 0x74, 0xe9, 0x14, 0x1d, 0x40, 0xab, 0xf9, 0x53, 0x46, 0x69, 0x30, 0x94, 0xb0, + 0x61, 0x15, 0xc8, 0x45, 0x0a, 0xb0, 0x50, 0xa0, 0x75, 0x56, 0x70, 0x15, 0x76, 0x47, 0xdd, 0xb8, + 0x9f, 0x10, 0xa7, 0x74, 0x66, 0x8a, 0x13, 0x80, 0xb9, 0xa9, 0xd9, 0x1f, 0x90, 0xfc, 0xff, 0xa0, + 0xc6, 0xd3, 0x5d, 0x8d, 0xfd, 0x7d, 0x8d, 0xfd, 0xaf, 0x1a, 0xfb, 0xef, 0x0d, 0xf6, 0xf6, 0x0d, + 0xf6, 0x3e, 0x1a, 0xec, 0x3d, 0xdf, 0xf1, 0x4c, 0xaf, 0xb7, 0x4b, 0xb2, 0x12, 0x39, 0x3d, 0xb1, + 0xea, 0x4b, 0x42, 0x5f, 0x7f, 0xa6, 0xd5, 0x55, 0x09, 0x6a, 0xd9, 0x6b, 0xc7, 0xbd, 0xff, 0x0e, + 0x00, 0x00, 0xff, 0xff, 0x03, 0x56, 0xc1, 0x14, 0x0e, 0x02, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -182,6 +190,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -204,9 +213,11 @@ func (m *GenesisState) Size() (n int) { 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 *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -357,6 +368,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/params.pb.go b/x/treasury/types/params.pb.go index 62345cd1..2931f460 100644 --- a/x/treasury/types/params.pb.go +++ b/x/treasury/types/params.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -23,8 +26,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Params defines the parameters for the module. -type Params struct { -} +type Params struct{} func (m *Params) Reset() { *m = Params{} } func (m *Params) String() string { return proto.CompactTextString(m) } @@ -32,9 +34,11 @@ func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_beaa29e219eae478, []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) @@ -47,12 +51,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 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) } @@ -68,16 +75,16 @@ func init() { } var fileDescriptor_beaa29e219eae478 = []byte{ - // 135 bytes of a gzipped FileDescriptorProto + // 138 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x28, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x4b, 0x8a, 0x52, 0x13, 0x8b, 0x4b, 0x8b, 0x2a, 0xf5, 0x0b, 0x12, 0x8b, 0x12, 0x73, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xa4, 0x91, 0x54, 0xea, 0x41, 0xd8, 0x7a, 0x30, 0x95, 0x4a, 0x1c, 0x5c, 0x6c, 0x01, 0x60, - 0xc5, 0x4e, 0x1e, 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, 0x97, 0x9e, - 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0xc5, 0xd6, 0x0a, 0x84, 0xbd, 0x25, - 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0x7b, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x38, - 0x9a, 0x75, 0x4c, 0xa3, 0x00, 0x00, 0x00, + 0xc5, 0x4e, 0xde, 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, 0x65, 0x98, 0x9e, + 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0xc5, 0xd6, 0x32, 0x23, 0xfd, 0x0a, + 0x84, 0xd5, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0xab, 0x8d, 0x01, 0x01, 0x00, 0x00, + 0xff, 0xff, 0xb7, 0x0a, 0x46, 0x5b, 0xa6, 0x00, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -114,6 +121,7 @@ func encodeVarintParams(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -126,9 +134,11 @@ func (m *Params) Size() (n int) { func sovParams(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozParams(x uint64) (n int) { return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -179,6 +189,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func skipParams(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/query.pb.go b/x/treasury/types/query.pb.go index ff89930d..1c9457a8 100644 --- a/x/treasury/types/query.pb.go +++ b/x/treasury/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/types/query" _ "github.com/cosmos/gogoproto/gogoproto" @@ -15,15 +19,14 @@ import ( 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -32,8 +35,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // QueryParamsRequest is request type for the Query/Params RPC method. -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -41,9 +43,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_0e6dcb8140229083, []int{0} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -56,12 +60,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -80,9 +87,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_0e6dcb8140229083, []int{1} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -95,12 +104,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -114,8 +126,7 @@ func (m *QueryParamsResponse) GetParams() Params { return Params{} } -type QueryFeesRequest struct { -} +type QueryFeesRequest struct{} func (m *QueryFeesRequest) Reset() { *m = QueryFeesRequest{} } func (m *QueryFeesRequest) String() string { return proto.CompactTextString(m) } @@ -123,9 +134,11 @@ func (*QueryFeesRequest) ProtoMessage() {} func (*QueryFeesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_0e6dcb8140229083, []int{2} } + func (m *QueryFeesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryFeesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryFeesRequest.Marshal(b, m, deterministic) @@ -138,12 +151,15 @@ func (m *QueryFeesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *QueryFeesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryFeesRequest.Merge(m, src) } + func (m *QueryFeesRequest) XXX_Size() int { return m.Size() } + func (m *QueryFeesRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryFeesRequest.DiscardUnknown(m) } @@ -163,9 +179,11 @@ func (*QueryRelayerFeeRequest) ProtoMessage() {} func (*QueryRelayerFeeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_0e6dcb8140229083, []int{3} } + func (m *QueryRelayerFeeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryRelayerFeeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryRelayerFeeRequest.Marshal(b, m, deterministic) @@ -178,12 +196,15 @@ func (m *QueryRelayerFeeRequest) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *QueryRelayerFeeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryRelayerFeeRequest.Merge(m, src) } + func (m *QueryRelayerFeeRequest) XXX_Size() int { return m.Size() } + func (m *QueryRelayerFeeRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryRelayerFeeRequest.DiscardUnknown(m) } @@ -207,9 +228,11 @@ func (*QueryRelayerFeesRequest) ProtoMessage() {} func (*QueryRelayerFeesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_0e6dcb8140229083, []int{4} } + func (m *QueryRelayerFeesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryRelayerFeesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryRelayerFeesRequest.Marshal(b, m, deterministic) @@ -222,12 +245,15 @@ func (m *QueryRelayerFeesRequest) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryRelayerFeesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryRelayerFeesRequest.Merge(m, src) } + func (m *QueryRelayerFeesRequest) XXX_Size() int { return m.Size() } + func (m *QueryRelayerFeesRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryRelayerFeesRequest.DiscardUnknown(m) } @@ -251,9 +277,11 @@ func (*QueryRelayerFeesResponse) ProtoMessage() {} func (*QueryRelayerFeesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_0e6dcb8140229083, []int{5} } + func (m *QueryRelayerFeesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryRelayerFeesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryRelayerFeesResponse.Marshal(b, m, deterministic) @@ -266,12 +294,15 @@ func (m *QueryRelayerFeesResponse) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryRelayerFeesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryRelayerFeesResponse.Merge(m, src) } + func (m *QueryRelayerFeesResponse) XXX_Size() int { return m.Size() } + func (m *QueryRelayerFeesResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryRelayerFeesResponse.DiscardUnknown(m) } @@ -299,47 +330,49 @@ func init() { } var fileDescriptor_0e6dcb8140229083 = []byte{ - // 546 bytes of a gzipped FileDescriptorProto + // 549 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x3d, 0x6f, 0x13, 0x41, 0x10, 0xf5, 0x02, 0xb1, 0x94, 0x35, 0x45, 0xb4, 0x58, 0x60, 0x0c, 0x3a, 0x92, 0xb3, 0x00, 0x27, - 0x21, 0xb7, 0xb1, 0x03, 0x05, 0x65, 0x5c, 0x04, 0xe8, 0xe0, 0x5c, 0x80, 0x68, 0x4e, 0x6b, 0x7b, - 0x72, 0x39, 0xe9, 0x7c, 0x7b, 0xd9, 0x5d, 0x5b, 0xb8, 0x85, 0x86, 0x12, 0x89, 0x86, 0x9e, 0x9a, - 0x8e, 0x1f, 0x91, 0x32, 0x82, 0x86, 0x0a, 0x21, 0x9b, 0x1f, 0x82, 0xbc, 0xbb, 0xfe, 0x00, 0xa3, - 0x73, 0xdc, 0xad, 0x67, 0xde, 0xbc, 0xf7, 0xee, 0xcd, 0xc8, 0xf8, 0x7e, 0xca, 0x62, 0xde, 0x65, - 0xed, 0x13, 0x16, 0x25, 0xd4, 0xbc, 0xa9, 0x12, 0xc0, 0x64, 0x4f, 0x0c, 0xe8, 0x69, 0x0f, 0xc4, - 0xc0, 0x4b, 0x05, 0x57, 0x9c, 0xdc, 0x9a, 0x03, 0x7a, 0xe6, 0xed, 0x4d, 0x80, 0xe5, 0x62, 0xc8, - 0x43, 0xae, 0x71, 0x74, 0xfc, 0x32, 0x23, 0xe5, 0xdb, 0x21, 0xe7, 0x61, 0x0c, 0x94, 0xa5, 0x11, - 0x65, 0x49, 0xc2, 0x15, 0x53, 0x11, 0x4f, 0xa4, 0xed, 0xee, 0xb4, 0xb9, 0xec, 0x72, 0x49, 0x5b, - 0x4c, 0x82, 0x51, 0xa2, 0xfd, 0x5a, 0x0b, 0x14, 0xab, 0xd1, 0x94, 0x85, 0x51, 0xa2, 0xc1, 0x16, - 0x7b, 0xd3, 0x60, 0x03, 0x23, 0x61, 0x7e, 0xd8, 0x56, 0x35, 0xeb, 0x03, 0x52, 0x26, 0x58, 0x77, - 0x82, 0xbc, 0x97, 0x85, 0x3c, 0x06, 0xb0, 0x38, 0xb7, 0x88, 0xc9, 0x8b, 0xb1, 0x9d, 0xe7, 0x7a, - 0xd8, 0x87, 0xd3, 0x1e, 0x48, 0xe5, 0xbe, 0xc2, 0xd7, 0xfe, 0xaa, 0xca, 0x94, 0x27, 0x12, 0xc8, - 0x21, 0xce, 0x1b, 0x91, 0x12, 0xda, 0x44, 0xd5, 0x42, 0xbd, 0xe2, 0x65, 0xe4, 0xe4, 0x99, 0xe1, - 0xc6, 0x95, 0xb3, 0x9f, 0x77, 0x72, 0xbe, 0x1d, 0x74, 0x09, 0xde, 0xd0, 0xcc, 0x47, 0x00, 0x53, - 0xb5, 0x26, 0xbe, 0xae, 0x6b, 0x3e, 0xc4, 0x6c, 0x00, 0xe2, 0x08, 0xc0, 0x76, 0xc8, 0x63, 0x5c, - 0xe8, 0xb3, 0x38, 0x60, 0x9d, 0x8e, 0x00, 0x69, 0x54, 0xd7, 0x1b, 0xa5, 0x6f, 0x5f, 0xf7, 0x8a, - 0x36, 0x96, 0x43, 0xd3, 0x69, 0x2a, 0x11, 0x25, 0xa1, 0x8f, 0xfb, 0x2c, 0xb6, 0x15, 0xf7, 0x09, - 0xbe, 0xf1, 0x0f, 0xe9, 0x44, 0x8f, 0x3c, 0xc0, 0x44, 0x3b, 0x0e, 0x04, 0x1c, 0x83, 0x80, 0xa4, - 0x0d, 0x41, 0xd4, 0x31, 0xe4, 0xfe, 0x86, 0xee, 0xf8, 0x93, 0xc6, 0xb3, 0x8e, 0x2b, 0x71, 0x69, - 0x91, 0xc8, 0x06, 0xf2, 0x12, 0x5f, 0x15, 0xa6, 0x1c, 0x8c, 0x33, 0x2d, 0xa1, 0xcd, 0xcb, 0xd5, - 0x42, 0xdd, 0xcb, 0x8c, 0x65, 0xc6, 0xd3, 0x04, 0xa5, 0xa2, 0x24, 0xb4, 0x09, 0x15, 0xc4, 0x4c, - 0xa0, 0xfe, 0x6e, 0x0d, 0xaf, 0x69, 0x55, 0xf2, 0x09, 0xe1, 0xbc, 0x49, 0x92, 0xd0, 0x4c, 0xde, - 0xc5, 0x35, 0x96, 0xf7, 0x2f, 0x3e, 0x60, 0x3e, 0xc8, 0xdd, 0x7d, 0xfb, 0xfd, 0xf7, 0xc7, 0x4b, - 0x77, 0x49, 0x85, 0x2e, 0xbf, 0x34, 0xf2, 0x1e, 0xe1, 0xf5, 0xe9, 0x32, 0xc9, 0xde, 0x72, 0xb1, - 0xb9, 0x25, 0x94, 0xb7, 0x32, 0xe1, 0x63, 0xa4, 0xbb, 0xad, 0xcd, 0x54, 0xc8, 0x16, 0x5d, 0x76, - 0xcc, 0xe4, 0x33, 0xc2, 0x78, 0x16, 0x2c, 0x39, 0x58, 0xee, 0x65, 0xe1, 0xd8, 0xca, 0x2b, 0xae, - 0xcd, 0xdd, 0xd7, 0xf6, 0x76, 0x48, 0x35, 0xd3, 0xde, 0xdc, 0x7d, 0x90, 0x2f, 0x08, 0x17, 0xe6, - 0xce, 0x88, 0x3c, 0x5c, 0xc5, 0xe6, 0x34, 0xb9, 0x47, 0x2b, 0x4e, 0xd9, 0xd5, 0xd6, 0xb4, 0xdd, - 0x5d, 0xb2, 0x7d, 0x51, 0xbb, 0xb2, 0xf1, 0xf4, 0x6c, 0xe8, 0xa0, 0xf3, 0xa1, 0x83, 0x7e, 0x0d, - 0x1d, 0xf4, 0x61, 0xe4, 0xe4, 0xce, 0x47, 0x4e, 0xee, 0xc7, 0xc8, 0xc9, 0xbd, 0xf6, 0xc2, 0x48, - 0x9d, 0xf4, 0x5a, 0x5e, 0x9b, 0x77, 0xff, 0x47, 0xf7, 0x66, 0x46, 0xa8, 0x06, 0x29, 0xc8, 0x56, - 0x5e, 0xff, 0xdb, 0x1c, 0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0x67, 0xda, 0x16, 0xf3, 0x82, 0x05, - 0x00, 0x00, + 0x21, 0xb7, 0xb1, 0x03, 0x05, 0x65, 0x5c, 0x04, 0x21, 0x1a, 0x38, 0x17, 0x20, 0x9a, 0xd3, 0xda, + 0x9e, 0x5c, 0x4e, 0x3a, 0xdf, 0x5e, 0x76, 0xd7, 0x16, 0x6e, 0xa1, 0xa1, 0x44, 0xa2, 0xa1, 0xa7, + 0xa6, 0xe3, 0x47, 0xa4, 0x8c, 0xa0, 0xa1, 0x42, 0xc8, 0xe6, 0x87, 0x20, 0xef, 0xae, 0x3f, 0xc0, + 0xe8, 0x1c, 0x77, 0xeb, 0x99, 0x37, 0xef, 0xbd, 0x7b, 0x33, 0x32, 0xbe, 0x9f, 0xb2, 0x98, 0x77, + 0x59, 0xfb, 0x84, 0x45, 0x09, 0x35, 0x6f, 0xaa, 0x04, 0x30, 0xd9, 0x13, 0x03, 0x7a, 0xda, 0x03, + 0x31, 0xf0, 0x52, 0xc1, 0x15, 0x27, 0xb7, 0xe6, 0x80, 0x9e, 0x79, 0x7b, 0x13, 0x60, 0xb9, 0x18, + 0xf2, 0x90, 0x6b, 0x1c, 0x1d, 0xbf, 0xcc, 0x48, 0xf9, 0x76, 0xc8, 0x79, 0x18, 0x03, 0x65, 0x69, + 0x44, 0x59, 0x92, 0x70, 0xc5, 0x54, 0xc4, 0x13, 0x69, 0xbb, 0x3b, 0x6d, 0x2e, 0xbb, 0x5c, 0xd2, + 0x16, 0x93, 0x60, 0x94, 0x68, 0xbf, 0xd6, 0x02, 0xc5, 0x6a, 0x34, 0x65, 0x61, 0x94, 0x68, 0xb0, + 0xc5, 0xde, 0x34, 0xd8, 0xc0, 0x48, 0x98, 0x1f, 0xb6, 0x55, 0xcd, 0xfa, 0x80, 0x94, 0x09, 0xd6, + 0x9d, 0x20, 0xef, 0x65, 0x21, 0x8f, 0x01, 0x2c, 0xce, 0x2d, 0x62, 0xf2, 0x62, 0x6c, 0xe7, 0xb9, + 0x1e, 0xf6, 0xe1, 0xb4, 0x07, 0x52, 0xb9, 0xaf, 0xf0, 0xb5, 0xbf, 0xaa, 0x32, 0xe5, 0x89, 0x04, + 0x72, 0x88, 0xf3, 0x46, 0xa4, 0x84, 0x36, 0x51, 0xb5, 0x50, 0xaf, 0x78, 0x19, 0x39, 0x79, 0x66, + 0xb8, 0x71, 0xe5, 0xec, 0xe7, 0x9d, 0x9c, 0x6f, 0x07, 0x5d, 0x82, 0x37, 0x34, 0xf3, 0x11, 0xc0, + 0x54, 0xad, 0x89, 0xaf, 0xeb, 0x9a, 0x0f, 0x31, 0x1b, 0x80, 0x38, 0x02, 0xb0, 0x1d, 0xf2, 0x18, + 0x17, 0xfa, 0x2c, 0x0e, 0x58, 0xa7, 0x23, 0x40, 0x1a, 0xd5, 0xf5, 0x46, 0xe9, 0xdb, 0xd7, 0xbd, + 0xa2, 0x8d, 0xe5, 0xd0, 0x74, 0x9a, 0x4a, 0x44, 0x49, 0xe8, 0xe3, 0x3e, 0x8b, 0x6d, 0xc5, 0x7d, + 0x82, 0x6f, 0xfc, 0x43, 0x3a, 0xd1, 0x23, 0x0f, 0x30, 0xd1, 0x8e, 0x03, 0x01, 0xc7, 0x20, 0x20, + 0x69, 0x43, 0x10, 0x75, 0x0c, 0xb9, 0xbf, 0xa1, 0x3b, 0xfe, 0xa4, 0xf1, 0xb4, 0xe3, 0x4a, 0x5c, + 0x5a, 0x24, 0xb2, 0x81, 0xbc, 0xc4, 0x57, 0x85, 0x29, 0x07, 0xe3, 0x4c, 0x4b, 0x68, 0xf3, 0x72, + 0xb5, 0x50, 0xf7, 0x32, 0x63, 0x99, 0xf1, 0x34, 0x41, 0xa9, 0x28, 0x09, 0x6d, 0x42, 0x05, 0x31, + 0x13, 0xa8, 0xbf, 0x5b, 0xc3, 0x6b, 0x5a, 0x95, 0x7c, 0x42, 0x38, 0x6f, 0x92, 0x24, 0x34, 0x93, + 0x77, 0x71, 0x8d, 0xe5, 0xfd, 0x8b, 0x0f, 0x98, 0x0f, 0x72, 0x77, 0xdf, 0x7e, 0xff, 0xfd, 0xf1, + 0xd2, 0x5d, 0x52, 0xa1, 0xcb, 0x2f, 0x8d, 0xbc, 0x47, 0x78, 0x7d, 0xba, 0x4c, 0xb2, 0xb7, 0x5c, + 0x6c, 0x6e, 0x09, 0xe5, 0xad, 0x4c, 0xf8, 0x18, 0xe9, 0x6e, 0x6b, 0x33, 0x15, 0xb2, 0x45, 0x97, + 0x1d, 0x33, 0xf9, 0x8c, 0x30, 0x9e, 0x05, 0x4b, 0x0e, 0x96, 0x7b, 0x59, 0x38, 0xb6, 0xf2, 0x8a, + 0x6b, 0x73, 0xf7, 0xb5, 0xbd, 0x1d, 0x52, 0xcd, 0xb4, 0x37, 0x77, 0x1f, 0xe4, 0x0b, 0xc2, 0x85, + 0xb9, 0x33, 0x22, 0x0f, 0x57, 0xb1, 0x39, 0x4d, 0xee, 0xd1, 0x8a, 0x53, 0x76, 0xb5, 0x35, 0x6d, + 0x77, 0x97, 0x6c, 0x5f, 0xd4, 0xae, 0x6c, 0x3c, 0x3b, 0x1b, 0x3a, 0xe8, 0x7c, 0xe8, 0xa0, 0x5f, + 0x43, 0x07, 0x7d, 0x18, 0x39, 0xb9, 0xf3, 0x91, 0x93, 0xfb, 0x31, 0x72, 0x72, 0xaf, 0x6b, 0x61, + 0xa4, 0x4e, 0x7a, 0x2d, 0xaf, 0xcd, 0xbb, 0xff, 0xa3, 0xeb, 0xd7, 0xe9, 0x9b, 0x19, 0xa7, 0x1a, + 0xa4, 0x20, 0x5b, 0x79, 0xfd, 0x87, 0x73, 0xf0, 0x27, 0x00, 0x00, 0xff, 0xff, 0x62, 0x1c, 0x64, + 0x18, 0x85, 0x05, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -414,18 +447,20 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } + func (*UnimplementedQueryServer) QueryFees(ctx context.Context, req *QueryFeesRequest) (*Fees, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryFees not implemented") } + func (*UnimplementedQueryServer) RelayerFee(ctx context.Context, req *QueryRelayerFeeRequest) (*RelayerFeeSetting, error) { return nil, status.Errorf(codes.Unimplemented, "method RelayerFee not implemented") } + func (*UnimplementedQueryServer) RelayerFees(ctx context.Context, req *QueryRelayerFeesRequest) (*QueryRelayerFeesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RelayerFees not implemented") } @@ -718,6 +753,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QueryParamsRequest) Size() (n int) { if m == nil { return 0 @@ -791,9 +827,11 @@ func (m *QueryRelayerFeesResponse) Size() (n int) { 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 *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -844,6 +882,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -927,6 +966,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryFeesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -977,6 +1017,7 @@ func (m *QueryFeesRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryRelayerFeeRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1059,6 +1100,7 @@ func (m *QueryRelayerFeeRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryRelayerFeesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1141,6 +1183,7 @@ func (m *QueryRelayerFeesRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryRelayerFeesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1225,6 +1268,7 @@ func (m *QueryRelayerFeesResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/security_fee_proposal.pb.go b/x/treasury/types/security_fee_proposal.pb.go index 0d166241..357760a9 100644 --- a/x/treasury/types/security_fee_proposal.pb.go +++ b/x/treasury/types/security_fee_proposal.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-proto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-proto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*SecurityFeeProposal) ProtoMessage() {} func (*SecurityFeeProposal) Descriptor() ([]byte, []int) { return fileDescriptor_ecf7accc42321f0c, []int{0} } + func (m *SecurityFeeProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SecurityFeeProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SecurityFeeProposal.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *SecurityFeeProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *SecurityFeeProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SecurityFeeProposal.Merge(m, src) } + func (m *SecurityFeeProposal) XXX_Size() int { return m.Size() } + func (m *SecurityFeeProposal) XXX_DiscardUnknown() { xxx_messageInfo_SecurityFeeProposal.DiscardUnknown(m) } @@ -92,7 +100,7 @@ func init() { } var fileDescriptor_ecf7accc42321f0c = []byte{ - // 236 bytes of a gzipped FileDescriptorProto + // 239 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2f, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x4b, 0x8a, 0x52, 0x13, 0x8b, 0x4b, 0x8b, 0x2a, 0xf5, 0x8b, 0x53, 0x93, 0x4b, 0x8b, 0x32, 0x4b, 0x2a, 0xe3, 0xd3, 0x52, 0x53, @@ -103,11 +111,11 @@ var fileDescriptor_ecf7accc42321f0c = []byte{ 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x10, 0x8e, 0x90, 0x02, 0x17, 0x77, 0x4a, 0x6a, 0x71, 0x72, 0x51, 0x66, 0x41, 0x49, 0x66, 0x7e, 0x9e, 0x04, 0x13, 0x58, 0x0e, 0x59, 0x48, 0x48, 0x81, 0x8b, 0x39, 0x2d, 0x35, 0x55, 0x82, 0x19, 0x24, 0xe3, 0xc4, 0x77, 0x69, 0x8b, 0x2e, 0x17, 0xd4, 0x36, - 0x97, 0xd4, 0xe4, 0x20, 0x90, 0x94, 0x93, 0xc7, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, + 0x97, 0xd4, 0xe4, 0x20, 0x90, 0x94, 0x93, 0xf7, 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, 0xe9, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x63, 0x09, - 0x86, 0x0a, 0x44, 0x40, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x7d, 0x60, 0x0c, 0x08, - 0x00, 0x00, 0xff, 0xff, 0x5e, 0x47, 0x4d, 0x2e, 0x34, 0x01, 0x00, 0x00, + 0x31, 0x44, 0x19, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x63, 0x09, + 0x86, 0x32, 0x23, 0xfd, 0x0a, 0x44, 0x58, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x3d, + 0x61, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x8b, 0xbe, 0x88, 0x0b, 0x37, 0x01, 0x00, 0x00, } func (m *SecurityFeeProposal) Marshal() (dAtA []byte, err error) { @@ -165,6 +173,7 @@ func encodeVarintSecurityFeeProposal(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *SecurityFeeProposal) Size() (n int) { if m == nil { return 0 @@ -189,9 +198,11 @@ func (m *SecurityFeeProposal) Size() (n int) { func sovSecurityFeeProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozSecurityFeeProposal(x uint64) (n int) { return sovSecurityFeeProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SecurityFeeProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -338,6 +349,7 @@ func (m *SecurityFeeProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipSecurityFeeProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/tx.pb.go b/x/treasury/types/tx.pb.go index e62a96eb..ec5d3c74 100644 --- a/x/treasury/types/tx.pb.go +++ b/x/treasury/types/tx.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" @@ -14,15 +18,14 @@ import ( 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -41,9 +44,11 @@ func (*MsgUpsertRelayerFee) ProtoMessage() {} func (*MsgUpsertRelayerFee) Descriptor() ([]byte, []int) { return fileDescriptor_8fb084195ecab9c5, []int{0} } + func (m *MsgUpsertRelayerFee) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgUpsertRelayerFee) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgUpsertRelayerFee.Marshal(b, m, deterministic) @@ -56,12 +61,15 @@ func (m *MsgUpsertRelayerFee) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *MsgUpsertRelayerFee) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgUpsertRelayerFee.Merge(m, src) } + func (m *MsgUpsertRelayerFee) XXX_Size() int { return m.Size() } + func (m *MsgUpsertRelayerFee) XXX_DiscardUnknown() { xxx_messageInfo_MsgUpsertRelayerFee.DiscardUnknown(m) } @@ -91,7 +99,7 @@ func init() { } var fileDescriptor_8fb084195ecab9c5 = []byte{ - // 320 bytes of a gzipped FileDescriptorProto + // 322 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x29, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0x4b, 0x8a, 0x52, 0x13, 0x8b, 0x4b, 0x8b, 0x2a, 0xf5, 0x4b, 0x2a, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xa4, 0x91, 0x54, @@ -107,16 +115,19 @@ var fileDescriptor_8fb084195ecab9c5 = []byte{ 0xd2, 0x25, 0x98, 0xc0, 0x86, 0xe9, 0xe9, 0xe1, 0x09, 0x13, 0x3d, 0x84, 0x3b, 0x82, 0x21, 0xba, 0x82, 0xb8, 0xd2, 0xe0, 0x6c, 0x2b, 0xde, 0xa6, 0xe7, 0x1b, 0xb4, 0xe0, 0xe6, 0x1b, 0xe5, 0x73, 0x31, 0xfb, 0x16, 0xa7, 0x0b, 0x65, 0x70, 0x09, 0x60, 0x78, 0xc2, 0x00, 0xaf, 0x2d, 0x58, 0xbc, - 0x2d, 0xa5, 0x84, 0x57, 0x87, 0x6b, 0x6e, 0x41, 0x49, 0xa5, 0x93, 0xc7, 0x89, 0x47, 0x72, 0x8c, + 0x2d, 0xa5, 0x84, 0x57, 0x87, 0x6b, 0x6e, 0x41, 0x49, 0xa5, 0x93, 0xf7, 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, 0xe9, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, - 0xe7, 0xea, 0x63, 0x09, 0xff, 0x0a, 0xa4, 0xb4, 0x51, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x8e, - 0x03, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x97, 0x52, 0x50, 0x47, 0x02, 0x00, 0x00, + 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x19, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, + 0xe7, 0xea, 0x63, 0x8b, 0x27, 0x23, 0xfd, 0x0a, 0xa4, 0xe4, 0x51, 0x59, 0x90, 0x5a, 0x9c, 0xc4, + 0x06, 0x8e, 0x06, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x18, 0x1c, 0xac, 0x4a, 0x02, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -152,8 +163,7 @@ type MsgServer interface { } // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func (*UnimplementedMsgServer) UpsertRelayerFee(ctx context.Context, req *MsgUpsertRelayerFee) (*Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method UpsertRelayerFee not implemented") @@ -250,6 +260,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgUpsertRelayerFee) Size() (n int) { if m == nil { return 0 @@ -268,9 +279,11 @@ func (m *MsgUpsertRelayerFee) Size() (n int) { 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 *MsgUpsertRelayerFee) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -390,6 +403,7 @@ func (m *MsgUpsertRelayerFee) Unmarshal(dAtA []byte) error { } return nil } + func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/common.pb.go b/x/valset/types/common.pb.go index 52b3a1b8..36d45d92 100644 --- a/x/valset/types/common.pb.go +++ b/x/valset/types/common.pb.go @@ -5,18 +5,21 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/cosmos-sdk/types/msgservice" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/cosmos-sdk/types/msgservice" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -39,9 +42,11 @@ func (*MsgMetadata) ProtoMessage() {} func (*MsgMetadata) Descriptor() ([]byte, []int) { return fileDescriptor_51034c49bc8984d6, []int{0} } + func (m *MsgMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgMetadata.Marshal(b, m, deterministic) @@ -54,12 +59,15 @@ func (m *MsgMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *MsgMetadata) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgMetadata.Merge(m, src) } + func (m *MsgMetadata) XXX_Size() int { return m.Size() } + func (m *MsgMetadata) XXX_DiscardUnknown() { xxx_messageInfo_MsgMetadata.DiscardUnknown(m) } @@ -75,7 +83,7 @@ func init() { } var fileDescriptor_51034c49bc8984d6 = []byte{ - // 221 bytes of a gzipped FileDescriptorProto + // 223 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2b, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0xcb, 0x12, 0x73, 0x8a, 0x53, 0x4b, 0xf4, 0x93, 0xf3, 0x73, 0x73, 0xf3, 0xf3, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x24, @@ -85,11 +93,11 @@ var fileDescriptor_51034c49bc8984d6 = []byte{ 0x96, 0x24, 0xa6, 0x24, 0x96, 0x24, 0x0a, 0x49, 0x70, 0xb1, 0x27, 0x17, 0xa5, 0x26, 0x96, 0xe4, 0x17, 0x49, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x06, 0xc1, 0xb8, 0x20, 0x99, 0xe2, 0xcc, 0xf4, 0xbc, 0xd4, 0xa2, 0x62, 0x09, 0x26, 0x05, 0x66, 0x90, 0x0c, 0x94, 0x6b, 0x25, 0xd0, 0xb1, 0x40, 0x9e, - 0xa1, 0xe9, 0xf9, 0x06, 0x2d, 0x98, 0x88, 0x93, 0xdb, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, + 0xa1, 0xe9, 0xf9, 0x06, 0x2d, 0x98, 0x88, 0x93, 0xe7, 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, 0xe9, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x63, - 0xf1, 0x6b, 0x05, 0xcc, 0xb7, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0x37, 0x1a, 0x03, - 0x02, 0x00, 0x00, 0xff, 0xff, 0x63, 0x11, 0xf2, 0x43, 0x17, 0x01, 0x00, 0x00, + 0xcb, 0x31, 0x44, 0xe9, 0xa7, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x63, + 0xf3, 0xab, 0x91, 0x7e, 0x05, 0xcc, 0xc3, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0x67, + 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xf8, 0x18, 0xcf, 0x11, 0x1a, 0x01, 0x00, 0x00, } func (m *MsgMetadata) Marshal() (dAtA []byte, err error) { @@ -142,6 +150,7 @@ func encodeVarintCommon(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgMetadata) Size() (n int) { if m == nil { return 0 @@ -164,9 +173,11 @@ func (m *MsgMetadata) Size() (n int) { func sovCommon(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozCommon(x uint64) (n int) { return sovCommon(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *MsgMetadata) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -281,6 +292,7 @@ func (m *MsgMetadata) Unmarshal(dAtA []byte) error { } return nil } + func skipCommon(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/genesis.pb.go b/x/valset/types/genesis.pb.go index 45f40738..2fd9e285 100644 --- a/x/valset/types/genesis.pb.go +++ b/x/valset/types/genesis.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -36,9 +39,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_9081b57942dae307, []int{0} } + 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) @@ -51,12 +56,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) 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) } @@ -93,7 +101,7 @@ func init() { } var fileDescriptor_9081b57942dae307 = []byte{ - // 271 bytes of a gzipped FileDescriptorProto + // 273 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2f, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0xcb, 0x12, 0x73, 0x8a, 0x53, 0x4b, 0xf4, 0xd3, 0x53, 0xf3, 0x52, 0x8b, 0x33, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, @@ -106,11 +114,12 @@ var fileDescriptor_9081b57942dae307 = []byte{ 0x3c, 0x43, 0x10, 0x54, 0x9b, 0x50, 0x2c, 0x97, 0x10, 0xc4, 0xba, 0x20, 0x24, 0xdb, 0x24, 0x98, 0xc0, 0x86, 0xe9, 0xe2, 0x33, 0x0c, 0x43, 0x53, 0x10, 0x16, 0x83, 0x84, 0x2a, 0xb8, 0xa4, 0x8b, 0x93, 0x33, 0x52, 0x53, 0x4a, 0x73, 0x52, 0x53, 0x30, 0xb5, 0x48, 0x30, 0x83, 0xed, 0x31, 0xc3, - 0x63, 0x4f, 0x30, 0x6e, 0xdd, 0x41, 0xf8, 0x8c, 0x76, 0x72, 0x3b, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, + 0x63, 0x4f, 0x30, 0x6e, 0xdd, 0x41, 0xf8, 0x8c, 0x76, 0xf2, 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, 0x9d, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, - 0x7d, 0x2c, 0x91, 0x50, 0x01, 0x8b, 0x86, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0x70, 0xc8, - 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x21, 0xf6, 0xa0, 0x9e, 0x32, 0x02, 0x00, 0x00, + 0xc6, 0x63, 0x39, 0x86, 0x28, 0xfd, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, + 0x7d, 0x6c, 0x91, 0x60, 0xa4, 0x5f, 0x01, 0x8b, 0x89, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, + 0x70, 0xe0, 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x78, 0x14, 0x8b, 0xf6, 0x35, 0x02, 0x00, + 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -181,6 +190,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -203,9 +213,11 @@ func (m *GenesisState) Size() (n int) { 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 *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -361,6 +373,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/jail.pb.go b/x/valset/types/jail.pb.go index 4c69c1e8..c0e94c40 100644 --- a/x/valset/types/jail.pb.go +++ b/x/valset/types/jail.pb.go @@ -5,6 +5,11 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + time "time" + _ "github.com/cosmos/cosmos-proto" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" @@ -12,17 +17,15 @@ import ( github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "google.golang.org/protobuf/types/known/durationpb" _ "google.golang.org/protobuf/types/known/timestamppb" - io "io" - math "math" - math_bits "math/bits" - time "time" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf -var _ = time.Kitchen +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = math.Inf + _ = time.Kitchen +) // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -45,9 +48,11 @@ func (*JailRecord) ProtoMessage() {} func (*JailRecord) Descriptor() ([]byte, []int) { return fileDescriptor_7d6891913aadee6b, []int{0} } + func (m *JailRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *JailRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_JailRecord.Marshal(b, m, deterministic) @@ -60,12 +65,15 @@ func (m *JailRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *JailRecord) XXX_Merge(src proto.Message) { xxx_messageInfo_JailRecord.Merge(m, src) } + func (m *JailRecord) XXX_Size() int { return m.Size() } + func (m *JailRecord) XXX_DiscardUnknown() { xxx_messageInfo_JailRecord.DiscardUnknown(m) } @@ -104,25 +112,25 @@ func init() { var fileDescriptor_7d6891913aadee6b = []byte{ // 314 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0x3f, 0x4f, 0x02, 0x31, - 0x14, 0xbf, 0x6a, 0xa2, 0xa4, 0x3a, 0x5d, 0x1c, 0x80, 0xa1, 0x47, 0x8c, 0x03, 0x83, 0xb4, 0x51, - 0x3f, 0x80, 0x42, 0x8c, 0x83, 0x6e, 0xc4, 0x38, 0xb8, 0x98, 0x72, 0xad, 0x47, 0xb5, 0xc7, 0xbb, - 0x5c, 0x8b, 0xd1, 0x6f, 0xc1, 0xe8, 0x47, 0x62, 0x64, 0x74, 0x30, 0x68, 0xe0, 0x5b, 0x38, 0x19, - 0xda, 0xab, 0x21, 0xea, 0xd4, 0xf7, 0xf2, 0xfb, 0xf3, 0xde, 0xaf, 0x0f, 0x1f, 0x14, 0x5c, 0x43, - 0xce, 0xd3, 0x21, 0x57, 0x23, 0xe6, 0x6b, 0xf6, 0xc4, 0xb5, 0x91, 0x96, 0x3d, 0x70, 0xa5, 0x69, - 0x51, 0x82, 0x85, 0xb8, 0xb1, 0xc6, 0xa2, 0xbe, 0xa6, 0x9e, 0xd5, 0xdc, 0xcb, 0x20, 0x03, 0xc7, - 0x62, 0xab, 0xca, 0x0b, 0x9a, 0x8d, 0x14, 0x4c, 0x0e, 0xe6, 0xce, 0x03, 0xbe, 0xa9, 0x20, 0x92, - 0x01, 0x64, 0x5a, 0x32, 0xd7, 0x0d, 0xc6, 0xf7, 0x4c, 0x8c, 0x4b, 0x6e, 0x15, 0x8c, 0x2a, 0x3c, - 0xf9, 0x8d, 0x5b, 0x95, 0x4b, 0x63, 0x79, 0x5e, 0x78, 0xc2, 0xfe, 0x3b, 0xc2, 0xf8, 0x92, 0x2b, - 0xdd, 0x97, 0x29, 0x94, 0x22, 0xbe, 0xc2, 0xdb, 0x5c, 0x88, 0x52, 0x1a, 0x53, 0x47, 0x2d, 0xd4, - 0xde, 0xed, 0x1d, 0x7d, 0xcd, 0x93, 0x4e, 0xa6, 0xec, 0x70, 0x3c, 0xa0, 0x29, 0xe4, 0xd5, 0xf4, - 0xea, 0xe9, 0x18, 0xf1, 0xc8, 0xec, 0x4b, 0x21, 0x0d, 0xbd, 0xe1, 0xba, 0xeb, 0x85, 0xfd, 0xe0, - 0x10, 0x9f, 0xe2, 0x5a, 0x58, 0xa7, 0xbe, 0xd1, 0x42, 0xed, 0x9d, 0xe3, 0x06, 0xf5, 0xfb, 0xd0, - 0xb0, 0x0f, 0x3d, 0xaf, 0x08, 0xbd, 0xda, 0x74, 0x9e, 0x44, 0xaf, 0x1f, 0x09, 0xea, 0xff, 0x88, - 0xe2, 0x33, 0x5c, 0x5b, 0xfd, 0x9b, 0x14, 0x5d, 0x5b, 0xdf, 0x74, 0x06, 0xcd, 0x3f, 0x06, 0xd7, - 0x21, 0x90, 0x77, 0x98, 0x38, 0x87, 0xa0, 0xea, 0x5d, 0x4c, 0x17, 0x04, 0xcd, 0x16, 0x04, 0x7d, - 0x2e, 0x08, 0x9a, 0x2c, 0x49, 0x34, 0x5b, 0x92, 0xe8, 0x6d, 0x49, 0xa2, 0xdb, 0xc3, 0xb5, 0x50, - 0xff, 0x9c, 0xed, 0x39, 0x1c, 0xce, 0xc5, 0x1b, 0x6c, 0xb9, 0x79, 0x27, 0xdf, 0x01, 0x00, 0x00, - 0xff, 0xff, 0xcb, 0xd6, 0x4e, 0x5d, 0xe2, 0x01, 0x00, 0x00, + 0x14, 0xbf, 0x6a, 0xa2, 0xa4, 0x3a, 0x5d, 0x1c, 0x80, 0xa1, 0x47, 0x8c, 0x03, 0x0b, 0x6d, 0xc4, + 0x0f, 0xa0, 0x10, 0x17, 0x75, 0x23, 0xc6, 0xc1, 0xc5, 0x94, 0x6b, 0x3d, 0xaa, 0x3d, 0xde, 0xe5, + 0x5a, 0x8c, 0x7e, 0x0b, 0x46, 0x3f, 0x12, 0x23, 0xa3, 0x83, 0x41, 0x03, 0xdf, 0xc2, 0xc9, 0xd0, + 0x5e, 0x0d, 0x51, 0xa7, 0xbe, 0x97, 0xdf, 0x9f, 0xf7, 0x7e, 0x7d, 0xf8, 0xa8, 0xe0, 0x1a, 0x72, + 0x9e, 0x8e, 0xb8, 0x1a, 0x33, 0x5f, 0xb3, 0x27, 0xae, 0x8d, 0xb4, 0xec, 0x81, 0x2b, 0x4d, 0x8b, + 0x12, 0x2c, 0xc4, 0x8d, 0x0d, 0x16, 0xf5, 0x35, 0xf5, 0xac, 0xe6, 0x41, 0x06, 0x19, 0x38, 0x16, + 0x5b, 0x57, 0x5e, 0xd0, 0x6c, 0xa4, 0x60, 0x72, 0x30, 0x77, 0x1e, 0xf0, 0x4d, 0x05, 0x91, 0x0c, + 0x20, 0xd3, 0x92, 0xb9, 0x6e, 0x38, 0xb9, 0x67, 0x62, 0x52, 0x72, 0xab, 0x60, 0x5c, 0xe1, 0xc9, + 0x6f, 0xdc, 0xaa, 0x5c, 0x1a, 0xcb, 0xf3, 0xc2, 0x13, 0x0e, 0xdf, 0x11, 0xc6, 0x97, 0x5c, 0xe9, + 0x81, 0x4c, 0xa1, 0x14, 0xf1, 0x15, 0xde, 0xe5, 0x42, 0x94, 0xd2, 0x98, 0x3a, 0x6a, 0xa1, 0xf6, + 0x7e, 0xff, 0xf8, 0x6b, 0x91, 0x74, 0x32, 0x65, 0x47, 0x93, 0x21, 0x4d, 0x21, 0xaf, 0xa6, 0x57, + 0x4f, 0xc7, 0x88, 0x47, 0x66, 0x5f, 0x0a, 0x69, 0xe8, 0x0d, 0xd7, 0x3d, 0x2f, 0x1c, 0x04, 0x87, + 0xf8, 0x14, 0xd7, 0xc2, 0x3a, 0xf5, 0xad, 0x16, 0x6a, 0xef, 0x75, 0x1b, 0xd4, 0xef, 0x43, 0xc3, + 0x3e, 0xf4, 0xbc, 0x22, 0xf4, 0x6b, 0xb3, 0x45, 0x12, 0xbd, 0x7e, 0x24, 0x68, 0xf0, 0x23, 0x8a, + 0xcf, 0x70, 0x6d, 0xfd, 0x6f, 0x52, 0xf4, 0x6c, 0x7d, 0xdb, 0x19, 0x34, 0xff, 0x18, 0x5c, 0x87, + 0x40, 0xde, 0x61, 0xea, 0x1c, 0x82, 0xaa, 0x7f, 0x31, 0x5b, 0x12, 0x34, 0x5f, 0x12, 0xf4, 0xb9, + 0x24, 0x68, 0xba, 0x22, 0xd1, 0x7c, 0x45, 0xa2, 0xb7, 0x15, 0x89, 0x6e, 0xd9, 0x46, 0xa8, 0xff, + 0xce, 0xd6, 0x65, 0xcf, 0xe1, 0x76, 0x2e, 0xe1, 0x70, 0xc7, 0x8d, 0x3c, 0xf9, 0x0e, 0x00, 0x00, + 0xff, 0xff, 0x10, 0xaa, 0xc8, 0x80, 0xe5, 0x01, 0x00, 0x00, } func (m *JailRecord) Marshal() (dAtA []byte, err error) { @@ -182,6 +190,7 @@ func encodeVarintJail(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *JailRecord) Size() (n int) { if m == nil { return 0 @@ -202,9 +211,11 @@ func (m *JailRecord) Size() (n int) { func sovJail(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozJail(x uint64) (n int) { return sovJail(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *JailRecord) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -355,6 +366,7 @@ func (m *JailRecord) Unmarshal(dAtA []byte) error { } return nil } + func skipJail(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/params.pb.go b/x/valset/types/params.pb.go index 78022f88..02251c12 100644 --- a/x/valset/types/params.pb.go +++ b/x/valset/types/params.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -24,17 +27,18 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Params defines the parameters for the module. -type Params struct { -} +type Params struct{} func (m *Params) Reset() { *m = Params{} } func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_47ceef5f87d4afe7, []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) @@ -47,12 +51,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 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) } @@ -68,17 +75,17 @@ func init() { } var fileDescriptor_47ceef5f87d4afe7 = []byte{ - // 152 bytes of a gzipped FileDescriptorProto + // 154 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2b, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0xcb, 0x12, 0x73, 0x8a, 0x53, 0x4b, 0xf4, 0x0b, 0x12, 0x8b, 0x12, 0x73, 0x8b, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x24, 0x91, 0xd4, 0xe9, 0x41, 0xd8, 0x7a, 0x10, 0x75, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x55, 0xfa, 0x20, 0x16, 0x44, 0x83, 0x12, 0x1f, 0x17, 0x5b, 0x00, 0xd8, 0x00, 0x2b, 0x96, 0x19, 0x0b, - 0xe4, 0x19, 0x9c, 0xdc, 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, 0x27, - 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x8b, 0x6b, 0x2a, 0x60, 0xee, - 0x29, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x1b, 0x6f, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, - 0x0b, 0xc0, 0x58, 0x4c, 0xb9, 0x00, 0x00, 0x00, + 0xe4, 0x19, 0x9c, 0x3c, 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, 0x3f, + 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x9b, 0x6b, 0x8c, 0xf4, 0x2b, + 0x60, 0x4e, 0x2a, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0xdb, 0x60, 0x0c, 0x08, 0x00, 0x00, + 0xff, 0xff, 0xc7, 0x3c, 0x2b, 0xf9, 0xbc, 0x00, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -115,6 +122,7 @@ func encodeVarintParams(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -127,9 +135,11 @@ func (m *Params) Size() (n int) { func sovParams(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozParams(x uint64) (n int) { return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -180,6 +190,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func skipParams(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/pigeon_requirements.pb.go b/x/valset/types/pigeon_requirements.pb.go index 8416407b..17ec9db8 100644 --- a/x/valset/types/pigeon_requirements.pb.go +++ b/x/valset/types/pigeon_requirements.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -32,9 +35,11 @@ func (*PigeonRequirements) ProtoMessage() {} func (*PigeonRequirements) Descriptor() ([]byte, []int) { return fileDescriptor_5ff0dae947bdd130, []int{0} } + func (m *PigeonRequirements) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *PigeonRequirements) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PigeonRequirements.Marshal(b, m, deterministic) @@ -47,12 +52,15 @@ func (m *PigeonRequirements) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *PigeonRequirements) XXX_Merge(src proto.Message) { xxx_messageInfo_PigeonRequirements.Merge(m, src) } + func (m *PigeonRequirements) XXX_Size() int { return m.Size() } + func (m *PigeonRequirements) XXX_DiscardUnknown() { xxx_messageInfo_PigeonRequirements.DiscardUnknown(m) } @@ -77,9 +85,11 @@ func (*ScheduledPigeonRequirements) ProtoMessage() {} func (*ScheduledPigeonRequirements) Descriptor() ([]byte, []int) { return fileDescriptor_5ff0dae947bdd130, []int{1} } + func (m *ScheduledPigeonRequirements) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ScheduledPigeonRequirements) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScheduledPigeonRequirements.Marshal(b, m, deterministic) @@ -92,12 +102,15 @@ func (m *ScheduledPigeonRequirements) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *ScheduledPigeonRequirements) XXX_Merge(src proto.Message) { xxx_messageInfo_ScheduledPigeonRequirements.Merge(m, src) } + func (m *ScheduledPigeonRequirements) XXX_Size() int { return m.Size() } + func (m *ScheduledPigeonRequirements) XXX_DiscardUnknown() { xxx_messageInfo_ScheduledPigeonRequirements.DiscardUnknown(m) } @@ -128,7 +141,7 @@ func init() { } var fileDescriptor_5ff0dae947bdd130 = []byte{ - // 240 bytes of a gzipped FileDescriptorProto + // 242 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2e, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0xcb, 0x12, 0x73, 0x8a, 0x53, 0x4b, 0xf4, 0x0b, 0x32, 0xd3, 0x53, 0xf3, 0xf3, 0xe2, 0x8b, 0x52, 0x0b, 0x4b, 0x33, 0x8b, 0x52, @@ -139,11 +152,12 @@ var fileDescriptor_5ff0dae947bdd130 = []byte{ 0x94, 0xe6, 0xa4, 0xa6, 0x60, 0xd1, 0x1f, 0xc8, 0xc5, 0x83, 0xec, 0x0c, 0xb0, 0x09, 0xdc, 0x46, 0xba, 0x7a, 0x38, 0xdd, 0xa1, 0x87, 0x69, 0x48, 0x10, 0x8a, 0x11, 0x42, 0x3a, 0x5c, 0x82, 0x25, 0x89, 0x45, 0xe9, 0xa9, 0x25, 0x4e, 0x39, 0xf9, 0xc9, 0xd9, 0x1e, 0xa9, 0x99, 0xe9, 0x19, 0x25, - 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0x2c, 0x41, 0x98, 0x12, 0x4e, 0x6e, 0x27, 0x1e, 0xc9, 0x31, 0x5e, + 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0x2c, 0x41, 0x98, 0x12, 0x4e, 0x9e, 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, 0x93, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, - 0xab, 0x8f, 0x25, 0x2c, 0x2b, 0x60, 0xa1, 0x59, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x0e, - 0x40, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x27, 0xa4, 0x51, 0xa3, 0x77, 0x01, 0x00, 0x00, + 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x9f, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, + 0xab, 0x8f, 0x2d, 0x2c, 0x8d, 0xf4, 0x2b, 0x60, 0x01, 0x5a, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, + 0x06, 0x0e, 0x43, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xab, 0x95, 0x31, 0xb0, 0x7a, 0x01, + 0x00, 0x00, } func (m *PigeonRequirements) Marshal() (dAtA []byte, err error) { @@ -227,6 +241,7 @@ func encodeVarintPigeonRequirements(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *PigeonRequirements) Size() (n int) { if m == nil { return 0 @@ -259,9 +274,11 @@ func (m *ScheduledPigeonRequirements) Size() (n int) { func sovPigeonRequirements(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozPigeonRequirements(x uint64) (n int) { return sovPigeonRequirements(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *PigeonRequirements) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -344,6 +361,7 @@ func (m *PigeonRequirements) Unmarshal(dAtA []byte) error { } return nil } + func (m *ScheduledPigeonRequirements) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -449,6 +467,7 @@ func (m *ScheduledPigeonRequirements) Unmarshal(dAtA []byte) error { } return nil } + func skipPigeonRequirements(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/query.pb.go b/x/valset/types/query.pb.go index 69425ed9..cad35633 100644 --- a/x/valset/types/query.pb.go +++ b/x/valset/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/cosmos-sdk/types/query" _ "github.com/cosmos/gogoproto/gogoproto" @@ -16,15 +20,14 @@ import ( 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -33,8 +36,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // QueryParamsRequest is request type for the Query/Params RPC method. -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -42,9 +44,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{0} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -57,12 +61,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -81,9 +88,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{1} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -96,12 +105,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -125,9 +137,11 @@ func (*QueryValidatorInfoRequest) ProtoMessage() {} func (*QueryValidatorInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{2} } + func (m *QueryValidatorInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryValidatorInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryValidatorInfoRequest.Marshal(b, m, deterministic) @@ -140,12 +154,15 @@ func (m *QueryValidatorInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryValidatorInfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryValidatorInfoRequest.Merge(m, src) } + func (m *QueryValidatorInfoRequest) XXX_Size() int { return m.Size() } + func (m *QueryValidatorInfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryValidatorInfoRequest.DiscardUnknown(m) } @@ -169,9 +186,11 @@ func (*QueryValidatorInfoResponse) ProtoMessage() {} func (*QueryValidatorInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{3} } + func (m *QueryValidatorInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryValidatorInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryValidatorInfoResponse.Marshal(b, m, deterministic) @@ -184,12 +203,15 @@ func (m *QueryValidatorInfoResponse) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *QueryValidatorInfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryValidatorInfoResponse.Merge(m, src) } + func (m *QueryValidatorInfoResponse) XXX_Size() int { return m.Size() } + func (m *QueryValidatorInfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryValidatorInfoResponse.DiscardUnknown(m) } @@ -213,9 +235,11 @@ func (*QueryGetSnapshotByIDRequest) ProtoMessage() {} func (*QueryGetSnapshotByIDRequest) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{4} } + func (m *QueryGetSnapshotByIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetSnapshotByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetSnapshotByIDRequest.Marshal(b, m, deterministic) @@ -228,12 +252,15 @@ func (m *QueryGetSnapshotByIDRequest) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryGetSnapshotByIDRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetSnapshotByIDRequest.Merge(m, src) } + func (m *QueryGetSnapshotByIDRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetSnapshotByIDRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetSnapshotByIDRequest.DiscardUnknown(m) } @@ -257,9 +284,11 @@ func (*QueryGetSnapshotByIDResponse) ProtoMessage() {} func (*QueryGetSnapshotByIDResponse) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{5} } + func (m *QueryGetSnapshotByIDResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetSnapshotByIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetSnapshotByIDResponse.Marshal(b, m, deterministic) @@ -272,12 +301,15 @@ func (m *QueryGetSnapshotByIDResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryGetSnapshotByIDResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetSnapshotByIDResponse.Merge(m, src) } + func (m *QueryGetSnapshotByIDResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetSnapshotByIDResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetSnapshotByIDResponse.DiscardUnknown(m) } @@ -303,9 +335,11 @@ func (*QueryGetLatestPublishedSnapshotRequest) ProtoMessage() {} func (*QueryGetLatestPublishedSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{6} } + func (m *QueryGetLatestPublishedSnapshotRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetLatestPublishedSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetLatestPublishedSnapshotRequest.Marshal(b, m, deterministic) @@ -318,12 +352,15 @@ func (m *QueryGetLatestPublishedSnapshotRequest) XXX_Marshal(b []byte, determini return b[:n], nil } } + func (m *QueryGetLatestPublishedSnapshotRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetLatestPublishedSnapshotRequest.Merge(m, src) } + func (m *QueryGetLatestPublishedSnapshotRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetLatestPublishedSnapshotRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetLatestPublishedSnapshotRequest.DiscardUnknown(m) } @@ -349,9 +386,11 @@ func (*QueryGetLatestPublishedSnapshotResponse) ProtoMessage() {} func (*QueryGetLatestPublishedSnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{7} } + func (m *QueryGetLatestPublishedSnapshotResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetLatestPublishedSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetLatestPublishedSnapshotResponse.Marshal(b, m, deterministic) @@ -364,12 +403,15 @@ func (m *QueryGetLatestPublishedSnapshotResponse) XXX_Marshal(b []byte, determin return b[:n], nil } } + func (m *QueryGetLatestPublishedSnapshotResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetLatestPublishedSnapshotResponse.Merge(m, src) } + func (m *QueryGetLatestPublishedSnapshotResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetLatestPublishedSnapshotResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetLatestPublishedSnapshotResponse.DiscardUnknown(m) } @@ -393,9 +435,11 @@ func (*QueryGetValidatorAliveUntilRequest) ProtoMessage() {} func (*QueryGetValidatorAliveUntilRequest) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{8} } + func (m *QueryGetValidatorAliveUntilRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetValidatorAliveUntilRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetValidatorAliveUntilRequest.Marshal(b, m, deterministic) @@ -408,12 +452,15 @@ func (m *QueryGetValidatorAliveUntilRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *QueryGetValidatorAliveUntilRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetValidatorAliveUntilRequest.Merge(m, src) } + func (m *QueryGetValidatorAliveUntilRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetValidatorAliveUntilRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetValidatorAliveUntilRequest.DiscardUnknown(m) } @@ -437,9 +484,11 @@ func (*QueryGetValidatorAliveUntilResponse) ProtoMessage() {} func (*QueryGetValidatorAliveUntilResponse) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{9} } + func (m *QueryGetValidatorAliveUntilResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetValidatorAliveUntilResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetValidatorAliveUntilResponse.Marshal(b, m, deterministic) @@ -452,12 +501,15 @@ func (m *QueryGetValidatorAliveUntilResponse) XXX_Marshal(b []byte, deterministi return b[:n], nil } } + func (m *QueryGetValidatorAliveUntilResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetValidatorAliveUntilResponse.Merge(m, src) } + func (m *QueryGetValidatorAliveUntilResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetValidatorAliveUntilResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetValidatorAliveUntilResponse.DiscardUnknown(m) } @@ -481,9 +533,11 @@ func (*QueryGetValidatorJailReasonRequest) ProtoMessage() {} func (*QueryGetValidatorJailReasonRequest) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{10} } + func (m *QueryGetValidatorJailReasonRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetValidatorJailReasonRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetValidatorJailReasonRequest.Marshal(b, m, deterministic) @@ -496,12 +550,15 @@ func (m *QueryGetValidatorJailReasonRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *QueryGetValidatorJailReasonRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetValidatorJailReasonRequest.Merge(m, src) } + func (m *QueryGetValidatorJailReasonRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetValidatorJailReasonRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetValidatorJailReasonRequest.DiscardUnknown(m) } @@ -525,9 +582,11 @@ func (*QueryGetValidatorJailReasonResponse) ProtoMessage() {} func (*QueryGetValidatorJailReasonResponse) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{11} } + func (m *QueryGetValidatorJailReasonResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetValidatorJailReasonResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetValidatorJailReasonResponse.Marshal(b, m, deterministic) @@ -540,12 +599,15 @@ func (m *QueryGetValidatorJailReasonResponse) XXX_Marshal(b []byte, deterministi return b[:n], nil } } + func (m *QueryGetValidatorJailReasonResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetValidatorJailReasonResponse.Merge(m, src) } + func (m *QueryGetValidatorJailReasonResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetValidatorJailReasonResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetValidatorJailReasonResponse.DiscardUnknown(m) } @@ -559,8 +621,7 @@ func (m *QueryGetValidatorJailReasonResponse) GetReason() string { return "" } -type QueryGetAlivePigeonsRequest struct { -} +type QueryGetAlivePigeonsRequest struct{} func (m *QueryGetAlivePigeonsRequest) Reset() { *m = QueryGetAlivePigeonsRequest{} } func (m *QueryGetAlivePigeonsRequest) String() string { return proto.CompactTextString(m) } @@ -568,9 +629,11 @@ func (*QueryGetAlivePigeonsRequest) ProtoMessage() {} func (*QueryGetAlivePigeonsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{12} } + func (m *QueryGetAlivePigeonsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetAlivePigeonsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetAlivePigeonsRequest.Marshal(b, m, deterministic) @@ -583,12 +646,15 @@ func (m *QueryGetAlivePigeonsRequest) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryGetAlivePigeonsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetAlivePigeonsRequest.Merge(m, src) } + func (m *QueryGetAlivePigeonsRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetAlivePigeonsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetAlivePigeonsRequest.DiscardUnknown(m) } @@ -605,9 +671,11 @@ func (*QueryGetAlivePigeonsResponse) ProtoMessage() {} func (*QueryGetAlivePigeonsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{13} } + func (m *QueryGetAlivePigeonsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetAlivePigeonsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetAlivePigeonsResponse.Marshal(b, m, deterministic) @@ -620,12 +688,15 @@ func (m *QueryGetAlivePigeonsResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryGetAlivePigeonsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetAlivePigeonsResponse.Merge(m, src) } + func (m *QueryGetAlivePigeonsResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetAlivePigeonsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetAlivePigeonsResponse.DiscardUnknown(m) } @@ -649,6 +720,7 @@ type QueryGetAlivePigeonsResponse_ValidatorAlive struct { func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) Reset() { *m = QueryGetAlivePigeonsResponse_ValidatorAlive{} } + func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) String() string { return proto.CompactTextString(m) } @@ -656,9 +728,11 @@ func (*QueryGetAlivePigeonsResponse_ValidatorAlive) ProtoMessage() {} func (*QueryGetAlivePigeonsResponse_ValidatorAlive) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{13, 0} } + func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetAlivePigeonsResponse_ValidatorAlive.Marshal(b, m, deterministic) @@ -671,12 +745,15 @@ func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) XXX_Marshal(b []byte, dete return b[:n], nil } } + func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetAlivePigeonsResponse_ValidatorAlive.Merge(m, src) } + func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) XXX_Size() int { return m.Size() } + func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetAlivePigeonsResponse_ValidatorAlive.DiscardUnknown(m) } @@ -711,8 +788,7 @@ func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) GetPigeonVersion() string return "" } -type QueryGetPigeonRequirementsRequest struct { -} +type QueryGetPigeonRequirementsRequest struct{} func (m *QueryGetPigeonRequirementsRequest) Reset() { *m = QueryGetPigeonRequirementsRequest{} } func (m *QueryGetPigeonRequirementsRequest) String() string { return proto.CompactTextString(m) } @@ -720,9 +796,11 @@ func (*QueryGetPigeonRequirementsRequest) ProtoMessage() {} func (*QueryGetPigeonRequirementsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{14} } + func (m *QueryGetPigeonRequirementsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetPigeonRequirementsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetPigeonRequirementsRequest.Marshal(b, m, deterministic) @@ -735,12 +813,15 @@ func (m *QueryGetPigeonRequirementsRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *QueryGetPigeonRequirementsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetPigeonRequirementsRequest.Merge(m, src) } + func (m *QueryGetPigeonRequirementsRequest) XXX_Size() int { return m.Size() } + func (m *QueryGetPigeonRequirementsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetPigeonRequirementsRequest.DiscardUnknown(m) } @@ -758,9 +839,11 @@ func (*QueryGetPigeonRequirementsResponse) ProtoMessage() {} func (*QueryGetPigeonRequirementsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_85b0a74ca430fb38, []int{15} } + func (m *QueryGetPigeonRequirementsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryGetPigeonRequirementsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryGetPigeonRequirementsResponse.Marshal(b, m, deterministic) @@ -773,12 +856,15 @@ func (m *QueryGetPigeonRequirementsResponse) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *QueryGetPigeonRequirementsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryGetPigeonRequirementsResponse.Merge(m, src) } + func (m *QueryGetPigeonRequirementsResponse) XXX_Size() int { return m.Size() } + func (m *QueryGetPigeonRequirementsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryGetPigeonRequirementsResponse.DiscardUnknown(m) } @@ -824,78 +910,81 @@ func init() { } var fileDescriptor_85b0a74ca430fb38 = []byte{ - // 1055 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xdd, 0x6e, 0x1b, 0x45, - 0x14, 0xf6, 0x3a, 0x8e, 0x09, 0x27, 0xfd, 0x89, 0x86, 0xb4, 0x72, 0xb7, 0xc5, 0x69, 0x36, 0x6a, - 0x09, 0x55, 0xb2, 0xab, 0x38, 0x4e, 0x90, 0x4a, 0x02, 0x8a, 0x29, 0x85, 0x44, 0xbd, 0x48, 0x17, - 0xc8, 0x05, 0x12, 0xb2, 0xc6, 0xf6, 0x64, 0xbd, 0xe9, 0x7a, 0x67, 0xb3, 0x33, 0x36, 0x89, 0xaa, - 0xde, 0x70, 0xc3, 0x2d, 0x82, 0x67, 0xe0, 0x1d, 0xe0, 0x05, 0x50, 0x2f, 0x23, 0x21, 0x24, 0xae, - 0x2a, 0x94, 0xf0, 0x0a, 0xdc, 0x20, 0x21, 0x21, 0xcf, 0xcc, 0xfa, 0x27, 0x5e, 0xaf, 0x9d, 0x40, - 0xaf, 0xb2, 0x3b, 0x7b, 0xce, 0x37, 0xdf, 0x77, 0xce, 0x99, 0xf9, 0x62, 0xb8, 0x17, 0x60, 0x8f, - 0x36, 0x70, 0xb5, 0x8e, 0x5d, 0xdf, 0x92, 0xcf, 0x56, 0x0b, 0x7b, 0x8c, 0x70, 0xeb, 0xb0, 0x49, - 0xc2, 0x63, 0x33, 0x08, 0x29, 0xa7, 0xe8, 0x56, 0x4f, 0x98, 0x29, 0x9f, 0x4d, 0x19, 0xa6, 0xcf, - 0x3a, 0xd4, 0xa1, 0x22, 0xca, 0x6a, 0x3f, 0xc9, 0x04, 0xfd, 0x8e, 0x43, 0xa9, 0xe3, 0x11, 0x0b, - 0x07, 0xae, 0x85, 0x7d, 0x9f, 0x72, 0xcc, 0x5d, 0xea, 0x33, 0xf5, 0xf5, 0x41, 0x95, 0xb2, 0x06, - 0x65, 0x56, 0x05, 0x33, 0x22, 0xf7, 0xb1, 0x5a, 0x2b, 0x15, 0xc2, 0xf1, 0x8a, 0x15, 0x60, 0xc7, - 0xf5, 0x45, 0xb0, 0x8a, 0xbd, 0x3f, 0x9c, 0x61, 0x80, 0x43, 0xdc, 0x88, 0x30, 0x17, 0x87, 0xc7, - 0x31, 0x1f, 0x07, 0xac, 0x4e, 0xb9, 0x8a, 0x5c, 0x4d, 0x40, 0x74, 0x1d, 0x42, 0xfd, 0x72, 0x48, - 0x0e, 0x9b, 0x6e, 0x48, 0x1a, 0xc4, 0xe7, 0x11, 0xfc, 0x9c, 0x12, 0x24, 0xde, 0x2a, 0xcd, 0x7d, - 0x8b, 0xbb, 0x0d, 0xc2, 0x38, 0x6e, 0x04, 0x32, 0xc0, 0x98, 0x05, 0xf4, 0xb4, 0xad, 0x64, 0x57, - 0x90, 0xb2, 0xc9, 0x61, 0x93, 0x30, 0x6e, 0xec, 0xc1, 0x5b, 0x7d, 0xab, 0x2c, 0xa0, 0x3e, 0x23, - 0xe8, 0x43, 0xc8, 0x4a, 0xf2, 0x39, 0xed, 0xae, 0xb6, 0x38, 0x5d, 0x98, 0x37, 0x87, 0x16, 0xd8, - 0x94, 0xa9, 0xa5, 0xcc, 0xcb, 0x57, 0x73, 0x29, 0x5b, 0xa5, 0x19, 0x6b, 0x70, 0x4b, 0xe0, 0xee, - 0x61, 0xcf, 0xad, 0x61, 0x4e, 0xc3, 0x6d, 0x7f, 0x9f, 0xaa, 0x4d, 0x51, 0x0e, 0xde, 0x68, 0x61, - 0x6f, 0xab, 0x56, 0x0b, 0x05, 0xfc, 0x9b, 0x76, 0xf4, 0x6a, 0x1c, 0x80, 0x1e, 0x97, 0xa6, 0x58, - 0x3d, 0x01, 0x10, 0x04, 0xda, 0x8b, 0x6d, 0x66, 0x13, 0x8b, 0xd3, 0x85, 0xa5, 0x04, 0x66, 0x1f, - 0x1f, 0x71, 0x12, 0xfa, 0xd8, 0xfb, 0x28, 0x4a, 0xb2, 0x7b, 0xf2, 0x8d, 0x4d, 0xb8, 0x2d, 0xf6, - 0xfa, 0x84, 0xf0, 0xcf, 0x54, 0x03, 0x4a, 0xc7, 0xdb, 0x8f, 0x22, 0x92, 0x79, 0x80, 0xa8, 0x2f, - 0xdb, 0x35, 0xc1, 0x33, 0x63, 0xf7, 0xac, 0x18, 0x65, 0xb8, 0x13, 0x9f, 0xde, 0x29, 0xe1, 0x54, - 0x14, 0xad, 0x8a, 0xb8, 0x90, 0x40, 0x35, 0x82, 0xb0, 0x3b, 0x49, 0xc6, 0xe7, 0x70, 0x3f, 0xda, - 0xe0, 0x09, 0xe6, 0x84, 0xf1, 0xdd, 0x66, 0xc5, 0x73, 0x59, 0x9d, 0xd4, 0x3a, 0xc1, 0x8a, 0xea, - 0x03, 0x98, 0x11, 0x98, 0x36, 0xd9, 0x27, 0x21, 0xf1, 0xab, 0x64, 0xfb, 0x91, 0x2a, 0xec, 0xc0, - 0xba, 0x71, 0x00, 0xef, 0x8c, 0x44, 0xfd, 0xbf, 0x14, 0x7c, 0x0d, 0x46, 0xb4, 0x57, 0xa7, 0xa1, - 0x5b, 0x9e, 0xdb, 0x22, 0x5f, 0xf8, 0xdc, 0xf5, 0x22, 0xf6, 0x4f, 0x01, 0x54, 0xfb, 0x09, 0x93, - 0xf3, 0x76, 0xa5, 0xb4, 0xf2, 0xf7, 0xab, 0xb9, 0x65, 0xc7, 0xe5, 0xf5, 0x66, 0xc5, 0xac, 0xd2, - 0x86, 0xa5, 0xce, 0xa3, 0xfc, 0xb3, 0xcc, 0x6a, 0xcf, 0x2c, 0x7e, 0x1c, 0x10, 0x66, 0xee, 0x75, - 0x12, 0xed, 0x1e, 0x10, 0x03, 0xc3, 0x42, 0xe2, 0xc6, 0x4a, 0x60, 0x11, 0x6e, 0xe0, 0xce, 0x6a, - 0xc9, 0xa3, 0xd5, 0x67, 0x9f, 0x12, 0xd7, 0xa9, 0xf3, 0x5c, 0xfa, 0xae, 0xb6, 0x38, 0x61, 0xc7, - 0x7f, 0xdc, 0xc9, 0x4c, 0x69, 0x33, 0xe9, 0x58, 0x6d, 0x3b, 0xb8, 0x0d, 0x8e, 0x19, 0xf5, 0x5f, - 0xa3, 0xb6, 0xcd, 0x18, 0x6d, 0xbd, 0x1b, 0x2b, 0x6d, 0x37, 0x21, 0x1b, 0x8a, 0x15, 0x35, 0x09, - 0xea, 0xcd, 0x78, 0xbb, 0x3b, 0xf5, 0xa2, 0x22, 0xbb, 0xe2, 0x46, 0xe9, 0xdc, 0x07, 0x7f, 0xa5, - 0xbb, 0x63, 0xdd, 0xff, 0x5d, 0xe1, 0x06, 0x70, 0x5d, 0x94, 0xa5, 0xb3, 0x77, 0x74, 0x10, 0x1f, - 0x27, 0xcc, 0x46, 0x12, 0xa2, 0xd9, 0xdf, 0x21, 0xfb, 0x3c, 0xbc, 0x7e, 0xaa, 0xc1, 0xb5, 0xfe, - 0x98, 0xd7, 0x50, 0x56, 0x34, 0x0b, 0x93, 0x24, 0x0c, 0x69, 0x98, 0xcb, 0x88, 0x72, 0xc9, 0x97, - 0xe1, 0x13, 0x32, 0x99, 0x30, 0x21, 0xe8, 0x1e, 0x5c, 0x53, 0x17, 0x75, 0x8b, 0x84, 0xcc, 0xa5, - 0x7e, 0x2e, 0x2b, 0x40, 0xaf, 0xca, 0xd5, 0x3d, 0xb9, 0xb8, 0x93, 0x99, 0x4a, 0xcf, 0x4c, 0xec, - 0x64, 0xa6, 0x26, 0x66, 0x32, 0xc6, 0x02, 0xcc, 0x47, 0x45, 0x92, 0xf5, 0xb1, 0x7b, 0xae, 0xf8, - 0xa8, 0x39, 0xff, 0x68, 0xdd, 0xa1, 0x8b, 0x8b, 0x52, 0x2d, 0xfa, 0x0a, 0x50, 0x30, 0xf0, 0x55, - 0x9d, 0xe0, 0xe5, 0xa4, 0x8b, 0x7c, 0x10, 0x32, 0x06, 0x08, 0x1d, 0xc1, 0x6d, 0x56, 0xad, 0x93, - 0x5a, 0xd3, 0x23, 0xb5, 0xc1, 0x14, 0x71, 0x76, 0xa6, 0x0b, 0xeb, 0x49, 0x37, 0xc5, 0xf0, 0x6c, - 0x3b, 0x09, 0xba, 0xf0, 0xed, 0x15, 0x98, 0x14, 0xfa, 0xd1, 0xf7, 0x1a, 0x64, 0xa5, 0xef, 0xa0, - 0xe5, 0x51, 0x73, 0xd7, 0x67, 0x78, 0xba, 0x39, 0x6e, 0xb8, 0x2c, 0xa6, 0xf1, 0xee, 0x37, 0xbf, - 0xfe, 0xf9, 0x43, 0x7a, 0x01, 0xcd, 0x5b, 0xa3, 0x7c, 0x1e, 0xfd, 0xac, 0xc1, 0xd5, 0x3e, 0xe3, - 0x42, 0xc5, 0x51, 0x9b, 0xc5, 0xd9, 0xa3, 0xbe, 0x76, 0xc1, 0x2c, 0xc5, 0xf4, 0x7d, 0xc1, 0x74, - 0x0d, 0xad, 0x26, 0x30, 0x6d, 0x45, 0x99, 0x65, 0xd7, 0xdf, 0xa7, 0xd6, 0x73, 0x75, 0x00, 0x5e, - 0xa0, 0x5f, 0x34, 0xb8, 0x7e, 0xce, 0xc9, 0xd0, 0xfa, 0x18, 0x27, 0x3a, 0xc6, 0x39, 0xf5, 0xf7, - 0x2e, 0x9c, 0xa7, 0x14, 0x94, 0x84, 0x82, 0x0d, 0xf4, 0x30, 0x41, 0x81, 0x43, 0x78, 0x39, 0x32, - 0x98, 0x72, 0xe5, 0xb8, 0xec, 0xd6, 0xac, 0xe7, 0x5d, 0x57, 0x7e, 0x81, 0x7e, 0xd4, 0x40, 0x1f, - 0xee, 0x6d, 0x68, 0x6b, 0x0c, 0x6e, 0xc9, 0x6e, 0xab, 0x97, 0xfe, 0x0b, 0x84, 0x52, 0x9a, 0x42, - 0xbf, 0x69, 0x70, 0x33, 0xde, 0x9e, 0xd0, 0xe6, 0x18, 0x1b, 0x0c, 0xf7, 0x53, 0xfd, 0x83, 0xcb, - 0xa6, 0x2b, 0x6e, 0x1b, 0xa2, 0x0b, 0xeb, 0xa8, 0x38, 0xa2, 0x0b, 0xdd, 0x59, 0x12, 0xb7, 0x60, - 0xb9, 0x29, 0xc8, 0x9f, 0xd7, 0xd5, 0xb5, 0xa6, 0x8b, 0xe9, 0x1a, 0xf0, 0xd2, 0x8b, 0xe9, 0x1a, - 0x74, 0xc4, 0x4b, 0xe8, 0x3a, 0xc0, 0xae, 0x57, 0x96, 0xbe, 0x89, 0x7e, 0x92, 0x07, 0xa4, 0xd7, - 0xc1, 0xc6, 0x3a, 0x20, 0x31, 0x26, 0x3b, 0xd6, 0x01, 0x89, 0xb3, 0x4a, 0xa3, 0x28, 0x24, 0x98, - 0x68, 0x69, 0x84, 0x04, 0xd9, 0x90, 0x40, 0xd1, 0x3c, 0xd1, 0xe0, 0x46, 0xac, 0x63, 0xa0, 0x8d, - 0x31, 0x88, 0x0c, 0xb5, 0x23, 0x7d, 0xf3, 0x92, 0xd9, 0x4a, 0xcc, 0x43, 0x21, 0xa6, 0x88, 0x0a, - 0x23, 0xc4, 0xc4, 0xfc, 0xe6, 0x29, 0x3d, 0x7e, 0x79, 0x9a, 0xd7, 0x4e, 0x4e, 0xf3, 0xda, 0x1f, - 0xa7, 0x79, 0xed, 0xbb, 0xb3, 0x7c, 0xea, 0xe4, 0x2c, 0x9f, 0xfa, 0xfd, 0x2c, 0x9f, 0xfa, 0x72, - 0xa9, 0xe7, 0x5f, 0x80, 0x18, 0xdc, 0xa3, 0x08, 0x59, 0xfc, 0x33, 0x50, 0xc9, 0x8a, 0xdf, 0x46, - 0xab, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x5b, 0xae, 0xa5, 0x7f, 0x67, 0x0e, 0x00, 0x00, + // 1058 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x5d, 0x6f, 0x1b, 0x45, + 0x17, 0xf6, 0x3a, 0x8e, 0xdf, 0xbc, 0x27, 0xfd, 0x88, 0x86, 0xb4, 0x72, 0xb7, 0xc5, 0x69, 0x36, + 0x6a, 0x09, 0x55, 0xb3, 0xab, 0x38, 0x4e, 0x90, 0x4a, 0x02, 0x8a, 0x29, 0x1f, 0x8e, 0x7a, 0x91, + 0x2e, 0x90, 0x0b, 0x24, 0x64, 0x8d, 0xed, 0xc9, 0x7a, 0xd3, 0xf5, 0xce, 0x66, 0x67, 0x6c, 0x12, + 0x55, 0xbd, 0xe1, 0x86, 0x5b, 0x04, 0xbf, 0x81, 0xff, 0x00, 0x7f, 0x00, 0xf5, 0x32, 0x12, 0x42, + 0xe2, 0xaa, 0x42, 0x09, 0x7f, 0x81, 0x1b, 0x24, 0x24, 0xe4, 0x99, 0x59, 0x7f, 0xc4, 0xeb, 0xb5, + 0x13, 0xe8, 0x55, 0x76, 0x67, 0xcf, 0x79, 0xe6, 0x79, 0xce, 0x39, 0x33, 0x4f, 0x0c, 0xf7, 0x02, + 0xec, 0xd1, 0x26, 0xae, 0x35, 0xb0, 0xeb, 0x5b, 0xf2, 0xd9, 0x6a, 0x63, 0x8f, 0x11, 0x6e, 0x1d, + 0xb6, 0x48, 0x78, 0x6c, 0x06, 0x21, 0xe5, 0x14, 0xdd, 0xea, 0x0b, 0x33, 0xe5, 0xb3, 0x29, 0xc3, + 0xf4, 0x79, 0x87, 0x3a, 0x54, 0x44, 0x59, 0x9d, 0x27, 0x99, 0xa0, 0xdf, 0x71, 0x28, 0x75, 0x3c, + 0x62, 0xe1, 0xc0, 0xb5, 0xb0, 0xef, 0x53, 0x8e, 0xb9, 0x4b, 0x7d, 0xa6, 0xbe, 0x3e, 0xa8, 0x51, + 0xd6, 0xa4, 0xcc, 0xaa, 0x62, 0x46, 0xe4, 0x3e, 0x56, 0x7b, 0xb5, 0x4a, 0x38, 0x5e, 0xb5, 0x02, + 0xec, 0xb8, 0xbe, 0x08, 0x56, 0xb1, 0xf7, 0x47, 0x33, 0x0c, 0x70, 0x88, 0x9b, 0x11, 0xe6, 0xf2, + 0xe8, 0x38, 0xe6, 0xe3, 0x80, 0x35, 0x28, 0x57, 0x91, 0x6b, 0x09, 0x88, 0xae, 0x43, 0xa8, 0x5f, + 0x09, 0xc9, 0x61, 0xcb, 0x0d, 0x49, 0x93, 0xf8, 0x3c, 0x82, 0x5f, 0x50, 0x82, 0xc4, 0x5b, 0xb5, + 0xb5, 0x6f, 0x71, 0xb7, 0x49, 0x18, 0xc7, 0xcd, 0x40, 0x06, 0x18, 0xf3, 0x80, 0x9e, 0x76, 0x94, + 0xec, 0x0a, 0x52, 0x36, 0x39, 0x6c, 0x11, 0xc6, 0x8d, 0x3d, 0x78, 0x63, 0x60, 0x95, 0x05, 0xd4, + 0x67, 0x04, 0xbd, 0x0f, 0x59, 0x49, 0x3e, 0xa7, 0xdd, 0xd5, 0x96, 0x67, 0x0b, 0x8b, 0xe6, 0xc8, + 0x02, 0x9b, 0x32, 0xb5, 0x94, 0x79, 0xf9, 0x6a, 0x21, 0x65, 0xab, 0x34, 0x63, 0x1d, 0x6e, 0x09, + 0xdc, 0x3d, 0xec, 0xb9, 0x75, 0xcc, 0x69, 0x58, 0xf6, 0xf7, 0xa9, 0xda, 0x14, 0xe5, 0xe0, 0x7f, + 0x6d, 0xec, 0x6d, 0xd7, 0xeb, 0xa1, 0x80, 0xff, 0xbf, 0x1d, 0xbd, 0x1a, 0x07, 0xa0, 0xc7, 0xa5, + 0x29, 0x56, 0x4f, 0x00, 0x04, 0x81, 0xce, 0x62, 0x87, 0xd9, 0xd4, 0xf2, 0x6c, 0xe1, 0x61, 0x02, + 0xb3, 0x0f, 0x8f, 0x38, 0x09, 0x7d, 0xec, 0x7d, 0x10, 0x25, 0xd9, 0x7d, 0xf9, 0xc6, 0x16, 0xdc, + 0x16, 0x7b, 0x7d, 0x4c, 0xf8, 0xa7, 0xaa, 0x01, 0xa5, 0xe3, 0xf2, 0xe3, 0x88, 0x64, 0x1e, 0x20, + 0xea, 0x4b, 0xb9, 0x2e, 0x78, 0x66, 0xec, 0xbe, 0x15, 0xa3, 0x02, 0x77, 0xe2, 0xd3, 0xbb, 0x25, + 0x9c, 0x89, 0xa2, 0x55, 0x11, 0x97, 0x12, 0xa8, 0x46, 0x10, 0x76, 0x37, 0xc9, 0xf8, 0x0c, 0xee, + 0x47, 0x1b, 0x3c, 0xc1, 0x9c, 0x30, 0xbe, 0xdb, 0xaa, 0x7a, 0x2e, 0x6b, 0x90, 0x7a, 0x37, 0x58, + 0x51, 0x7d, 0x00, 0x73, 0x02, 0xd3, 0x26, 0xfb, 0x24, 0x24, 0x7e, 0x8d, 0x94, 0x1f, 0xab, 0xc2, + 0x0e, 0xad, 0x1b, 0x07, 0xf0, 0xd6, 0x58, 0xd4, 0xff, 0x4a, 0xc1, 0x57, 0x60, 0x44, 0x7b, 0x75, + 0x1b, 0xba, 0xed, 0xb9, 0x6d, 0xf2, 0xb9, 0xcf, 0x5d, 0x2f, 0x62, 0xff, 0x14, 0x40, 0xb5, 0x9f, + 0x30, 0x39, 0x6f, 0x57, 0x4a, 0xab, 0x7f, 0xbd, 0x5a, 0x58, 0x71, 0x5c, 0xde, 0x68, 0x55, 0xcd, + 0x1a, 0x6d, 0x5a, 0xea, 0x3c, 0xca, 0x3f, 0x2b, 0xac, 0xfe, 0xcc, 0xe2, 0xc7, 0x01, 0x61, 0xe6, + 0x5e, 0x37, 0xd1, 0xee, 0x03, 0x31, 0x30, 0x2c, 0x25, 0x6e, 0xac, 0x04, 0x16, 0xe1, 0x06, 0xee, + 0xae, 0x96, 0x3c, 0x5a, 0x7b, 0xf6, 0x09, 0x71, 0x9d, 0x06, 0xcf, 0xa5, 0xef, 0x6a, 0xcb, 0x53, + 0x76, 0xfc, 0xc7, 0x9d, 0xcc, 0x8c, 0x36, 0x97, 0x8e, 0xd5, 0xb6, 0x83, 0x3b, 0xe0, 0x98, 0x51, + 0xff, 0x35, 0x6a, 0xdb, 0x8a, 0xd1, 0xd6, 0xbf, 0xb1, 0xd2, 0x76, 0x13, 0xb2, 0xa1, 0x58, 0x51, + 0x93, 0xa0, 0xde, 0x8c, 0x37, 0x7b, 0x53, 0x2f, 0x2a, 0xb2, 0x2b, 0x6e, 0x94, 0xee, 0x7d, 0xf0, + 0x67, 0xba, 0x37, 0xd6, 0x83, 0xdf, 0x15, 0x6e, 0x00, 0xd7, 0x45, 0x59, 0xba, 0x7b, 0x47, 0x07, + 0xf1, 0xa3, 0x84, 0xd9, 0x48, 0x42, 0x34, 0x07, 0x3b, 0x64, 0x9f, 0x87, 0xd7, 0x4f, 0x35, 0xb8, + 0x36, 0x18, 0xf3, 0x1a, 0xca, 0x8a, 0xe6, 0x61, 0x9a, 0x84, 0x21, 0x0d, 0x73, 0x19, 0x51, 0x2e, + 0xf9, 0x32, 0x7a, 0x42, 0xa6, 0x13, 0x26, 0x04, 0xdd, 0x83, 0x6b, 0xea, 0xa2, 0x6e, 0x93, 0x90, + 0xb9, 0xd4, 0xcf, 0x65, 0x05, 0xe8, 0x55, 0xb9, 0xba, 0x27, 0x17, 0x77, 0x32, 0x33, 0xe9, 0xb9, + 0xa9, 0x9d, 0xcc, 0xcc, 0xd4, 0x5c, 0xc6, 0x58, 0x82, 0xc5, 0xa8, 0x48, 0xb2, 0x3e, 0x76, 0xdf, + 0x15, 0x1f, 0x35, 0xe7, 0x6f, 0xad, 0x37, 0x74, 0x71, 0x51, 0xaa, 0x45, 0x5f, 0x02, 0x0a, 0x86, + 0xbe, 0xaa, 0x13, 0xbc, 0x92, 0x74, 0x91, 0x0f, 0x43, 0xc6, 0x00, 0xa1, 0x23, 0xb8, 0xcd, 0x6a, + 0x0d, 0x52, 0x6f, 0x79, 0xa4, 0x3e, 0x9c, 0x22, 0xce, 0xce, 0x6c, 0x61, 0x23, 0xe9, 0xa6, 0x18, + 0x9d, 0x6d, 0x27, 0x41, 0x17, 0xbe, 0xb9, 0x02, 0xd3, 0x42, 0x3f, 0xfa, 0x4e, 0x83, 0xac, 0xf4, + 0x1d, 0xb4, 0x32, 0x6e, 0xee, 0x06, 0x0c, 0x4f, 0x37, 0x27, 0x0d, 0x97, 0xc5, 0x34, 0xde, 0xfe, + 0xfa, 0x97, 0x3f, 0xbe, 0x4f, 0x2f, 0xa1, 0x45, 0x6b, 0x9c, 0xcf, 0xa3, 0x9f, 0x34, 0xb8, 0x3a, + 0x60, 0x5c, 0xa8, 0x38, 0x6e, 0xb3, 0x38, 0x7b, 0xd4, 0xd7, 0x2f, 0x98, 0xa5, 0x98, 0xbe, 0x2b, + 0x98, 0xae, 0xa3, 0xb5, 0x04, 0xa6, 0xed, 0x28, 0xb3, 0xe2, 0xfa, 0xfb, 0xd4, 0x7a, 0xae, 0x0e, + 0xc0, 0x0b, 0xf4, 0xb3, 0x06, 0xd7, 0xcf, 0x39, 0x19, 0xda, 0x98, 0xe0, 0x44, 0xc7, 0x38, 0xa7, + 0xfe, 0xce, 0x85, 0xf3, 0x94, 0x82, 0x92, 0x50, 0xb0, 0x89, 0x1e, 0x25, 0x28, 0x70, 0x08, 0xaf, + 0x44, 0x06, 0x53, 0xa9, 0x1e, 0x57, 0xdc, 0xba, 0xf5, 0xbc, 0xe7, 0xca, 0x2f, 0xd0, 0x0f, 0x1a, + 0xe8, 0xa3, 0xbd, 0x0d, 0x6d, 0x4f, 0xc0, 0x2d, 0xd9, 0x6d, 0xf5, 0xd2, 0xbf, 0x81, 0x50, 0x4a, + 0x53, 0xe8, 0x57, 0x0d, 0x6e, 0xc6, 0xdb, 0x13, 0xda, 0x9a, 0x60, 0x83, 0xd1, 0x7e, 0xaa, 0xbf, + 0x77, 0xd9, 0x74, 0xc5, 0x6d, 0x53, 0x74, 0x61, 0x03, 0x15, 0xc7, 0x74, 0xa1, 0x37, 0x4b, 0xe2, + 0x16, 0xac, 0xb4, 0x04, 0xf9, 0xf3, 0xba, 0x7a, 0xd6, 0x74, 0x31, 0x5d, 0x43, 0x5e, 0x7a, 0x31, + 0x5d, 0xc3, 0x8e, 0x78, 0x09, 0x5d, 0x07, 0xd8, 0xf5, 0x2a, 0xd2, 0x37, 0xd1, 0x8f, 0xf2, 0x80, + 0xf4, 0x3b, 0xd8, 0x44, 0x07, 0x24, 0xc6, 0x64, 0x27, 0x3a, 0x20, 0x71, 0x56, 0x69, 0x14, 0x85, + 0x04, 0x13, 0x3d, 0x1c, 0x23, 0x41, 0x36, 0x24, 0x50, 0x34, 0x4f, 0x34, 0xb8, 0x11, 0xeb, 0x18, + 0x68, 0x73, 0x02, 0x22, 0x23, 0xed, 0x48, 0xdf, 0xba, 0x64, 0xb6, 0x12, 0xf3, 0x48, 0x88, 0x29, + 0xa2, 0xc2, 0x18, 0x31, 0x31, 0xbf, 0x79, 0x4a, 0xe5, 0x97, 0xa7, 0x79, 0xed, 0xe4, 0x34, 0xaf, + 0xfd, 0x7e, 0x9a, 0xd7, 0xbe, 0x3d, 0xcb, 0xa7, 0x4e, 0xce, 0xf2, 0xa9, 0xdf, 0xce, 0xf2, 0xa9, + 0x2f, 0xac, 0xbe, 0x7f, 0x01, 0xe2, 0x70, 0x0b, 0xd6, 0x51, 0x04, 0x2e, 0xfe, 0x1f, 0xa8, 0x66, + 0xc5, 0xcf, 0xa3, 0xb5, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xcc, 0xda, 0xe5, 0xad, 0x6a, 0x0e, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -1024,30 +1113,36 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } + func (*UnimplementedQueryServer) ValidatorInfo(ctx context.Context, req *QueryValidatorInfoRequest) (*QueryValidatorInfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ValidatorInfo not implemented") } + func (*UnimplementedQueryServer) GetSnapshotByID(ctx context.Context, req *QueryGetSnapshotByIDRequest) (*QueryGetSnapshotByIDResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetSnapshotByID not implemented") } + func (*UnimplementedQueryServer) GetLatestPublishedSnapshot(ctx context.Context, req *QueryGetLatestPublishedSnapshotRequest) (*QueryGetLatestPublishedSnapshotResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetLatestPublishedSnapshot not implemented") } + func (*UnimplementedQueryServer) GetValidatorAliveUntil(ctx context.Context, req *QueryGetValidatorAliveUntilRequest) (*QueryGetValidatorAliveUntilResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetValidatorAliveUntil not implemented") } + func (*UnimplementedQueryServer) GetValidatorJailReason(ctx context.Context, req *QueryGetValidatorJailReasonRequest) (*QueryGetValidatorJailReasonResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetValidatorJailReason not implemented") } + func (*UnimplementedQueryServer) GetAlivePigeons(ctx context.Context, req *QueryGetAlivePigeonsRequest) (*QueryGetAlivePigeonsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetAlivePigeons not implemented") } + func (*UnimplementedQueryServer) GetPigeonRequirements(ctx context.Context, req *QueryGetPigeonRequirementsRequest) (*QueryGetPigeonRequirementsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetPigeonRequirements not implemented") } @@ -1800,6 +1895,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QueryParamsRequest) Size() (n int) { if m == nil { return 0 @@ -2027,9 +2123,11 @@ func (m *QueryGetPigeonRequirementsResponse) Size() (n int) { 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 *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2080,6 +2178,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2163,6 +2262,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryValidatorInfoRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2245,6 +2345,7 @@ func (m *QueryValidatorInfoRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryValidatorInfoResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2329,6 +2430,7 @@ func (m *QueryValidatorInfoResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetSnapshotByIDRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2398,6 +2500,7 @@ func (m *QueryGetSnapshotByIDRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetSnapshotByIDResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2484,6 +2587,7 @@ func (m *QueryGetSnapshotByIDResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetLatestPublishedSnapshotRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2566,6 +2670,7 @@ func (m *QueryGetLatestPublishedSnapshotRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetLatestPublishedSnapshotResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2652,6 +2757,7 @@ func (m *QueryGetLatestPublishedSnapshotResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetValidatorAliveUntilRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2736,6 +2842,7 @@ func (m *QueryGetValidatorAliveUntilRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetValidatorAliveUntilResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2805,6 +2912,7 @@ func (m *QueryGetValidatorAliveUntilResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetValidatorJailReasonRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2889,6 +2997,7 @@ func (m *QueryGetValidatorJailReasonRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetValidatorJailReasonResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2971,6 +3080,7 @@ func (m *QueryGetValidatorJailReasonResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetAlivePigeonsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3021,6 +3131,7 @@ func (m *QueryGetAlivePigeonsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetAlivePigeonsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3105,6 +3216,7 @@ func (m *QueryGetAlivePigeonsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3272,6 +3384,7 @@ func (m *QueryGetAlivePigeonsResponse_ValidatorAlive) Unmarshal(dAtA []byte) err } return nil } + func (m *QueryGetPigeonRequirementsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3322,6 +3435,7 @@ func (m *QueryGetPigeonRequirementsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryGetPigeonRequirementsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3444,6 +3558,7 @@ func (m *QueryGetPigeonRequirementsResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/set_pigeon_requirements_proposal.pb.go b/x/valset/types/set_pigeon_requirements_proposal.pb.go index 955df3f5..8d1d7579 100644 --- a/x/valset/types/set_pigeon_requirements_proposal.pb.go +++ b/x/valset/types/set_pigeon_requirements_proposal.pb.go @@ -5,16 +5,19 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/cosmos/gogoproto/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*SetPigeonRequirementsProposal) ProtoMessage() {} func (*SetPigeonRequirementsProposal) Descriptor() ([]byte, []int) { return fileDescriptor_901303cf21f17746, []int{0} } + func (m *SetPigeonRequirementsProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *SetPigeonRequirementsProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetPigeonRequirementsProposal.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *SetPigeonRequirementsProposal) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } + func (m *SetPigeonRequirementsProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_SetPigeonRequirementsProposal.Merge(m, src) } + func (m *SetPigeonRequirementsProposal) XXX_Size() int { return m.Size() } + func (m *SetPigeonRequirementsProposal) XXX_DiscardUnknown() { xxx_messageInfo_SetPigeonRequirementsProposal.DiscardUnknown(m) } @@ -99,23 +107,23 @@ func init() { } var fileDescriptor_901303cf21f17746 = []byte{ - // 254 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4a, 0xc4, 0x40, - 0x10, 0x86, 0xb3, 0x7a, 0x0a, 0xae, 0x95, 0xc1, 0x22, 0x16, 0x2e, 0xc1, 0xea, 0x8a, 0x23, 0x29, - 0x7c, 0x01, 0xb9, 0x42, 0x2c, 0x8f, 0x08, 0x16, 0x36, 0x61, 0x2f, 0x0e, 0xc9, 0xe0, 0x66, 0x67, - 0xdd, 0x9d, 0x13, 0x7d, 0x0b, 0x5f, 0xc2, 0x77, 0xb1, 0xbc, 0xd2, 0x52, 0x92, 0x17, 0x11, 0x13, - 0x85, 0x80, 0xd7, 0xcd, 0xfc, 0xff, 0xcf, 0x57, 0x7c, 0xf2, 0xca, 0x69, 0x43, 0xad, 0xae, 0x1a, - 0x8d, 0x36, 0x1f, 0xef, 0xfc, 0x59, 0x9b, 0x00, 0x9c, 0x07, 0xe0, 0xd2, 0x61, 0x0d, 0x64, 0x4b, - 0x0f, 0x4f, 0x1b, 0xf4, 0xd0, 0x82, 0xe5, 0x50, 0x3a, 0x4f, 0x8e, 0x82, 0x36, 0x99, 0xf3, 0xc4, - 0x14, 0x9f, 0x4d, 0x08, 0xd9, 0x78, 0x67, 0x23, 0xe1, 0xe2, 0x5d, 0xc8, 0xf3, 0x5b, 0xe0, 0xd5, - 0x00, 0x29, 0x26, 0x8c, 0xd5, 0x2f, 0x22, 0x3e, 0x95, 0x07, 0x8c, 0x6c, 0x20, 0x11, 0xa9, 0x98, - 0x1f, 0x15, 0xe3, 0x13, 0xa7, 0xf2, 0xf8, 0x01, 0x42, 0xe5, 0xd1, 0x31, 0x92, 0x4d, 0xf6, 0x86, - 0x6e, 0x1a, 0xc5, 0x4a, 0xca, 0x16, 0xed, 0x1d, 0xf8, 0xf0, 0x33, 0xd8, 0x1f, 0x06, 0x93, 0x24, - 0x5e, 0xc8, 0x13, 0xd6, 0xbe, 0x06, 0x5e, 0x1a, 0xaa, 0x1e, 0x6f, 0x00, 0xeb, 0x86, 0x93, 0x59, - 0x2a, 0xe6, 0xb3, 0xe2, 0x7f, 0xb1, 0xbc, 0xfe, 0xe8, 0x94, 0xd8, 0x76, 0x4a, 0x7c, 0x75, 0x4a, - 0xbc, 0xf5, 0x2a, 0xda, 0xf6, 0x2a, 0xfa, 0xec, 0x55, 0x74, 0xbf, 0xa8, 0x91, 0x9b, 0xcd, 0x3a, - 0xab, 0xa8, 0xcd, 0x77, 0x98, 0x7a, 0xf9, 0x73, 0xc5, 0xaf, 0x0e, 0xc2, 0xfa, 0x70, 0x30, 0x72, - 0xf9, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xdd, 0x84, 0xcd, 0x31, 0x55, 0x01, 0x00, 0x00, + // 256 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x31, 0x4a, 0xc4, 0x40, + 0x14, 0x86, 0x33, 0xba, 0x0a, 0x8e, 0x95, 0x83, 0x45, 0x2c, 0x1c, 0x82, 0xd5, 0x16, 0x92, 0x01, + 0xbd, 0x80, 0x6c, 0xa5, 0xdd, 0x12, 0xc1, 0xc2, 0x26, 0xcc, 0xc6, 0x47, 0x32, 0x38, 0x99, 0x37, + 0xce, 0xbc, 0x15, 0xbd, 0x85, 0x97, 0xf0, 0x2e, 0x96, 0x5b, 0x5a, 0x4a, 0x72, 0x11, 0x31, 0x51, + 0x08, 0xb8, 0xdd, 0x7b, 0xff, 0xff, 0xf3, 0x15, 0x1f, 0xbf, 0xf2, 0xda, 0x62, 0xab, 0xab, 0x46, + 0x1b, 0xa7, 0xc6, 0x5b, 0x3d, 0x6b, 0x1b, 0x81, 0x54, 0x04, 0x2a, 0xbd, 0xa9, 0x01, 0x5d, 0x19, + 0xe0, 0x69, 0x6d, 0x02, 0xb4, 0xe0, 0x28, 0x96, 0x3e, 0xa0, 0xc7, 0xa8, 0x6d, 0xee, 0x03, 0x12, + 0x8a, 0x93, 0x09, 0x21, 0x1f, 0xef, 0x7c, 0x24, 0x9c, 0xbd, 0x33, 0x7e, 0x7a, 0x0b, 0xb4, 0x1c, + 0x20, 0xc5, 0x84, 0xb1, 0xfc, 0x45, 0x88, 0x63, 0xbe, 0x47, 0x86, 0x2c, 0xa4, 0x2c, 0x63, 0xf3, + 0x83, 0x62, 0x7c, 0x44, 0xc6, 0x0f, 0x1f, 0x20, 0x56, 0xc1, 0x78, 0x32, 0xe8, 0xd2, 0x9d, 0xa1, + 0x9b, 0x46, 0x42, 0x72, 0xde, 0x1a, 0x77, 0x07, 0x21, 0xfe, 0x0c, 0x76, 0x87, 0xc1, 0x24, 0x11, + 0xe7, 0xfc, 0x88, 0x74, 0xa8, 0x81, 0x16, 0x16, 0xab, 0xc7, 0x6b, 0x30, 0x75, 0x43, 0xe9, 0x2c, + 0x63, 0xf3, 0x59, 0xf1, 0xbf, 0x58, 0xdc, 0x7c, 0x74, 0x92, 0x6d, 0x3a, 0xc9, 0xbe, 0x3a, 0xc9, + 0xde, 0x7a, 0x99, 0x6c, 0x7a, 0x99, 0x7c, 0xf6, 0x32, 0xb9, 0x57, 0xb5, 0xa1, 0x66, 0xbd, 0xca, + 0x2b, 0x6c, 0xd5, 0x36, 0x53, 0x17, 0xea, 0xe5, 0x4f, 0x17, 0xbd, 0x7a, 0x88, 0xab, 0xfd, 0x41, + 0xca, 0xe5, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x98, 0x5f, 0x64, 0x58, 0x01, 0x00, 0x00, } func (m *SetPigeonRequirementsProposal) Marshal() (dAtA []byte, err error) { @@ -178,6 +186,7 @@ func encodeVarintSetPigeonRequirementsProposal(dAtA []byte, offset int, v uint64 dAtA[offset] = uint8(v) return base } + func (m *SetPigeonRequirementsProposal) Size() (n int) { if m == nil { return 0 @@ -205,9 +214,11 @@ func (m *SetPigeonRequirementsProposal) Size() (n int) { func sovSetPigeonRequirementsProposal(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozSetPigeonRequirementsProposal(x uint64) (n int) { return sovSetPigeonRequirementsProposal(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *SetPigeonRequirementsProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -373,6 +384,7 @@ func (m *SetPigeonRequirementsProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipSetPigeonRequirementsProposal(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/snapshot.pb.go b/x/valset/types/snapshot.pb.go index 454ec15f..9831513d 100644 --- a/x/valset/types/snapshot.pb.go +++ b/x/valset/types/snapshot.pb.go @@ -4,8 +4,13 @@ package types import ( - cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + time "time" + + cosmossdk_io_math "cosmossdk.io/math" _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/types" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" @@ -13,17 +18,15 @@ import ( proto "github.com/cosmos/gogoproto/proto" github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "google.golang.org/protobuf/types/known/timestamppb" - io "io" - math "math" - math_bits "math/bits" - time "time" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf -var _ = time.Kitchen +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = math.Inf + _ = time.Kitchen +) // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -72,9 +75,11 @@ func (*Validator) ProtoMessage() {} func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptor_5e751d08b53d6c50, []int{0} } + func (m *Validator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Validator.Marshal(b, m, deterministic) @@ -87,12 +92,15 @@ func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Validator) XXX_Merge(src proto.Message) { xxx_messageInfo_Validator.Merge(m, src) } + func (m *Validator) XXX_Size() int { return m.Size() } + func (m *Validator) XXX_DiscardUnknown() { xxx_messageInfo_Validator.DiscardUnknown(m) } @@ -131,9 +139,11 @@ func (*ValidatorExternalAccounts) ProtoMessage() {} func (*ValidatorExternalAccounts) Descriptor() ([]byte, []int) { return fileDescriptor_5e751d08b53d6c50, []int{1} } + func (m *ValidatorExternalAccounts) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ValidatorExternalAccounts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ValidatorExternalAccounts.Marshal(b, m, deterministic) @@ -146,12 +156,15 @@ func (m *ValidatorExternalAccounts) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *ValidatorExternalAccounts) XXX_Merge(src proto.Message) { xxx_messageInfo_ValidatorExternalAccounts.Merge(m, src) } + func (m *ValidatorExternalAccounts) XXX_Size() int { return m.Size() } + func (m *ValidatorExternalAccounts) XXX_DiscardUnknown() { xxx_messageInfo_ValidatorExternalAccounts.DiscardUnknown(m) } @@ -187,9 +200,11 @@ func (*Snapshot) ProtoMessage() {} func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptor_5e751d08b53d6c50, []int{2} } + func (m *Snapshot) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic) @@ -202,12 +217,15 @@ func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Snapshot) XXX_Merge(src proto.Message) { xxx_messageInfo_Snapshot.Merge(m, src) } + func (m *Snapshot) XXX_Size() int { return m.Size() } + func (m *Snapshot) XXX_DiscardUnknown() { xxx_messageInfo_Snapshot.DiscardUnknown(m) } @@ -264,9 +282,11 @@ func (*ExternalChainInfo) ProtoMessage() {} func (*ExternalChainInfo) Descriptor() ([]byte, []int) { return fileDescriptor_5e751d08b53d6c50, []int{3} } + func (m *ExternalChainInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ExternalChainInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalChainInfo.Marshal(b, m, deterministic) @@ -279,12 +299,15 @@ func (m *ExternalChainInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *ExternalChainInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalChainInfo.Merge(m, src) } + func (m *ExternalChainInfo) XXX_Size() int { return m.Size() } + func (m *ExternalChainInfo) XXX_DiscardUnknown() { xxx_messageInfo_ExternalChainInfo.DiscardUnknown(m) } @@ -348,45 +371,45 @@ func init() { var fileDescriptor_5e751d08b53d6c50 = []byte{ // 640 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4f, 0x4f, 0xdb, 0x30, - 0x14, 0xaf, 0xd3, 0xd2, 0x11, 0x33, 0xa1, 0xce, 0xda, 0x50, 0x40, 0x5b, 0x5a, 0x55, 0x3b, 0x74, - 0x08, 0x12, 0xd1, 0x9d, 0x27, 0xd4, 0x42, 0x27, 0x95, 0x4d, 0x4c, 0x32, 0x88, 0x03, 0x9a, 0x34, - 0x39, 0x89, 0x69, 0x22, 0x92, 0x38, 0x8a, 0x5d, 0x04, 0xdf, 0x82, 0xfb, 0xbe, 0xc7, 0xee, 0x93, - 0x76, 0xe0, 0xc8, 0x71, 0xda, 0x81, 0x4d, 0xf0, 0x2d, 0x76, 0x9a, 0x6c, 0x27, 0xa5, 0x0c, 0xf6, - 0x47, 0xdb, 0x29, 0xfe, 0xe5, 0xbd, 0xdf, 0x7b, 0xfe, 0xbd, 0x3f, 0x86, 0x9d, 0x8c, 0xc4, 0x2c, - 0x21, 0x7e, 0x48, 0xa2, 0xd4, 0xd5, 0x67, 0xf7, 0x88, 0xc4, 0x9c, 0x0a, 0x97, 0xa7, 0x24, 0xe3, - 0x21, 0x13, 0x4e, 0x96, 0x33, 0xc1, 0xd0, 0xe2, 0x94, 0xa7, 0xa3, 0xcf, 0x8e, 0xf6, 0x5c, 0x7a, - 0x38, 0x62, 0x23, 0xa6, 0xbc, 0x5c, 0x79, 0xd2, 0x84, 0xa5, 0x45, 0x9f, 0xf1, 0x84, 0xf1, 0x77, - 0xda, 0xa0, 0x41, 0x61, 0x6a, 0x8e, 0x18, 0x1b, 0xc5, 0xd4, 0x55, 0xc8, 0x1b, 0x1f, 0xb8, 0x22, - 0x4a, 0x28, 0x17, 0x24, 0xc9, 0x0a, 0x07, 0x5b, 0xbb, 0xbb, 0x1e, 0xe1, 0xd4, 0x3d, 0x5a, 0xf3, - 0xa8, 0x20, 0x6b, 0xae, 0xcf, 0x64, 0x66, 0x69, 0x6f, 0x7f, 0x30, 0xa0, 0xb9, 0x47, 0xe2, 0x28, - 0x20, 0x82, 0xe5, 0xe8, 0x05, 0x84, 0x3c, 0x24, 0x39, 0xdd, 0x60, 0xe3, 0x54, 0x58, 0xa0, 0x05, - 0x3a, 0xf7, 0xfb, 0x4f, 0xce, 0x2e, 0x9a, 0x95, 0x2f, 0x17, 0xcd, 0x47, 0x3a, 0x12, 0x0f, 0x0e, - 0x9d, 0x88, 0xb9, 0x09, 0x11, 0xa1, 0x33, 0x4c, 0x05, 0x9e, 0x22, 0xa0, 0x75, 0x38, 0xc3, 0x05, - 0x11, 0xd4, 0x32, 0x5a, 0xa0, 0x33, 0xdf, 0x7d, 0xe6, 0xfc, 0x52, 0xa9, 0x33, 0xc9, 0xb9, 0x23, - 0x09, 0x58, 0xf3, 0xd0, 0x5b, 0x88, 0xe8, 0xb1, 0xa0, 0x79, 0x4a, 0xe2, 0x0d, 0x49, 0x1a, 0xa6, - 0x07, 0x8c, 0x5b, 0xd5, 0x56, 0xb5, 0x33, 0xd7, 0x5d, 0xf9, 0x4d, 0xb4, 0xc1, 0xcf, 0x24, 0x7c, - 0x47, 0x1c, 0xf4, 0x0a, 0xde, 0x23, 0x41, 0x90, 0x53, 0xce, 0xad, 0x9a, 0x92, 0xb6, 0xf6, 0xfd, - 0xa2, 0xb9, 0x3a, 0x8a, 0x44, 0x38, 0xf6, 0x1c, 0x9f, 0x25, 0x45, 0x69, 0x8b, 0xcf, 0x2a, 0x0f, - 0x0e, 0x5d, 0x71, 0x92, 0x51, 0x2e, 0x2f, 0xdb, 0xd3, 0x44, 0x5c, 0x46, 0x68, 0x7f, 0x02, 0x70, - 0x71, 0x22, 0xa2, 0xcc, 0xdf, 0xf3, 0x7d, 0x59, 0x88, 0x1b, 0xa9, 0xc0, 0xff, 0xa6, 0x42, 0xfb, - 0xf0, 0xc1, 0x2d, 0x81, 0x96, 0xf1, 0x0f, 0x45, 0xb9, 0x1d, 0xa6, 0xfd, 0xde, 0x80, 0xb3, 0x3b, - 0xc5, 0x7c, 0xa2, 0x79, 0x68, 0x44, 0x81, 0xba, 0x70, 0x0d, 0x1b, 0x51, 0x80, 0x16, 0x60, 0x3d, - 0xa4, 0xd1, 0x28, 0x14, 0xaa, 0xa1, 0x55, 0x5c, 0x20, 0xb4, 0x05, 0xe1, 0x51, 0x29, 0xbd, 0x6c, - 0xcf, 0xd3, 0xbf, 0x69, 0x76, 0xbf, 0x26, 0x87, 0x09, 0x4f, 0xb1, 0xd1, 0x3a, 0x9c, 0x13, 0x4c, - 0x90, 0x78, 0x47, 0x8e, 0x51, 0xd9, 0x98, 0x3f, 0xcc, 0xdc, 0x34, 0x03, 0xf5, 0xa1, 0xe9, 0xe7, - 0x94, 0x08, 0x1a, 0xf4, 0x84, 0x35, 0xd3, 0x02, 0x9d, 0xb9, 0xee, 0x92, 0xa3, 0xd7, 0xc2, 0x29, - 0xd7, 0xc2, 0xd9, 0x2d, 0xd7, 0xa2, 0x3f, 0x2b, 0x43, 0x9f, 0x7e, 0x6d, 0x02, 0x7c, 0x4d, 0x93, - 0x42, 0xd5, 0xbd, 0xb9, 0x55, 0x6f, 0x55, 0x3b, 0x26, 0x2e, 0x50, 0xfb, 0x23, 0xb8, 0xa3, 0xf4, - 0xe8, 0x31, 0x34, 0x95, 0x7d, 0xf7, 0x24, 0xa3, 0xaa, 0x5a, 0x26, 0xbe, 0xfe, 0x81, 0x96, 0x61, - 0x43, 0x01, 0x4c, 0x0f, 0x68, 0x4e, 0x53, 0x9f, 0x0e, 0x37, 0x55, 0xf9, 0x4c, 0x7c, 0xeb, 0x3f, - 0xb2, 0xae, 0xc7, 0xa4, 0xaa, 0x5c, 0x26, 0x3d, 0x5f, 0x80, 0xf5, 0x6c, 0xec, 0x1d, 0xd2, 0x13, - 0x5d, 0x11, 0x5c, 0x20, 0xc9, 0xf0, 0x48, 0x4c, 0x52, 0x9f, 0x2a, 0xad, 0x26, 0x2e, 0xa1, 0x64, - 0x88, 0x9c, 0x44, 0x62, 0xa2, 0x41, 0xa3, 0xe5, 0x2e, 0x9c, 0xbf, 0xb9, 0x6c, 0x68, 0x16, 0xd6, - 0xb6, 0xdf, 0x6c, 0x0f, 0x1a, 0x15, 0x04, 0x61, 0xbd, 0xb7, 0xb1, 0x3b, 0xdc, 0x1b, 0x34, 0x80, - 0x3c, 0x6f, 0xf5, 0x86, 0xaf, 0x07, 0x9b, 0x0d, 0xa3, 0xff, 0xf2, 0xec, 0xd2, 0x06, 0xe7, 0x97, - 0x36, 0xf8, 0x76, 0x69, 0x83, 0xd3, 0x2b, 0xbb, 0x72, 0x7e, 0x65, 0x57, 0x3e, 0x5f, 0xd9, 0x95, - 0xfd, 0x95, 0xa9, 0x19, 0xbe, 0xe3, 0xc5, 0x3b, 0x2e, 0xdf, 0x3c, 0x35, 0xcd, 0x5e, 0x5d, 0x35, - 0xe0, 0xf9, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x61, 0x12, 0xf3, 0x9c, 0x1d, 0x05, 0x00, 0x00, + 0x14, 0x6f, 0xd2, 0xd2, 0x11, 0x33, 0xa1, 0xce, 0xda, 0x50, 0x40, 0x5b, 0x5a, 0x55, 0x3b, 0x74, + 0x68, 0xc4, 0xa2, 0x3b, 0x4f, 0xa8, 0x85, 0x1e, 0xca, 0x26, 0x26, 0x19, 0xc4, 0x01, 0x4d, 0x9a, + 0x9c, 0xc4, 0x34, 0x11, 0x49, 0x1c, 0xc5, 0x2e, 0x82, 0x6f, 0xc1, 0x7d, 0xdf, 0x63, 0xf7, 0x49, + 0x3b, 0x70, 0xe4, 0x38, 0xed, 0xc0, 0x26, 0xf8, 0x16, 0x3b, 0x4d, 0xb6, 0x93, 0x52, 0x46, 0xf7, + 0x47, 0xdb, 0x29, 0xfe, 0xe5, 0xbd, 0xdf, 0x7b, 0xfe, 0xbd, 0x3f, 0x06, 0x9d, 0x8c, 0xc4, 0x2c, + 0x21, 0x7e, 0x48, 0xa2, 0x14, 0xe9, 0x33, 0x3a, 0x26, 0x31, 0xa7, 0x02, 0xf1, 0x94, 0x64, 0x3c, + 0x64, 0xc2, 0xcd, 0x72, 0x26, 0x18, 0x5c, 0x9e, 0xf2, 0x74, 0xf5, 0xd9, 0xd5, 0x9e, 0x2b, 0x0f, + 0x47, 0x6c, 0xc4, 0x94, 0x17, 0x92, 0x27, 0x4d, 0x58, 0x59, 0xf6, 0x19, 0x4f, 0x18, 0x7f, 0xa7, + 0x0d, 0x1a, 0x14, 0xa6, 0xe6, 0x88, 0xb1, 0x51, 0x4c, 0x91, 0x42, 0xde, 0xf8, 0x10, 0x89, 0x28, + 0xa1, 0x5c, 0x90, 0x24, 0x2b, 0x1c, 0x1c, 0xed, 0x8e, 0x3c, 0xc2, 0x29, 0x3a, 0x5e, 0xf7, 0xa8, + 0x20, 0xeb, 0xc8, 0x67, 0x32, 0xb3, 0xb4, 0xb7, 0x3f, 0x98, 0xc0, 0xda, 0x27, 0x71, 0x14, 0x10, + 0xc1, 0x72, 0xf8, 0x12, 0x00, 0x1e, 0x92, 0x9c, 0x6e, 0xb2, 0x71, 0x2a, 0x6c, 0xa3, 0x65, 0x74, + 0xee, 0xf7, 0x9f, 0x9c, 0x5f, 0x36, 0x2b, 0x5f, 0x2e, 0x9b, 0x8f, 0x74, 0x24, 0x1e, 0x1c, 0xb9, + 0x11, 0x43, 0x09, 0x11, 0xa1, 0x3b, 0x4c, 0x05, 0x9e, 0x22, 0xc0, 0x0d, 0x30, 0xc7, 0x05, 0x11, + 0xd4, 0x36, 0x5b, 0x46, 0x67, 0xb1, 0xfb, 0xcc, 0xfd, 0xa5, 0x52, 0x77, 0x92, 0x73, 0x57, 0x12, + 0xb0, 0xe6, 0xc1, 0xb7, 0x00, 0xd2, 0x13, 0x41, 0xf3, 0x94, 0xc4, 0x9b, 0x92, 0x34, 0x4c, 0x0f, + 0x19, 0xb7, 0xab, 0xad, 0x6a, 0x67, 0xa1, 0xfb, 0xfc, 0x37, 0xd1, 0x06, 0x3f, 0x93, 0xf0, 0x8c, + 0x38, 0xf0, 0x15, 0xb8, 0x47, 0x82, 0x20, 0xa7, 0x9c, 0xdb, 0x35, 0x25, 0x6d, 0xfd, 0xfb, 0x65, + 0x73, 0x6d, 0x14, 0x89, 0x70, 0xec, 0xb9, 0x3e, 0x4b, 0x8a, 0xd2, 0x16, 0x9f, 0x35, 0x1e, 0x1c, + 0x21, 0x71, 0x9a, 0x51, 0x2e, 0x2f, 0xdb, 0xd3, 0x44, 0x5c, 0x46, 0x68, 0x7f, 0x32, 0xc0, 0xf2, + 0x44, 0x44, 0x99, 0xbf, 0xe7, 0xfb, 0xb2, 0x10, 0xb7, 0x52, 0x19, 0xff, 0x9b, 0x0a, 0x1e, 0x80, + 0x07, 0x77, 0x04, 0xda, 0xe6, 0x3f, 0x14, 0xe5, 0x6e, 0x98, 0xf6, 0x7b, 0x13, 0xcc, 0xef, 0x16, + 0xf3, 0x09, 0x17, 0x81, 0x19, 0x05, 0xea, 0xc2, 0x35, 0x6c, 0x46, 0x01, 0x5c, 0x02, 0xf5, 0x90, + 0x46, 0xa3, 0x50, 0xa8, 0x86, 0x56, 0x71, 0x81, 0xe0, 0x36, 0x00, 0xc7, 0xa5, 0xf4, 0xb2, 0x3d, + 0x4f, 0xff, 0xa6, 0xd9, 0xfd, 0x9a, 0x1c, 0x26, 0x3c, 0xc5, 0x86, 0x1b, 0x60, 0x41, 0x30, 0x41, + 0xe2, 0x5d, 0x39, 0x46, 0x65, 0x63, 0xfe, 0x30, 0x73, 0xd3, 0x0c, 0xd8, 0x07, 0x96, 0x9f, 0x53, + 0x22, 0x68, 0xd0, 0x13, 0xf6, 0x5c, 0xcb, 0xe8, 0x2c, 0x74, 0x57, 0x5c, 0xbd, 0x16, 0x6e, 0xb9, + 0x16, 0xee, 0x5e, 0xb9, 0x16, 0xfd, 0x79, 0x19, 0xfa, 0xec, 0x6b, 0xd3, 0xc0, 0x37, 0x34, 0x29, + 0x54, 0xdd, 0x9b, 0xdb, 0xf5, 0x56, 0xb5, 0x63, 0xe1, 0x02, 0xb5, 0x3f, 0x1a, 0x33, 0x4a, 0x0f, + 0x1f, 0x03, 0x4b, 0xd9, 0xf7, 0x4e, 0x33, 0xaa, 0xaa, 0x65, 0xe1, 0x9b, 0x1f, 0x70, 0x15, 0x34, + 0x14, 0xc0, 0xf4, 0x90, 0xe6, 0x34, 0xf5, 0xe9, 0x70, 0x4b, 0x95, 0xcf, 0xc2, 0x77, 0xfe, 0x43, + 0xfb, 0x66, 0x4c, 0xaa, 0xca, 0x65, 0xd2, 0xf3, 0x25, 0x50, 0xcf, 0xc6, 0xde, 0x11, 0x3d, 0xd5, + 0x15, 0xc1, 0x05, 0x92, 0x0c, 0x8f, 0xc4, 0x24, 0xf5, 0xa9, 0xd2, 0x6a, 0xe1, 0x12, 0x4a, 0x86, + 0xc8, 0x49, 0x24, 0x26, 0x1a, 0x34, 0x5a, 0xed, 0x82, 0xc5, 0xdb, 0xcb, 0x06, 0xe7, 0x41, 0x6d, + 0xe7, 0xcd, 0xce, 0xa0, 0x51, 0x81, 0x00, 0xd4, 0x7b, 0x9b, 0x7b, 0xc3, 0xfd, 0x41, 0xc3, 0x90, + 0xe7, 0xed, 0xde, 0xf0, 0xf5, 0x60, 0xab, 0x61, 0xf6, 0x87, 0xe7, 0x57, 0x8e, 0x71, 0x71, 0xe5, + 0x18, 0xdf, 0xae, 0x1c, 0xe3, 0xec, 0xda, 0xa9, 0x5c, 0x5c, 0x3b, 0x95, 0xcf, 0xd7, 0x4e, 0xe5, + 0x00, 0x4d, 0xcd, 0xf0, 0xac, 0x17, 0xaf, 0x8b, 0x4e, 0xca, 0x67, 0x4f, 0x0d, 0xb4, 0x57, 0x57, + 0x3d, 0x78, 0xf1, 0x23, 0x00, 0x00, 0xff, 0xff, 0x1c, 0xaf, 0x61, 0x4e, 0x20, 0x05, 0x00, 0x00, } func (m *Validator) Marshal() (dAtA []byte, err error) { @@ -644,6 +667,7 @@ func encodeVarintSnapshot(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Validator) Size() (n int) { if m == nil { return 0 @@ -756,9 +780,11 @@ func (m *ExternalChainInfo) Size() (n int) { func sovSnapshot(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozSnapshot(x uint64) (n int) { return sovSnapshot(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Validator) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -929,6 +955,7 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } return nil } + func (m *ValidatorExternalAccounts) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1047,6 +1074,7 @@ func (m *ValidatorExternalAccounts) Unmarshal(dAtA []byte) error { } return nil } + func (m *Snapshot) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1267,6 +1295,7 @@ func (m *Snapshot) Unmarshal(dAtA []byte) error { } return nil } + func (m *ExternalChainInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1511,6 +1540,7 @@ func (m *ExternalChainInfo) Unmarshal(dAtA []byte) error { } return nil } + func skipSnapshot(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/valset/types/tx.pb.go b/x/valset/types/tx.pb.go index acfbe535..e385fb3d 100644 --- a/x/valset/types/tx.pb.go +++ b/x/valset/types/tx.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" @@ -13,15 +17,14 @@ import ( 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 +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -40,9 +43,11 @@ func (*MsgAddExternalChainInfoForValidator) ProtoMessage() {} func (*MsgAddExternalChainInfoForValidator) Descriptor() ([]byte, []int) { return fileDescriptor_ade79cb2279aed8e, []int{0} } + func (m *MsgAddExternalChainInfoForValidator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAddExternalChainInfoForValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAddExternalChainInfoForValidator.Marshal(b, m, deterministic) @@ -55,12 +60,15 @@ func (m *MsgAddExternalChainInfoForValidator) XXX_Marshal(b []byte, deterministi return b[:n], nil } } + func (m *MsgAddExternalChainInfoForValidator) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAddExternalChainInfoForValidator.Merge(m, src) } + func (m *MsgAddExternalChainInfoForValidator) XXX_Size() int { return m.Size() } + func (m *MsgAddExternalChainInfoForValidator) XXX_DiscardUnknown() { xxx_messageInfo_MsgAddExternalChainInfoForValidator.DiscardUnknown(m) } @@ -81,12 +89,12 @@ func (m *MsgAddExternalChainInfoForValidator) GetMetadata() MsgMetadata { return MsgMetadata{} } -type MsgAddExternalChainInfoForValidatorResponse struct { -} +type MsgAddExternalChainInfoForValidatorResponse struct{} func (m *MsgAddExternalChainInfoForValidatorResponse) Reset() { *m = MsgAddExternalChainInfoForValidatorResponse{} } + func (m *MsgAddExternalChainInfoForValidatorResponse) String() string { return proto.CompactTextString(m) } @@ -94,9 +102,11 @@ func (*MsgAddExternalChainInfoForValidatorResponse) ProtoMessage() {} func (*MsgAddExternalChainInfoForValidatorResponse) Descriptor() ([]byte, []int) { return fileDescriptor_ade79cb2279aed8e, []int{1} } + func (m *MsgAddExternalChainInfoForValidatorResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAddExternalChainInfoForValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAddExternalChainInfoForValidatorResponse.Marshal(b, m, deterministic) @@ -109,12 +119,15 @@ func (m *MsgAddExternalChainInfoForValidatorResponse) XXX_Marshal(b []byte, dete return b[:n], nil } } + func (m *MsgAddExternalChainInfoForValidatorResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAddExternalChainInfoForValidatorResponse.Merge(m, src) } + func (m *MsgAddExternalChainInfoForValidatorResponse) XXX_Size() int { return m.Size() } + func (m *MsgAddExternalChainInfoForValidatorResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgAddExternalChainInfoForValidatorResponse.DiscardUnknown(m) } @@ -132,9 +145,11 @@ func (*MsgKeepAlive) ProtoMessage() {} func (*MsgKeepAlive) Descriptor() ([]byte, []int) { return fileDescriptor_ade79cb2279aed8e, []int{2} } + func (m *MsgKeepAlive) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgKeepAlive) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgKeepAlive.Marshal(b, m, deterministic) @@ -147,12 +162,15 @@ func (m *MsgKeepAlive) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *MsgKeepAlive) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgKeepAlive.Merge(m, src) } + func (m *MsgKeepAlive) XXX_Size() int { return m.Size() } + func (m *MsgKeepAlive) XXX_DiscardUnknown() { xxx_messageInfo_MsgKeepAlive.DiscardUnknown(m) } @@ -173,8 +191,7 @@ func (m *MsgKeepAlive) GetMetadata() MsgMetadata { return MsgMetadata{} } -type MsgKeepAliveResponse struct { -} +type MsgKeepAliveResponse struct{} func (m *MsgKeepAliveResponse) Reset() { *m = MsgKeepAliveResponse{} } func (m *MsgKeepAliveResponse) String() string { return proto.CompactTextString(m) } @@ -182,9 +199,11 @@ func (*MsgKeepAliveResponse) ProtoMessage() {} func (*MsgKeepAliveResponse) Descriptor() ([]byte, []int) { return fileDescriptor_ade79cb2279aed8e, []int{3} } + func (m *MsgKeepAliveResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgKeepAliveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgKeepAliveResponse.Marshal(b, m, deterministic) @@ -197,12 +216,15 @@ func (m *MsgKeepAliveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *MsgKeepAliveResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgKeepAliveResponse.Merge(m, src) } + func (m *MsgKeepAliveResponse) XXX_Size() int { return m.Size() } + func (m *MsgKeepAliveResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgKeepAliveResponse.DiscardUnknown(m) } @@ -221,7 +243,7 @@ func init() { } var fileDescriptor_ade79cb2279aed8e = []byte{ - // 415 bytes of a gzipped FileDescriptorProto + // 417 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2a, 0x48, 0xcc, 0xc9, 0xcf, 0x4d, 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x87, 0xb0, 0xf5, 0xcb, 0x12, 0x73, 0x8a, 0x53, 0x4b, 0xf4, 0x4b, 0x2a, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x24, 0x91, 0xd4, 0xe8, 0x41, @@ -243,16 +265,19 @@ var fileDescriptor_ade79cb2279aed8e = []byte{ 0xa4, 0x9b, 0x6f, 0xc4, 0xb8, 0x44, 0x90, 0x5d, 0x07, 0x73, 0xb6, 0xd1, 0x4c, 0x26, 0x2e, 0x66, 0xdf, 0xe2, 0x74, 0xa1, 0x55, 0x8c, 0x5c, 0x0a, 0x04, 0x23, 0xd2, 0x0e, 0xbf, 0xd3, 0x08, 0xe9, 0x97, 0x72, 0xa3, 0x4c, 0x3f, 0xcc, 0xd1, 0x42, 0xa9, 0x5c, 0x9c, 0x88, 0x70, 0x56, 0xc7, 0x6f, - 0x28, 0x5c, 0xa1, 0x94, 0x3e, 0x91, 0x0a, 0x61, 0xd6, 0x38, 0xb9, 0x9d, 0x78, 0x24, 0xc7, 0x78, + 0x28, 0x5c, 0xa1, 0x94, 0x3e, 0x91, 0x0a, 0x61, 0xd6, 0x38, 0x79, 0x9e, 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, 0x4e, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, - 0xae, 0x3e, 0x96, 0xcc, 0x52, 0x01, 0xcf, 0xc6, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0xec, - 0x62, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x8f, 0x41, 0x97, 0x8d, 0xf0, 0x03, 0x00, 0x00, + 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x7e, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, + 0xae, 0x3e, 0xb6, 0xcc, 0x62, 0xa4, 0x5f, 0x01, 0xcf, 0xc9, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, + 0xe0, 0x1c, 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x71, 0xf9, 0x54, 0x36, 0xf3, 0x03, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ 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. @@ -299,12 +324,12 @@ type MsgServer interface { } // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func (*UnimplementedMsgServer) AddExternalChainInfoForValidator(ctx context.Context, req *MsgAddExternalChainInfoForValidator) (*MsgAddExternalChainInfoForValidatorResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AddExternalChainInfoForValidator not implemented") } + func (*UnimplementedMsgServer) KeepAlive(ctx context.Context, req *MsgKeepAlive) (*MsgKeepAliveResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method KeepAlive not implemented") } @@ -510,6 +535,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgAddExternalChainInfoForValidator) Size() (n int) { if m == nil { return 0 @@ -563,9 +589,11 @@ func (m *MsgKeepAliveResponse) Size() (n int) { 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 *MsgAddExternalChainInfoForValidator) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -683,6 +711,7 @@ func (m *MsgAddExternalChainInfoForValidator) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAddExternalChainInfoForValidatorResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -733,6 +762,7 @@ func (m *MsgAddExternalChainInfoForValidatorResponse) Unmarshal(dAtA []byte) err } return nil } + func (m *MsgKeepAlive) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -848,6 +878,7 @@ func (m *MsgKeepAlive) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgKeepAliveResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -898,6 +929,7 @@ func (m *MsgKeepAliveResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 From 62bfdefbe95c0250953a811adc964bdf804701e9 Mon Sep 17 00:00:00 2001 From: Christian Lohr Date: Fri, 13 Dec 2024 18:04:10 +0100 Subject: [PATCH 9/9] Update tests --- tests/integration/evm/keeper/test_helpers_test.go | 1 + x/skyway/client/cli/tx.go | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/integration/evm/keeper/test_helpers_test.go b/tests/integration/evm/keeper/test_helpers_test.go index 48ab2460..d13785b1 100644 --- a/tests/integration/evm/keeper/test_helpers_test.go +++ b/tests/integration/evm/keeper/test_helpers_test.go @@ -341,6 +341,7 @@ func initFixture(t ginkgo.FullGinkgoTInterface) *fixture { evmKeeper, consensusKeeper, nil, + nil, skywaymodulekeeper.NewSkywayStoreGetter(keys[skywaymoduletypes.StoreKey]), authtypes.NewModuleAddress(govtypes.ModuleName).String(), authcodec.NewBech32Codec(params2.ValidatorAddressPrefix), diff --git a/x/skyway/client/cli/tx.go b/x/skyway/client/cli/tx.go index 57855f34..5bb4185f 100644 --- a/x/skyway/client/cli/tx.go +++ b/x/skyway/client/cli/tx.go @@ -149,7 +149,6 @@ func CmdSetErc20ToTokenDenom() *cobra.Command { return tx.GenerateOrBroadcastTxCLI(cliCtx, cmd.Flags(), msg) }, } - flags.AddTxFlagsToCmd(cmd) return cmd }