From 633fa06317c99085484d064e03766409d8998c0d Mon Sep 17 00:00:00 2001 From: gyuguen Date: Thu, 7 Mar 2024 18:34:47 +0900 Subject: [PATCH 1/4] feat: Added nft module and denom feature --- app/app.go | 15 +- app/keepers/keepers.go | 14 +- app/keepers/keys.go | 6 +- go.mod | 2 +- proto/panacea/aol/v2/query.proto | 2 +- proto/panacea/pnft/v2/event.proto | 26 + proto/panacea/pnft/v2/genesis.proto | 12 + proto/panacea/pnft/v2/pnft.proto | 21 + proto/panacea/pnft/v2/query.proto | 60 + proto/panacea/pnft/v2/tx.proto | 51 + x/pnft/client/cli/flags.go | 11 + x/pnft/client/cli/query.go | 56 + x/pnft/client/cli/tx.go | 25 + x/pnft/client/cli/tx_denom.go | 213 +++ x/pnft/genesis.go | 29 + x/pnft/keeper/denom.go | 160 +++ x/pnft/keeper/grpc_query.go | 72 + x/pnft/keeper/keeper.go | 36 + x/pnft/keeper/keys.go | 12 + x/pnft/keeper/msg_server.go | 85 ++ x/pnft/module.go | 128 ++ x/pnft/types/codec.go | 29 + x/pnft/types/denom.go | 67 + x/pnft/types/errors.go | 12 + x/pnft/types/event.pb.go | 1086 ++++++++++++++ x/pnft/types/genesis.go | 17 + x/pnft/types/genesis.pb.go | 328 +++++ x/pnft/types/keys.go | 8 + x/pnft/types/message_denom.go | 213 +++ x/pnft/types/pnft.pb.go | 900 ++++++++++++ x/pnft/types/query.pb.go | 1454 +++++++++++++++++++ x/pnft/types/query.pb.gw.go | 373 +++++ x/pnft/types/tx.pb.go | 2032 +++++++++++++++++++++++++++ 33 files changed, 7539 insertions(+), 16 deletions(-) create mode 100644 proto/panacea/pnft/v2/event.proto create mode 100644 proto/panacea/pnft/v2/genesis.proto create mode 100644 proto/panacea/pnft/v2/pnft.proto create mode 100644 proto/panacea/pnft/v2/query.proto create mode 100644 proto/panacea/pnft/v2/tx.proto create mode 100644 x/pnft/client/cli/flags.go create mode 100644 x/pnft/client/cli/query.go create mode 100644 x/pnft/client/cli/tx.go create mode 100644 x/pnft/client/cli/tx_denom.go create mode 100644 x/pnft/genesis.go create mode 100644 x/pnft/keeper/denom.go create mode 100644 x/pnft/keeper/grpc_query.go create mode 100644 x/pnft/keeper/keeper.go create mode 100644 x/pnft/keeper/keys.go create mode 100644 x/pnft/keeper/msg_server.go create mode 100644 x/pnft/module.go create mode 100644 x/pnft/types/codec.go create mode 100644 x/pnft/types/denom.go create mode 100644 x/pnft/types/errors.go create mode 100644 x/pnft/types/event.pb.go create mode 100644 x/pnft/types/genesis.go create mode 100644 x/pnft/types/genesis.pb.go create mode 100644 x/pnft/types/keys.go create mode 100644 x/pnft/types/message_denom.go create mode 100644 x/pnft/types/pnft.pb.go create mode 100644 x/pnft/types/query.pb.go create mode 100644 x/pnft/types/query.pb.gw.go create mode 100644 x/pnft/types/tx.pb.go diff --git a/app/app.go b/app/app.go index ea7a12b9..49033a99 100644 --- a/app/app.go +++ b/app/app.go @@ -21,10 +21,11 @@ import ( "github.com/cosmos/cosmos-sdk/x/group" groupmodule "github.com/cosmos/cosmos-sdk/x/group/module" "github.com/cosmos/cosmos-sdk/x/nft" - nftmodule "github.com/cosmos/cosmos-sdk/x/nft/module" "github.com/cosmos/cosmos-sdk/x/upgrade" "github.com/medibloc/panacea-core/v2/app/keepers" "github.com/medibloc/panacea-core/v2/app/upgrades" + "github.com/medibloc/panacea-core/v2/x/pnft" + pnfttypes "github.com/medibloc/panacea-core/v2/x/pnft/types" "github.com/spf13/cast" "io" "os" @@ -140,7 +141,6 @@ var ( authzmodule.AppModuleBasic{}, groupmodule.AppModuleBasic{}, vesting.AppModuleBasic{}, - nftmodule.AppModuleBasic{}, consensus.AppModuleBasic{}, // ibc ibc.AppModuleBasic{}, @@ -151,6 +151,7 @@ var ( aol.AppModuleBasic{}, did.AppModuleBasic{}, burn.AppModuleBasic{}, + pnft.AppModuleBasic{}, ) // module account permissions @@ -161,9 +162,9 @@ var ( stakingtypes.BondedPoolName: {authtypes.Burner, authtypes.Staking}, stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking}, govtypes.ModuleName: {authtypes.Burner}, - nft.ModuleName: nil, ibctransfertypes.ModuleName: {authtypes.Minter, authtypes.Burner}, burntypes.ModuleName: {authtypes.Burner}, + nft.ModuleName: nil, } _ runtime.AppI = (*App)(nil) @@ -284,13 +285,13 @@ func New( params.NewAppModule(app.ParamsKeeper), authzmodule.NewAppModule(appCodec, app.AuthzKeeper, app.AccountKeeper, app.BankKeeper, app.interfaceRegistry), groupmodule.NewAppModule(appCodec, app.GroupKeeper, app.AccountKeeper, app.BankKeeper, app.interfaceRegistry), - nftmodule.NewAppModule(appCodec, app.NFTKeeper, app.AccountKeeper, app.BankKeeper, app.interfaceRegistry), consensus.NewAppModule(appCodec, app.ConsensusParamsKeeper), ibc.NewAppModule(app.IBCKeeper), transfer.NewAppModule(app.TransferKeeper), aol.NewAppModule(appCodec, app.AolKeeper), did.NewAppModule(appCodec, app.DidKeeper), burn.NewAppModule(appCodec, app.BurnKeeper), + pnft.NewAppModule(appCodec, &app.PnftKeeper), ) // During begin block slashing happens after distr.BeginBlocker so that @@ -305,7 +306,7 @@ func New( authz.ModuleName, feegrant.ModuleName, nft.ModuleName, group.ModuleName, paramstypes.ModuleName, vestingtypes.ModuleName, consensusparamtypes.ModuleName, ibcexported.ModuleName, ibctransfertypes.ModuleName, - aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, + aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, pnfttypes.ModuleName, ) app.ModuleManager.SetOrderEndBlockers( @@ -316,7 +317,7 @@ func New( feegrant.ModuleName, nft.ModuleName, group.ModuleName, paramstypes.ModuleName, upgradetypes.ModuleName, vestingtypes.ModuleName, consensusparamtypes.ModuleName, ibcexported.ModuleName, ibctransfertypes.ModuleName, - aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, + aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, pnfttypes.ModuleName, ) // NOTE: The genutils module must occur after staking so that pools are @@ -332,7 +333,7 @@ func New( feegrant.ModuleName, nft.ModuleName, group.ModuleName, paramstypes.ModuleName, upgradetypes.ModuleName, vestingtypes.ModuleName, consensusparamtypes.ModuleName, ibcexported.ModuleName, ibctransfertypes.ModuleName, - aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, + aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, pnfttypes.ModuleName, } app.ModuleManager.SetOrderInitGenesis(genesisModuleOrder...) app.ModuleManager.SetOrderExportGenesis(genesisModuleOrder...) diff --git a/app/keepers/keepers.go b/app/keepers/keepers.go index 9a2c4f41..02607018 100644 --- a/app/keepers/keepers.go +++ b/app/keepers/keepers.go @@ -32,7 +32,6 @@ import ( groupkeeper "github.com/cosmos/cosmos-sdk/x/group/keeper" mintkeeper "github.com/cosmos/cosmos-sdk/x/mint/keeper" minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" - nftkeeper "github.com/cosmos/cosmos-sdk/x/nft/keeper" "github.com/cosmos/cosmos-sdk/x/params" paramskeeper "github.com/cosmos/cosmos-sdk/x/params/keeper" paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" @@ -58,6 +57,8 @@ import ( burnkeeper "github.com/medibloc/panacea-core/v2/x/burn/keeper" didkeeper "github.com/medibloc/panacea-core/v2/x/did/keeper" didtypes "github.com/medibloc/panacea-core/v2/x/did/types" + pnftkeeper "github.com/medibloc/panacea-core/v2/x/pnft/keeper" + pnfttypes "github.com/medibloc/panacea-core/v2/x/pnft/types" "github.com/spf13/cast" ) @@ -77,7 +78,6 @@ type AppKeepersWithKey struct { EvidenceKeeper evidencekeeper.Keeper FeeGrantKeeper feegrantkeeper.Keeper GroupKeeper groupkeeper.Keeper - NFTKeeper nftkeeper.Keeper ConsensusParamsKeeper consensusparamkeeper.Keeper IBCKeeper *ibckeeper.Keeper // IBC Keeper must be a pointer in the app, so we can SetRouter on it correctly @@ -90,6 +90,7 @@ type AppKeepersWithKey struct { AolKeeper aolkeeper.Keeper DidKeeper didkeeper.Keeper BurnKeeper burnkeeper.Keeper + PnftKeeper pnftkeeper.Keeper keys map[string]*storetypes.KVStoreKey tkeys map[string]*storetypes.TransientStoreKey @@ -165,8 +166,6 @@ func (appKeepers *AppKeepersWithKey) InitKeyAndKeepers( // set the governance module account as the authority for conducting upgrades appKeepers.UpgradeKeeper = upgradekeeper.NewKeeper(skipUpgradeHeights, appKeepers.keys[upgradetypes.StoreKey], appCodec, homePath, bApp, authtypes.NewModuleAddress(govtypes.ModuleName).String()) - appKeepers.NFTKeeper = nftkeeper.NewKeeper(appKeepers.keys[nftkeeper.StoreKey], appCodec, appKeepers.AccountKeeper, appKeepers.BankKeeper) - // Create evidence Keeper for to register the IBC light client misbehaviour evidence route evidenceKeeper := evidencekeeper.NewKeeper( appCodec, appKeepers.keys[evidencetypes.StoreKey], appKeepers.StakingKeeper, appKeepers.SlashingKeeper, @@ -211,6 +210,13 @@ func (appKeepers *AppKeepersWithKey) InitKeyAndKeepers( appKeepers.BankKeeper, ) + appKeepers.PnftKeeper = pnftkeeper.NewKeeper( + appCodec, + appKeepers.keys[pnfttypes.StoreKey], + appKeepers.AccountKeeper, + appKeepers.BankKeeper, + ) + // Set router // Register the proposal types diff --git a/app/keepers/keys.go b/app/keepers/keys.go index cb46c82f..d73f60a0 100644 --- a/app/keepers/keys.go +++ b/app/keepers/keys.go @@ -15,7 +15,6 @@ import ( govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/cosmos/cosmos-sdk/x/group" minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" - nftkeeper "github.com/cosmos/cosmos-sdk/x/nft/keeper" paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -25,6 +24,7 @@ import ( aoltypes "github.com/medibloc/panacea-core/v2/x/aol/types" burntypes "github.com/medibloc/panacea-core/v2/x/burn/types" didtypes "github.com/medibloc/panacea-core/v2/x/did/types" + pnfttypes "github.com/medibloc/panacea-core/v2/x/pnft/types" ) func (appKeepers *AppKeepersWithKey) GenerateKeys() { @@ -33,9 +33,9 @@ func (appKeepers *AppKeepersWithKey) GenerateKeys() { minttypes.StoreKey, distrtypes.StoreKey, slashingtypes.StoreKey, govtypes.StoreKey, paramstypes.StoreKey, consensusparamtypes.StoreKey, upgradetypes.StoreKey, feegrant.StoreKey, evidencetypes.StoreKey, capabilitytypes.StoreKey, - authzkeeper.StoreKey, nftkeeper.StoreKey, group.StoreKey, + authzkeeper.StoreKey, group.StoreKey, ibcexported.StoreKey, ibctransfertypes.StoreKey, - aoltypes.StoreKey, didtypes.StoreKey, burntypes.StoreKey, + aoltypes.StoreKey, didtypes.StoreKey, burntypes.StoreKey, pnfttypes.StoreKey, ) appKeepers.tkeys = sdk.NewTransientStoreKeys(paramstypes.TStoreKey) diff --git a/go.mod b/go.mod index 85fb9925..07861dad 100644 --- a/go.mod +++ b/go.mod @@ -14,6 +14,7 @@ require ( github.com/cosmos/ibc-go/v7 v7.3.2 github.com/gogo/protobuf v1.3.2 github.com/golang/protobuf v1.5.3 + github.com/google/uuid v1.4.0 github.com/grpc-ecosystem/grpc-gateway v1.16.0 github.com/pborman/uuid v1.2.1 github.com/pkg/errors v0.9.1 @@ -93,7 +94,6 @@ require ( github.com/google/go-cmp v0.6.0 // indirect github.com/google/orderedcode v0.0.1 // indirect github.com/google/s2a-go v0.1.7 // indirect - github.com/google/uuid v1.4.0 // indirect github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect github.com/googleapis/gax-go/v2 v2.12.0 // indirect github.com/gorilla/handlers v1.5.1 // indirect diff --git a/proto/panacea/aol/v2/query.proto b/proto/panacea/aol/v2/query.proto index cae31e34..0d5be4fb 100644 --- a/proto/panacea/aol/v2/query.proto +++ b/proto/panacea/aol/v2/query.proto @@ -10,7 +10,7 @@ import "panacea/aol/v2/topic.proto"; option java_multiple_files = true; option go_package = "github.com/medibloc/panacea-core/x/aol/types"; -// Query defines the gRPC querier service. +// QueryService defines the gRPC querier service. service QueryService { // Topic returns topic details. rpc Topic(QueryServiceTopicRequest) returns (QueryServiceTopicResponse) { diff --git a/proto/panacea/pnft/v2/event.proto b/proto/panacea/pnft/v2/event.proto new file mode 100644 index 00000000..945a063e --- /dev/null +++ b/proto/panacea/pnft/v2/event.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; +package panacea.pnft.v2; + +option go_package = "github.com/medibloc/panacea-core/x/pnft/types"; +option java_multiple_files = true; + +message EventSaveDenom { + string id = 1; + string creator = 2; +} + +message EventUpdateDenom { + string id = 1; + string updater = 2; +} + +message EventDeleteDenom { + string id = 1; + string remover = 2; +} + +message EventTransferDenom { + string id = 1; + string sender = 2; + string receiver = 3; +} \ No newline at end of file diff --git a/proto/panacea/pnft/v2/genesis.proto b/proto/panacea/pnft/v2/genesis.proto new file mode 100644 index 00000000..8a336e17 --- /dev/null +++ b/proto/panacea/pnft/v2/genesis.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; +package panacea.pnft.v2; + +import "panacea/pnft/v2/pnft.proto"; + +option go_package = "github.com/medibloc/panacea-core/x/pnft/types"; +option java_multiple_files = true; + +// GenesisState defines the nft module's genesis state. +message GenesisState { + repeated panacea.pnft.v2.Denom denoms = 1; +} \ No newline at end of file diff --git a/proto/panacea/pnft/v2/pnft.proto b/proto/panacea/pnft/v2/pnft.proto new file mode 100644 index 00000000..710efaf2 --- /dev/null +++ b/proto/panacea/pnft/v2/pnft.proto @@ -0,0 +1,21 @@ +syntax = "proto3"; +package panacea.pnft.v2; + +option go_package = "github.com/medibloc/panacea-core/x/pnft/types"; +option java_multiple_files = true; + +message Denom { + string id = 1; + string name = 2; + string symbol = 3; + string description = 4; + string uri = 5; + string uri_hash = 6; + string creator = 7; + string data = 8; +} + +message DenomMeta { + string creator = 1; + string data = 2; +} diff --git a/proto/panacea/pnft/v2/query.proto b/proto/panacea/pnft/v2/query.proto new file mode 100644 index 00000000..a9245a80 --- /dev/null +++ b/proto/panacea/pnft/v2/query.proto @@ -0,0 +1,60 @@ +syntax = "proto3"; +package panacea.pnft.v2; + +import "google/api/annotations.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; +import "panacea/pnft/v2/pnft.proto"; + +option java_multiple_files = true; +option go_package = "github.com/medibloc/panacea-core/x/pnft/types"; + +// QueryService defines the gRPC querier service. +service QueryService { + // Denoms returns denom list. + rpc Denoms(QueryServiceDenomsRequest) returns (QueryServiceDenomsResponse) { + option (google.api.http).get = + "/panacea/pnft/v2/denoms"; + } + + rpc DenomsByCreator(QueryServiceDenomsByCreatorRequest) returns (QueryServiceDenomsByCreatorResponse) { + option (google.api.http).get = + "/panacea/pnft/v2/denoms/creators/{creator}"; + } + + // Denom returns denom detail. + rpc Denom(QueryServiceDenomRequest) returns (QueryServiceDenomResponse) { + option (google.api.http).get = + "/panacea/pnft/v2/denoms/{id}"; + } +} + +// QueryServiceDenomsRequest is the response type for the Query RPC method. +message QueryServiceDenomsRequest { + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryServiceDenomsResponse is the response type for the Query RPC method. +message QueryServiceDenomsResponse { + repeated panacea.pnft.v2.Denom denoms = 1; + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryServiceDenomsByCreatorRequest is the response type for the Query RPC method. +message QueryServiceDenomsByCreatorRequest { + string creator = 1; +} + +// QueryServiceDenomsByCreatorResponse is the response type for the Query RPC method. +message QueryServiceDenomsByCreatorResponse { + repeated panacea.pnft.v2.Denom denoms = 1; +} + +// QueryServiceDenomRequest is the response type for the Query RPC method. +message QueryServiceDenomRequest { + string id = 1; +} + +// QueryServiceDenomResponse is the response type for the Query RPC method. +message QueryServiceDenomResponse { + panacea.pnft.v2.Denom denom = 1; +} \ No newline at end of file diff --git a/proto/panacea/pnft/v2/tx.proto b/proto/panacea/pnft/v2/tx.proto new file mode 100644 index 00000000..8e383935 --- /dev/null +++ b/proto/panacea/pnft/v2/tx.proto @@ -0,0 +1,51 @@ +syntax = "proto3"; +package panacea.pnft.v2; + +import "panacea/pnft/v2/pnft.proto"; + +option go_package = "github.com/medibloc/panacea-core/x/pnft/types"; +option java_multiple_files = true; + +service MsgService { + rpc CreateDenom(MsgServiceCreateDenomRequest) returns (MsgServiceCreateDenomResponse); + + rpc UpdateDenom(MsgServiceUpdateDenomRequest) returns (MsgServiceUpdateDenomResponse); + + rpc DeleteDenom(MsgServiceDeleteDenomRequest) returns (MsgServiceDeleteDenomResponse); + + rpc TransferDenom(MsgServiceTransferDenomRequest) returns (MsgServiceTransferDenomResponse); +} + +message MsgServiceCreateDenomRequest { + panacea.pnft.v2.Denom denom = 1; +} + +message MsgServiceCreateDenomResponse {} + +message MsgServiceUpdateDenomRequest { + string id = 1; + string name = 2; + string symbol = 3; + string description = 4; + string uri = 5; + string uri_hash = 6; + string data = 7; + string updater = 8; +} + +message MsgServiceUpdateDenomResponse {} + +message MsgServiceDeleteDenomRequest { + string id = 1; + string remover = 2; +} + +message MsgServiceDeleteDenomResponse {} + +message MsgServiceTransferDenomRequest { + string id = 1; + string sender = 2; + string receiver = 3; +} + +message MsgServiceTransferDenomResponse {} \ No newline at end of file diff --git a/x/pnft/client/cli/flags.go b/x/pnft/client/cli/flags.go new file mode 100644 index 00000000..b0761c89 --- /dev/null +++ b/x/pnft/client/cli/flags.go @@ -0,0 +1,11 @@ +package cli + +const ( + FlagSymbol = "denom-symbol" + FlagDenomName = "denom-name" + FlagDenomDescription = "denom-description" + FlagDenomData = "denom-data" + FlagDenomURI = "denom-uri" + FlagDenomURIHash = "denom-uri-hash" + FlagDenomCreator = "denom-creator" +) diff --git a/x/pnft/client/cli/query.go b/x/pnft/client/cli/query.go new file mode 100644 index 00000000..efcaddb8 --- /dev/null +++ b/x/pnft/client/cli/query.go @@ -0,0 +1,56 @@ +package cli + +import ( + "context" + "fmt" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/medibloc/panacea-core/v2/x/pnft/types" + "github.com/spf13/cobra" +) + +func NewGetQueryCmd() *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(NewCmdGetDenoms()) + + return cmd +} + +func NewCmdGetDenoms() *cobra.Command { + cmd := &cobra.Command{ + Use: "list-denom", + Short: "List all denoms", + Args: cobra.ExactArgs(0), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx := client.GetClientContextFromCmd(cmd) + pagination, err := client.ReadPageRequest(cmd.Flags()) + if err != nil { + return err + } + + queryClient := types.NewQueryServiceClient(clientCtx) + + msg := &types.QueryServiceDenomsRequest{ + Pagination: pagination, + } + + res, err := queryClient.Denoms(context.Background(), msg) + + if err != nil { + return err + } + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/pnft/client/cli/tx.go b/x/pnft/client/cli/tx.go new file mode 100644 index 00000000..08d0ac6a --- /dev/null +++ b/x/pnft/client/cli/tx.go @@ -0,0 +1,25 @@ +package cli + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/client" + "github.com/medibloc/panacea-core/v2/x/pnft/types" + "github.com/spf13/cobra" +) + +func NewTxCmd() *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(NewCmdCreateDenom()) + cmd.AddCommand(NewCmdUpdateDenom()) + cmd.AddCommand(NewCmdDeleteDenom()) + cmd.AddCommand(NewCmdTransferDenom()) + + return cmd +} diff --git a/x/pnft/client/cli/tx_denom.go b/x/pnft/client/cli/tx_denom.go new file mode 100644 index 00000000..82ecd60e --- /dev/null +++ b/x/pnft/client/cli/tx_denom.go @@ -0,0 +1,213 @@ +package cli + +import ( + sdkerrors "cosmossdk.io/errors" + "fmt" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + "github.com/medibloc/panacea-core/v2/x/pnft/types" + "github.com/spf13/cobra" +) + +func NewCmdCreateDenom() *cobra.Command { + cmd := &cobra.Command{ + Use: "create-denom", + Long: fmt.Sprintf(`Create a new denom.`), + Args: cobra.ExactArgs(0), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + symbol, err := cmd.Flags().GetString(FlagSymbol) + if err != nil { + return err + } + + denomName, err := cmd.Flags().GetString(FlagDenomName) + if err != nil { + return err + } + + description, err := cmd.Flags().GetString(FlagDenomDescription) + if err != nil { + return err + } + + uri, err := cmd.Flags().GetString(FlagDenomURI) + if err != nil { + return err + } + + uriHash, err := cmd.Flags().GetString(FlagDenomURIHash) + if err != nil { + return err + } + + data, err := cmd.Flags().GetString(FlagDenomData) + if err != nil { + return err + } + + creator := clientCtx.GetFromAddress().String() + + msg := types.NewMsgServiceCreateDenomRequest( + symbol, + denomName, + description, + uri, + uriHash, + creator, + data, + ) + + if err := msg.ValidateBasic(); err != nil { + return sdkerrors.Wrap(types.ErrCreateDenom, err.Error()) + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + flags.AddTxFlagsToCmd(cmd) + _ = cmd.MarkFlagRequired(FlagDenomName) + cmd.Flags().String(FlagSymbol, "", "Set the symbol for a Denom") + cmd.Flags().String(FlagDenomName, "", "Set the name for a Denom") + cmd.Flags().String(FlagDenomDescription, "", "Set the description for a Denom") + cmd.Flags().String(FlagDenomURI, "", "Set the URI for a Denom") + cmd.Flags().String(FlagDenomURIHash, "", "Set the URI hash for a Denom") + cmd.Flags().String(FlagDenomData, "", "Set the data for a Denom") + return cmd +} + +func NewCmdUpdateDenom() *cobra.Command { + cmd := &cobra.Command{ + Use: "update-denom [denom-id]", + Long: fmt.Sprintf(`update a exist denom.`), + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + denomId := args[0] + + symbol, err := cmd.Flags().GetString(FlagSymbol) + if err != nil { + return err + } + + denomName, err := cmd.Flags().GetString(FlagDenomName) + if err != nil { + return err + } + + description, err := cmd.Flags().GetString(FlagDenomDescription) + if err != nil { + return err + } + + uri, err := cmd.Flags().GetString(FlagDenomURI) + if err != nil { + return err + } + + uriHash, err := cmd.Flags().GetString(FlagDenomURIHash) + if err != nil { + return err + } + + data, err := cmd.Flags().GetString(FlagDenomData) + if err != nil { + return err + } + + updater := clientCtx.GetFromAddress().String() + + msg := types.NewMsgServiceUpdateDenomRequest( + denomId, + symbol, + denomName, + description, + uri, + uriHash, + data, + updater, + ) + + if err := msg.ValidateBasic(); err != nil { + return sdkerrors.Wrap(types.ErrUpdateDenom, err.Error()) + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + flags.AddTxFlagsToCmd(cmd) + _ = cmd.MarkFlagRequired(FlagDenomName) + cmd.Flags().String(FlagSymbol, "", "Set the symbol for a Denom") + cmd.Flags().String(FlagDenomName, "", "Set the name for a Denom") + cmd.Flags().String(FlagDenomDescription, "", "Set the description for a Denom") + cmd.Flags().String(FlagDenomURI, "", "Set the URI for a Denom") + cmd.Flags().String(FlagDenomURIHash, "", "Set the URI hash for a Denom") + cmd.Flags().String(FlagDenomData, "", "Set the data for a Denom") + return cmd +} + +func NewCmdDeleteDenom() *cobra.Command { + cmd := &cobra.Command{ + Use: "delete-denom [denom-id]", + Long: fmt.Sprintf(`delete a exist denom.`), + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + denomId := args[0] + + remover := clientCtx.GetFromAddress().String() + + msg := types.NewMsgServiceDeleteDenomRequest(denomId, remover) + + if err := msg.ValidateBasic(); err != nil { + return sdkerrors.Wrap(types.ErrDeleteDenom, err.Error()) + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + flags.AddTxFlagsToCmd(cmd) + return cmd +} + +func NewCmdTransferDenom() *cobra.Command { + cmd := &cobra.Command{ + Use: "transfer-denom [denom-id] [receiver]", + Long: fmt.Sprintf(`transfer denom owner to receiver.`), + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + denomId := args[0] + receiver := args[1] + + sender := clientCtx.GetFromAddress().String() + + msg := types.NewMsgServiceTransferRequest(denomId, sender, receiver) + + if err := msg.ValidateBasic(); err != nil { + return sdkerrors.Wrap(types.ErrTransferDenom, err.Error()) + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/pnft/genesis.go b/x/pnft/genesis.go new file mode 100644 index 00000000..930618b0 --- /dev/null +++ b/x/pnft/genesis.go @@ -0,0 +1,29 @@ +package pnft + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/medibloc/panacea-core/v2/x/pnft/keeper" + "github.com/medibloc/panacea-core/v2/x/pnft/types" +) + +func InitGenesis(ctx sdk.Context, k *keeper.Keeper, genState types.GenesisState) { + for _, denom := range genState.Denoms { + if err := k.SaveDenom(ctx, denom); err != nil { + panic(err) + } + } +} + +// ExportGenesis returns the pnft module's exported genesis. +func ExportGenesis(ctx sdk.Context, k *keeper.Keeper) *types.GenesisState { + genesis := types.DefaultGenesis() + + denoms, err := k.GetAllDenoms(ctx) + if err != nil { + panic(err) + } + + genesis.Denoms = denoms + + return genesis +} diff --git a/x/pnft/keeper/denom.go b/x/pnft/keeper/denom.go new file mode 100644 index 00000000..837397a3 --- /dev/null +++ b/x/pnft/keeper/denom.go @@ -0,0 +1,160 @@ +package keeper + +import ( + "errors" + "fmt" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/nft" + "github.com/medibloc/panacea-core/v2/x/pnft/types" +) + +func (k Keeper) SaveDenom( + ctx sdk.Context, + denom *types.Denom, +) error { + class, err := types.NewClassFromDenom(k.cdc, denom) + if err != nil { + return err + } + + if err := k.nftKeeper.SaveClass(ctx, *class); err != nil { + return err + } + + return ctx.EventManager().EmitTypedEvent(&types.EventSaveDenom{ + Id: denom.Id, + Creator: denom.Creator, + }) +} + +func (k Keeper) ParseDenoms(classes []*nft.Class) ([]*types.Denom, error) { + denoms := []*types.Denom{} + for _, class := range classes { + denom, err := types.NewDenomFromClass(k.cdc, class) + if err != nil { + return nil, err + } + + denoms = append(denoms, denom) + } + + return denoms, nil +} + +func (k Keeper) UpdateDenom(ctx sdk.Context, msg *types.Denom, updater string) error { + denom, err := k.GetDenom(ctx, msg.GetId()) + if err != nil { + return err + } + + if updater != denom.Creator { + return errors.New(fmt.Sprintf("permission denied: %s does not have permission to modify this resource.", updater)) + } + + if msg.Name != "" { + denom.Name = msg.Name + } + if msg.Symbol != "" { + denom.Symbol = msg.Symbol + } + if msg.Description != "" { + denom.Description = msg.Description + } + if msg.Uri != "" { + denom.Uri = msg.Uri + } + if msg.UriHash != "" { + denom.UriHash = msg.UriHash + } + if msg.Data != "" { + denom.Data = msg.Name + } + + class, err := types.NewClassFromDenom(k.cdc, denom) + if err != nil { + return err + } + + if err := k.nftKeeper.UpdateClass(ctx, *class); err != nil { + return err + } + + return ctx.EventManager().EmitTypedEvent(&types.EventUpdateDenom{ + Id: denom.Id, + Updater: updater, + }) +} + +func (k Keeper) DeleteDenom(ctx sdk.Context, id string, remover string) error { + denom, err := k.GetDenom(ctx, id) + if err != nil { + return err + } + + if remover != denom.Creator { + return errors.New(fmt.Sprintf("permission denied: %s does not have permission to remove this resource.", remover)) + } + + store := ctx.KVStore(k.storeKey) + store.Delete(classStoreKey(id)) + + return ctx.EventManager().EmitTypedEvent(&types.EventDeleteDenom{ + Id: denom.Id, + Remover: remover, + }) +} + +func (k Keeper) TransferDenomOwner( + ctx sdk.Context, + id string, + sender string, + receiver string, +) error { + denom, err := k.GetDenom(ctx, id) + if err != nil { + return err + } + + if sender != denom.Creator { + return errors.New(fmt.Sprintf("%s is not allowed transfer denom to %s", sender, receiver)) + } + + denom.Creator = receiver + class, err := types.NewClassFromDenom(k.cdc, denom) + if err != nil { + return err + } + + if err := k.nftKeeper.UpdateClass(ctx, *class); err != nil { + return err + } + + return ctx.EventManager().EmitTypedEvent(&types.EventTransferDenom{ + Id: denom.Id, + Sender: sender, + Receiver: receiver, + }) +} + +func (k Keeper) GetAllDenoms(ctx sdk.Context) ([]*types.Denom, error) { + var denoms []*types.Denom + classes := k.nftKeeper.GetClasses(ctx) + + for _, class := range classes { + denom, err := types.NewDenomFromClass(k.cdc, class) + if err != nil { + return nil, err + } + denoms = append(denoms, denom) + } + return denoms, nil +} + +func (k Keeper) GetDenom(ctx sdk.Context, id string) (*types.Denom, error) { + class, found := k.nftKeeper.GetClass(ctx, id) + if !found { + return nil, errors.New("not found class.") + } + + return types.NewDenomFromClass(k.cdc, &class) +} diff --git a/x/pnft/keeper/grpc_query.go b/x/pnft/keeper/grpc_query.go new file mode 100644 index 00000000..b38647de --- /dev/null +++ b/x/pnft/keeper/grpc_query.go @@ -0,0 +1,72 @@ +package keeper + +import ( + "context" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/nft" + "github.com/medibloc/panacea-core/v2/x/pnft/types" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +var _ types.QueryServiceServer = Keeper{} + +func (k Keeper) Denoms(goCtx context.Context, request *types.QueryServiceDenomsRequest) (*types.QueryServiceDenomsResponse, error) { + if request == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + classRes, err := k.nftKeeper.Classes(goCtx, &nft.QueryClassesRequest{ + Pagination: request.Pagination, + }) + if err != nil { + return nil, err + } + + denoms, err := k.ParseDenoms(classRes.GetClasses()) + if err != nil { + return nil, err + } + + return &types.QueryServiceDenomsResponse{ + Denoms: denoms, + Pagination: classRes.Pagination, + }, nil +} + +func (k Keeper) DenomsByCreator(goCtx context.Context, request *types.QueryServiceDenomsByCreatorRequest) (*types.QueryServiceDenomsByCreatorResponse, error) { + if request == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + classRes, err := k.nftKeeper.Classes(goCtx, &nft.QueryClassesRequest{}) + if err != nil { + return nil, err + } + + denoms, err := k.ParseDenoms(classRes.Classes) + if err != nil { + return nil, err + } + + return &types.QueryServiceDenomsByCreatorResponse{ + Denoms: denoms, + }, nil +} + +func (k Keeper) Denom(goCtx context.Context, request *types.QueryServiceDenomRequest) (*types.QueryServiceDenomResponse, error) { + if request == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + denom, err := k.GetDenom(ctx, request.GetId()) + if err != nil { + return nil, err + } + + return &types.QueryServiceDenomResponse{ + Denom: denom, + }, nil +} diff --git a/x/pnft/keeper/keeper.go b/x/pnft/keeper/keeper.go new file mode 100644 index 00000000..b19cc1ab --- /dev/null +++ b/x/pnft/keeper/keeper.go @@ -0,0 +1,36 @@ +package keeper + +import ( + "fmt" + "github.com/cometbft/cometbft/libs/log" + "github.com/cosmos/cosmos-sdk/codec" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/nft" + nftkeeper "github.com/cosmos/cosmos-sdk/x/nft/keeper" + "github.com/medibloc/panacea-core/v2/x/pnft/types" +) + +type Keeper struct { + cdc codec.BinaryCodec + storeKey storetypes.StoreKey + + nftKeeper nftkeeper.Keeper +} + +func NewKeeper( + cdc codec.Codec, + storeKey storetypes.StoreKey, + ak nft.AccountKeeper, + bk nft.BankKeeper, +) Keeper { + return Keeper{ + cdc: cdc, + storeKey: storeKey, + nftKeeper: nftkeeper.NewKeeper(storeKey, cdc, ak, bk), + } +} + +func (k Keeper) Logger(ctx sdk.Context) log.Logger { + return ctx.Logger().With("module", fmt.Sprintf("OmniFlix/%s", types.ModuleName)) +} diff --git a/x/pnft/keeper/keys.go b/x/pnft/keeper/keys.go new file mode 100644 index 00000000..80dd109d --- /dev/null +++ b/x/pnft/keeper/keys.go @@ -0,0 +1,12 @@ +package keeper + +import nftkeeper "github.com/cosmos/cosmos-sdk/x/nft/keeper" + +// classStoreKey returns the byte representation of the nft class key +// reference from x/nft/keeper/keys.go +func classStoreKey(classID string) []byte { + key := make([]byte, len(nftkeeper.ClassKey)+len(classID)) + copy(key, nftkeeper.ClassKey) + copy(key[len(nftkeeper.ClassKey):], classID) + return key +} diff --git a/x/pnft/keeper/msg_server.go b/x/pnft/keeper/msg_server.go new file mode 100644 index 00000000..3ebc090c --- /dev/null +++ b/x/pnft/keeper/msg_server.go @@ -0,0 +1,85 @@ +package keeper + +import ( + "context" + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/medibloc/panacea-core/v2/x/pnft/types" +) + +type msgServer struct { + *Keeper +} + +func NewMsgServerImpl(keeper *Keeper) types.MsgServiceServer { + return &msgServer{Keeper: keeper} +} + +func (m msgServer) CreateDenom(goCtx context.Context, request *types.MsgServiceCreateDenomRequest) (*types.MsgServiceCreateDenomResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := request.ValidateBasic(); err != nil { + return nil, err + } + + err := m.Keeper.SaveDenom(ctx, request.Denom) + if err != nil { + return nil, errors.Wrapf(types.ErrCreateDenom, err.Error()) + } + return &types.MsgServiceCreateDenomResponse{}, nil +} + +func (m msgServer) UpdateDenom(goCtx context.Context, request *types.MsgServiceUpdateDenomRequest) (*types.MsgServiceUpdateDenomResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := request.ValidateBasic(); err != nil { + return nil, err + } + + if err := m.Keeper.UpdateDenom( + ctx, + &types.Denom{ + Id: request.Id, + Name: request.Name, + Symbol: request.Symbol, + Description: request.Description, + Uri: request.Uri, + UriHash: request.UriHash, + Creator: "", + Data: request.Data, + }, + request.Updater, + ); err != nil { + return nil, errors.Wrapf(types.ErrUpdateDenom, err.Error()) + } + + return &types.MsgServiceUpdateDenomResponse{}, nil +} + +func (m msgServer) DeleteDenom(goCtx context.Context, request *types.MsgServiceDeleteDenomRequest) (*types.MsgServiceDeleteDenomResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := request.ValidateBasic(); err != nil { + return nil, err + } + + if err := m.Keeper.DeleteDenom(ctx, request.Id, request.Remover); err != nil { + return nil, errors.Wrapf(types.ErrDeleteDenom, err.Error()) + } + + return &types.MsgServiceDeleteDenomResponse{}, nil +} + +func (m msgServer) TransferDenom(goCtx context.Context, request *types.MsgServiceTransferDenomRequest) (*types.MsgServiceTransferDenomResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := request.ValidateBasic(); err != nil { + return nil, err + } + + if err := m.Keeper.TransferDenomOwner(ctx, request.Id, request.Sender, request.Receiver); err != nil { + return nil, err + } + + return &types.MsgServiceTransferDenomResponse{}, nil +} diff --git a/x/pnft/module.go b/x/pnft/module.go new file mode 100644 index 00000000..f8b96990 --- /dev/null +++ b/x/pnft/module.go @@ -0,0 +1,128 @@ +package pnft + +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" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/medibloc/panacea-core/v2/x/pnft/client/cli" + "github.com/medibloc/panacea-core/v2/x/pnft/keeper" + "github.com/medibloc/panacea-core/v2/x/pnft/types" + "github.com/spf13/cobra" +) + +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} +) + +type AppModuleBasic struct { + cdc codec.Codec +} + +func NewAppModuleBasic(cdc codec.Codec) AppModuleBasic { + return AppModuleBasic{cdc: cdc} +} + +func (a AppModuleBasic) Name() string { + return types.ModuleName +} + +func (a AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + types.RegisterCodec(cdc) +} + +func (a AppModuleBasic) RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + types.RegisterInterfaces(registry) +} + +// DefaultGenesis returns the capability 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 capability module. +func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, _ 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.ValidateBasic() +} + +func (a AppModuleBasic) RegisterGRPCGatewayRoutes(clientContext client.Context, mux *runtime.ServeMux) { + if err := types.RegisterQueryServiceHandlerClient( + context.Background(), + mux, + types.NewQueryServiceClient(clientContext), + ); err != nil { + panic(err) + } +} + +func (a AppModuleBasic) GetTxCmd() *cobra.Command { + return cli.NewTxCmd() +} + +func (a AppModuleBasic) GetQueryCmd() *cobra.Command { + return cli.NewGetQueryCmd() +} + +type AppModule struct { + AppModuleBasic + + keeper *keeper.Keeper +} + +func NewAppModule(cdc codec.Codec, keeper *keeper.Keeper) AppModule { + return AppModule{ + AppModuleBasic: NewAppModuleBasic(cdc), + keeper: keeper, + } +} + +// 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.RegisterQueryServiceServer(cfg.QueryServer(), am.keeper) + types.RegisterMsgServiceServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper)) +} + +// RegisterInvariants registers the capability module's invariants. +func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {} + +// InitGenesis performs the capability module's genesis initialization It returns +// no validator updates. +func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate { + var genState types.GenesisState + // Initialize global index to index in genesis state + cdc.MustUnmarshalJSON(data, &genState) + + InitGenesis(ctx, am.keeper, genState) + + return []abci.ValidatorUpdate{} +} + +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + genState := ExportGenesis(ctx, am.keeper) + return cdc.MustMarshalJSON(genState) +} + +// BeginBlock executes all ABCI BeginBlock logic respective to the capability module. +func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {} + +func (am AppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate { + return []abci.ValidatorUpdate{} +} + +// ConsensusVersion implements AppModule/ConsensusVersion. +func (AppModule) ConsensusVersion() uint64 { return 1 } diff --git a/x/pnft/types/codec.go b/x/pnft/types/codec.go new file mode 100644 index 00000000..edcde862 --- /dev/null +++ b/x/pnft/types/codec.go @@ -0,0 +1,29 @@ +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(&MsgServiceCreateDenomRequest{}, "pnft/CreateDenom", nil) + cdc.RegisterConcrete(&MsgServiceUpdateDenomRequest{}, "pnft/UpdateDenom", nil) + cdc.RegisterConcrete(&MsgServiceDeleteDenomRequest{}, "pnft/DeleteDenom", nil) +} + +func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgServiceCreateDenomRequest{}, + &MsgServiceUpdateDenomRequest{}, + &MsgServiceDeleteDenomRequest{}, + ) + + msgservice.RegisterMsgServiceDesc(registry, &_MsgService_serviceDesc) +} + +var ( + amino = codec.NewLegacyAmino() + ModuleCdc = codec.NewAminoCodec(amino) +) diff --git a/x/pnft/types/denom.go b/x/pnft/types/denom.go new file mode 100644 index 00000000..2d371ea0 --- /dev/null +++ b/x/pnft/types/denom.go @@ -0,0 +1,67 @@ +package types + +import ( + "errors" + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + "github.com/cosmos/cosmos-sdk/x/nft" +) + +func NewClassFromDenom(cdc codec.BinaryCodec, denom *Denom) (*nft.Class, error) { + meta, err := codectypes.NewAnyWithValue( + &DenomMeta{ + Creator: denom.Creator, + Data: denom.Data, + }) + if err != nil { + return nil, err + } + + return &nft.Class{ + Id: denom.Id, + Name: denom.Name, + Symbol: denom.Symbol, + Description: denom.Description, + Uri: denom.Uri, + UriHash: denom.UriHash, + Data: meta, + }, nil +} + +func NewDenomFromClass(cdc codec.BinaryCodec, class *nft.Class) (*Denom, error) { + var meta DenomMeta + if err := cdc.Unmarshal(class.Data.GetValue(), &meta); err != nil { + return nil, err + } + + return &Denom{ + Id: class.Id, + Name: class.Name, + Symbol: class.Symbol, + Description: class.Description, + Uri: class.Uri, + UriHash: class.UriHash, + Creator: meta.Creator, + Data: meta.Data, + }, nil +} + +func (d Denom) ValidateBasic() error { + if d.Id == "" { + return errors.New("Id cannot be empty.") + } + + if d.Name == "" { + return errors.New("Name cannot be empty.") + } + + if d.Symbol == "" { + return errors.New("Symbol cannot be empty.") + } + + if d.Creator == "" { + return errors.New("Creator cannot be empty.") + } + + return nil +} diff --git a/x/pnft/types/errors.go b/x/pnft/types/errors.go new file mode 100644 index 00000000..3be66181 --- /dev/null +++ b/x/pnft/types/errors.go @@ -0,0 +1,12 @@ +package types + +import "cosmossdk.io/errors" + +var ( + ErrCreateDenom = errors.Register(ModuleName, 1, "Error creating denom") + ErrUpdateDenom = errors.Register(ModuleName, 2, "Error updating denom") + ErrDeleteDenom = errors.Register(ModuleName, 3, "Error deleting denom") + + ErrTransferDenom = errors.Register(ModuleName, 4, "Error transfer denom") + ErrGetDenom = errors.Register(ModuleName, 5, "Error get denom") +) diff --git a/x/pnft/types/event.pb.go b/x/pnft/types/event.pb.go new file mode 100644 index 00000000..8f324f95 --- /dev/null +++ b/x/pnft/types/event.pb.go @@ -0,0 +1,1086 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: panacea/pnft/v2/event.proto + +package types + +import ( + fmt "fmt" + 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 + +type EventSaveDenom struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Creator string `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"` +} + +func (m *EventSaveDenom) Reset() { *m = EventSaveDenom{} } +func (m *EventSaveDenom) String() string { return proto.CompactTextString(m) } +func (*EventSaveDenom) ProtoMessage() {} +func (*EventSaveDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_c2aab2ec5131034c, []int{0} +} +func (m *EventSaveDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventSaveDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventSaveDenom.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 *EventSaveDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventSaveDenom.Merge(m, src) +} +func (m *EventSaveDenom) XXX_Size() int { + return m.Size() +} +func (m *EventSaveDenom) XXX_DiscardUnknown() { + xxx_messageInfo_EventSaveDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_EventSaveDenom proto.InternalMessageInfo + +func (m *EventSaveDenom) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *EventSaveDenom) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +type EventUpdateDenom struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Updater string `protobuf:"bytes,2,opt,name=updater,proto3" json:"updater,omitempty"` +} + +func (m *EventUpdateDenom) Reset() { *m = EventUpdateDenom{} } +func (m *EventUpdateDenom) String() string { return proto.CompactTextString(m) } +func (*EventUpdateDenom) ProtoMessage() {} +func (*EventUpdateDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_c2aab2ec5131034c, []int{1} +} +func (m *EventUpdateDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventUpdateDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventUpdateDenom.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 *EventUpdateDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventUpdateDenom.Merge(m, src) +} +func (m *EventUpdateDenom) XXX_Size() int { + return m.Size() +} +func (m *EventUpdateDenom) XXX_DiscardUnknown() { + xxx_messageInfo_EventUpdateDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_EventUpdateDenom proto.InternalMessageInfo + +func (m *EventUpdateDenom) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *EventUpdateDenom) GetUpdater() string { + if m != nil { + return m.Updater + } + return "" +} + +type EventDeleteDenom struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Remover string `protobuf:"bytes,2,opt,name=remover,proto3" json:"remover,omitempty"` +} + +func (m *EventDeleteDenom) Reset() { *m = EventDeleteDenom{} } +func (m *EventDeleteDenom) String() string { return proto.CompactTextString(m) } +func (*EventDeleteDenom) ProtoMessage() {} +func (*EventDeleteDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_c2aab2ec5131034c, []int{2} +} +func (m *EventDeleteDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventDeleteDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventDeleteDenom.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 *EventDeleteDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventDeleteDenom.Merge(m, src) +} +func (m *EventDeleteDenom) XXX_Size() int { + return m.Size() +} +func (m *EventDeleteDenom) XXX_DiscardUnknown() { + xxx_messageInfo_EventDeleteDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_EventDeleteDenom proto.InternalMessageInfo + +func (m *EventDeleteDenom) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *EventDeleteDenom) GetRemover() string { + if m != nil { + return m.Remover + } + return "" +} + +type EventTransferDenom struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Sender string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"` + Receiver string `protobuf:"bytes,3,opt,name=receiver,proto3" json:"receiver,omitempty"` +} + +func (m *EventTransferDenom) Reset() { *m = EventTransferDenom{} } +func (m *EventTransferDenom) String() string { return proto.CompactTextString(m) } +func (*EventTransferDenom) ProtoMessage() {} +func (*EventTransferDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_c2aab2ec5131034c, []int{3} +} +func (m *EventTransferDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventTransferDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventTransferDenom.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 *EventTransferDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventTransferDenom.Merge(m, src) +} +func (m *EventTransferDenom) XXX_Size() int { + return m.Size() +} +func (m *EventTransferDenom) XXX_DiscardUnknown() { + xxx_messageInfo_EventTransferDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_EventTransferDenom proto.InternalMessageInfo + +func (m *EventTransferDenom) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *EventTransferDenom) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + +func (m *EventTransferDenom) GetReceiver() string { + if m != nil { + return m.Receiver + } + return "" +} + +func init() { + proto.RegisterType((*EventSaveDenom)(nil), "panacea.pnft.v2.EventSaveDenom") + proto.RegisterType((*EventUpdateDenom)(nil), "panacea.pnft.v2.EventUpdateDenom") + proto.RegisterType((*EventDeleteDenom)(nil), "panacea.pnft.v2.EventDeleteDenom") + proto.RegisterType((*EventTransferDenom)(nil), "panacea.pnft.v2.EventTransferDenom") +} + +func init() { proto.RegisterFile("panacea/pnft/v2/event.proto", fileDescriptor_c2aab2ec5131034c) } + +var fileDescriptor_c2aab2ec5131034c = []byte{ + // 261 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0xbf, 0x4a, 0x34, 0x31, + 0x14, 0x47, 0x27, 0xf3, 0xc1, 0x7e, 0x9a, 0x62, 0x95, 0x14, 0x32, 0x28, 0x04, 0x99, 0xca, 0x66, + 0x27, 0xb0, 0x76, 0x62, 0x25, 0x6b, 0x61, 0x27, 0xfe, 0x01, 0xb1, 0xcb, 0x24, 0x77, 0x35, 0xb0, + 0x93, 0x84, 0x4c, 0x36, 0xe8, 0x5b, 0xf8, 0x58, 0x96, 0x5b, 0x5a, 0xca, 0xcc, 0x8b, 0xc8, 0xc4, + 0x38, 0x36, 0x6a, 0x79, 0xee, 0xe1, 0xdc, 0xe2, 0x87, 0x0f, 0x2c, 0xd7, 0x5c, 0x00, 0x67, 0x56, + 0x2f, 0x3d, 0x0b, 0x73, 0x06, 0x01, 0xb4, 0xaf, 0xac, 0x33, 0xde, 0x90, 0x9d, 0x24, 0xab, 0x41, + 0x56, 0x61, 0x5e, 0x9e, 0xe0, 0xe9, 0xf9, 0xe0, 0xaf, 0x79, 0x80, 0x05, 0x68, 0xd3, 0x90, 0x29, + 0xce, 0x95, 0x2c, 0xd0, 0x21, 0x3a, 0xda, 0xbe, 0xca, 0x95, 0x24, 0x05, 0xfe, 0x2f, 0x1c, 0x70, + 0x6f, 0x5c, 0x91, 0xc7, 0xe3, 0x17, 0x96, 0xa7, 0x78, 0x37, 0xb6, 0xb7, 0x56, 0x72, 0xff, 0x7b, + 0xbd, 0x8e, 0x7a, 0xac, 0x13, 0x8e, 0xf5, 0x02, 0x56, 0xf0, 0x47, 0xed, 0xa0, 0x31, 0xe1, 0xbb, + 0x4e, 0x58, 0xde, 0x61, 0x12, 0xeb, 0x1b, 0xc7, 0x75, 0xbb, 0x04, 0xf7, 0x73, 0xbf, 0x87, 0x27, + 0x2d, 0x68, 0x39, 0xe6, 0x89, 0xc8, 0x3e, 0xde, 0x72, 0x20, 0x40, 0x0d, 0x8f, 0xff, 0x45, 0x33, + 0xf2, 0xd9, 0xc5, 0x6b, 0x47, 0xd1, 0xa6, 0xa3, 0xe8, 0xbd, 0xa3, 0xe8, 0xa5, 0xa7, 0xd9, 0xa6, + 0xa7, 0xd9, 0x5b, 0x4f, 0xb3, 0x4b, 0x74, 0x3f, 0x7b, 0x50, 0xfe, 0x71, 0x5d, 0x57, 0xc2, 0x34, + 0xac, 0x01, 0xa9, 0xea, 0x95, 0x11, 0x2c, 0x4d, 0x3a, 0x13, 0xc6, 0x01, 0x7b, 0xfa, 0x9c, 0xdd, + 0x3f, 0x5b, 0x68, 0xeb, 0x49, 0x1c, 0xfd, 0xf8, 0x23, 0x00, 0x00, 0xff, 0xff, 0xd2, 0x75, 0xc7, + 0x1c, 0x93, 0x01, 0x00, 0x00, +} + +func (m *EventSaveDenom) 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 *EventSaveDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventSaveDenom) 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 = encodeVarintEvent(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventUpdateDenom) 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 *EventUpdateDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventUpdateDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Updater) > 0 { + i -= len(m.Updater) + copy(dAtA[i:], m.Updater) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Updater))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventDeleteDenom) 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 *EventDeleteDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventDeleteDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Remover) > 0 { + i -= len(m.Remover) + copy(dAtA[i:], m.Remover) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Remover))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventTransferDenom) 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 *EventTransferDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventTransferDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Receiver) > 0 { + i -= len(m.Receiver) + copy(dAtA[i:], m.Receiver) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Receiver))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintEvent(dAtA []byte, offset int, v uint64) int { + offset -= sovEvent(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *EventSaveDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + return n +} + +func (m *EventUpdateDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.Updater) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + return n +} + +func (m *EventDeleteDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.Remover) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + return n +} + +func (m *EventTransferDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.Receiver) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + return n +} + +func sovEvent(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozEvent(x uint64) (n int) { + return sovEvent(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *EventSaveDenom) 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 ErrIntOverflowEvent + } + 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: EventSaveDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventSaveDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + 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 ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvent(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvent + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventUpdateDenom) 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 ErrIntOverflowEvent + } + 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: EventUpdateDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventUpdateDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Updater", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Updater = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvent(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvent + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventDeleteDenom) 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 ErrIntOverflowEvent + } + 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: EventDeleteDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventDeleteDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Remover", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Remover = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvent(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvent + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventTransferDenom) 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 ErrIntOverflowEvent + } + 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: EventTransferDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventTransferDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + 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 ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Receiver = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvent(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvent + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipEvent(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, ErrIntOverflowEvent + } + 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, ErrIntOverflowEvent + } + 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, ErrIntOverflowEvent + } + 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, ErrInvalidLengthEvent + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupEvent + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthEvent + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthEvent = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowEvent = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupEvent = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/pnft/types/genesis.go b/x/pnft/types/genesis.go new file mode 100644 index 00000000..e52b7928 --- /dev/null +++ b/x/pnft/types/genesis.go @@ -0,0 +1,17 @@ +package types + +func DefaultGenesis() *GenesisState { + return &GenesisState{ + Denoms: []*Denom{}, + } +} + +func (data GenesisState) ValidateBasic() error { + for _, denom := range data.Denoms { + if err := denom.ValidateBasic(); err != nil { + return err + } + } + + return nil +} diff --git a/x/pnft/types/genesis.pb.go b/x/pnft/types/genesis.pb.go new file mode 100644 index 00000000..4b250b94 --- /dev/null +++ b/x/pnft/types/genesis.pb.go @@ -0,0 +1,328 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: panacea/pnft/v2/genesis.proto + +package types + +import ( + fmt "fmt" + 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 nft module's genesis state. +type GenesisState struct { + Denoms []*Denom `protobuf:"bytes,1,rep,name=denoms,proto3" json:"denoms,omitempty"` +} + +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_273b9fa0993f076c, []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) GetDenoms() []*Denom { + if m != nil { + return m.Denoms + } + return nil +} + +func init() { + proto.RegisterType((*GenesisState)(nil), "panacea.pnft.v2.GenesisState") +} + +func init() { proto.RegisterFile("panacea/pnft/v2/genesis.proto", fileDescriptor_273b9fa0993f076c) } + +var fileDescriptor_273b9fa0993f076c = []byte{ + // 186 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2d, 0x48, 0xcc, 0x4b, + 0x4c, 0x4e, 0x4d, 0xd4, 0x2f, 0xc8, 0x4b, 0x2b, 0xd1, 0x2f, 0x33, 0xd2, 0x4f, 0x4f, 0xcd, 0x4b, + 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x87, 0x4a, 0xeb, 0x81, 0xa4, + 0xf5, 0xca, 0x8c, 0xa4, 0xa4, 0xd0, 0xd5, 0x83, 0x25, 0xc0, 0x8a, 0x95, 0xec, 0xb8, 0x78, 0xdc, + 0x21, 0xba, 0x83, 0x4b, 0x12, 0x4b, 0x52, 0x85, 0xf4, 0xb8, 0xd8, 0x52, 0x52, 0xf3, 0xf2, 0x73, + 0x8b, 0x25, 0x18, 0x15, 0x98, 0x35, 0xb8, 0x8d, 0xc4, 0xf4, 0xd0, 0x4c, 0xd3, 0x73, 0x01, 0x49, + 0x07, 0x41, 0x55, 0x39, 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, 0x00, + 0x63, 0x94, 0x6e, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x6e, 0x6a, + 0x4a, 0x66, 0x52, 0x4e, 0x7e, 0xb2, 0x3e, 0xd4, 0x38, 0xdd, 0xe4, 0xfc, 0xa2, 0x54, 0xfd, 0x0a, + 0x88, 0x93, 0x4a, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0x2e, 0x32, 0x06, 0x04, 0x00, 0x00, + 0xff, 0xff, 0x63, 0x78, 0x50, 0xff, 0xdf, 0x00, 0x00, 0x00, +} + +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.Denoms) > 0 { + for iNdEx := len(m.Denoms) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Denoms[iNdEx].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 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 + if len(m.Denoms) > 0 { + for _, e := range m.Denoms { + l = e.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 Denoms", 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.Denoms = append(m.Denoms, &Denom{}) + if err := m.Denoms[len(m.Denoms)-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 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/pnft/types/keys.go b/x/pnft/types/keys.go new file mode 100644 index 00000000..65379020 --- /dev/null +++ b/x/pnft/types/keys.go @@ -0,0 +1,8 @@ +package types + +const ( + ModuleName = "pnft" + StoreKey = ModuleName + RouterKey = ModuleName + QuerierRoute = ModuleName +) diff --git a/x/pnft/types/message_denom.go b/x/pnft/types/message_denom.go new file mode 100644 index 00000000..8799cbf7 --- /dev/null +++ b/x/pnft/types/message_denom.go @@ -0,0 +1,213 @@ +package types + +import ( + "errors" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/google/uuid" +) + +func NewMsgServiceCreateDenomRequest( + symbol string, + name string, + description string, + uri string, + uriHash string, + creator string, + data string, +) *MsgServiceCreateDenomRequest { + return &MsgServiceCreateDenomRequest{ + Denom: &Denom{ + Id: uuid.New().String(), + Name: name, + Symbol: symbol, + Description: description, + Uri: uri, + UriHash: uriHash, + Creator: creator, + Data: data, + }, + } +} + +// GetSignBytes returns a byte array which is used to generate a signature for verifying DID ownership. +func (msg *MsgServiceCreateDenomRequest) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgServiceCreateDenomRequest) GetSigners() []sdk.AccAddress { + from, err := sdk.AccAddressFromBech32(msg.Denom.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{from} +} + +func (msg *MsgServiceCreateDenomRequest) ValidateBasic() error { + if msg.Denom == nil { + return errors.New("denom cannot be empty") + } + + if msg.Denom.Id == "" { + return errors.New("id cannot be empty") + } + + if msg.Denom.Name == "" { + return errors.New("name cannot be empty") + } + + if msg.Denom.Symbol == "" { + return errors.New("symbol cannot be empty") + } + + if msg.Denom.Creator == "" { + return errors.New("creator cannot be empty") + } + + if _, err := sdk.AccAddressFromBech32(msg.Denom.Creator); err != nil { + return err + } + + return nil +} + +func NewMsgServiceUpdateDenomRequest( + id string, + symbol string, + name string, + description string, + uri string, + uriHash string, + data string, + update string, +) *MsgServiceUpdateDenomRequest { + return &MsgServiceUpdateDenomRequest{ + Id: id, + Name: name, + Symbol: symbol, + Description: description, + Uri: uri, + UriHash: uriHash, + Data: data, + Updater: update, + } +} + +// GetSignBytes returns a byte array which is used to generate a signature for verifying DID ownership. +func (msg *MsgServiceUpdateDenomRequest) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgServiceUpdateDenomRequest) GetSigners() []sdk.AccAddress { + from, err := sdk.AccAddressFromBech32(msg.Updater) + if err != nil { + panic(err) + } + return []sdk.AccAddress{from} +} + +func (msg *MsgServiceUpdateDenomRequest) ValidateBasic() error { + if msg.Id == "" { + return errors.New("Id cannot be empty") + } + + if msg.Updater == "" { + return errors.New("updater cannot be empty") + } + + if _, err := sdk.AccAddressFromBech32(msg.Updater); err != nil { + return err + } + return nil +} + +func NewMsgServiceDeleteDenomRequest( + id string, + remover string, +) *MsgServiceDeleteDenomRequest { + return &MsgServiceDeleteDenomRequest{ + Id: id, + Remover: remover, + } +} + +// GetSignBytes returns a byte array which is used to generate a signature for verifying DID ownership. +func (msg *MsgServiceDeleteDenomRequest) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgServiceDeleteDenomRequest) GetSigners() []sdk.AccAddress { + from, err := sdk.AccAddressFromBech32(msg.Remover) + if err != nil { + panic(err) + } + return []sdk.AccAddress{from} +} + +func (msg *MsgServiceDeleteDenomRequest) ValidateBasic() error { + if msg.Id == "" { + return errors.New("id cannot be empty") + } + + if msg.Remover == "" { + return errors.New("remover cannot be empty") + } + + if _, err := sdk.AccAddressFromBech32(msg.Remover); err != nil { + return err + } + + return nil +} + +func NewMsgServiceTransferRequest( + id string, + sender string, + receiver string, +) *MsgServiceTransferDenomRequest { + return &MsgServiceTransferDenomRequest{ + Id: id, + Sender: sender, + Receiver: receiver, + } +} + +// GetSignBytes returns a byte array which is used to generate a signature for verifying DID ownership. +func (msg *MsgServiceTransferDenomRequest) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgServiceTransferDenomRequest) GetSigners() []sdk.AccAddress { + from, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + panic(err) + } + return []sdk.AccAddress{from} +} + +func (msg *MsgServiceTransferDenomRequest) ValidateBasic() error { + if msg.Id == "" { + return errors.New("id cannot be empty") + } + + if msg.Sender == "" { + return errors.New("sender cannot be empty") + } + + if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil { + return err + } + + if msg.Receiver == "" { + return errors.New("receiver cannot be empty") + } + + if _, err := sdk.AccAddressFromBech32(msg.Receiver); err != nil { + return err + } + + return nil +} diff --git a/x/pnft/types/pnft.pb.go b/x/pnft/types/pnft.pb.go new file mode 100644 index 00000000..39c8624f --- /dev/null +++ b/x/pnft/types/pnft.pb.go @@ -0,0 +1,900 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: panacea/pnft/v2/pnft.proto + +package types + +import ( + fmt "fmt" + 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 + +type Denom struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Symbol string `protobuf:"bytes,3,opt,name=symbol,proto3" json:"symbol,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + Uri string `protobuf:"bytes,5,opt,name=uri,proto3" json:"uri,omitempty"` + UriHash string `protobuf:"bytes,6,opt,name=uri_hash,json=uriHash,proto3" json:"uri_hash,omitempty"` + Creator string `protobuf:"bytes,7,opt,name=creator,proto3" json:"creator,omitempty"` + Data string `protobuf:"bytes,8,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *Denom) Reset() { *m = Denom{} } +func (m *Denom) String() string { return proto.CompactTextString(m) } +func (*Denom) ProtoMessage() {} +func (*Denom) Descriptor() ([]byte, []int) { + return fileDescriptor_a86f7bf121c1dcbb, []int{0} +} +func (m *Denom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Denom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Denom.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 *Denom) XXX_Merge(src proto.Message) { + xxx_messageInfo_Denom.Merge(m, src) +} +func (m *Denom) XXX_Size() int { + return m.Size() +} +func (m *Denom) XXX_DiscardUnknown() { + xxx_messageInfo_Denom.DiscardUnknown(m) +} + +var xxx_messageInfo_Denom proto.InternalMessageInfo + +func (m *Denom) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *Denom) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *Denom) GetSymbol() string { + if m != nil { + return m.Symbol + } + return "" +} + +func (m *Denom) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *Denom) GetUri() string { + if m != nil { + return m.Uri + } + return "" +} + +func (m *Denom) GetUriHash() string { + if m != nil { + return m.UriHash + } + return "" +} + +func (m *Denom) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *Denom) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +type DenomMeta struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + Data string `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *DenomMeta) Reset() { *m = DenomMeta{} } +func (m *DenomMeta) String() string { return proto.CompactTextString(m) } +func (*DenomMeta) ProtoMessage() {} +func (*DenomMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_a86f7bf121c1dcbb, []int{1} +} +func (m *DenomMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DenomMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DenomMeta.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 *DenomMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_DenomMeta.Merge(m, src) +} +func (m *DenomMeta) XXX_Size() int { + return m.Size() +} +func (m *DenomMeta) XXX_DiscardUnknown() { + xxx_messageInfo_DenomMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_DenomMeta proto.InternalMessageInfo + +func (m *DenomMeta) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *DenomMeta) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +func init() { + proto.RegisterType((*Denom)(nil), "panacea.pnft.v2.Denom") + proto.RegisterType((*DenomMeta)(nil), "panacea.pnft.v2.DenomMeta") +} + +func init() { proto.RegisterFile("panacea/pnft/v2/pnft.proto", fileDescriptor_a86f7bf121c1dcbb) } + +var fileDescriptor_a86f7bf121c1dcbb = []byte{ + // 284 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30, + 0x18, 0x84, 0xeb, 0xb4, 0x4d, 0x5a, 0x23, 0x01, 0xf2, 0x80, 0x0c, 0x83, 0x55, 0x75, 0x62, 0x69, + 0x22, 0x95, 0x89, 0x15, 0x31, 0xc0, 0x80, 0x84, 0x18, 0x59, 0xd0, 0x1f, 0xc7, 0x10, 0x4b, 0x4d, + 0x1c, 0xd9, 0x4e, 0x45, 0xdf, 0x82, 0x47, 0x62, 0x64, 0xec, 0xc8, 0x88, 0x92, 0x17, 0x41, 0xf9, + 0x13, 0x89, 0x0e, 0x4c, 0xbe, 0xff, 0x3b, 0x9d, 0x74, 0x3e, 0x7a, 0x51, 0x41, 0x09, 0x52, 0x41, + 0x52, 0x95, 0xaf, 0x3e, 0xd9, 0xae, 0xf1, 0x8d, 0x2b, 0x6b, 0xbc, 0x61, 0x27, 0x83, 0x17, 0x23, + 0xdb, 0xae, 0x97, 0x9f, 0x84, 0x4e, 0x6f, 0x55, 0x69, 0x0a, 0x76, 0x4c, 0x03, 0x9d, 0x71, 0xb2, + 0x20, 0x97, 0xf3, 0xa7, 0x40, 0x67, 0x8c, 0xd1, 0x49, 0x09, 0x85, 0xe2, 0x01, 0x12, 0xd4, 0xec, + 0x8c, 0x86, 0x6e, 0x57, 0xa4, 0x66, 0xc3, 0xc7, 0x48, 0x87, 0x8b, 0x2d, 0xe8, 0x51, 0xa6, 0x9c, + 0xb4, 0xba, 0xf2, 0xda, 0x94, 0x7c, 0x82, 0xe6, 0x21, 0x62, 0xa7, 0x74, 0x5c, 0x5b, 0xcd, 0xa7, + 0xe8, 0x74, 0x92, 0x9d, 0xd3, 0x59, 0x6d, 0xf5, 0x4b, 0x0e, 0x2e, 0xe7, 0x21, 0xe2, 0xa8, 0xb6, + 0xfa, 0x0e, 0x5c, 0xce, 0x38, 0x8d, 0xa4, 0x55, 0xe0, 0x8d, 0xe5, 0x51, 0xef, 0x0c, 0x67, 0x57, + 0x2a, 0x03, 0x0f, 0x7c, 0xd6, 0x97, 0xea, 0xf4, 0xf2, 0x9a, 0xce, 0xf1, 0x07, 0x0f, 0xca, 0xc3, + 0x61, 0x94, 0xfc, 0x1f, 0x0d, 0xfe, 0xa2, 0x37, 0xf7, 0x5f, 0x8d, 0x20, 0xfb, 0x46, 0x90, 0x9f, + 0x46, 0x90, 0x8f, 0x56, 0x8c, 0xf6, 0xad, 0x18, 0x7d, 0xb7, 0x62, 0xf4, 0x48, 0x9e, 0x57, 0x6f, + 0xda, 0xe7, 0x75, 0x1a, 0x4b, 0x53, 0x24, 0x85, 0xca, 0x74, 0xba, 0x31, 0x32, 0x19, 0xe6, 0x5b, + 0x49, 0x63, 0x55, 0xf2, 0xde, 0x2f, 0xec, 0x77, 0x95, 0x72, 0x69, 0x88, 0x03, 0x5f, 0xfd, 0x06, + 0x00, 0x00, 0xff, 0xff, 0xf9, 0xa0, 0x94, 0xd4, 0x7e, 0x01, 0x00, 0x00, +} + +func (m *Denom) 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 *Denom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Denom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x42 + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0x3a + } + if len(m.UriHash) > 0 { + i -= len(m.UriHash) + copy(dAtA[i:], m.UriHash) + i = encodeVarintPnft(dAtA, i, uint64(len(m.UriHash))) + i-- + dAtA[i] = 0x32 + } + if len(m.Uri) > 0 { + i -= len(m.Uri) + copy(dAtA[i:], m.Uri) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Uri))) + i-- + dAtA[i] = 0x2a + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x22 + } + if len(m.Symbol) > 0 { + i -= len(m.Symbol) + copy(dAtA[i:], m.Symbol) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Symbol))) + i-- + dAtA[i] = 0x1a + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DenomMeta) 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 *DenomMeta) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DenomMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintPnft(dAtA []byte, offset int, v uint64) int { + offset -= sovPnft(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Denom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + l = len(m.Symbol) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + l = len(m.Uri) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + l = len(m.UriHash) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + return n +} + +func (m *DenomMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovPnft(uint64(l)) + } + return n +} + +func sovPnft(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozPnft(x uint64) (n int) { + return sovPnft(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Denom) 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 ErrIntOverflowPnft + } + 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: Denom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Denom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Symbol = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uri", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Uri = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UriHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UriHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + 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 ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPnft(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPnft + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DenomMeta) 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 ErrIntOverflowPnft + } + 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: DenomMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DenomMeta: 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 ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPnft + } + 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 ErrInvalidLengthPnft + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPnft + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPnft(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPnft + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipPnft(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, ErrIntOverflowPnft + } + 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, ErrIntOverflowPnft + } + 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, ErrIntOverflowPnft + } + 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, ErrInvalidLengthPnft + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupPnft + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthPnft + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthPnft = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowPnft = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupPnft = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/pnft/types/query.pb.go b/x/pnft/types/query.pb.go new file mode 100644 index 00000000..ef3c8e85 --- /dev/null +++ b/x/pnft/types/query.pb.go @@ -0,0 +1,1454 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: panacea/pnft/v2/query.proto + +package types + +import ( + context "context" + fmt "fmt" + query "github.com/cosmos/cosmos-sdk/types/query" + 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 + +// QueryServiceDenomsRequest is the response type for the Query RPC method. +type QueryServiceDenomsRequest struct { + Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryServiceDenomsRequest) Reset() { *m = QueryServiceDenomsRequest{} } +func (m *QueryServiceDenomsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryServiceDenomsRequest) ProtoMessage() {} +func (*QueryServiceDenomsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_2ef03de89249ecec, []int{0} +} +func (m *QueryServiceDenomsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryServiceDenomsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryServiceDenomsRequest.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 *QueryServiceDenomsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryServiceDenomsRequest.Merge(m, src) +} +func (m *QueryServiceDenomsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryServiceDenomsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryServiceDenomsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryServiceDenomsRequest proto.InternalMessageInfo + +func (m *QueryServiceDenomsRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryServiceDenomsResponse is the response type for the Query RPC method. +type QueryServiceDenomsResponse struct { + Denoms []*Denom `protobuf:"bytes,1,rep,name=denoms,proto3" json:"denoms,omitempty"` + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryServiceDenomsResponse) Reset() { *m = QueryServiceDenomsResponse{} } +func (m *QueryServiceDenomsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryServiceDenomsResponse) ProtoMessage() {} +func (*QueryServiceDenomsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_2ef03de89249ecec, []int{1} +} +func (m *QueryServiceDenomsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryServiceDenomsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryServiceDenomsResponse.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 *QueryServiceDenomsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryServiceDenomsResponse.Merge(m, src) +} +func (m *QueryServiceDenomsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryServiceDenomsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryServiceDenomsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryServiceDenomsResponse proto.InternalMessageInfo + +func (m *QueryServiceDenomsResponse) GetDenoms() []*Denom { + if m != nil { + return m.Denoms + } + return nil +} + +func (m *QueryServiceDenomsResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryServiceDenomsByCreatorRequest is the response type for the Query RPC method. +type QueryServiceDenomsByCreatorRequest struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` +} + +func (m *QueryServiceDenomsByCreatorRequest) Reset() { *m = QueryServiceDenomsByCreatorRequest{} } +func (m *QueryServiceDenomsByCreatorRequest) String() string { return proto.CompactTextString(m) } +func (*QueryServiceDenomsByCreatorRequest) ProtoMessage() {} +func (*QueryServiceDenomsByCreatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_2ef03de89249ecec, []int{2} +} +func (m *QueryServiceDenomsByCreatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryServiceDenomsByCreatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryServiceDenomsByCreatorRequest.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 *QueryServiceDenomsByCreatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryServiceDenomsByCreatorRequest.Merge(m, src) +} +func (m *QueryServiceDenomsByCreatorRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryServiceDenomsByCreatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryServiceDenomsByCreatorRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryServiceDenomsByCreatorRequest proto.InternalMessageInfo + +func (m *QueryServiceDenomsByCreatorRequest) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +// QueryServiceDenomsByCreatorResponse is the response type for the Query RPC method. +type QueryServiceDenomsByCreatorResponse struct { + Denoms []*Denom `protobuf:"bytes,1,rep,name=denoms,proto3" json:"denoms,omitempty"` +} + +func (m *QueryServiceDenomsByCreatorResponse) Reset() { *m = QueryServiceDenomsByCreatorResponse{} } +func (m *QueryServiceDenomsByCreatorResponse) String() string { return proto.CompactTextString(m) } +func (*QueryServiceDenomsByCreatorResponse) ProtoMessage() {} +func (*QueryServiceDenomsByCreatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_2ef03de89249ecec, []int{3} +} +func (m *QueryServiceDenomsByCreatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryServiceDenomsByCreatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryServiceDenomsByCreatorResponse.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 *QueryServiceDenomsByCreatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryServiceDenomsByCreatorResponse.Merge(m, src) +} +func (m *QueryServiceDenomsByCreatorResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryServiceDenomsByCreatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryServiceDenomsByCreatorResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryServiceDenomsByCreatorResponse proto.InternalMessageInfo + +func (m *QueryServiceDenomsByCreatorResponse) GetDenoms() []*Denom { + if m != nil { + return m.Denoms + } + return nil +} + +// QueryServiceDenomRequest is the response type for the Query RPC method. +type QueryServiceDenomRequest struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *QueryServiceDenomRequest) Reset() { *m = QueryServiceDenomRequest{} } +func (m *QueryServiceDenomRequest) String() string { return proto.CompactTextString(m) } +func (*QueryServiceDenomRequest) ProtoMessage() {} +func (*QueryServiceDenomRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_2ef03de89249ecec, []int{4} +} +func (m *QueryServiceDenomRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryServiceDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryServiceDenomRequest.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 *QueryServiceDenomRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryServiceDenomRequest.Merge(m, src) +} +func (m *QueryServiceDenomRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryServiceDenomRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryServiceDenomRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryServiceDenomRequest proto.InternalMessageInfo + +func (m *QueryServiceDenomRequest) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +// QueryServiceDenomResponse is the response type for the Query RPC method. +type QueryServiceDenomResponse struct { + Denom *Denom `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` +} + +func (m *QueryServiceDenomResponse) Reset() { *m = QueryServiceDenomResponse{} } +func (m *QueryServiceDenomResponse) String() string { return proto.CompactTextString(m) } +func (*QueryServiceDenomResponse) ProtoMessage() {} +func (*QueryServiceDenomResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_2ef03de89249ecec, []int{5} +} +func (m *QueryServiceDenomResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryServiceDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryServiceDenomResponse.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 *QueryServiceDenomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryServiceDenomResponse.Merge(m, src) +} +func (m *QueryServiceDenomResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryServiceDenomResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryServiceDenomResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryServiceDenomResponse proto.InternalMessageInfo + +func (m *QueryServiceDenomResponse) GetDenom() *Denom { + if m != nil { + return m.Denom + } + return nil +} + +func init() { + proto.RegisterType((*QueryServiceDenomsRequest)(nil), "panacea.pnft.v2.QueryServiceDenomsRequest") + proto.RegisterType((*QueryServiceDenomsResponse)(nil), "panacea.pnft.v2.QueryServiceDenomsResponse") + proto.RegisterType((*QueryServiceDenomsByCreatorRequest)(nil), "panacea.pnft.v2.QueryServiceDenomsByCreatorRequest") + proto.RegisterType((*QueryServiceDenomsByCreatorResponse)(nil), "panacea.pnft.v2.QueryServiceDenomsByCreatorResponse") + proto.RegisterType((*QueryServiceDenomRequest)(nil), "panacea.pnft.v2.QueryServiceDenomRequest") + proto.RegisterType((*QueryServiceDenomResponse)(nil), "panacea.pnft.v2.QueryServiceDenomResponse") +} + +func init() { proto.RegisterFile("panacea/pnft/v2/query.proto", fileDescriptor_2ef03de89249ecec) } + +var fileDescriptor_2ef03de89249ecec = []byte{ + // 490 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x94, 0xcf, 0x6e, 0xd3, 0x30, + 0x1c, 0xc7, 0xeb, 0x4e, 0x2b, 0xc2, 0x43, 0x4c, 0xf2, 0x01, 0xb2, 0x30, 0x85, 0x2a, 0x20, 0x28, + 0x61, 0xb3, 0xb5, 0x8c, 0x33, 0x87, 0x81, 0x40, 0xbb, 0x8d, 0x22, 0x2e, 0xdc, 0x9c, 0xc4, 0x04, + 0x4b, 0xab, 0x9d, 0xc5, 0x6e, 0x45, 0x35, 0xed, 0x32, 0xf1, 0x00, 0x48, 0x88, 0xf7, 0xe0, 0x31, + 0xb8, 0x20, 0x4d, 0xe2, 0xc2, 0x11, 0xb5, 0x3c, 0x08, 0xaa, 0xed, 0xc0, 0x48, 0x1b, 0x56, 0x76, + 0x6b, 0xed, 0xef, 0x9f, 0x8f, 0xed, 0x9f, 0x02, 0x6f, 0x15, 0x54, 0xd0, 0x94, 0x51, 0x52, 0x88, + 0x37, 0x9a, 0x8c, 0x62, 0x72, 0x34, 0x64, 0xe5, 0x18, 0x17, 0xa5, 0xd4, 0x12, 0xad, 0xbb, 0x4d, + 0x3c, 0xdb, 0xc4, 0xa3, 0xd8, 0xdf, 0xcc, 0xa5, 0xcc, 0x0f, 0x19, 0xa1, 0x05, 0x27, 0x54, 0x08, + 0xa9, 0xa9, 0xe6, 0x52, 0x28, 0x2b, 0xf7, 0xa3, 0x54, 0xaa, 0x81, 0x54, 0x24, 0xa1, 0x8a, 0xd9, + 0x1c, 0x32, 0xda, 0x49, 0x98, 0xa6, 0x3b, 0xa4, 0xa0, 0x39, 0x17, 0x46, 0xec, 0xb4, 0x7e, 0xbd, + 0xd7, 0x54, 0x98, 0xbd, 0x30, 0x85, 0x1b, 0x2f, 0x66, 0xee, 0x97, 0xac, 0x1c, 0xf1, 0x94, 0x3d, + 0x65, 0x42, 0x0e, 0x54, 0x9f, 0x1d, 0x0d, 0x99, 0xd2, 0xe8, 0x19, 0x84, 0x7f, 0xc2, 0xbc, 0x76, + 0x17, 0xf4, 0xd6, 0xe2, 0x7b, 0xd8, 0x36, 0xe3, 0x59, 0x33, 0xb6, 0x27, 0x70, 0xcd, 0xf8, 0x80, + 0xe6, 0xcc, 0x79, 0xfb, 0xe7, 0x9c, 0xe1, 0x27, 0x00, 0xfd, 0x45, 0x2d, 0xaa, 0x90, 0x42, 0x31, + 0x84, 0x61, 0x27, 0x33, 0x2b, 0x1e, 0xe8, 0xae, 0xf4, 0xd6, 0xe2, 0x1b, 0xb8, 0x76, 0x17, 0xd8, + 0x18, 0xfa, 0x4e, 0x85, 0x9e, 0x2f, 0xc0, 0xba, 0x7f, 0x21, 0x96, 0x2d, 0xfb, 0x8b, 0xeb, 0x31, + 0x0c, 0xe7, 0xb1, 0xf6, 0xc6, 0x4f, 0x4a, 0x46, 0xb5, 0x2c, 0xab, 0x5b, 0xf0, 0xe0, 0x95, 0xd4, + 0xae, 0x78, 0xa0, 0x0b, 0x7a, 0x57, 0xfb, 0xd5, 0xdf, 0xf0, 0x15, 0xbc, 0xf3, 0x4f, 0xff, 0xe5, + 0xce, 0x17, 0x46, 0xd0, 0x9b, 0x8b, 0xad, 0x60, 0xae, 0xc3, 0x36, 0xcf, 0x1c, 0x47, 0x9b, 0x67, + 0xe1, 0xfe, 0x82, 0xf7, 0xfb, 0x5d, 0xbc, 0x05, 0x57, 0x4d, 0xa4, 0xd1, 0x37, 0xf7, 0x5a, 0x51, + 0xfc, 0x75, 0x05, 0x5e, 0x3b, 0x9f, 0x85, 0x4e, 0x01, 0xec, 0xd8, 0x33, 0xa1, 0x68, 0xce, 0xda, + 0x38, 0x35, 0xfe, 0xc3, 0xa5, 0xb4, 0x16, 0x31, 0xbc, 0x7d, 0xfa, 0xed, 0xe7, 0xc7, 0xf6, 0x06, + 0xba, 0x49, 0xea, 0x43, 0xea, 0x1e, 0xfb, 0x33, 0x80, 0xeb, 0xb5, 0x8b, 0x45, 0xbb, 0x4b, 0x34, + 0xd4, 0x9f, 0xd1, 0x7f, 0xf4, 0x7f, 0x26, 0xc7, 0x17, 0x1b, 0xbe, 0x2d, 0x14, 0x35, 0xf0, 0x11, + 0x37, 0x0b, 0x8a, 0x1c, 0xbb, 0x5f, 0x27, 0xe8, 0x3d, 0x80, 0xab, 0x26, 0x0f, 0x3d, 0xb8, 0xb8, + 0xb3, 0xc2, 0x8b, 0x96, 0x91, 0x3a, 0xa8, 0xbb, 0x06, 0x2a, 0x40, 0x9b, 0x4d, 0x50, 0xc7, 0x3c, + 0x3b, 0xd9, 0xdb, 0xff, 0x32, 0x09, 0xc0, 0xd9, 0x24, 0x00, 0x3f, 0x26, 0x01, 0xf8, 0x30, 0x0d, + 0x5a, 0x67, 0xd3, 0xa0, 0xf5, 0x7d, 0x1a, 0xb4, 0x0e, 0xc0, 0xeb, 0xed, 0x9c, 0xeb, 0xb7, 0xc3, + 0x04, 0xa7, 0x72, 0x40, 0x06, 0x2c, 0xe3, 0xc9, 0xa1, 0x4c, 0xab, 0xb0, 0xed, 0x54, 0x96, 0x8c, + 0xbc, 0xb3, 0x99, 0x7a, 0x5c, 0x30, 0x95, 0x74, 0xcc, 0xc7, 0x62, 0xf7, 0x57, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x14, 0x6e, 0xc6, 0x3f, 0xc2, 0x04, 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 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + // Denoms returns denom list. + Denoms(ctx context.Context, in *QueryServiceDenomsRequest, opts ...grpc.CallOption) (*QueryServiceDenomsResponse, error) + DenomsByCreator(ctx context.Context, in *QueryServiceDenomsByCreatorRequest, opts ...grpc.CallOption) (*QueryServiceDenomsByCreatorResponse, error) + // Denom returns denom detail. + Denom(ctx context.Context, in *QueryServiceDenomRequest, opts ...grpc.CallOption) (*QueryServiceDenomResponse, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) Denoms(ctx context.Context, in *QueryServiceDenomsRequest, opts ...grpc.CallOption) (*QueryServiceDenomsResponse, error) { + out := new(QueryServiceDenomsResponse) + err := c.cc.Invoke(ctx, "/panacea.pnft.v2.QueryService/Denoms", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) DenomsByCreator(ctx context.Context, in *QueryServiceDenomsByCreatorRequest, opts ...grpc.CallOption) (*QueryServiceDenomsByCreatorResponse, error) { + out := new(QueryServiceDenomsByCreatorResponse) + err := c.cc.Invoke(ctx, "/panacea.pnft.v2.QueryService/DenomsByCreator", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) Denom(ctx context.Context, in *QueryServiceDenomRequest, opts ...grpc.CallOption) (*QueryServiceDenomResponse, error) { + out := new(QueryServiceDenomResponse) + err := c.cc.Invoke(ctx, "/panacea.pnft.v2.QueryService/Denom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + // Denoms returns denom list. + Denoms(context.Context, *QueryServiceDenomsRequest) (*QueryServiceDenomsResponse, error) + DenomsByCreator(context.Context, *QueryServiceDenomsByCreatorRequest) (*QueryServiceDenomsByCreatorResponse, error) + // Denom returns denom detail. + Denom(context.Context, *QueryServiceDenomRequest) (*QueryServiceDenomResponse, error) +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) Denoms(ctx context.Context, req *QueryServiceDenomsRequest) (*QueryServiceDenomsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Denoms not implemented") +} +func (*UnimplementedQueryServiceServer) DenomsByCreator(ctx context.Context, req *QueryServiceDenomsByCreatorRequest) (*QueryServiceDenomsByCreatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DenomsByCreator not implemented") +} +func (*UnimplementedQueryServiceServer) Denom(ctx context.Context, req *QueryServiceDenomRequest) (*QueryServiceDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Denom not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_Denoms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryServiceDenomsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).Denoms(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/panacea.pnft.v2.QueryService/Denoms", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).Denoms(ctx, req.(*QueryServiceDenomsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_DenomsByCreator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryServiceDenomsByCreatorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).DenomsByCreator(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/panacea.pnft.v2.QueryService/DenomsByCreator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).DenomsByCreator(ctx, req.(*QueryServiceDenomsByCreatorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_Denom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryServiceDenomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).Denom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/panacea.pnft.v2.QueryService/Denom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).Denom(ctx, req.(*QueryServiceDenomRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "panacea.pnft.v2.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Denoms", + Handler: _QueryService_Denoms_Handler, + }, + { + MethodName: "DenomsByCreator", + Handler: _QueryService_DenomsByCreator_Handler, + }, + { + MethodName: "Denom", + Handler: _QueryService_Denom_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "panacea/pnft/v2/query.proto", +} + +func (m *QueryServiceDenomsRequest) 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 *QueryServiceDenomsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryServiceDenomsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *QueryServiceDenomsResponse) 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 *QueryServiceDenomsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryServiceDenomsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Denoms) > 0 { + for iNdEx := len(m.Denoms) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Denoms[iNdEx].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 *QueryServiceDenomsByCreatorRequest) 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 *QueryServiceDenomsByCreatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryServiceDenomsByCreatorRequest) 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 *QueryServiceDenomsByCreatorResponse) 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 *QueryServiceDenomsByCreatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryServiceDenomsByCreatorResponse) 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-- { + { + size, err := m.Denoms[iNdEx].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 *QueryServiceDenomRequest) 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 *QueryServiceDenomRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryServiceDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryServiceDenomResponse) 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 *QueryServiceDenomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryServiceDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Denom != nil { + { + size, err := m.Denom.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 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 *QueryServiceDenomsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryServiceDenomsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Denoms) > 0 { + for _, e := range m.Denoms { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryServiceDenomsByCreatorRequest) 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 *QueryServiceDenomsByCreatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Denoms) > 0 { + for _, e := range m.Denoms { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func (m *QueryServiceDenomRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryServiceDenomResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Denom != nil { + l = m.Denom.Size() + 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 *QueryServiceDenomsRequest) 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: QueryServiceDenomsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryServiceDenomsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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 m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.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 *QueryServiceDenomsResponse) 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: QueryServiceDenomsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryServiceDenomsResponse: 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 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 + } + m.Denoms = append(m.Denoms, &Denom{}) + if err := m.Denoms[len(m.Denoms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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 m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.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 *QueryServiceDenomsByCreatorRequest) 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: QueryServiceDenomsByCreatorRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryServiceDenomsByCreatorRequest: 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 *QueryServiceDenomsByCreatorResponse) 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: QueryServiceDenomsByCreatorResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryServiceDenomsByCreatorResponse: 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 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 + } + m.Denoms = append(m.Denoms, &Denom{}) + if err := m.Denoms[len(m.Denoms)-1].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 *QueryServiceDenomRequest) 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: QueryServiceDenomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryServiceDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = 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 *QueryServiceDenomResponse) 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: QueryServiceDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryServiceDenomResponse: 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 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 m.Denom == nil { + m.Denom = &Denom{} + } + if err := m.Denom.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 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/pnft/types/query.pb.gw.go b/x/pnft/types/query.pb.gw.go new file mode 100644 index 00000000..bf289e04 --- /dev/null +++ b/x/pnft/types/query.pb.gw.go @@ -0,0 +1,373 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: panacea/pnft/v2/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 + +var ( + filter_QueryService_Denoms_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_QueryService_Denoms_0(ctx context.Context, marshaler runtime.Marshaler, client QueryServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryServiceDenomsRequest + 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_QueryService_Denoms_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Denoms(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_QueryService_Denoms_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryServiceDenomsRequest + 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_QueryService_Denoms_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.Denoms(ctx, &protoReq) + return msg, metadata, err + +} + +func request_QueryService_DenomsByCreator_0(ctx context.Context, marshaler runtime.Marshaler, client QueryServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryServiceDenomsByCreatorRequest + 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.DenomsByCreator(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_QueryService_DenomsByCreator_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryServiceDenomsByCreatorRequest + 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.DenomsByCreator(ctx, &protoReq) + return msg, metadata, err + +} + +func request_QueryService_Denom_0(ctx context.Context, marshaler runtime.Marshaler, client QueryServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryServiceDenomRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + + protoReq.Id, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + + msg, err := client.Denom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_QueryService_Denom_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryServiceDenomRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + + protoReq.Id, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + + msg, err := server.Denom(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryServiceHandlerServer registers the http handlers for service QueryService to "mux". +// UnaryRPC :call QueryServiceServer 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 RegisterQueryServiceHandlerFromEndpoint instead. +func RegisterQueryServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServiceServer) error { + + mux.Handle("GET", pattern_QueryService_Denoms_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_QueryService_Denoms_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_QueryService_Denoms_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_QueryService_DenomsByCreator_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_QueryService_DenomsByCreator_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_QueryService_DenomsByCreator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_QueryService_Denom_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_QueryService_Denom_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_QueryService_Denom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryServiceHandlerFromEndpoint is same as RegisterQueryServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryServiceHandlerFromEndpoint(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 RegisterQueryServiceHandler(ctx, mux, conn) +} + +// RegisterQueryServiceHandler registers the http handlers for service QueryService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryServiceHandlerClient(ctx, mux, NewQueryServiceClient(conn)) +} + +// RegisterQueryServiceHandlerClient registers the http handlers for service QueryService +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryServiceClient" to call the correct interceptors. +func RegisterQueryServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryServiceClient) error { + + mux.Handle("GET", pattern_QueryService_Denoms_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_QueryService_Denoms_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_QueryService_Denoms_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_QueryService_DenomsByCreator_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_QueryService_DenomsByCreator_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_QueryService_DenomsByCreator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_QueryService_Denom_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_QueryService_Denom_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_QueryService_Denom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_QueryService_Denoms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"panacea", "pnft", "v2", "denoms"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_QueryService_DenomsByCreator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"panacea", "pnft", "v2", "denoms", "creators", "creator"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_QueryService_Denom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"panacea", "pnft", "v2", "denoms", "id"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_QueryService_Denoms_0 = runtime.ForwardResponseMessage + + forward_QueryService_DenomsByCreator_0 = runtime.ForwardResponseMessage + + forward_QueryService_Denom_0 = runtime.ForwardResponseMessage +) diff --git a/x/pnft/types/tx.pb.go b/x/pnft/types/tx.pb.go new file mode 100644 index 00000000..dfe0d465 --- /dev/null +++ b/x/pnft/types/tx.pb.go @@ -0,0 +1,2032 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: panacea/pnft/v2/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type MsgServiceCreateDenomRequest struct { + Denom *Denom `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` +} + +func (m *MsgServiceCreateDenomRequest) Reset() { *m = MsgServiceCreateDenomRequest{} } +func (m *MsgServiceCreateDenomRequest) String() string { return proto.CompactTextString(m) } +func (*MsgServiceCreateDenomRequest) ProtoMessage() {} +func (*MsgServiceCreateDenomRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_da49c5b4a63605b2, []int{0} +} +func (m *MsgServiceCreateDenomRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgServiceCreateDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgServiceCreateDenomRequest.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 *MsgServiceCreateDenomRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgServiceCreateDenomRequest.Merge(m, src) +} +func (m *MsgServiceCreateDenomRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgServiceCreateDenomRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgServiceCreateDenomRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgServiceCreateDenomRequest proto.InternalMessageInfo + +func (m *MsgServiceCreateDenomRequest) GetDenom() *Denom { + if m != nil { + return m.Denom + } + return nil +} + +type MsgServiceCreateDenomResponse struct { +} + +func (m *MsgServiceCreateDenomResponse) Reset() { *m = MsgServiceCreateDenomResponse{} } +func (m *MsgServiceCreateDenomResponse) String() string { return proto.CompactTextString(m) } +func (*MsgServiceCreateDenomResponse) ProtoMessage() {} +func (*MsgServiceCreateDenomResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_da49c5b4a63605b2, []int{1} +} +func (m *MsgServiceCreateDenomResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgServiceCreateDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgServiceCreateDenomResponse.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 *MsgServiceCreateDenomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgServiceCreateDenomResponse.Merge(m, src) +} +func (m *MsgServiceCreateDenomResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgServiceCreateDenomResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgServiceCreateDenomResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgServiceCreateDenomResponse proto.InternalMessageInfo + +type MsgServiceUpdateDenomRequest struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Symbol string `protobuf:"bytes,3,opt,name=symbol,proto3" json:"symbol,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + Uri string `protobuf:"bytes,5,opt,name=uri,proto3" json:"uri,omitempty"` + UriHash string `protobuf:"bytes,6,opt,name=uri_hash,json=uriHash,proto3" json:"uri_hash,omitempty"` + Data string `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"` + Updater string `protobuf:"bytes,8,opt,name=updater,proto3" json:"updater,omitempty"` +} + +func (m *MsgServiceUpdateDenomRequest) Reset() { *m = MsgServiceUpdateDenomRequest{} } +func (m *MsgServiceUpdateDenomRequest) String() string { return proto.CompactTextString(m) } +func (*MsgServiceUpdateDenomRequest) ProtoMessage() {} +func (*MsgServiceUpdateDenomRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_da49c5b4a63605b2, []int{2} +} +func (m *MsgServiceUpdateDenomRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgServiceUpdateDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgServiceUpdateDenomRequest.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 *MsgServiceUpdateDenomRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgServiceUpdateDenomRequest.Merge(m, src) +} +func (m *MsgServiceUpdateDenomRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgServiceUpdateDenomRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgServiceUpdateDenomRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgServiceUpdateDenomRequest proto.InternalMessageInfo + +func (m *MsgServiceUpdateDenomRequest) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *MsgServiceUpdateDenomRequest) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *MsgServiceUpdateDenomRequest) GetSymbol() string { + if m != nil { + return m.Symbol + } + return "" +} + +func (m *MsgServiceUpdateDenomRequest) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *MsgServiceUpdateDenomRequest) GetUri() string { + if m != nil { + return m.Uri + } + return "" +} + +func (m *MsgServiceUpdateDenomRequest) GetUriHash() string { + if m != nil { + return m.UriHash + } + return "" +} + +func (m *MsgServiceUpdateDenomRequest) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +func (m *MsgServiceUpdateDenomRequest) GetUpdater() string { + if m != nil { + return m.Updater + } + return "" +} + +type MsgServiceUpdateDenomResponse struct { +} + +func (m *MsgServiceUpdateDenomResponse) Reset() { *m = MsgServiceUpdateDenomResponse{} } +func (m *MsgServiceUpdateDenomResponse) String() string { return proto.CompactTextString(m) } +func (*MsgServiceUpdateDenomResponse) ProtoMessage() {} +func (*MsgServiceUpdateDenomResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_da49c5b4a63605b2, []int{3} +} +func (m *MsgServiceUpdateDenomResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgServiceUpdateDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgServiceUpdateDenomResponse.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 *MsgServiceUpdateDenomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgServiceUpdateDenomResponse.Merge(m, src) +} +func (m *MsgServiceUpdateDenomResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgServiceUpdateDenomResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgServiceUpdateDenomResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgServiceUpdateDenomResponse proto.InternalMessageInfo + +type MsgServiceDeleteDenomRequest struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Remover string `protobuf:"bytes,2,opt,name=remover,proto3" json:"remover,omitempty"` +} + +func (m *MsgServiceDeleteDenomRequest) Reset() { *m = MsgServiceDeleteDenomRequest{} } +func (m *MsgServiceDeleteDenomRequest) String() string { return proto.CompactTextString(m) } +func (*MsgServiceDeleteDenomRequest) ProtoMessage() {} +func (*MsgServiceDeleteDenomRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_da49c5b4a63605b2, []int{4} +} +func (m *MsgServiceDeleteDenomRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgServiceDeleteDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgServiceDeleteDenomRequest.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 *MsgServiceDeleteDenomRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgServiceDeleteDenomRequest.Merge(m, src) +} +func (m *MsgServiceDeleteDenomRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgServiceDeleteDenomRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgServiceDeleteDenomRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgServiceDeleteDenomRequest proto.InternalMessageInfo + +func (m *MsgServiceDeleteDenomRequest) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *MsgServiceDeleteDenomRequest) GetRemover() string { + if m != nil { + return m.Remover + } + return "" +} + +type MsgServiceDeleteDenomResponse struct { +} + +func (m *MsgServiceDeleteDenomResponse) Reset() { *m = MsgServiceDeleteDenomResponse{} } +func (m *MsgServiceDeleteDenomResponse) String() string { return proto.CompactTextString(m) } +func (*MsgServiceDeleteDenomResponse) ProtoMessage() {} +func (*MsgServiceDeleteDenomResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_da49c5b4a63605b2, []int{5} +} +func (m *MsgServiceDeleteDenomResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgServiceDeleteDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgServiceDeleteDenomResponse.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 *MsgServiceDeleteDenomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgServiceDeleteDenomResponse.Merge(m, src) +} +func (m *MsgServiceDeleteDenomResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgServiceDeleteDenomResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgServiceDeleteDenomResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgServiceDeleteDenomResponse proto.InternalMessageInfo + +type MsgServiceTransferDenomRequest struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Sender string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"` + Receiver string `protobuf:"bytes,3,opt,name=receiver,proto3" json:"receiver,omitempty"` +} + +func (m *MsgServiceTransferDenomRequest) Reset() { *m = MsgServiceTransferDenomRequest{} } +func (m *MsgServiceTransferDenomRequest) String() string { return proto.CompactTextString(m) } +func (*MsgServiceTransferDenomRequest) ProtoMessage() {} +func (*MsgServiceTransferDenomRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_da49c5b4a63605b2, []int{6} +} +func (m *MsgServiceTransferDenomRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgServiceTransferDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgServiceTransferDenomRequest.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 *MsgServiceTransferDenomRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgServiceTransferDenomRequest.Merge(m, src) +} +func (m *MsgServiceTransferDenomRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgServiceTransferDenomRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgServiceTransferDenomRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgServiceTransferDenomRequest proto.InternalMessageInfo + +func (m *MsgServiceTransferDenomRequest) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *MsgServiceTransferDenomRequest) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + +func (m *MsgServiceTransferDenomRequest) GetReceiver() string { + if m != nil { + return m.Receiver + } + return "" +} + +type MsgServiceTransferDenomResponse struct { +} + +func (m *MsgServiceTransferDenomResponse) Reset() { *m = MsgServiceTransferDenomResponse{} } +func (m *MsgServiceTransferDenomResponse) String() string { return proto.CompactTextString(m) } +func (*MsgServiceTransferDenomResponse) ProtoMessage() {} +func (*MsgServiceTransferDenomResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_da49c5b4a63605b2, []int{7} +} +func (m *MsgServiceTransferDenomResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgServiceTransferDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgServiceTransferDenomResponse.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 *MsgServiceTransferDenomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgServiceTransferDenomResponse.Merge(m, src) +} +func (m *MsgServiceTransferDenomResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgServiceTransferDenomResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgServiceTransferDenomResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgServiceTransferDenomResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgServiceCreateDenomRequest)(nil), "panacea.pnft.v2.MsgServiceCreateDenomRequest") + proto.RegisterType((*MsgServiceCreateDenomResponse)(nil), "panacea.pnft.v2.MsgServiceCreateDenomResponse") + proto.RegisterType((*MsgServiceUpdateDenomRequest)(nil), "panacea.pnft.v2.MsgServiceUpdateDenomRequest") + proto.RegisterType((*MsgServiceUpdateDenomResponse)(nil), "panacea.pnft.v2.MsgServiceUpdateDenomResponse") + proto.RegisterType((*MsgServiceDeleteDenomRequest)(nil), "panacea.pnft.v2.MsgServiceDeleteDenomRequest") + proto.RegisterType((*MsgServiceDeleteDenomResponse)(nil), "panacea.pnft.v2.MsgServiceDeleteDenomResponse") + proto.RegisterType((*MsgServiceTransferDenomRequest)(nil), "panacea.pnft.v2.MsgServiceTransferDenomRequest") + proto.RegisterType((*MsgServiceTransferDenomResponse)(nil), "panacea.pnft.v2.MsgServiceTransferDenomResponse") +} + +func init() { proto.RegisterFile("panacea/pnft/v2/tx.proto", fileDescriptor_da49c5b4a63605b2) } + +var fileDescriptor_da49c5b4a63605b2 = []byte{ + // 477 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xcf, 0x6e, 0xd3, 0x40, + 0x10, 0xc6, 0xe3, 0xa4, 0x4d, 0xc2, 0x44, 0xfc, 0xd1, 0x1e, 0xaa, 0xc5, 0x02, 0xb7, 0xe4, 0xc4, + 0x81, 0xd8, 0x28, 0xbc, 0x01, 0xf4, 0x50, 0x24, 0x90, 0x50, 0x81, 0x0b, 0x17, 0xb4, 0xf1, 0x4e, + 0x9b, 0x95, 0x62, 0xaf, 0xd9, 0x5d, 0x47, 0xed, 0x5b, 0xf0, 0x58, 0x88, 0x53, 0x6f, 0x70, 0x44, + 0xc9, 0x8b, 0xa0, 0xdd, 0x35, 0xad, 0x9d, 0xa4, 0xa6, 0xb7, 0x9d, 0x99, 0xcf, 0xf3, 0xdb, 0x6f, + 0x67, 0x64, 0xa0, 0x05, 0xcb, 0x59, 0x8a, 0x2c, 0x29, 0xf2, 0x33, 0x93, 0x2c, 0xa7, 0x89, 0xb9, + 0x88, 0x0b, 0x25, 0x8d, 0x24, 0x0f, 0xab, 0x4a, 0x6c, 0x2b, 0xf1, 0x72, 0x1a, 0x86, 0x9b, 0x52, + 0x57, 0x70, 0xe2, 0xf1, 0x3b, 0x78, 0xf2, 0x5e, 0x9f, 0x7f, 0x44, 0xb5, 0x14, 0x29, 0xbe, 0x51, + 0xc8, 0x0c, 0x1e, 0x63, 0x2e, 0xb3, 0x53, 0xfc, 0x56, 0xa2, 0x36, 0xe4, 0x05, 0xec, 0x73, 0x1b, + 0xd3, 0xe0, 0x28, 0x78, 0x3e, 0x9a, 0x1e, 0xc4, 0x1b, 0xcd, 0x63, 0xaf, 0xf6, 0xa2, 0xf1, 0x21, + 0x3c, 0xbd, 0xa5, 0x9b, 0x2e, 0x64, 0xae, 0x71, 0xfc, 0x2b, 0xa8, 0xf3, 0x3e, 0x17, 0x7c, 0x93, + 0xf7, 0x00, 0xba, 0x82, 0x3b, 0xd8, 0xbd, 0xd3, 0xae, 0xe0, 0x84, 0xc0, 0x5e, 0xce, 0x32, 0xa4, + 0x5d, 0x97, 0x71, 0x67, 0x72, 0x00, 0x7d, 0x7d, 0x99, 0xcd, 0xe4, 0x82, 0xf6, 0x5c, 0xb6, 0x8a, + 0xc8, 0x11, 0x8c, 0x38, 0xea, 0x54, 0x89, 0xc2, 0x08, 0x99, 0xd3, 0x3d, 0x57, 0xac, 0xa7, 0xc8, + 0x23, 0xe8, 0x95, 0x4a, 0xd0, 0x7d, 0x57, 0xb1, 0x47, 0xf2, 0x18, 0x86, 0xa5, 0x12, 0x5f, 0xe7, + 0x4c, 0xcf, 0x69, 0xdf, 0xa5, 0x07, 0xa5, 0x12, 0x27, 0x4c, 0xcf, 0x2d, 0x9a, 0x33, 0xc3, 0xe8, + 0xc0, 0xa3, 0xed, 0x99, 0x50, 0x18, 0x94, 0xee, 0xd2, 0x8a, 0x0e, 0x2b, 0xb5, 0x0f, 0x9b, 0xd6, + 0x1b, 0xc6, 0x2a, 0xeb, 0x27, 0x75, 0xe7, 0xc7, 0xb8, 0xc0, 0xff, 0x38, 0xa7, 0x30, 0x50, 0x98, + 0xc9, 0x25, 0xaa, 0xca, 0xfc, 0xbf, 0xb0, 0x89, 0x6a, 0x74, 0xaa, 0x50, 0x1c, 0xa2, 0x1b, 0xc1, + 0x27, 0xc5, 0x72, 0x7d, 0x86, 0xaa, 0x15, 0x66, 0x9f, 0x14, 0x73, 0x7e, 0xcd, 0xaa, 0x22, 0x12, + 0xc2, 0x50, 0x61, 0x8a, 0xc2, 0xde, 0xc2, 0x3f, 0xf6, 0x75, 0x3c, 0x7e, 0x06, 0x87, 0xb7, 0x52, + 0xfc, 0x45, 0xa6, 0x3f, 0x7b, 0x00, 0x37, 0x1a, 0xb2, 0x80, 0x51, 0x6d, 0x29, 0xc8, 0x64, 0x6b, + 0x99, 0xda, 0x56, 0x31, 0x8c, 0xef, 0x2a, 0xf7, 0x70, 0x4b, 0xab, 0xcd, 0xa1, 0x95, 0xb6, 0xbd, + 0x88, 0xad, 0xb4, 0x1d, 0xe3, 0xb5, 0xb4, 0xda, 0x28, 0x5a, 0x69, 0xdb, 0xc3, 0x6f, 0xa5, 0xed, + 0x98, 0x30, 0x51, 0x70, 0xbf, 0xf1, 0xe2, 0x24, 0x69, 0x69, 0xb0, 0x6b, 0x03, 0xc2, 0x97, 0x77, + 0xff, 0xc0, 0x33, 0x5f, 0xbf, 0xfd, 0xb1, 0x8a, 0x82, 0xab, 0x55, 0x14, 0xfc, 0x59, 0x45, 0xc1, + 0xf7, 0x75, 0xd4, 0xb9, 0x5a, 0x47, 0x9d, 0xdf, 0xeb, 0xa8, 0xf3, 0x21, 0xf8, 0x32, 0x39, 0x17, + 0x66, 0x5e, 0xce, 0xe2, 0x54, 0x66, 0x49, 0x86, 0x5c, 0xcc, 0x16, 0x32, 0x4d, 0x2a, 0xc0, 0x24, + 0x95, 0x0a, 0x93, 0x0b, 0xff, 0xf7, 0x31, 0x97, 0x05, 0xea, 0x59, 0xdf, 0xfd, 0x7c, 0x5e, 0xfd, + 0x0d, 0x00, 0x00, 0xff, 0xff, 0x8e, 0x20, 0x79, 0xb5, 0xc5, 0x04, 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 + +// MsgServiceClient is the client API for MsgService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgServiceClient interface { + CreateDenom(ctx context.Context, in *MsgServiceCreateDenomRequest, opts ...grpc.CallOption) (*MsgServiceCreateDenomResponse, error) + UpdateDenom(ctx context.Context, in *MsgServiceUpdateDenomRequest, opts ...grpc.CallOption) (*MsgServiceUpdateDenomResponse, error) + DeleteDenom(ctx context.Context, in *MsgServiceDeleteDenomRequest, opts ...grpc.CallOption) (*MsgServiceDeleteDenomResponse, error) + TransferDenom(ctx context.Context, in *MsgServiceTransferDenomRequest, opts ...grpc.CallOption) (*MsgServiceTransferDenomResponse, error) +} + +type msgServiceClient struct { + cc grpc1.ClientConn +} + +func NewMsgServiceClient(cc grpc1.ClientConn) MsgServiceClient { + return &msgServiceClient{cc} +} + +func (c *msgServiceClient) CreateDenom(ctx context.Context, in *MsgServiceCreateDenomRequest, opts ...grpc.CallOption) (*MsgServiceCreateDenomResponse, error) { + out := new(MsgServiceCreateDenomResponse) + err := c.cc.Invoke(ctx, "/panacea.pnft.v2.MsgService/CreateDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgServiceClient) UpdateDenom(ctx context.Context, in *MsgServiceUpdateDenomRequest, opts ...grpc.CallOption) (*MsgServiceUpdateDenomResponse, error) { + out := new(MsgServiceUpdateDenomResponse) + err := c.cc.Invoke(ctx, "/panacea.pnft.v2.MsgService/UpdateDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgServiceClient) DeleteDenom(ctx context.Context, in *MsgServiceDeleteDenomRequest, opts ...grpc.CallOption) (*MsgServiceDeleteDenomResponse, error) { + out := new(MsgServiceDeleteDenomResponse) + err := c.cc.Invoke(ctx, "/panacea.pnft.v2.MsgService/DeleteDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgServiceClient) TransferDenom(ctx context.Context, in *MsgServiceTransferDenomRequest, opts ...grpc.CallOption) (*MsgServiceTransferDenomResponse, error) { + out := new(MsgServiceTransferDenomResponse) + err := c.cc.Invoke(ctx, "/panacea.pnft.v2.MsgService/TransferDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServiceServer is the server API for MsgService service. +type MsgServiceServer interface { + CreateDenom(context.Context, *MsgServiceCreateDenomRequest) (*MsgServiceCreateDenomResponse, error) + UpdateDenom(context.Context, *MsgServiceUpdateDenomRequest) (*MsgServiceUpdateDenomResponse, error) + DeleteDenom(context.Context, *MsgServiceDeleteDenomRequest) (*MsgServiceDeleteDenomResponse, error) + TransferDenom(context.Context, *MsgServiceTransferDenomRequest) (*MsgServiceTransferDenomResponse, error) +} + +// UnimplementedMsgServiceServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServiceServer struct { +} + +func (*UnimplementedMsgServiceServer) CreateDenom(ctx context.Context, req *MsgServiceCreateDenomRequest) (*MsgServiceCreateDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateDenom not implemented") +} +func (*UnimplementedMsgServiceServer) UpdateDenom(ctx context.Context, req *MsgServiceUpdateDenomRequest) (*MsgServiceUpdateDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateDenom not implemented") +} +func (*UnimplementedMsgServiceServer) DeleteDenom(ctx context.Context, req *MsgServiceDeleteDenomRequest) (*MsgServiceDeleteDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteDenom not implemented") +} +func (*UnimplementedMsgServiceServer) TransferDenom(ctx context.Context, req *MsgServiceTransferDenomRequest) (*MsgServiceTransferDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TransferDenom not implemented") +} + +func RegisterMsgServiceServer(s grpc1.Server, srv MsgServiceServer) { + s.RegisterService(&_MsgService_serviceDesc, srv) +} + +func _MsgService_CreateDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgServiceCreateDenomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServiceServer).CreateDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/panacea.pnft.v2.MsgService/CreateDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServiceServer).CreateDenom(ctx, req.(*MsgServiceCreateDenomRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _MsgService_UpdateDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgServiceUpdateDenomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServiceServer).UpdateDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/panacea.pnft.v2.MsgService/UpdateDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServiceServer).UpdateDenom(ctx, req.(*MsgServiceUpdateDenomRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _MsgService_DeleteDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgServiceDeleteDenomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServiceServer).DeleteDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/panacea.pnft.v2.MsgService/DeleteDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServiceServer).DeleteDenom(ctx, req.(*MsgServiceDeleteDenomRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _MsgService_TransferDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgServiceTransferDenomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServiceServer).TransferDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/panacea.pnft.v2.MsgService/TransferDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServiceServer).TransferDenom(ctx, req.(*MsgServiceTransferDenomRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _MsgService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "panacea.pnft.v2.MsgService", + HandlerType: (*MsgServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateDenom", + Handler: _MsgService_CreateDenom_Handler, + }, + { + MethodName: "UpdateDenom", + Handler: _MsgService_UpdateDenom_Handler, + }, + { + MethodName: "DeleteDenom", + Handler: _MsgService_DeleteDenom_Handler, + }, + { + MethodName: "TransferDenom", + Handler: _MsgService_TransferDenom_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "panacea/pnft/v2/tx.proto", +} + +func (m *MsgServiceCreateDenomRequest) 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 *MsgServiceCreateDenomRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgServiceCreateDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Denom != nil { + { + size, err := m.Denom.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 *MsgServiceCreateDenomResponse) 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 *MsgServiceCreateDenomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgServiceCreateDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgServiceUpdateDenomRequest) 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 *MsgServiceUpdateDenomRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgServiceUpdateDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Updater) > 0 { + i -= len(m.Updater) + copy(dAtA[i:], m.Updater) + i = encodeVarintTx(dAtA, i, uint64(len(m.Updater))) + i-- + dAtA[i] = 0x42 + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x3a + } + if len(m.UriHash) > 0 { + i -= len(m.UriHash) + copy(dAtA[i:], m.UriHash) + i = encodeVarintTx(dAtA, i, uint64(len(m.UriHash))) + i-- + dAtA[i] = 0x32 + } + if len(m.Uri) > 0 { + i -= len(m.Uri) + copy(dAtA[i:], m.Uri) + i = encodeVarintTx(dAtA, i, uint64(len(m.Uri))) + i-- + dAtA[i] = 0x2a + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintTx(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x22 + } + if len(m.Symbol) > 0 { + i -= len(m.Symbol) + copy(dAtA[i:], m.Symbol) + i = encodeVarintTx(dAtA, i, uint64(len(m.Symbol))) + i-- + dAtA[i] = 0x1a + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintTx(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintTx(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgServiceUpdateDenomResponse) 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 *MsgServiceUpdateDenomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgServiceUpdateDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgServiceDeleteDenomRequest) 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 *MsgServiceDeleteDenomRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgServiceDeleteDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Remover) > 0 { + i -= len(m.Remover) + copy(dAtA[i:], m.Remover) + i = encodeVarintTx(dAtA, i, uint64(len(m.Remover))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintTx(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgServiceDeleteDenomResponse) 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 *MsgServiceDeleteDenomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgServiceDeleteDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgServiceTransferDenomRequest) 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 *MsgServiceTransferDenomRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgServiceTransferDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Receiver) > 0 { + i -= len(m.Receiver) + copy(dAtA[i:], m.Receiver) + i = encodeVarintTx(dAtA, i, uint64(len(m.Receiver))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintTx(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgServiceTransferDenomResponse) 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 *MsgServiceTransferDenomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgServiceTransferDenomResponse) 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 *MsgServiceCreateDenomRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Denom != nil { + l = m.Denom.Size() + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgServiceCreateDenomResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgServiceUpdateDenomRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Symbol) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Uri) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.UriHash) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Updater) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgServiceUpdateDenomResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgServiceDeleteDenomRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Remover) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgServiceDeleteDenomResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgServiceTransferDenomRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Receiver) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgServiceTransferDenomResponse) 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 *MsgServiceCreateDenomRequest) 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: MsgServiceCreateDenomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgServiceCreateDenomRequest: 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 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 m.Denom == nil { + m.Denom = &Denom{} + } + if err := m.Denom.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 *MsgServiceCreateDenomResponse) 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: MsgServiceCreateDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgServiceCreateDenomResponse: 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 *MsgServiceUpdateDenomRequest) 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: MsgServiceUpdateDenomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgServiceUpdateDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Symbol", 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.Symbol = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uri", 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.Uri = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UriHash", 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.UriHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", 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.Data = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Updater", 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.Updater = 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 *MsgServiceUpdateDenomResponse) 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: MsgServiceUpdateDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgServiceUpdateDenomResponse: 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 *MsgServiceDeleteDenomRequest) 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: MsgServiceDeleteDenomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgServiceDeleteDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Remover", 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.Remover = 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 *MsgServiceDeleteDenomResponse) 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: MsgServiceDeleteDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgServiceDeleteDenomResponse: 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 *MsgServiceTransferDenomRequest) 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: MsgServiceTransferDenomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgServiceTransferDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = 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 *MsgServiceTransferDenomResponse) 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: MsgServiceTransferDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgServiceTransferDenomResponse: 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 d61f5fa07a9f25c89464969b5220ec0847c265a9 Mon Sep 17 00:00:00 2001 From: gyuguen Date: Sun, 10 Mar 2024 08:01:17 +0900 Subject: [PATCH 2/4] fix --- app/app.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/app/app.go b/app/app.go index 49033a99..b3903eb5 100644 --- a/app/app.go +++ b/app/app.go @@ -303,7 +303,7 @@ func New( upgradetypes.ModuleName, capabilitytypes.ModuleName, minttypes.ModuleName, distrtypes.ModuleName, slashingtypes.ModuleName, evidencetypes.ModuleName, stakingtypes.ModuleName, authtypes.ModuleName, banktypes.ModuleName, govtypes.ModuleName, crisistypes.ModuleName, genutiltypes.ModuleName, - authz.ModuleName, feegrant.ModuleName, nft.ModuleName, group.ModuleName, + authz.ModuleName, feegrant.ModuleName, group.ModuleName, paramstypes.ModuleName, vestingtypes.ModuleName, consensusparamtypes.ModuleName, ibcexported.ModuleName, ibctransfertypes.ModuleName, aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, pnfttypes.ModuleName, @@ -314,7 +314,7 @@ func New( capabilitytypes.ModuleName, authtypes.ModuleName, banktypes.ModuleName, distrtypes.ModuleName, slashingtypes.ModuleName, minttypes.ModuleName, genutiltypes.ModuleName, evidencetypes.ModuleName, authz.ModuleName, - feegrant.ModuleName, nft.ModuleName, group.ModuleName, + feegrant.ModuleName, group.ModuleName, paramstypes.ModuleName, upgradetypes.ModuleName, vestingtypes.ModuleName, consensusparamtypes.ModuleName, ibcexported.ModuleName, ibctransfertypes.ModuleName, aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, pnfttypes.ModuleName, @@ -330,7 +330,7 @@ func New( capabilitytypes.ModuleName, authtypes.ModuleName, banktypes.ModuleName, distrtypes.ModuleName, stakingtypes.ModuleName, slashingtypes.ModuleName, govtypes.ModuleName, minttypes.ModuleName, crisistypes.ModuleName, genutiltypes.ModuleName, evidencetypes.ModuleName, authz.ModuleName, - feegrant.ModuleName, nft.ModuleName, group.ModuleName, paramstypes.ModuleName, upgradetypes.ModuleName, + feegrant.ModuleName, group.ModuleName, paramstypes.ModuleName, upgradetypes.ModuleName, vestingtypes.ModuleName, consensusparamtypes.ModuleName, ibcexported.ModuleName, ibctransfertypes.ModuleName, aoltypes.ModuleName, didtypes.ModuleName, burntypes.ModuleName, pnfttypes.ModuleName, From 517403d196ba1fefa600cade0c577ba6233a12ec Mon Sep 17 00:00:00 2001 From: gyuguen Date: Sun, 10 Mar 2024 08:25:40 +0900 Subject: [PATCH 3/4] fix --- proto/panacea/pnft/v2/pnft.proto | 4 +- proto/panacea/pnft/v2/tx.proto | 9 +- x/pnft/client/cli/flags.go | 4 +- x/pnft/client/cli/tx_denom.go | 21 +- x/pnft/keeper/denom.go | 13 +- x/pnft/keeper/msg_server.go | 17 +- x/pnft/types/denom.go | 10 +- x/pnft/types/message_denom.go | 36 +-- x/pnft/types/pnft.pb.go | 78 +++--- x/pnft/types/tx.pb.go | 458 +++++++++++++++++++++++++++---- 10 files changed, 512 insertions(+), 138 deletions(-) diff --git a/proto/panacea/pnft/v2/pnft.proto b/proto/panacea/pnft/v2/pnft.proto index 710efaf2..c8ebc13b 100644 --- a/proto/panacea/pnft/v2/pnft.proto +++ b/proto/panacea/pnft/v2/pnft.proto @@ -11,11 +11,11 @@ message Denom { string description = 4; string uri = 5; string uri_hash = 6; - string creator = 7; + string owner = 7; string data = 8; } message DenomMeta { - string creator = 1; + string owner = 1; string data = 2; } diff --git a/proto/panacea/pnft/v2/tx.proto b/proto/panacea/pnft/v2/tx.proto index 8e383935..640b35d5 100644 --- a/proto/panacea/pnft/v2/tx.proto +++ b/proto/panacea/pnft/v2/tx.proto @@ -17,7 +17,14 @@ service MsgService { } message MsgServiceCreateDenomRequest { - panacea.pnft.v2.Denom denom = 1; + string id = 1; + string name = 2; + string symbol = 3; + string description = 4; + string uri = 5; + string uri_hash = 6; + string data = 7; + string creator = 8; } message MsgServiceCreateDenomResponse {} diff --git a/x/pnft/client/cli/flags.go b/x/pnft/client/cli/flags.go index b0761c89..d902b057 100644 --- a/x/pnft/client/cli/flags.go +++ b/x/pnft/client/cli/flags.go @@ -1,11 +1,11 @@ package cli const ( - FlagSymbol = "denom-symbol" + FlagDenomId = "denom-id" + FlagDenomSymbol = "denom-symbol" FlagDenomName = "denom-name" FlagDenomDescription = "denom-description" FlagDenomData = "denom-data" FlagDenomURI = "denom-uri" FlagDenomURIHash = "denom-uri-hash" - FlagDenomCreator = "denom-creator" ) diff --git a/x/pnft/client/cli/tx_denom.go b/x/pnft/client/cli/tx_denom.go index 82ecd60e..efd06d4e 100644 --- a/x/pnft/client/cli/tx_denom.go +++ b/x/pnft/client/cli/tx_denom.go @@ -6,6 +6,7 @@ import ( "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/client/tx" + "github.com/google/uuid" "github.com/medibloc/panacea-core/v2/x/pnft/types" "github.com/spf13/cobra" ) @@ -21,7 +22,17 @@ func NewCmdCreateDenom() *cobra.Command { return err } - symbol, err := cmd.Flags().GetString(FlagSymbol) + id, err := cmd.Flags().GetString(FlagDenomId) + + if err != nil { + return err + } + + if id == "" { + id = uuid.New().String() + } + + symbol, err := cmd.Flags().GetString(FlagDenomSymbol) if err != nil { return err } @@ -54,6 +65,7 @@ func NewCmdCreateDenom() *cobra.Command { creator := clientCtx.GetFromAddress().String() msg := types.NewMsgServiceCreateDenomRequest( + id, symbol, denomName, description, @@ -72,7 +84,8 @@ func NewCmdCreateDenom() *cobra.Command { } flags.AddTxFlagsToCmd(cmd) _ = cmd.MarkFlagRequired(FlagDenomName) - cmd.Flags().String(FlagSymbol, "", "Set the symbol for a Denom") + cmd.Flags().String(FlagDenomId, "", "Set the id for a Denom. If this value is empty, a random value will be generated") + cmd.Flags().String(FlagDenomSymbol, "", "Set the symbol for a Denom") cmd.Flags().String(FlagDenomName, "", "Set the name for a Denom") cmd.Flags().String(FlagDenomDescription, "", "Set the description for a Denom") cmd.Flags().String(FlagDenomURI, "", "Set the URI for a Denom") @@ -94,7 +107,7 @@ func NewCmdUpdateDenom() *cobra.Command { denomId := args[0] - symbol, err := cmd.Flags().GetString(FlagSymbol) + symbol, err := cmd.Flags().GetString(FlagDenomSymbol) if err != nil { return err } @@ -146,7 +159,7 @@ func NewCmdUpdateDenom() *cobra.Command { } flags.AddTxFlagsToCmd(cmd) _ = cmd.MarkFlagRequired(FlagDenomName) - cmd.Flags().String(FlagSymbol, "", "Set the symbol for a Denom") + cmd.Flags().String(FlagDenomSymbol, "", "Set the symbol for a Denom") cmd.Flags().String(FlagDenomName, "", "Set the name for a Denom") cmd.Flags().String(FlagDenomDescription, "", "Set the description for a Denom") cmd.Flags().String(FlagDenomURI, "", "Set the URI for a Denom") diff --git a/x/pnft/keeper/denom.go b/x/pnft/keeper/denom.go index 837397a3..2136b2dd 100644 --- a/x/pnft/keeper/denom.go +++ b/x/pnft/keeper/denom.go @@ -23,7 +23,7 @@ func (k Keeper) SaveDenom( return ctx.EventManager().EmitTypedEvent(&types.EventSaveDenom{ Id: denom.Id, - Creator: denom.Creator, + Creator: denom.Owner, }) } @@ -41,13 +41,14 @@ func (k Keeper) ParseDenoms(classes []*nft.Class) ([]*types.Denom, error) { return denoms, nil } -func (k Keeper) UpdateDenom(ctx sdk.Context, msg *types.Denom, updater string) error { +func (k Keeper) UpdateDenom(ctx sdk.Context, msg *types.Denom) error { denom, err := k.GetDenom(ctx, msg.GetId()) if err != nil { return err } - if updater != denom.Creator { + updater := msg.Owner + if updater != denom.Owner { return errors.New(fmt.Sprintf("permission denied: %s does not have permission to modify this resource.", updater)) } @@ -91,7 +92,7 @@ func (k Keeper) DeleteDenom(ctx sdk.Context, id string, remover string) error { return err } - if remover != denom.Creator { + if remover != denom.Owner { return errors.New(fmt.Sprintf("permission denied: %s does not have permission to remove this resource.", remover)) } @@ -115,11 +116,11 @@ func (k Keeper) TransferDenomOwner( return err } - if sender != denom.Creator { + if sender != denom.Owner { return errors.New(fmt.Sprintf("%s is not allowed transfer denom to %s", sender, receiver)) } - denom.Creator = receiver + denom.Owner = receiver class, err := types.NewClassFromDenom(k.cdc, denom) if err != nil { return err diff --git a/x/pnft/keeper/msg_server.go b/x/pnft/keeper/msg_server.go index 3ebc090c..88965faa 100644 --- a/x/pnft/keeper/msg_server.go +++ b/x/pnft/keeper/msg_server.go @@ -22,7 +22,19 @@ func (m msgServer) CreateDenom(goCtx context.Context, request *types.MsgServiceC return nil, err } - err := m.Keeper.SaveDenom(ctx, request.Denom) + err := m.Keeper.SaveDenom( + ctx, + &types.Denom{ + Id: request.Id, + Name: request.Name, + Symbol: request.Symbol, + Description: request.Description, + Uri: request.Uri, + UriHash: request.UriHash, + Owner: request.Creator, + Data: request.Data, + }, + ) if err != nil { return nil, errors.Wrapf(types.ErrCreateDenom, err.Error()) } @@ -45,10 +57,9 @@ func (m msgServer) UpdateDenom(goCtx context.Context, request *types.MsgServiceU Description: request.Description, Uri: request.Uri, UriHash: request.UriHash, - Creator: "", + Owner: request.Updater, Data: request.Data, }, - request.Updater, ); err != nil { return nil, errors.Wrapf(types.ErrUpdateDenom, err.Error()) } diff --git a/x/pnft/types/denom.go b/x/pnft/types/denom.go index 2d371ea0..23aafc05 100644 --- a/x/pnft/types/denom.go +++ b/x/pnft/types/denom.go @@ -10,8 +10,8 @@ import ( func NewClassFromDenom(cdc codec.BinaryCodec, denom *Denom) (*nft.Class, error) { meta, err := codectypes.NewAnyWithValue( &DenomMeta{ - Creator: denom.Creator, - Data: denom.Data, + Owner: denom.Owner, + Data: denom.Data, }) if err != nil { return nil, err @@ -41,7 +41,7 @@ func NewDenomFromClass(cdc codec.BinaryCodec, class *nft.Class) (*Denom, error) Description: class.Description, Uri: class.Uri, UriHash: class.UriHash, - Creator: meta.Creator, + Owner: meta.Owner, Data: meta.Data, }, nil } @@ -59,8 +59,8 @@ func (d Denom) ValidateBasic() error { return errors.New("Symbol cannot be empty.") } - if d.Creator == "" { - return errors.New("Creator cannot be empty.") + if d.Owner == "" { + return errors.New("Ower cannot be empty.") } return nil diff --git a/x/pnft/types/message_denom.go b/x/pnft/types/message_denom.go index 8799cbf7..60bc5cd8 100644 --- a/x/pnft/types/message_denom.go +++ b/x/pnft/types/message_denom.go @@ -3,10 +3,10 @@ package types import ( "errors" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/google/uuid" ) func NewMsgServiceCreateDenomRequest( + id string, symbol string, name string, description string, @@ -16,16 +16,14 @@ func NewMsgServiceCreateDenomRequest( data string, ) *MsgServiceCreateDenomRequest { return &MsgServiceCreateDenomRequest{ - Denom: &Denom{ - Id: uuid.New().String(), - Name: name, - Symbol: symbol, - Description: description, - Uri: uri, - UriHash: uriHash, - Creator: creator, - Data: data, - }, + Id: id, + Name: name, + Symbol: symbol, + Description: description, + Uri: uri, + UriHash: uriHash, + Data: data, + Creator: creator, } } @@ -36,7 +34,7 @@ func (msg *MsgServiceCreateDenomRequest) GetSignBytes() []byte { } func (msg *MsgServiceCreateDenomRequest) GetSigners() []sdk.AccAddress { - from, err := sdk.AccAddressFromBech32(msg.Denom.Creator) + from, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { panic(err) } @@ -44,27 +42,23 @@ func (msg *MsgServiceCreateDenomRequest) GetSigners() []sdk.AccAddress { } func (msg *MsgServiceCreateDenomRequest) ValidateBasic() error { - if msg.Denom == nil { - return errors.New("denom cannot be empty") - } - - if msg.Denom.Id == "" { + if msg.Id == "" { return errors.New("id cannot be empty") } - if msg.Denom.Name == "" { + if msg.Name == "" { return errors.New("name cannot be empty") } - if msg.Denom.Symbol == "" { + if msg.Symbol == "" { return errors.New("symbol cannot be empty") } - if msg.Denom.Creator == "" { + if msg.Creator == "" { return errors.New("creator cannot be empty") } - if _, err := sdk.AccAddressFromBech32(msg.Denom.Creator); err != nil { + if _, err := sdk.AccAddressFromBech32(msg.Creator); err != nil { return err } diff --git a/x/pnft/types/pnft.pb.go b/x/pnft/types/pnft.pb.go index 39c8624f..e1173ae4 100644 --- a/x/pnft/types/pnft.pb.go +++ b/x/pnft/types/pnft.pb.go @@ -29,7 +29,7 @@ type Denom struct { Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` Uri string `protobuf:"bytes,5,opt,name=uri,proto3" json:"uri,omitempty"` UriHash string `protobuf:"bytes,6,opt,name=uri_hash,json=uriHash,proto3" json:"uri_hash,omitempty"` - Creator string `protobuf:"bytes,7,opt,name=creator,proto3" json:"creator,omitempty"` + Owner string `protobuf:"bytes,7,opt,name=owner,proto3" json:"owner,omitempty"` Data string `protobuf:"bytes,8,opt,name=data,proto3" json:"data,omitempty"` } @@ -108,9 +108,9 @@ func (m *Denom) GetUriHash() string { return "" } -func (m *Denom) GetCreator() string { +func (m *Denom) GetOwner() string { if m != nil { - return m.Creator + return m.Owner } return "" } @@ -123,8 +123,8 @@ func (m *Denom) GetData() string { } type DenomMeta struct { - Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` - Data string `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` + Data string `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` } func (m *DenomMeta) Reset() { *m = DenomMeta{} } @@ -160,9 +160,9 @@ func (m *DenomMeta) XXX_DiscardUnknown() { var xxx_messageInfo_DenomMeta proto.InternalMessageInfo -func (m *DenomMeta) GetCreator() string { +func (m *DenomMeta) GetOwner() string { if m != nil { - return m.Creator + return m.Owner } return "" } @@ -183,24 +183,24 @@ func init() { proto.RegisterFile("panacea/pnft/v2/pnft.proto", fileDescriptor_a8 var fileDescriptor_a86f7bf121c1dcbb = []byte{ // 284 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30, - 0x18, 0x84, 0xeb, 0xb4, 0x4d, 0x5a, 0x23, 0x01, 0xf2, 0x80, 0x0c, 0x83, 0x55, 0x75, 0x62, 0x69, - 0x22, 0x95, 0x89, 0x15, 0x31, 0xc0, 0x80, 0x84, 0x18, 0x59, 0xd0, 0x1f, 0xc7, 0x10, 0x4b, 0x4d, - 0x1c, 0xd9, 0x4e, 0x45, 0xdf, 0x82, 0x47, 0x62, 0x64, 0xec, 0xc8, 0x88, 0x92, 0x17, 0x41, 0xf9, - 0x13, 0x89, 0x0e, 0x4c, 0xbe, 0xff, 0x3b, 0x9d, 0x74, 0x3e, 0x7a, 0x51, 0x41, 0x09, 0x52, 0x41, - 0x52, 0x95, 0xaf, 0x3e, 0xd9, 0xae, 0xf1, 0x8d, 0x2b, 0x6b, 0xbc, 0x61, 0x27, 0x83, 0x17, 0x23, - 0xdb, 0xae, 0x97, 0x9f, 0x84, 0x4e, 0x6f, 0x55, 0x69, 0x0a, 0x76, 0x4c, 0x03, 0x9d, 0x71, 0xb2, - 0x20, 0x97, 0xf3, 0xa7, 0x40, 0x67, 0x8c, 0xd1, 0x49, 0x09, 0x85, 0xe2, 0x01, 0x12, 0xd4, 0xec, - 0x8c, 0x86, 0x6e, 0x57, 0xa4, 0x66, 0xc3, 0xc7, 0x48, 0x87, 0x8b, 0x2d, 0xe8, 0x51, 0xa6, 0x9c, - 0xb4, 0xba, 0xf2, 0xda, 0x94, 0x7c, 0x82, 0xe6, 0x21, 0x62, 0xa7, 0x74, 0x5c, 0x5b, 0xcd, 0xa7, - 0xe8, 0x74, 0x92, 0x9d, 0xd3, 0x59, 0x6d, 0xf5, 0x4b, 0x0e, 0x2e, 0xe7, 0x21, 0xe2, 0xa8, 0xb6, - 0xfa, 0x0e, 0x5c, 0xce, 0x38, 0x8d, 0xa4, 0x55, 0xe0, 0x8d, 0xe5, 0x51, 0xef, 0x0c, 0x67, 0x57, - 0x2a, 0x03, 0x0f, 0x7c, 0xd6, 0x97, 0xea, 0xf4, 0xf2, 0x9a, 0xce, 0xf1, 0x07, 0x0f, 0xca, 0xc3, - 0x61, 0x94, 0xfc, 0x1f, 0x0d, 0xfe, 0xa2, 0x37, 0xf7, 0x5f, 0x8d, 0x20, 0xfb, 0x46, 0x90, 0x9f, - 0x46, 0x90, 0x8f, 0x56, 0x8c, 0xf6, 0xad, 0x18, 0x7d, 0xb7, 0x62, 0xf4, 0x48, 0x9e, 0x57, 0x6f, - 0xda, 0xe7, 0x75, 0x1a, 0x4b, 0x53, 0x24, 0x85, 0xca, 0x74, 0xba, 0x31, 0x32, 0x19, 0xe6, 0x5b, - 0x49, 0x63, 0x55, 0xf2, 0xde, 0x2f, 0xec, 0x77, 0x95, 0x72, 0x69, 0x88, 0x03, 0x5f, 0xfd, 0x06, - 0x00, 0x00, 0xff, 0xff, 0xf9, 0xa0, 0x94, 0xd4, 0x7e, 0x01, 0x00, 0x00, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4a, 0xc3, 0x40, + 0x18, 0x85, 0x33, 0x69, 0x93, 0xb6, 0xbf, 0xa0, 0x32, 0x88, 0x8c, 0x2e, 0x86, 0xd2, 0x95, 0x9b, + 0x26, 0x50, 0xf1, 0x02, 0xe2, 0x42, 0x17, 0x82, 0xb8, 0x74, 0x23, 0x93, 0x64, 0x34, 0x03, 0xcd, + 0x4c, 0x98, 0x4c, 0xaa, 0xbd, 0x85, 0x07, 0xf2, 0x00, 0x2e, 0xbb, 0x74, 0x29, 0xc9, 0x45, 0x24, + 0x7f, 0x02, 0x75, 0xe1, 0xea, 0x7f, 0xff, 0xf7, 0x78, 0xf0, 0x78, 0x70, 0x5e, 0x0a, 0x2d, 0x52, + 0x29, 0xe2, 0x52, 0xbf, 0xb8, 0x78, 0xb3, 0xc2, 0x1b, 0x95, 0xd6, 0x38, 0x43, 0x8f, 0x06, 0x2f, + 0x42, 0xb6, 0x59, 0x2d, 0x3e, 0x09, 0x04, 0x37, 0x52, 0x9b, 0x82, 0x1e, 0x82, 0xaf, 0x32, 0x46, + 0xe6, 0xe4, 0x62, 0xf6, 0xe8, 0xab, 0x8c, 0x52, 0x18, 0x6b, 0x51, 0x48, 0xe6, 0x23, 0x41, 0x4d, + 0x4f, 0x21, 0xac, 0xb6, 0x45, 0x62, 0xd6, 0x6c, 0x84, 0x74, 0xf8, 0xe8, 0x1c, 0x0e, 0x32, 0x59, + 0xa5, 0x56, 0x95, 0x4e, 0x19, 0xcd, 0xc6, 0x68, 0xfe, 0x45, 0xf4, 0x18, 0x46, 0xb5, 0x55, 0x2c, + 0x40, 0xa7, 0x93, 0xf4, 0x0c, 0xa6, 0xb5, 0x55, 0xcf, 0xb9, 0xa8, 0x72, 0x16, 0x22, 0x9e, 0xd4, + 0x56, 0xdd, 0x8a, 0x2a, 0xa7, 0x27, 0x10, 0x98, 0x37, 0x2d, 0x2d, 0x9b, 0x20, 0xef, 0x9f, 0xae, + 0x50, 0x26, 0x9c, 0x60, 0xd3, 0xbe, 0x50, 0xa7, 0x17, 0x57, 0x30, 0xc3, 0xf6, 0xf7, 0xd2, 0x89, + 0x7d, 0x8c, 0xfc, 0x17, 0xf3, 0xf7, 0xb1, 0xeb, 0xbb, 0xaf, 0x86, 0x93, 0x5d, 0xc3, 0xc9, 0x4f, + 0xc3, 0xc9, 0x47, 0xcb, 0xbd, 0x5d, 0xcb, 0xbd, 0xef, 0x96, 0x7b, 0x0f, 0xe4, 0x69, 0xf9, 0xaa, + 0x5c, 0x5e, 0x27, 0x51, 0x6a, 0x8a, 0xb8, 0x90, 0x99, 0x4a, 0xd6, 0x26, 0x8d, 0x87, 0xd9, 0x96, + 0xa9, 0xb1, 0x32, 0x7e, 0xef, 0x97, 0x75, 0xdb, 0x52, 0x56, 0x49, 0x88, 0xc3, 0x5e, 0xfe, 0x06, + 0x00, 0x00, 0xff, 0xff, 0xa2, 0x5a, 0x4b, 0x88, 0x76, 0x01, 0x00, 0x00, } func (m *Denom) Marshal() (dAtA []byte, err error) { @@ -230,10 +230,10 @@ func (m *Denom) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x42 } - if len(m.Creator) > 0 { - i -= len(m.Creator) - copy(dAtA[i:], m.Creator) - i = encodeVarintPnft(dAtA, i, uint64(len(m.Creator))) + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Owner))) i-- dAtA[i] = 0x3a } @@ -309,10 +309,10 @@ func (m *DenomMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if len(m.Creator) > 0 { - i -= len(m.Creator) - copy(dAtA[i:], m.Creator) - i = encodeVarintPnft(dAtA, i, uint64(len(m.Creator))) + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintPnft(dAtA, i, uint64(len(m.Owner))) i-- dAtA[i] = 0xa } @@ -360,7 +360,7 @@ func (m *Denom) Size() (n int) { if l > 0 { n += 1 + l + sovPnft(uint64(l)) } - l = len(m.Creator) + l = len(m.Owner) if l > 0 { n += 1 + l + sovPnft(uint64(l)) } @@ -377,7 +377,7 @@ func (m *DenomMeta) Size() (n int) { } var l int _ = l - l = len(m.Creator) + l = len(m.Owner) if l > 0 { n += 1 + l + sovPnft(uint64(l)) } @@ -617,7 +617,7 @@ func (m *Denom) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -645,7 +645,7 @@ func (m *Denom) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Creator = string(dAtA[iNdEx:postIndex]) + m.Owner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { @@ -731,7 +731,7 @@ func (m *DenomMeta) Unmarshal(dAtA []byte) error { switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -759,7 +759,7 @@ func (m *DenomMeta) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Creator = string(dAtA[iNdEx:postIndex]) + m.Owner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { diff --git a/x/pnft/types/tx.pb.go b/x/pnft/types/tx.pb.go index dfe0d465..1f1ef267 100644 --- a/x/pnft/types/tx.pb.go +++ b/x/pnft/types/tx.pb.go @@ -28,7 +28,14 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type MsgServiceCreateDenomRequest struct { - Denom *Denom `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Symbol string `protobuf:"bytes,3,opt,name=symbol,proto3" json:"symbol,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + Uri string `protobuf:"bytes,5,opt,name=uri,proto3" json:"uri,omitempty"` + UriHash string `protobuf:"bytes,6,opt,name=uri_hash,json=uriHash,proto3" json:"uri_hash,omitempty"` + Data string `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"` + Creator string `protobuf:"bytes,8,opt,name=creator,proto3" json:"creator,omitempty"` } func (m *MsgServiceCreateDenomRequest) Reset() { *m = MsgServiceCreateDenomRequest{} } @@ -64,11 +71,60 @@ func (m *MsgServiceCreateDenomRequest) XXX_DiscardUnknown() { var xxx_messageInfo_MsgServiceCreateDenomRequest proto.InternalMessageInfo -func (m *MsgServiceCreateDenomRequest) GetDenom() *Denom { +func (m *MsgServiceCreateDenomRequest) GetId() string { if m != nil { - return m.Denom + return m.Id } - return nil + return "" +} + +func (m *MsgServiceCreateDenomRequest) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *MsgServiceCreateDenomRequest) GetSymbol() string { + if m != nil { + return m.Symbol + } + return "" +} + +func (m *MsgServiceCreateDenomRequest) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *MsgServiceCreateDenomRequest) GetUri() string { + if m != nil { + return m.Uri + } + return "" +} + +func (m *MsgServiceCreateDenomRequest) GetUriHash() string { + if m != nil { + return m.UriHash + } + return "" +} + +func (m *MsgServiceCreateDenomRequest) GetData() string { + if m != nil { + return m.Data + } + return "" +} + +func (m *MsgServiceCreateDenomRequest) GetCreator() string { + if m != nil { + return m.Creator + } + return "" } type MsgServiceCreateDenomResponse struct { @@ -441,37 +497,37 @@ func init() { func init() { proto.RegisterFile("panacea/pnft/v2/tx.proto", fileDescriptor_da49c5b4a63605b2) } var fileDescriptor_da49c5b4a63605b2 = []byte{ - // 477 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xcf, 0x6e, 0xd3, 0x40, - 0x10, 0xc6, 0xe3, 0xa4, 0x4d, 0xc2, 0x44, 0xfc, 0xd1, 0x1e, 0xaa, 0xc5, 0x02, 0xb7, 0xe4, 0xc4, - 0x81, 0xd8, 0x28, 0xbc, 0x01, 0xf4, 0x50, 0x24, 0x90, 0x50, 0x81, 0x0b, 0x17, 0xb4, 0xf1, 0x4e, - 0x9b, 0x95, 0x62, 0xaf, 0xd9, 0x5d, 0x47, 0xed, 0x5b, 0xf0, 0x58, 0x88, 0x53, 0x6f, 0x70, 0x44, - 0xc9, 0x8b, 0xa0, 0xdd, 0x35, 0xad, 0x9d, 0xa4, 0xa6, 0xb7, 0x9d, 0x99, 0xcf, 0xf3, 0xdb, 0x6f, - 0x67, 0x64, 0xa0, 0x05, 0xcb, 0x59, 0x8a, 0x2c, 0x29, 0xf2, 0x33, 0x93, 0x2c, 0xa7, 0x89, 0xb9, - 0x88, 0x0b, 0x25, 0x8d, 0x24, 0x0f, 0xab, 0x4a, 0x6c, 0x2b, 0xf1, 0x72, 0x1a, 0x86, 0x9b, 0x52, - 0x57, 0x70, 0xe2, 0xf1, 0x3b, 0x78, 0xf2, 0x5e, 0x9f, 0x7f, 0x44, 0xb5, 0x14, 0x29, 0xbe, 0x51, - 0xc8, 0x0c, 0x1e, 0x63, 0x2e, 0xb3, 0x53, 0xfc, 0x56, 0xa2, 0x36, 0xe4, 0x05, 0xec, 0x73, 0x1b, - 0xd3, 0xe0, 0x28, 0x78, 0x3e, 0x9a, 0x1e, 0xc4, 0x1b, 0xcd, 0x63, 0xaf, 0xf6, 0xa2, 0xf1, 0x21, - 0x3c, 0xbd, 0xa5, 0x9b, 0x2e, 0x64, 0xae, 0x71, 0xfc, 0x2b, 0xa8, 0xf3, 0x3e, 0x17, 0x7c, 0x93, - 0xf7, 0x00, 0xba, 0x82, 0x3b, 0xd8, 0xbd, 0xd3, 0xae, 0xe0, 0x84, 0xc0, 0x5e, 0xce, 0x32, 0xa4, - 0x5d, 0x97, 0x71, 0x67, 0x72, 0x00, 0x7d, 0x7d, 0x99, 0xcd, 0xe4, 0x82, 0xf6, 0x5c, 0xb6, 0x8a, - 0xc8, 0x11, 0x8c, 0x38, 0xea, 0x54, 0x89, 0xc2, 0x08, 0x99, 0xd3, 0x3d, 0x57, 0xac, 0xa7, 0xc8, - 0x23, 0xe8, 0x95, 0x4a, 0xd0, 0x7d, 0x57, 0xb1, 0x47, 0xf2, 0x18, 0x86, 0xa5, 0x12, 0x5f, 0xe7, - 0x4c, 0xcf, 0x69, 0xdf, 0xa5, 0x07, 0xa5, 0x12, 0x27, 0x4c, 0xcf, 0x2d, 0x9a, 0x33, 0xc3, 0xe8, - 0xc0, 0xa3, 0xed, 0x99, 0x50, 0x18, 0x94, 0xee, 0xd2, 0x8a, 0x0e, 0x2b, 0xb5, 0x0f, 0x9b, 0xd6, - 0x1b, 0xc6, 0x2a, 0xeb, 0x27, 0x75, 0xe7, 0xc7, 0xb8, 0xc0, 0xff, 0x38, 0xa7, 0x30, 0x50, 0x98, - 0xc9, 0x25, 0xaa, 0xca, 0xfc, 0xbf, 0xb0, 0x89, 0x6a, 0x74, 0xaa, 0x50, 0x1c, 0xa2, 0x1b, 0xc1, - 0x27, 0xc5, 0x72, 0x7d, 0x86, 0xaa, 0x15, 0x66, 0x9f, 0x14, 0x73, 0x7e, 0xcd, 0xaa, 0x22, 0x12, - 0xc2, 0x50, 0x61, 0x8a, 0xc2, 0xde, 0xc2, 0x3f, 0xf6, 0x75, 0x3c, 0x7e, 0x06, 0x87, 0xb7, 0x52, - 0xfc, 0x45, 0xa6, 0x3f, 0x7b, 0x00, 0x37, 0x1a, 0xb2, 0x80, 0x51, 0x6d, 0x29, 0xc8, 0x64, 0x6b, - 0x99, 0xda, 0x56, 0x31, 0x8c, 0xef, 0x2a, 0xf7, 0x70, 0x4b, 0xab, 0xcd, 0xa1, 0x95, 0xb6, 0xbd, - 0x88, 0xad, 0xb4, 0x1d, 0xe3, 0xb5, 0xb4, 0xda, 0x28, 0x5a, 0x69, 0xdb, 0xc3, 0x6f, 0xa5, 0xed, - 0x98, 0x30, 0x51, 0x70, 0xbf, 0xf1, 0xe2, 0x24, 0x69, 0x69, 0xb0, 0x6b, 0x03, 0xc2, 0x97, 0x77, - 0xff, 0xc0, 0x33, 0x5f, 0xbf, 0xfd, 0xb1, 0x8a, 0x82, 0xab, 0x55, 0x14, 0xfc, 0x59, 0x45, 0xc1, - 0xf7, 0x75, 0xd4, 0xb9, 0x5a, 0x47, 0x9d, 0xdf, 0xeb, 0xa8, 0xf3, 0x21, 0xf8, 0x32, 0x39, 0x17, - 0x66, 0x5e, 0xce, 0xe2, 0x54, 0x66, 0x49, 0x86, 0x5c, 0xcc, 0x16, 0x32, 0x4d, 0x2a, 0xc0, 0x24, - 0x95, 0x0a, 0x93, 0x0b, 0xff, 0xf7, 0x31, 0x97, 0x05, 0xea, 0x59, 0xdf, 0xfd, 0x7c, 0x5e, 0xfd, - 0x0d, 0x00, 0x00, 0xff, 0xff, 0x8e, 0x20, 0x79, 0xb5, 0xc5, 0x04, 0x00, 0x00, + // 470 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x94, 0xcf, 0x72, 0xd3, 0x30, + 0x10, 0xc6, 0xe3, 0xa4, 0x24, 0x61, 0x3b, 0xfc, 0x19, 0x1d, 0x18, 0xe1, 0x01, 0xb7, 0xe4, 0xc4, + 0x25, 0x36, 0x13, 0xde, 0x00, 0x7a, 0x28, 0x07, 0x66, 0x98, 0x02, 0x17, 0x2e, 0x8c, 0x62, 0x6f, + 0x1b, 0xcd, 0xc4, 0x92, 0x91, 0x64, 0x4f, 0xfb, 0x16, 0x3c, 0x16, 0xc3, 0xa9, 0x37, 0x38, 0x32, + 0xc9, 0x8b, 0x30, 0x92, 0x45, 0x6a, 0xa7, 0xa9, 0xe9, 0xb5, 0x37, 0xed, 0xee, 0x67, 0xff, 0xf6, + 0xd3, 0x4a, 0x02, 0x5a, 0x30, 0xc1, 0x52, 0x64, 0x49, 0x21, 0x4e, 0x4d, 0x52, 0xcd, 0x12, 0x73, + 0x1e, 0x17, 0x4a, 0x1a, 0x49, 0x1e, 0xf9, 0x4a, 0x6c, 0x2b, 0x71, 0x35, 0x0b, 0xc3, 0x6d, 0xa9, + 0x2b, 0x38, 0xf1, 0xe4, 0x57, 0x00, 0xcf, 0xde, 0xeb, 0xb3, 0x8f, 0xa8, 0x2a, 0x9e, 0xe2, 0x5b, + 0x85, 0xcc, 0xe0, 0x11, 0x0a, 0x99, 0x9f, 0xe0, 0xb7, 0x12, 0xb5, 0x21, 0x0f, 0xa1, 0xcf, 0x33, + 0x1a, 0x1c, 0x06, 0x2f, 0xef, 0x9f, 0xf4, 0x79, 0x46, 0x08, 0xec, 0x09, 0x96, 0x23, 0xed, 0xbb, + 0x8c, 0x5b, 0x93, 0x27, 0x30, 0xd4, 0x17, 0xf9, 0x5c, 0x2e, 0xe9, 0xc0, 0x65, 0x7d, 0x44, 0x0e, + 0x61, 0x3f, 0x43, 0x9d, 0x2a, 0x5e, 0x18, 0x2e, 0x05, 0xdd, 0x73, 0xc5, 0x66, 0x8a, 0x3c, 0x86, + 0x41, 0xa9, 0x38, 0xbd, 0xe7, 0x2a, 0x76, 0x49, 0x9e, 0xc2, 0xb8, 0x54, 0xfc, 0xeb, 0x82, 0xe9, + 0x05, 0x1d, 0xba, 0xf4, 0xa8, 0x54, 0xfc, 0x98, 0xe9, 0x85, 0x45, 0x67, 0xcc, 0x30, 0x3a, 0xaa, + 0xd1, 0x76, 0x4d, 0x28, 0x8c, 0x52, 0xdb, 0xb4, 0x54, 0x74, 0x5c, 0xab, 0x7d, 0x38, 0x39, 0x80, + 0xe7, 0x37, 0x18, 0xd3, 0x85, 0x14, 0x1a, 0xb7, 0xac, 0x7f, 0x2e, 0xb2, 0xbb, 0x67, 0xbd, 0x74, + 0x4d, 0x6f, 0xac, 0xfb, 0xb0, 0x6d, 0xbd, 0x65, 0xcc, 0x5b, 0x3f, 0x6e, 0x3a, 0x3f, 0xc2, 0x25, + 0xfe, 0xc7, 0x39, 0x85, 0x91, 0xc2, 0x5c, 0x56, 0xa8, 0xbc, 0xf9, 0x7f, 0x61, 0x1b, 0xd5, 0xfa, + 0x93, 0x47, 0x65, 0x10, 0x5d, 0x09, 0x3e, 0x29, 0x26, 0xf4, 0x29, 0xaa, 0x4e, 0x98, 0xdd, 0x52, + 0x14, 0xd9, 0x86, 0xe5, 0x23, 0x12, 0xc2, 0x58, 0x61, 0x8a, 0xdc, 0x76, 0x51, 0x6f, 0xf6, 0x26, + 0x9e, 0xbc, 0x80, 0x83, 0x1b, 0x29, 0x75, 0x23, 0xb3, 0x9f, 0x03, 0x80, 0x2b, 0x0d, 0x59, 0xc2, + 0x7e, 0xe3, 0x50, 0x90, 0x69, 0xbc, 0x75, 0x6b, 0xe2, 0xae, 0x5b, 0x11, 0xc6, 0xb7, 0x95, 0xd7, + 0x70, 0x4b, 0x6b, 0xcc, 0xa1, 0x93, 0x76, 0xfd, 0x20, 0x76, 0xd2, 0x76, 0x8c, 0xd7, 0xd2, 0x1a, + 0xa3, 0xe8, 0xa4, 0x5d, 0x1f, 0x7e, 0x27, 0x6d, 0xc7, 0x84, 0x89, 0x82, 0x07, 0xad, 0x1d, 0x27, + 0x49, 0xc7, 0x0f, 0x76, 0x9d, 0x80, 0xf0, 0xd5, 0xed, 0x3f, 0xa8, 0x99, 0x6f, 0xde, 0xfd, 0x58, + 0x45, 0xc1, 0xe5, 0x2a, 0x0a, 0xfe, 0xac, 0xa2, 0xe0, 0xfb, 0x3a, 0xea, 0x5d, 0xae, 0xa3, 0xde, + 0xef, 0x75, 0xd4, 0xfb, 0x10, 0x7c, 0x99, 0x9e, 0x71, 0xb3, 0x28, 0xe7, 0x71, 0x2a, 0xf3, 0x24, + 0xc7, 0x8c, 0xcf, 0x97, 0x32, 0x4d, 0x3c, 0x60, 0x9a, 0x4a, 0x85, 0xc9, 0x79, 0xfd, 0x12, 0x9a, + 0x8b, 0x02, 0xf5, 0x7c, 0xe8, 0x1e, 0xc2, 0xd7, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x17, 0x58, + 0xb9, 0x4c, 0x51, 0x05, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -682,15 +738,59 @@ func (m *MsgServiceCreateDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, e _ = i var l int _ = l - if m.Denom != nil { - { - size, err := m.Denom.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0x42 + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x3a + } + if len(m.UriHash) > 0 { + i -= len(m.UriHash) + copy(dAtA[i:], m.UriHash) + i = encodeVarintTx(dAtA, i, uint64(len(m.UriHash))) + i-- + dAtA[i] = 0x32 + } + if len(m.Uri) > 0 { + i -= len(m.Uri) + copy(dAtA[i:], m.Uri) + i = encodeVarintTx(dAtA, i, uint64(len(m.Uri))) + i-- + dAtA[i] = 0x2a + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintTx(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x22 + } + if len(m.Symbol) > 0 { + i -= len(m.Symbol) + copy(dAtA[i:], m.Symbol) + i = encodeVarintTx(dAtA, i, uint64(len(m.Symbol))) + i-- + dAtA[i] = 0x1a + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintTx(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintTx(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } @@ -966,8 +1066,36 @@ func (m *MsgServiceCreateDenomRequest) Size() (n int) { } var l int _ = l - if m.Denom != nil { - l = m.Denom.Size() + l = len(m.Id) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Symbol) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Uri) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.UriHash) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Creator) + if l > 0 { n += 1 + l + sovTx(uint64(l)) } return n @@ -1125,9 +1253,41 @@ func (m *MsgServiceCreateDenomRequest) Unmarshal(dAtA []byte) error { switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -1137,27 +1297,215 @@ func (m *MsgServiceCreateDenomRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Denom == nil { - m.Denom = &Denom{} + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType) } - if err := m.Denom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + 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.Symbol = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uri", 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.Uri = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UriHash", 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.UriHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", 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.Data = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + 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 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.Creator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex From 6bbf49a87929993ca18c8e0dc32789b49223bf2f Mon Sep 17 00:00:00 2001 From: gyuguen Date: Sun, 10 Mar 2024 08:38:15 +0900 Subject: [PATCH 4/4] fix lint --- x/pnft/client/cli/tx_denom.go | 9 ++++----- x/pnft/keeper/denom.go | 11 +++++------ 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/x/pnft/client/cli/tx_denom.go b/x/pnft/client/cli/tx_denom.go index efd06d4e..daf4a48c 100644 --- a/x/pnft/client/cli/tx_denom.go +++ b/x/pnft/client/cli/tx_denom.go @@ -2,7 +2,6 @@ package cli import ( sdkerrors "cosmossdk.io/errors" - "fmt" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/client/tx" @@ -14,7 +13,7 @@ import ( func NewCmdCreateDenom() *cobra.Command { cmd := &cobra.Command{ Use: "create-denom", - Long: fmt.Sprintf(`Create a new denom.`), + Long: "Create a new denom.", Args: cobra.ExactArgs(0), RunE: func(cmd *cobra.Command, args []string) error { clientCtx, err := client.GetClientTxContext(cmd) @@ -97,7 +96,7 @@ func NewCmdCreateDenom() *cobra.Command { func NewCmdUpdateDenom() *cobra.Command { cmd := &cobra.Command{ Use: "update-denom [denom-id]", - Long: fmt.Sprintf(`update a exist denom.`), + Long: "update a exist denom.", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { clientCtx, err := client.GetClientTxContext(cmd) @@ -171,7 +170,7 @@ func NewCmdUpdateDenom() *cobra.Command { func NewCmdDeleteDenom() *cobra.Command { cmd := &cobra.Command{ Use: "delete-denom [denom-id]", - Long: fmt.Sprintf(`delete a exist denom.`), + Long: "Delete a exist denom.", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { clientCtx, err := client.GetClientTxContext(cmd) @@ -199,7 +198,7 @@ func NewCmdDeleteDenom() *cobra.Command { func NewCmdTransferDenom() *cobra.Command { cmd := &cobra.Command{ Use: "transfer-denom [denom-id] [receiver]", - Long: fmt.Sprintf(`transfer denom owner to receiver.`), + Long: "Transfer denom owner to receiver.", Args: cobra.ExactArgs(2), RunE: func(cmd *cobra.Command, args []string) error { clientCtx, err := client.GetClientTxContext(cmd) diff --git a/x/pnft/keeper/denom.go b/x/pnft/keeper/denom.go index 2136b2dd..4802e2bd 100644 --- a/x/pnft/keeper/denom.go +++ b/x/pnft/keeper/denom.go @@ -1,7 +1,6 @@ package keeper import ( - "errors" "fmt" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/nft" @@ -28,7 +27,7 @@ func (k Keeper) SaveDenom( } func (k Keeper) ParseDenoms(classes []*nft.Class) ([]*types.Denom, error) { - denoms := []*types.Denom{} + var denoms []*types.Denom for _, class := range classes { denom, err := types.NewDenomFromClass(k.cdc, class) if err != nil { @@ -49,7 +48,7 @@ func (k Keeper) UpdateDenom(ctx sdk.Context, msg *types.Denom) error { updater := msg.Owner if updater != denom.Owner { - return errors.New(fmt.Sprintf("permission denied: %s does not have permission to modify this resource.", updater)) + return fmt.Errorf("permission denied: %s does not have permission to modify this resource", updater) } if msg.Name != "" { @@ -93,7 +92,7 @@ func (k Keeper) DeleteDenom(ctx sdk.Context, id string, remover string) error { } if remover != denom.Owner { - return errors.New(fmt.Sprintf("permission denied: %s does not have permission to remove this resource.", remover)) + return fmt.Errorf("permission denied: %s does not have permission to remove this resource", remover) } store := ctx.KVStore(k.storeKey) @@ -117,7 +116,7 @@ func (k Keeper) TransferDenomOwner( } if sender != denom.Owner { - return errors.New(fmt.Sprintf("%s is not allowed transfer denom to %s", sender, receiver)) + return fmt.Errorf("%s is not allowed transfer denom to %s", sender, receiver) } denom.Owner = receiver @@ -154,7 +153,7 @@ func (k Keeper) GetAllDenoms(ctx sdk.Context) ([]*types.Denom, error) { func (k Keeper) GetDenom(ctx sdk.Context, id string) (*types.Denom, error) { class, found := k.nftKeeper.GetClass(ctx, id) if !found { - return nil, errors.New("not found class.") + return nil, fmt.Errorf("not found class") } return types.NewDenomFromClass(k.cdc, &class)