From ffe8e06500e248b4e45097700c3b296131971084 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C4=90=E1=BB=97=20Vi=E1=BB=87t=20Ho=C3=A0ng?= Date: Thu, 21 Mar 2024 18:18:28 +0700 Subject: [PATCH 1/3] feat: permissioned creation of token metadata (#327) Co-authored-by: Trinity Co-authored-by: Michael Tsitrin <114929630+mtsitrin@users.noreply.github.com> Co-authored-by: zale144 Co-authored-by: Omri --- proto/denommetadata/genesis.proto | 14 + proto/denommetadata/params.proto | 13 + proto/denommetadata/query.proto | 26 + proto/denommetadata/tx.proto | 42 + proto/mint/v1beta1/genesis.proto | 0 {proto => scripts}/protocgen.sh | 13 +- testutil/app/app.go | 55 +- testutil/keepers/keepers.go | 8 +- .../proto/cosmos/bank/v1beta1/bank.proto | 54 + x/denommetadata/client/cli/query.go | 59 ++ x/denommetadata/client/cli/tx.go | 130 +++ x/denommetadata/genesis.go | 35 + x/denommetadata/keeper/grpc_query.go | 31 + x/denommetadata/keeper/grpc_query_test.go | 23 + x/denommetadata/keeper/keeper.go | 77 ++ x/denommetadata/keeper/keeper_test.go | 32 + x/denommetadata/keeper/msg_server.go | 73 ++ x/denommetadata/keeper/msg_server_test.go | 49 + x/denommetadata/module.go | 157 +++ x/denommetadata/testutils/testutils.go | 18 + x/denommetadata/types/codec.go | 60 ++ x/denommetadata/types/errors.go | 13 + x/denommetadata/types/expected_keeper.go | 13 + x/denommetadata/types/genesis.pb.go | 325 ++++++ x/denommetadata/types/hooks.go | 39 + x/denommetadata/types/keys.go | 12 + x/denommetadata/types/msg.go | 107 ++ x/denommetadata/types/params.go | 68 ++ x/denommetadata/types/params.pb.go | 326 ++++++ x/denommetadata/types/query.pb.go | 536 ++++++++++ x/denommetadata/types/query.pb.gw.go | 153 +++ x/denommetadata/types/tx.pb.go | 972 ++++++++++++++++++ x/epochs/types/query.pb.gw.go | 13 +- x/mint/types/params.go | 2 +- x/mint/types/query.pb.gw.go | 7 +- x/sequencers/types/query.pb.gw.go | 16 +- 36 files changed, 3539 insertions(+), 32 deletions(-) create mode 100644 proto/denommetadata/genesis.proto create mode 100644 proto/denommetadata/params.proto create mode 100644 proto/denommetadata/query.proto create mode 100644 proto/denommetadata/tx.proto mode change 100755 => 100644 proto/mint/v1beta1/genesis.proto rename {proto => scripts}/protocgen.sh (61%) create mode 100644 third_party/proto/cosmos/bank/v1beta1/bank.proto create mode 100644 x/denommetadata/client/cli/query.go create mode 100644 x/denommetadata/client/cli/tx.go create mode 100644 x/denommetadata/genesis.go create mode 100644 x/denommetadata/keeper/grpc_query.go create mode 100644 x/denommetadata/keeper/grpc_query_test.go create mode 100644 x/denommetadata/keeper/keeper.go create mode 100644 x/denommetadata/keeper/keeper_test.go create mode 100644 x/denommetadata/keeper/msg_server.go create mode 100644 x/denommetadata/keeper/msg_server_test.go create mode 100644 x/denommetadata/module.go create mode 100644 x/denommetadata/testutils/testutils.go create mode 100644 x/denommetadata/types/codec.go create mode 100644 x/denommetadata/types/errors.go create mode 100644 x/denommetadata/types/expected_keeper.go create mode 100644 x/denommetadata/types/genesis.pb.go create mode 100644 x/denommetadata/types/hooks.go create mode 100644 x/denommetadata/types/keys.go create mode 100644 x/denommetadata/types/msg.go create mode 100644 x/denommetadata/types/params.go create mode 100644 x/denommetadata/types/params.pb.go create mode 100644 x/denommetadata/types/query.pb.go create mode 100644 x/denommetadata/types/query.pb.gw.go create mode 100644 x/denommetadata/types/tx.pb.go diff --git a/proto/denommetadata/genesis.proto b/proto/denommetadata/genesis.proto new file mode 100644 index 00000000..bf15d583 --- /dev/null +++ b/proto/denommetadata/genesis.proto @@ -0,0 +1,14 @@ +syntax = "proto3"; +package rollapp.denommetadata.types; + +import "gogoproto/gogo.proto"; +import "denommetadata/params.proto"; +import "cosmos/staking/v1beta1/staking.proto"; + +option go_package = "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types"; + +// GenesisState defines the test module's genesis state. +message GenesisState { + // params are all parameters for the module + Params params = 1 [ (gogoproto.nullable) = false ]; +} diff --git a/proto/denommetadata/params.proto b/proto/denommetadata/params.proto new file mode 100644 index 00000000..e3d3b50b --- /dev/null +++ b/proto/denommetadata/params.proto @@ -0,0 +1,13 @@ +syntax = "proto3"; +package rollapp.denommetadata.types; +import "gogoproto/gogo.proto"; + +option go_package = "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types"; + +// Params defines the parameters for the module. +message Params { + // allowed_addresses defines the list of addresses authorized to use the + // module + repeated string allowed_addresses = 1 + [ (gogoproto.moretags) = "yaml:\"allowed_addresses\"" ]; +} diff --git a/proto/denommetadata/query.proto b/proto/denommetadata/query.proto new file mode 100644 index 00000000..f77bbcfa --- /dev/null +++ b/proto/denommetadata/query.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; +package rollapp.denommetadata.types; + +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "denommetadata/params.proto"; + +option go_package = "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types"; + +// Query defines the gRPC querier service. +service Query { + // Parameters retrieves the denom metadata module params + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = + "/dymensionxyz/dymension-rdk/denommetadata/params"; + } +} + +// QueryParamsRequest is request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is response type for the Query/Params RPC method. +message QueryParamsResponse { + // params holds all the parameters of this module. + Params params = 1 [ (gogoproto.nullable) = false ]; +} \ No newline at end of file diff --git a/proto/denommetadata/tx.proto b/proto/denommetadata/tx.proto new file mode 100644 index 00000000..215a368b --- /dev/null +++ b/proto/denommetadata/tx.proto @@ -0,0 +1,42 @@ +syntax = "proto3"; +package rollapp.denommetadata.types; + +import "gogoproto/gogo.proto"; +import "cosmos/bank/v1beta1/bank.proto"; + +import "denommetadata/params.proto"; + +option go_package = "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types"; + +// Msg defines the Msg service. +service Msg { + rpc CreateDenomMetadata(MsgCreateDenomMetadata) + returns (MsgCreateDenomMetadataResponse) {}; + + rpc UpdateDenomMetadata(MsgUpdateDenomMetadata) + returns (MsgUpdateDenomMetadataResponse) {}; +} + +// MsgCreateDenomMetadata defines a message that create the denom metadata. +message MsgCreateDenomMetadata { + // sender_address is the bech32 address of message sender. + string sender_address = 1; + cosmos.bank.v1beta1.Metadata token_metadata = 2 + [ (gogoproto.nullable) = false ]; +} + +// MsgCreateDenomMetadataResponse defines the MsgCreateDenomMetadata response +// type +message MsgCreateDenomMetadataResponse {} + +// MsgDistributeTokens defines a message that update the denom metadata. +message MsgUpdateDenomMetadata { + // sender_address is the bech32 address of message sender. + string sender_address = 1; + cosmos.bank.v1beta1.Metadata token_metadata = 2 + [ (gogoproto.nullable) = false ]; +} + +// MsgUpdateDenomMetadataResponse defines the MsgUpdateDenomMetadata response +// type +message MsgUpdateDenomMetadataResponse {} diff --git a/proto/mint/v1beta1/genesis.proto b/proto/mint/v1beta1/genesis.proto old mode 100755 new mode 100644 diff --git a/proto/protocgen.sh b/scripts/protocgen.sh similarity index 61% rename from proto/protocgen.sh rename to scripts/protocgen.sh index f9720e62..bc41bc07 100755 --- a/proto/protocgen.sh +++ b/scripts/protocgen.sh @@ -2,20 +2,9 @@ set -eo pipefail -protoc_gen_gocosmos() { - if ! grep "github.com/gogo/protobuf => github.com/regen-network/protobuf" go.mod &>/dev/null ; then - echo -e "\tPlease run this command from somewhere inside the cosmos-sdk folder." - return 1 - fi - - go get github.com/regen-network/cosmos-proto/protoc-gen-gocosmos@latest 2>/dev/null -} - -protoc_gen_gocosmos - proto_dirs=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) for dir in $proto_dirs; do - buf protoc \ + protoc \ -I "proto" \ -I "third_party/proto" \ --gocosmos_out=plugins=interfacetype+grpc,\ diff --git a/testutil/app/app.go b/testutil/app/app.go index 2d9c0979..7b21c58f 100644 --- a/testutil/app/app.go +++ b/testutil/app/app.go @@ -77,6 +77,10 @@ import ( mintkeeper "github.com/dymensionxyz/dymension-rdk/x/mint/keeper" minttypes "github.com/dymensionxyz/dymension-rdk/x/mint/types" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata" + denommetadatakeeper "github.com/dymensionxyz/dymension-rdk/x/denommetadata/keeper" + denommetadatatypes "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" + "github.com/dymensionxyz/dymension-rdk/x/epochs" epochskeeper "github.com/dymensionxyz/dymension-rdk/x/epochs/keeper" epochstypes "github.com/dymensionxyz/dymension-rdk/x/epochs/types" @@ -116,7 +120,7 @@ var ( kvstorekeys = []string{ authtypes.StoreKey, banktypes.StoreKey, stakingtypes.StoreKey, seqtypes.StoreKey, - minttypes.StoreKey, distrtypes.StoreKey, + minttypes.StoreKey, denommetadatatypes.StoreKey, distrtypes.StoreKey, govtypes.StoreKey, paramstypes.StoreKey, ibchost.StoreKey, upgradetypes.StoreKey, epochstypes.StoreKey, hubgentypes.StoreKey, @@ -154,6 +158,7 @@ var ( staking.AppModuleBasic{}, sequencers.AppModuleBasic{}, mint.AppModuleBasic{}, + denommetadata.AppModuleBasic{}, epochs.AppModuleBasic{}, distr.AppModuleBasic{}, gov.NewAppModuleBasic(getGovProposalHandlers()), @@ -196,20 +201,21 @@ type App struct { memKeys map[string]*storetypes.MemoryStoreKey // keepers - AccountKeeper authkeeper.AccountKeeper - BankKeeper bankkeeper.Keeper - CapabilityKeeper *capabilitykeeper.Keeper - StakingKeeper stakingkeeper.Keeper - SequencersKeeper seqkeeper.Keeper - MintKeeper mintkeeper.Keeper - EpochsKeeper epochskeeper.Keeper - DistrKeeper distrkeeper.Keeper - GovKeeper govkeeper.Keeper - HubGenesisKeeper hubgenkeeper.Keeper - UpgradeKeeper upgradekeeper.Keeper - ParamsKeeper paramskeeper.Keeper - IBCKeeper *ibckeeper.Keeper // IBC Keeper must be a pointer in the app, so we can SetRouter on it correctly - TransferKeeper ibctransferkeeper.Keeper + AccountKeeper authkeeper.AccountKeeper + BankKeeper bankkeeper.Keeper + CapabilityKeeper *capabilitykeeper.Keeper + StakingKeeper stakingkeeper.Keeper + SequencersKeeper seqkeeper.Keeper + MintKeeper mintkeeper.Keeper + DenommetadataKeeper denommetadatakeeper.Keeper + EpochsKeeper epochskeeper.Keeper + DistrKeeper distrkeeper.Keeper + GovKeeper govkeeper.Keeper + HubGenesisKeeper hubgenkeeper.Keeper + UpgradeKeeper upgradekeeper.Keeper + ParamsKeeper paramskeeper.Keeper + IBCKeeper *ibckeeper.Keeper // IBC Keeper must be a pointer in the app, so we can SetRouter on it correctly + TransferKeeper ibctransferkeeper.Keeper // make scoped keepers public for test purposes ScopedIBCKeeper capabilitykeeper.ScopedKeeper @@ -338,6 +344,20 @@ func NewRollapp( ), ) + app.DenommetadataKeeper = denommetadatakeeper.NewKeeper( + appCodec, + keys[denommetadatatypes.StoreKey], + app.BankKeeper, + nil, + app.GetSubspace(denommetadatatypes.ModuleName), + ) + // set hook for denom metadata keeper later + app.DenommetadataKeeper.SetHooks( + denommetadatatypes.NewMultiDenommetadataHooks( + // insert denom metadata hooks receivers here + ), + ) + app.DistrKeeper = distrkeeper.NewKeeper( appCodec, keys[distrtypes.StoreKey], app.GetSubspace(distrtypes.ModuleName), app.AccountKeeper, app.BankKeeper, &stakingKeeper, &app.SequencersKeeper, authtypes.FeeCollectorName, app.ModuleAccountAddrs(), @@ -436,6 +456,7 @@ func NewRollapp( capability.NewAppModule(appCodec, *app.CapabilityKeeper), gov.NewAppModule(appCodec, app.GovKeeper, app.AccountKeeper, app.BankKeeper), mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, app.BankKeeper), + denommetadata.NewAppModule(appCodec, app.DenommetadataKeeper, app.BankKeeper), distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper), staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper), sequencers.NewAppModule(appCodec, app.SequencersKeeper), @@ -458,6 +479,7 @@ func NewRollapp( upgradetypes.ModuleName, capabilitytypes.ModuleName, minttypes.ModuleName, + denommetadatatypes.ModuleName, distrtypes.ModuleName, stakingtypes.ModuleName, seqtypes.ModuleName, @@ -484,6 +506,7 @@ func NewRollapp( distrtypes.ModuleName, vestingtypes.ModuleName, minttypes.ModuleName, + denommetadatatypes.ModuleName, genutiltypes.ModuleName, epochstypes.ModuleName, paramstypes.ModuleName, @@ -511,6 +534,7 @@ func NewRollapp( vestingtypes.ModuleName, govtypes.ModuleName, minttypes.ModuleName, + denommetadatatypes.ModuleName, ibchost.ModuleName, genutiltypes.ModuleName, paramstypes.ModuleName, @@ -819,6 +843,7 @@ func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino paramsKeeper.Subspace(stakingtypes.ModuleName) paramsKeeper.Subspace(seqtypes.ModuleName) paramsKeeper.Subspace(minttypes.ModuleName) + paramsKeeper.Subspace(denommetadatatypes.ModuleName) paramsKeeper.Subspace(epochstypes.ModuleName) paramsKeeper.Subspace(distrtypes.ModuleName) paramsKeeper.Subspace(govtypes.ModuleName).WithKeyTable(govv1.ParamKeyTable()) diff --git a/testutil/keepers/keepers.go b/testutil/keepers/keepers.go index 07baf90f..df346579 100644 --- a/testutil/keepers/keepers.go +++ b/testutil/keepers/keepers.go @@ -5,11 +5,11 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" + denommetadatakeeper "github.com/dymensionxyz/dymension-rdk/x/denommetadata/keeper" epochkeeper "github.com/dymensionxyz/dymension-rdk/x/epochs/keeper" hubgenkeeper "github.com/dymensionxyz/dymension-rdk/x/hub-genesis/keeper" mintkeeper "github.com/dymensionxyz/dymension-rdk/x/mint/keeper" seqkeeper "github.com/dymensionxyz/dymension-rdk/x/sequencers/keeper" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" app "github.com/dymensionxyz/dymension-rdk/testutil/app" @@ -33,6 +33,12 @@ func NewTestMintKeeperFromApp(app *app.App) (*mintkeeper.Keeper, sdk.Context) { return k, ctx } +func NewTestDenommetadataKeeperFromApp(app *app.App) (*denommetadatakeeper.Keeper, sdk.Context) { + k := &app.DenommetadataKeeper + ctx := app.BaseApp.NewContext(false, tmproto.Header{Height: 1, ChainID: "rollapp-1", Time: time.Now().UTC()}) + return k, ctx +} + func NewTestHubGenesisKeeperFromApp(app *app.App) (*hubgenkeeper.Keeper, sdk.Context) { k := &app.HubGenesisKeeper ctx := app.BaseApp.NewContext(false, tmproto.Header{Height: 1, ChainID: "rollapp-1", Time: time.Now().UTC()}) diff --git a/third_party/proto/cosmos/bank/v1beta1/bank.proto b/third_party/proto/cosmos/bank/v1beta1/bank.proto new file mode 100644 index 00000000..a6b56c63 --- /dev/null +++ b/third_party/proto/cosmos/bank/v1beta1/bank.proto @@ -0,0 +1,54 @@ +syntax = "proto3"; +package cosmos.bank.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos_proto/cosmos.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/bank/types"; + +// DenomUnit represents a struct that describes a given +// denomination unit of the basic token. +message DenomUnit { + // denom represents the string name of the given denom unit (e.g uatom). + string denom = 1; + // exponent represents power of 10 exponent that one must + // raise the base_denom to in order to equal the given DenomUnit's denom + // 1 denom = 10^exponent base_denom + // (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with + // exponent = 6, thus: 1 atom = 10^6 uatom). + uint32 exponent = 2; + // aliases is a list of string aliases for the given denom + repeated string aliases = 3; +} + +// Metadata represents a struct that describes +// a basic token. +message Metadata { + string description = 1; + // denom_units represents the list of DenomUnit's for a given coin + repeated DenomUnit denom_units = 2; + // base represents the base denom (should be the DenomUnit with exponent = 0). + string base = 3; + // display indicates the suggested denom that should be + // displayed in clients. + string display = 4; + // name defines the name of the token (eg: Cosmos Atom) + // + // Since: cosmos-sdk 0.43 + string name = 5; + // symbol is the token symbol usually shown on exchanges (eg: ATOM). This can + // be the same as the display. + // + // Since: cosmos-sdk 0.43 + string symbol = 6; + // URI to a document (on or off-chain) that contains additional information. Optional. + // + // Since: cosmos-sdk 0.46 + string uri = 7 [(gogoproto.customname) = "URI"]; + // URIHash is a sha256 hash of a document pointed by URI. It's used to verify that + // the document didn't change. Optional. + // + // Since: cosmos-sdk 0.46 + string uri_hash = 8 [(gogoproto.customname) = "URIHash"]; +} diff --git a/x/denommetadata/client/cli/query.go b/x/denommetadata/client/cli/query.go new file mode 100644 index 00000000..99727972 --- /dev/null +++ b/x/denommetadata/client/cli/query.go @@ -0,0 +1,59 @@ +package cli + +import ( + "context" + "fmt" + + "github.com/spf13/cobra" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" +) + +// GetQueryCmd returns the cli query commands for this module +func GetQueryCmd() *cobra.Command { + feesQueryCmd := &cobra.Command{ + Use: types.ModuleName, + Short: fmt.Sprintf("Querying commands for the %s module", types.ModuleName), + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + feesQueryCmd.AddCommand( + GetCmdQueryParams(), + ) + + return feesQueryCmd +} + +// GetCmdQueryParams implements a command to return the current parameters. +func GetCmdQueryParams() *cobra.Command { + cmd := &cobra.Command{ + Use: "params", + Short: "Query the current denom metadata module parameters", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryParamsRequest{} + + res, err := queryClient.Params(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintProto(&res.Params) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/denommetadata/client/cli/tx.go b/x/denommetadata/client/cli/tx.go new file mode 100644 index 00000000..a649e397 --- /dev/null +++ b/x/denommetadata/client/cli/tx.go @@ -0,0 +1,130 @@ +package cli + +import ( + "encoding/json" + "os" + + "github.com/spf13/cobra" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" +) + +// NewTxCmd returns a root CLI command handler for certain modules transaction commands. +func NewTxCmd() *cobra.Command { + txCmd := &cobra.Command{ + Use: types.ModuleName, + Short: "Denom Metadata subcommands", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + txCmd.AddCommand( + NewCmdCreateDenomMetadata(), + NewCmdUpdateDenomMetadata(), + ) + return txCmd +} + +// NewCmdCreateDenomMetadata broadcasts a CreateMetadata message. +func NewCmdCreateDenomMetadata() *cobra.Command { + cmd := &cobra.Command{ + Use: "create-denom-metadata denommetadata.json [flags]", + Short: "create new denom metadata for a specific token", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + sender := clientCtx.GetFromAddress() + + path := args[0] + + //nolint:gosec + fileContent, err := os.ReadFile(path) + if err != nil { + return err + } + + metadata := banktypes.Metadata{} + err = json.Unmarshal([]byte(fileContent), &metadata) + if err != nil { + return err + } + + err = metadata.Validate() + if err != nil { + return err + } + + msg := &types.MsgCreateDenomMetadata{ + SenderAddress: sender.String(), + TokenMetadata: metadata, + } + + if err := msg.ValidateBasic(); err != nil { + return err + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} + +// NewCmdUpdateDenomMetadata broadcasts a UpdateMetadata message. +func NewCmdUpdateDenomMetadata() *cobra.Command { + cmd := &cobra.Command{ + Use: "update-denom-metadata denommetadata.json [flags]", + Short: "update new denom metadata for a specific token", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + sender := clientCtx.GetFromAddress() + + path := args[0] + + //nolint:gosec + fileContent, err := os.ReadFile(path) + if err != nil { + return err + } + + metadata := banktypes.Metadata{} + err = json.Unmarshal([]byte(fileContent), &metadata) + if err != nil { + return err + } + + err = metadata.Validate() + if err != nil { + return err + } + + msg := &types.MsgUpdateDenomMetadata{ + SenderAddress: sender.String(), + TokenMetadata: metadata, + } + + if err := msg.ValidateBasic(); err != nil { + return err + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/denommetadata/genesis.go b/x/denommetadata/genesis.go new file mode 100644 index 00000000..1f38810d --- /dev/null +++ b/x/denommetadata/genesis.go @@ -0,0 +1,35 @@ +package denommetadata + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/keeper" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" +) + +// DefaultGenesis returns the default Capability genesis state +func DefaultGenesis() *types.GenesisState { + return &types.GenesisState{ + Params: types.DefaultParams(), + } +} + +// InitGenesis import module genesis +func InitGenesis( + ctx sdk.Context, + k keeper.Keeper, + data types.GenesisState, +) { + k.SetParams(ctx, data.Params) +} + +// ExportGenesis export module state +func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState { + return &types.GenesisState{ + Params: k.GetParams(ctx), + } +} + +func ValidateGenesis(gs types.GenesisState) error { + return gs.Params.Validate() +} diff --git a/x/denommetadata/keeper/grpc_query.go b/x/denommetadata/keeper/grpc_query.go new file mode 100644 index 00000000..46b238b4 --- /dev/null +++ b/x/denommetadata/keeper/grpc_query.go @@ -0,0 +1,31 @@ +package keeper + +import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" +) + +var _ types.QueryServer = Querier{} + +// Querier defines a wrapper around the x/FeeShare keeper providing gRPC method +// handlers. +type Querier struct { + Keeper +} + +func NewQuerier(k Keeper) Querier { + return Querier{Keeper: k} +} + +// Params returns denommetadata module params +func (q Querier) Params( + c context.Context, + _ *types.QueryParamsRequest, +) (*types.QueryParamsResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + params := q.GetParams(ctx) + return &types.QueryParamsResponse{Params: params}, nil +} diff --git a/x/denommetadata/keeper/grpc_query_test.go b/x/denommetadata/keeper/grpc_query_test.go new file mode 100644 index 00000000..d544e3cd --- /dev/null +++ b/x/denommetadata/keeper/grpc_query_test.go @@ -0,0 +1,23 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/keeper" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/testutils" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" + "github.com/stretchr/testify/require" +) + +func TestParamsQuery(t *testing.T) { + k, ctx := testutils.NewTestDenommetadataKeeper(t) + + q := keeper.Querier{Keeper: *k} + + wctx := sdk.WrapSDKContext(ctx) + + response, err := q.Params(wctx, &types.QueryParamsRequest{}) + require.NoError(t, err) + require.Equal(t, &types.QueryParamsResponse{Params: types.DefaultParams()}, response) +} diff --git a/x/denommetadata/keeper/keeper.go b/x/denommetadata/keeper/keeper.go new file mode 100644 index 00000000..0bb9faaa --- /dev/null +++ b/x/denommetadata/keeper/keeper.go @@ -0,0 +1,77 @@ +package keeper + +import ( + "github.com/cosmos/cosmos-sdk/codec" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" + + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" +) + +// Keeper of this module maintains distributing tokens to all stakers. +type Keeper struct { + storeKey storetypes.StoreKey + cdc codec.BinaryCodec + paramSpace paramtypes.Subspace + + bankKeeper types.BankKeeper + hooks types.MultiDenomMetadataHooks +} + +// NewKeeper creates new instances of the Keeper +func NewKeeper( + cdc codec.BinaryCodec, + storeKey storetypes.StoreKey, + bk types.BankKeeper, + hooks types.MultiDenomMetadataHooks, + paramSpace paramtypes.Subspace, +) Keeper { + // set KeyTable if it has not already been set + if !paramSpace.HasKeyTable() { + paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable()) + } + + return Keeper{ + storeKey: storeKey, + cdc: cdc, + paramSpace: paramSpace, + bankKeeper: bk, + hooks: hooks, + } +} + +// GetParams returns the total set of denommetadata parameters. +func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) { + k.paramSpace.GetParamSet(ctx, ¶ms) + return +} + +// SetParams sets the total set of denommetadata parameters. +func (k Keeper) SetParams(ctx sdk.Context, params types.Params) { + k.paramSpace.SetParamSet(ctx, ¶ms) +} + +// IsAddressPermissioned checks if the given address is permissioned to create or update denom metadata +func (k Keeper) IsAddressPermissioned(ctx sdk.Context, address string) bool { + params := k.GetParams(ctx) + for _, PermissionedAddress := range params.AllowedAddresses { + if PermissionedAddress == address { + return true + } + } + return false +} + +// SetHooks set the denommetadata hooks +func (k *Keeper) SetHooks(sh types.MultiDenomMetadataHooks) { + if k.hooks != nil { + panic("cannot set rollapp hooks twice") + } + k.hooks = sh +} + +// GetHooks get the denommetadata hooks +func (k *Keeper) GetHooks() types.MultiDenomMetadataHooks { + return k.hooks +} diff --git a/x/denommetadata/keeper/keeper_test.go b/x/denommetadata/keeper/keeper_test.go new file mode 100644 index 00000000..5ba02a92 --- /dev/null +++ b/x/denommetadata/keeper/keeper_test.go @@ -0,0 +1,32 @@ +package keeper_test + +import ( + "testing" + + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/testutils" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" + "github.com/stretchr/testify/require" +) + +func TestParams(t *testing.T) { + // Setup the test environment + k, ctx := testutils.NewTestDenommetadataKeeper(t) // Assume you have a similar utility function for denommetadata keeper + + // Set some initial parameters + initialParams := types.DefaultParams() + initialParams.AllowedAddresses = []string{"cosmos19crd4fwzm9qtf5ln5l3e2vmquhevjwprk8tgxp", "cosmos1gusne8eh37myphx09hgdsy85zpl2t0kzdvu3en"} // Example addresses + k.SetParams(ctx, initialParams) + + // Retrieve the parameters + retrievedParams := k.GetParams(ctx) + + // Assert that the retrieved parameters match the initial ones + require.Equal(t, initialParams, retrievedParams, "retrieved parameters should match the initial ones") + + // Test setting and getting a different set of parameters + updatedParams := initialParams + updatedParams.AllowedAddresses = append(updatedParams.AllowedAddresses, "cosmos1s77x8wr2gzdhq8gt8c085vate0s23xu9u80wtx") + k.SetParams(ctx, updatedParams) + retrievedParams = k.GetParams(ctx) + require.Equal(t, updatedParams, retrievedParams, "retrieved parameters should match the updated ones") +} diff --git a/x/denommetadata/keeper/msg_server.go b/x/denommetadata/keeper/msg_server.go new file mode 100644 index 00000000..339f07f6 --- /dev/null +++ b/x/denommetadata/keeper/msg_server.go @@ -0,0 +1,73 @@ +package keeper + +import ( + "context" + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" +) + +var _ types.MsgServer = &Keeper{} + +// CreateDenomMetadata create the denom metadata in bank module +func (k Keeper) CreateDenomMetadata( + goCtx context.Context, + msg *types.MsgCreateDenomMetadata, +) (*types.MsgCreateDenomMetadataResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := msg.ValidateBasic(); err != nil { + return nil, err + } + + if !k.IsAddressPermissioned(ctx, msg.SenderAddress) { + return nil, types.ErrNoPermission + } + + found := k.bankKeeper.HasDenomMetaData(ctx, msg.TokenMetadata.Base) + if found { + return nil, types.ErrDenomAlreadyExists + } + + k.bankKeeper.SetDenomMetaData(ctx, msg.TokenMetadata) + // set hook after denom metadata creation + err := k.hooks.AfterDenomMetadataCreation(ctx, msg.TokenMetadata) + if err != nil { + return nil, fmt.Errorf("error in after denom metadata creation hook: %w", err) + } + + return &types.MsgCreateDenomMetadataResponse{}, nil +} + +// UpdateDenomMetadata update the denom metadata in bank module +func (k Keeper) UpdateDenomMetadata( + goCtx context.Context, + msg *types.MsgUpdateDenomMetadata, +) (*types.MsgUpdateDenomMetadataResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := msg.ValidateBasic(); err != nil { + return nil, err + } + + if !k.IsAddressPermissioned(ctx, msg.SenderAddress) { + return nil, types.ErrNoPermission + } + + found := k.bankKeeper.HasDenomMetaData(ctx, msg.TokenMetadata.Base) + if !found { + return nil, types.ErrDenomDoesNotExist + } + + k.bankKeeper.SetDenomMetaData(ctx, msg.TokenMetadata) + + // set hook after denom metadata update + err := k.hooks.AfterDenomMetadataUpdate(ctx, msg.TokenMetadata) + if err != nil { + return nil, fmt.Errorf("error in after denom metadata update hook: %w", err) + } + + return &types.MsgUpdateDenomMetadataResponse{}, nil +} diff --git a/x/denommetadata/keeper/msg_server_test.go b/x/denommetadata/keeper/msg_server_test.go new file mode 100644 index 00000000..daf5dd1a --- /dev/null +++ b/x/denommetadata/keeper/msg_server_test.go @@ -0,0 +1,49 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/testutils" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" +) + +func TestCreateDenomMetadata(t *testing.T) { + k, ctx := testutils.NewTestDenommetadataKeeper(t) + + // Prepare the test message for creating denom metadata + createMsg := &types.MsgCreateDenomMetadata{ + SenderAddress: "cosmos1s77x8wr2gzdhq8gt8c085vate0s23xu9u80wtx", + TokenMetadata: banktypes.Metadata{ + Name: "Dymension Hub token", + Symbol: "DYM", + Description: "Denom metadata for DYM.", + DenomUnits: []*banktypes.DenomUnit{ + {Denom: "adym", Exponent: uint32(0), Aliases: []string{}}, + {Denom: "DYM", Exponent: uint32(18), Aliases: []string{}}, + }, + Base: "adym", + Display: "DYM", + }, + } + + // Test permission error + _, err := k.CreateDenomMetadata(sdk.WrapSDKContext(ctx), createMsg) + require.ErrorIs(t, err, types.ErrNoPermission, "should return permission error") + + // Set allowed addresses + initialParams := types.DefaultParams() + initialParams.AllowedAddresses = []string{"cosmos1s77x8wr2gzdhq8gt8c085vate0s23xu9u80wtx", "cosmos1gusne8eh37myphx09hgdsy85zpl2t0kzdvu3en"} + k.SetParams(ctx, initialParams) + + // Test creating denom metadata successfully + _, err = k.CreateDenomMetadata(sdk.WrapSDKContext(ctx), createMsg) + require.NoError(t, err, "creating denom metadata with allowed address should not error") + + // Test creating duplicate denom metadata + _, err = k.CreateDenomMetadata(sdk.WrapSDKContext(ctx), createMsg) + require.ErrorIs(t, err, types.ErrDenomAlreadyExists, "creating duplicate denom metadata should fail") +} diff --git a/x/denommetadata/module.go b/x/denommetadata/module.go new file mode 100644 index 00000000..8730ccc8 --- /dev/null +++ b/x/denommetadata/module.go @@ -0,0 +1,157 @@ +package denommetadata + +import ( + "context" + "encoding/json" + "fmt" + + abci "github.com/tendermint/tendermint/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/dymensionxyz/dymension-rdk/x/denommetadata/client/cli" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/keeper" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/types" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/spf13/cobra" +) + +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} +) + +// ---------------------------------------------------------------------------- +// AppModuleBasic +// ---------------------------------------------------------------------------- + +// AppModuleBasic implements the AppModuleBasic interface for the capability module. +type AppModuleBasic struct{} + +// Name returns the capability module's name. +func (AppModuleBasic) Name() string { + return types.ModuleName +} + +func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + types.RegisterLegacyAminoCodec(cdc) +} +func (a AppModuleBasic) RegisterInterfaces(reg cdctypes.InterfaceRegistry) { + types.RegisterInterfaces(reg) +} + +// DefaultGenesis returns the capability module's default genesis state. +func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { + return cdc.MustMarshalJSON(DefaultGenesis()) +} + +// ValidateGenesis performs genesis state validation for the capability module. +func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error { + var genState types.GenesisState + if err := cdc.UnmarshalJSON(bz, &genState); err != nil { + return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) + } + return ValidateGenesis(genState) +} + +// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the module. +func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) { + if err := types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx)); err != nil { + panic(err) + } +} + +// GetTxCmd returns the capability module's root tx command. +func (a AppModuleBasic) GetTxCmd() *cobra.Command { + return cli.NewTxCmd() +} + +// GetQueryCmd returns the capability module's root query command. +func (AppModuleBasic) GetQueryCmd() *cobra.Command { + return cli.GetQueryCmd() +} + +// ---------------------------------------------------------------------------- +// AppModule +// ---------------------------------------------------------------------------- + +// AppModule implements the AppModule interface for the capability module. +type AppModule struct { + AppModuleBasic + + keeper keeper.Keeper + bankKeeper types.BankKeeper +} + +func NewAppModule( + cdc codec.Codec, + keeper keeper.Keeper, + bankKeeper types.BankKeeper, +) AppModule { + return AppModule{ + AppModuleBasic: AppModuleBasic{}, + keeper: keeper, + bankKeeper: bankKeeper, + } +} + +// Name returns the capability module's name. +func (am AppModule) Name() string { + return am.AppModuleBasic.Name() +} + +// Route returns the capability module's message routing key. +func (am AppModule) Route() sdk.Route { + return sdk.Route{} +} + +// QuerierRoute returns the capability module's query routing key. +func (AppModule) QuerierRoute() string { return types.RouterKey } + +// LegacyQuerierHandler returns the capability module's Querier. +func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sdk.Querier { + return nil +} + +// RegisterServices registers a GRPC query service to respond to the +// module-specific GRPC queries. +func (am AppModule) RegisterServices(cfg module.Configurator) { + types.RegisterQueryServer(cfg.QueryServer(), keeper.Querier{Keeper: am.keeper}) + types.RegisterMsgServer(cfg.MsgServer(), 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, gs json.RawMessage) []abci.ValidatorUpdate { + // Initialize global index to index in genesis state + var genState types.GenesisState + cdc.MustUnmarshalJSON(gs, &genState) + InitGenesis(ctx, am.keeper, genState) + return []abci.ValidatorUpdate{} +} + +// ExportGenesis returns the capability module's exported genesis state as raw JSON bytes. +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + genState := ExportGenesis(ctx, am.keeper) + return cdc.MustMarshalJSON(genState) +} + +// ConsensusVersion implements ConsensusVersion. +func (AppModule) ConsensusVersion() uint64 { return 1 } + +// BeginBlock executes all ABCI BeginBlock logic respective to the fees module. +func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) { +} + +// EndBlock executes all ABCI EndBlock logic respective to the fee-share module. It +// returns no validator updates. +func (am AppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate { + return []abci.ValidatorUpdate{} +} diff --git a/x/denommetadata/testutils/testutils.go b/x/denommetadata/testutils/testutils.go new file mode 100644 index 00000000..cf862eba --- /dev/null +++ b/x/denommetadata/testutils/testutils.go @@ -0,0 +1,18 @@ +package testutils + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + + testkeepers "github.com/dymensionxyz/dymension-rdk/testutil/keepers" + "github.com/dymensionxyz/dymension-rdk/testutil/utils" + "github.com/dymensionxyz/dymension-rdk/x/denommetadata/keeper" +) + +// NewTestDenommetadataKeeper creates a new denommetadata keeper for testing +func NewTestDenommetadataKeeper(t *testing.T) (*keeper.Keeper, sdk.Context) { + app := utils.Setup(t, false) + k, ctx := testkeepers.NewTestDenommetadataKeeperFromApp(app) + return k, ctx +} diff --git a/x/denommetadata/types/codec.go b/x/denommetadata/types/codec.go new file mode 100644 index 00000000..02ce2b30 --- /dev/null +++ b/x/denommetadata/types/codec.go @@ -0,0 +1,60 @@ +package types + +import ( + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/msgservice" + authzcodec "github.com/cosmos/cosmos-sdk/x/authz/codec" +) + +var ( + Amino = codec.NewLegacyAmino() + + // ModuleCdc references the global erc20 module codec. Note, the codec should + // ONLY be used in certain instances of tests and for JSON encoding. + // + // The actual codec used for serialization should be provided to modules/erc20 and + // defined at the application level. + ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry()) + + // AminoCdc is a amino codec created to support amino JSON compatible msgs. + AminoCdc = codec.NewAminoCodec(Amino) +) + +const ( + // Amino names + createDenomMetadataName = "denommetadata/MsgCreateDenomMetadata" //nolint:gosec // these are not hard coded credentials + updateDenomMetadataName = "denommetadata/MsgUpdateDenomMetadata" //nolint:gosec // these are not hard coded credentials +) + +// NOTE: This is required for the GetSignBytes function +func init() { + RegisterLegacyAminoCodec(Amino) + sdk.RegisterLegacyAminoCodec(Amino) + Amino.Seal() + + // Register all Amino interfaces and concrete types on the authz Amino codec + // so that this can later be used to properly serialize MsgGrant and MsgExec + // instances. + RegisterLegacyAminoCodec(authzcodec.Amino) +} + +// RegisterInterfaces register implementations +func RegisterInterfaces(registry codectypes.InterfaceRegistry) { + registry.RegisterImplementations( + (*sdk.Msg)(nil), + &MsgCreateDenomMetadata{}, + &MsgUpdateDenomMetadata{}, + ) + + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) +} + +// RegisterLegacyAminoCodec registers the necessary x/FeeShare interfaces and +// concrete types on the provided LegacyAmino codec. These types are used for +// Amino JSON serialization and EIP-712 compatibility. +func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgCreateDenomMetadata{}, createDenomMetadataName, nil) + cdc.RegisterConcrete(&MsgUpdateDenomMetadata{}, updateDenomMetadataName, nil) +} diff --git a/x/denommetadata/types/errors.go b/x/denommetadata/types/errors.go new file mode 100644 index 00000000..b227ac4d --- /dev/null +++ b/x/denommetadata/types/errors.go @@ -0,0 +1,13 @@ +package types + +import ( + errorsmod "cosmossdk.io/errors" +) + +var ( + ErrDuplicate = errorsmod.Register(ModuleName, 200, "duplicate") + ErrBlank = errorsmod.Register(ModuleName, 201, "address cannot be blank") + ErrNoPermission = errorsmod.Register(ModuleName, 202, "signer not in the permissions list to create or update denom metadata") + ErrDenomAlreadyExists = errorsmod.Register(ModuleName, 203, "denom metadata is already registered") + ErrDenomDoesNotExist = errorsmod.Register(ModuleName, 204, "unable to find denom metadata registered") +) diff --git a/x/denommetadata/types/expected_keeper.go b/x/denommetadata/types/expected_keeper.go new file mode 100644 index 00000000..5a1c67b3 --- /dev/null +++ b/x/denommetadata/types/expected_keeper.go @@ -0,0 +1,13 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + types "github.com/cosmos/cosmos-sdk/x/bank/types" +) + +// BankKeeper defines the expected interface needed to retrieve account balances. +type BankKeeper interface { + GetDenomMetaData(ctx sdk.Context, denom string) (types.Metadata, bool) + HasDenomMetaData(ctx sdk.Context, denom string) bool + SetDenomMetaData(ctx sdk.Context, denomMetaData types.Metadata) +} diff --git a/x/denommetadata/types/genesis.pb.go b/x/denommetadata/types/genesis.pb.go new file mode 100644 index 00000000..8d659117 --- /dev/null +++ b/x/denommetadata/types/genesis.pb.go @@ -0,0 +1,325 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: denommetadata/genesis.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-sdk/x/staking/types" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// GenesisState defines the test module's genesis state. +type GenesisState struct { + // params are all parameters for the module + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +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_d7024f2838e64694, []int{0} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +func (m *GenesisState) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func init() { + proto.RegisterType((*GenesisState)(nil), "rollapp.denommetadata.types.GenesisState") +} + +func init() { proto.RegisterFile("denommetadata/genesis.proto", fileDescriptor_d7024f2838e64694) } + +var fileDescriptor_d7024f2838e64694 = []byte{ + // 237 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0x49, 0xcd, 0xcb, + 0xcf, 0xcd, 0x4d, 0x2d, 0x49, 0x4c, 0x49, 0x2c, 0x49, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, + 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x2e, 0xca, 0xcf, 0xc9, 0x49, 0x2c, 0x28, + 0xd0, 0x43, 0x51, 0xa4, 0x57, 0x52, 0x59, 0x90, 0x5a, 0x2c, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, + 0x56, 0xa7, 0x0f, 0x62, 0x41, 0xb4, 0x48, 0x49, 0xa1, 0x9a, 0x57, 0x90, 0x58, 0x94, 0x98, 0x0b, + 0x35, 0x4e, 0x4a, 0x25, 0x39, 0xbf, 0x38, 0x37, 0xbf, 0x58, 0xbf, 0xb8, 0x24, 0x31, 0x3b, 0x33, + 0x2f, 0x5d, 0xbf, 0xcc, 0x30, 0x29, 0xb5, 0x24, 0xd1, 0x10, 0xc6, 0x87, 0xa8, 0x52, 0x0a, 0xe4, + 0xe2, 0x71, 0x87, 0xb8, 0x22, 0xb8, 0x24, 0xb1, 0x24, 0x55, 0xc8, 0x91, 0x8b, 0x0d, 0x62, 0x8a, + 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb7, 0x91, 0xb2, 0x1e, 0x1e, 0x57, 0xe9, 0x05, 0x80, 0x95, 0x3a, + 0xb1, 0x9c, 0xb8, 0x27, 0xcf, 0x10, 0x04, 0xd5, 0xe8, 0x14, 0x7a, 0xe2, 0x91, 0x1c, 0xe3, 0x85, + 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, + 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0xd6, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, + 0xfa, 0x29, 0x95, 0xb9, 0xa9, 0x79, 0xc5, 0x99, 0xf9, 0x79, 0x15, 0x95, 0x55, 0x08, 0x8e, 0x6e, + 0x51, 0x4a, 0xb6, 0x7e, 0x85, 0x3e, 0xaa, 0xb7, 0xc0, 0x76, 0x25, 0xb1, 0x81, 0x1d, 0x6c, 0x0c, + 0x08, 0x00, 0x00, 0xff, 0xff, 0x36, 0x3e, 0x50, 0xac, 0x44, 0x01, 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 + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GenesisState) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + 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/denommetadata/types/hooks.go b/x/denommetadata/types/hooks.go new file mode 100644 index 00000000..b54a5051 --- /dev/null +++ b/x/denommetadata/types/hooks.go @@ -0,0 +1,39 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" +) + +// DenomMetadataHooks event hooks for denom metadata creation/update +type DenomMetadataHooks interface { + AfterDenomMetadataCreation(ctx sdk.Context, metadata banktypes.Metadata) error + AfterDenomMetadataUpdate(ctx sdk.Context, metadata banktypes.Metadata) error +} + +// MultiDenomMetadataHooks combine multiple DenomMetadata hooks, all hook functions are run in array sequence +type MultiDenomMetadataHooks []DenomMetadataHooks + +func NewMultiDenommetadataHooks(hooks ...DenomMetadataHooks) MultiDenomMetadataHooks { + return hooks +} + +func (h MultiDenomMetadataHooks) AfterDenomMetadataCreation(ctx sdk.Context, metadata banktypes.Metadata) error { + for i := range h { + err := h[i].AfterDenomMetadataCreation(ctx, metadata) + if err != nil { + return err + } + } + return nil +} + +func (h MultiDenomMetadataHooks) AfterDenomMetadataUpdate(ctx sdk.Context, metadata banktypes.Metadata) error { + for i := range h { + err := h[i].AfterDenomMetadataUpdate(ctx, metadata) + if err != nil { + return err + } + } + return nil +} diff --git a/x/denommetadata/types/keys.go b/x/denommetadata/types/keys.go new file mode 100644 index 00000000..ae7f8f91 --- /dev/null +++ b/x/denommetadata/types/keys.go @@ -0,0 +1,12 @@ +package types + +const ( + // module name + ModuleName = "denommetadata" + + // StoreKey to be used when creating the KVStore + StoreKey = ModuleName + + // RouterKey to be used for message routing + RouterKey = ModuleName +) diff --git a/x/denommetadata/types/msg.go b/x/denommetadata/types/msg.go new file mode 100644 index 00000000..9294f2a9 --- /dev/null +++ b/x/denommetadata/types/msg.go @@ -0,0 +1,107 @@ +package types + +import ( + errorsmod "cosmossdk.io/errors" + + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var ( + _ sdk.Msg = &MsgCreateDenomMetadata{} + _ sdk.Msg = &MsgUpdateDenomMetadata{} +) + +const ( + TypeMsgCreateDenomMetadata = "create_denom_metadata" + TypeMsgUpdateDenomMetadata = "update_denom_metadata" +) + +// NewMsgCreateDenomMetadata creates new instance of MsgCreateDenomMetadata +func NewMsgCreateDenomMetadata( + sender sdk.Address, + tokenMetadata banktypes.Metadata, +) *MsgCreateDenomMetadata { + return &MsgCreateDenomMetadata{ + SenderAddress: sender.String(), + TokenMetadata: tokenMetadata, + } +} + +// Route returns the name of the module +func (msg MsgCreateDenomMetadata) Route() string { return RouterKey } + +// Type returns the the action +func (msg MsgCreateDenomMetadata) Type() string { return TypeMsgCreateDenomMetadata } + +// ValidateBasic runs stateless checks on the message +func (msg MsgCreateDenomMetadata) ValidateBasic() error { + + // this also checks for empty addresses + if _, err := sdk.AccAddressFromBech32(msg.SenderAddress); err != nil { + return errorsmod.Wrapf(err, "invalid sender address: %s", err.Error()) + } + + err := msg.TokenMetadata.Validate() + if err != nil { + return err + } + + return nil +} + +// GetSignBytes encodes the message for signing +func (msg *MsgCreateDenomMetadata) GetSignBytes() []byte { + return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(msg)) +} + +// GetSigners defines whose signature is required +func (msg MsgCreateDenomMetadata) GetSigners() []sdk.AccAddress { + from, _ := sdk.AccAddressFromBech32(msg.SenderAddress) + return []sdk.AccAddress{from} +} + +// NewMsgCreateDenomMetadata creates new instance of MsgCreateDenomMetadata +func NewMsgUpdateDenomMetadata( + sender sdk.Address, + tokenMetadata banktypes.Metadata, +) *MsgUpdateDenomMetadata { + return &MsgUpdateDenomMetadata{ + SenderAddress: sender.String(), + TokenMetadata: tokenMetadata, + } +} + +// Route returns the name of the module +func (msg MsgUpdateDenomMetadata) Route() string { return RouterKey } + +// Type returns the the action +func (msg MsgUpdateDenomMetadata) Type() string { return TypeMsgUpdateDenomMetadata } + +// ValidateBasic runs stateless checks on the message +func (msg MsgUpdateDenomMetadata) ValidateBasic() error { + + // this also checks for empty addresses + if _, err := sdk.AccAddressFromBech32(msg.SenderAddress); err != nil { + return errorsmod.Wrapf(err, "invalid sender address: %s", err.Error()) + } + + err := msg.TokenMetadata.Validate() + if err != nil { + return err + } + + return nil +} + +// GetSignBytes encodes the message for signing +func (msg *MsgUpdateDenomMetadata) GetSignBytes() []byte { + return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(msg)) +} + +// GetSigners defines whose signature is required +func (msg MsgUpdateDenomMetadata) GetSigners() []sdk.AccAddress { + from, _ := sdk.AccAddressFromBech32(msg.SenderAddress) + return []sdk.AccAddress{from} +} diff --git a/x/denommetadata/types/params.go b/x/denommetadata/types/params.go new file mode 100644 index 00000000..3cb65ab6 --- /dev/null +++ b/x/denommetadata/types/params.go @@ -0,0 +1,68 @@ +package types + +import ( + "fmt" + + errorsmod "cosmossdk.io/errors" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var ( + KeyAllowedAddresses = []byte("AllowedAddresses") + DefaultAllowedAddresses = []string(nil) // no one allowed +) + +// ParamKeyTable for minting module. +func ParamKeyTable() paramtypes.KeyTable { + return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) +} + +// NewParams creates a new Params object +func NewParams( + allowedAddresses []string, +) Params { + return Params{ + AllowedAddresses: allowedAddresses, + } +} + +// DefaultParams returns default x/denommetadata module parameters. +func DefaultParams() Params { + return Params{ + AllowedAddresses: DefaultAllowedAddresses, + } +} + +func (p Params) Validate() error { + return assertValidAddresses(p.AllowedAddresses) +} + +func assertValidAddresses(i any) error { + addrs, ok := i.([]string) + if !ok { + return fmt.Errorf("invalid parameter type: %T", i) + } + + idx := make(map[string]struct{}, len(addrs)) + for _, a := range addrs { + + // this also checks for empty addresses + if _, err := sdk.AccAddressFromBech32(a); err != nil { + return errorsmod.Wrapf(err, "address: %s", a) + } + if _, exists := idx[a]; exists { + return ErrDuplicate.Wrapf("address: %s", a) + } + idx[a] = struct{}{} + } + return nil +} + +// Implements params.ParamSet. +func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { + return paramtypes.ParamSetPairs{ + paramtypes.NewParamSetPair(KeyAllowedAddresses, &p.AllowedAddresses, assertValidAddresses), + } +} diff --git a/x/denommetadata/types/params.pb.go b/x/denommetadata/types/params.pb.go new file mode 100644 index 00000000..66ef3f40 --- /dev/null +++ b/x/denommetadata/types/params.pb.go @@ -0,0 +1,326 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: denommetadata/params.proto + +package types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// Params defines the parameters for the module. +type Params struct { + // allowed_addresses defines the list of addresses authorized to use the + // module + AllowedAddresses []string `protobuf:"bytes,1,rep,name=allowed_addresses,json=allowedAddresses,proto3" json:"allowed_addresses,omitempty" yaml:"allowed_addresses"` +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_c251c710bb35ef69, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +func (m *Params) GetAllowedAddresses() []string { + if m != nil { + return m.AllowedAddresses + } + return nil +} + +func init() { + proto.RegisterType((*Params)(nil), "rollapp.denommetadata.types.Params") +} + +func init() { proto.RegisterFile("denommetadata/params.proto", fileDescriptor_c251c710bb35ef69) } + +var fileDescriptor_c251c710bb35ef69 = []byte{ + // 210 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0x49, 0xcd, 0xcb, + 0xcf, 0xcd, 0x4d, 0x2d, 0x49, 0x4c, 0x49, 0x2c, 0x49, 0xd4, 0x2f, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, + 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x2e, 0xca, 0xcf, 0xc9, 0x49, 0x2c, 0x28, 0xd0, + 0x43, 0x51, 0xa3, 0x57, 0x52, 0x59, 0x90, 0x5a, 0x2c, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, 0x56, + 0xa7, 0x0f, 0x62, 0x41, 0xb4, 0x28, 0x05, 0x73, 0xb1, 0x05, 0x80, 0x8d, 0x10, 0xf2, 0xe4, 0x12, + 0x4c, 0xcc, 0xc9, 0xc9, 0x2f, 0x4f, 0x4d, 0x89, 0x4f, 0x4c, 0x49, 0x29, 0x4a, 0x2d, 0x2e, 0x4e, + 0x2d, 0x96, 0x60, 0x54, 0x60, 0xd6, 0xe0, 0x74, 0x92, 0xf9, 0x74, 0x4f, 0x5e, 0xa2, 0x32, 0x31, + 0x37, 0xc7, 0x4a, 0x09, 0x43, 0x89, 0x52, 0x90, 0x00, 0x54, 0xcc, 0x11, 0x26, 0xe4, 0x14, 0x7a, + 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, + 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0xd6, 0xe9, 0x99, 0x25, 0x19, 0xa5, + 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x29, 0x95, 0xb9, 0xa9, 0x79, 0xc5, 0x99, 0xf9, 0x79, 0x15, + 0x95, 0x55, 0x08, 0x8e, 0x6e, 0x51, 0x4a, 0xb6, 0x7e, 0x85, 0x3e, 0xaa, 0x2f, 0xc1, 0x3e, 0x48, + 0x62, 0x03, 0x3b, 0xd9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x51, 0xf5, 0x4c, 0x14, 0x03, 0x01, + 0x00, 0x00, +} + +func (m *Params) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AllowedAddresses) > 0 { + for iNdEx := len(m.AllowedAddresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.AllowedAddresses[iNdEx]) + copy(dAtA[i:], m.AllowedAddresses[iNdEx]) + i = encodeVarintParams(dAtA, i, uint64(len(m.AllowedAddresses[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintParams(dAtA []byte, offset int, v uint64) int { + offset -= sovParams(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AllowedAddresses) > 0 { + for _, s := range m.AllowedAddresses { + l = len(s) + n += 1 + l + sovParams(uint64(l)) + } + } + return n +} + +func sovParams(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozParams(x uint64) (n int) { + return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllowedAddresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + 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 ErrInvalidLengthParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AllowedAddresses = append(m.AllowedAddresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipParams(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthParams + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipParams(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthParams + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupParams + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthParams + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthParams = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowParams = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/denommetadata/types/query.pb.go b/x/denommetadata/types/query.pb.go new file mode 100644 index 00000000..1f0ebd83 --- /dev/null +++ b/x/denommetadata/types/query.pb.go @@ -0,0 +1,536 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: denommetadata/query.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// QueryParamsRequest is request type for the Query/Params RPC method. +type QueryParamsRequest struct { +} + +func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } +func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryParamsRequest) ProtoMessage() {} +func (*QueryParamsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_81a3ad864530e6e9, []int{0} +} +func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsRequest.Merge(m, src) +} +func (m *QueryParamsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo + +// QueryParamsResponse is response type for the Query/Params RPC method. +type QueryParamsResponse struct { + // params holds all the parameters of this module. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } +func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryParamsResponse) ProtoMessage() {} +func (*QueryParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_81a3ad864530e6e9, []int{1} +} +func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsResponse.Merge(m, src) +} +func (m *QueryParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo + +func (m *QueryParamsResponse) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func init() { + proto.RegisterType((*QueryParamsRequest)(nil), "rollapp.denommetadata.types.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "rollapp.denommetadata.types.QueryParamsResponse") +} + +func init() { proto.RegisterFile("denommetadata/query.proto", fileDescriptor_81a3ad864530e6e9) } + +var fileDescriptor_81a3ad864530e6e9 = []byte{ + // 290 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0x49, 0xcd, 0xcb, + 0xcf, 0xcd, 0x4d, 0x2d, 0x49, 0x4c, 0x49, 0x2c, 0x49, 0xd4, 0x2f, 0x2c, 0x4d, 0x2d, 0xaa, 0xd4, + 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x2e, 0xca, 0xcf, 0xc9, 0x49, 0x2c, 0x28, 0xd0, 0x43, + 0x51, 0xa2, 0x57, 0x52, 0x59, 0x90, 0x5a, 0x2c, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, 0x56, 0xa7, + 0x0f, 0x62, 0x41, 0xb4, 0x48, 0xc9, 0xa4, 0xe7, 0xe7, 0xa7, 0xe7, 0xa4, 0xea, 0x27, 0x16, 0x64, + 0xea, 0x27, 0xe6, 0xe5, 0xe5, 0x97, 0x24, 0x96, 0x64, 0xe6, 0xe7, 0x15, 0x43, 0x65, 0xa5, 0x50, + 0xed, 0x2a, 0x48, 0x2c, 0x4a, 0xcc, 0x85, 0xca, 0x29, 0x89, 0x70, 0x09, 0x05, 0x82, 0xec, 0x0e, + 0x00, 0x0b, 0x06, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x28, 0x45, 0x70, 0x09, 0xa3, 0x88, 0x16, + 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0x39, 0x72, 0xb1, 0x41, 0x34, 0x4b, 0x30, 0x2a, 0x30, 0x6a, + 0x70, 0x1b, 0x29, 0xeb, 0xe1, 0x71, 0xaa, 0x1e, 0x44, 0xb3, 0x13, 0xcb, 0x89, 0x7b, 0xf2, 0x0c, + 0x41, 0x50, 0x8d, 0x46, 0xeb, 0x19, 0xb9, 0x58, 0xc1, 0x46, 0x0b, 0x2d, 0x65, 0xe4, 0x62, 0x83, + 0x28, 0x11, 0xd2, 0xc7, 0x6b, 0x0e, 0xa6, 0xfb, 0xa4, 0x0c, 0x88, 0xd7, 0x00, 0x71, 0xba, 0x92, + 0x45, 0xd3, 0xe5, 0x27, 0x93, 0x99, 0x8c, 0x84, 0x0c, 0xf4, 0x53, 0x2a, 0x73, 0x53, 0xf3, 0x8a, + 0x33, 0xf3, 0xf3, 0x2a, 0x2a, 0xab, 0x10, 0x1c, 0xdd, 0xa2, 0x94, 0x6c, 0x7d, 0x6c, 0xe1, 0xe4, + 0x14, 0x7a, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, + 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0xd6, 0xe9, 0x99, 0x25, + 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xf8, 0x4c, 0xad, 0x40, 0x33, 0x17, 0xec, 0xc8, 0x24, + 0x36, 0x70, 0xf8, 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd4, 0xbd, 0x47, 0xe6, 0x09, 0x02, + 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + // Parameters retrieves the denom metadata module params + Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { + out := new(QueryParamsResponse) + err := c.cc.Invoke(ctx, "/rollapp.denommetadata.types.Query/Params", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // Parameters retrieves the denom metadata module params + Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryParamsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Params(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/rollapp.denommetadata.types.Query/Params", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "rollapp.denommetadata.types.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Params", + Handler: _Query_Params_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "denommetadata/query.proto", +} + +func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func 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/denommetadata/types/query.pb.gw.go b/x/denommetadata/types/query.pb.gw.go new file mode 100644 index 00000000..1bf05b34 --- /dev/null +++ b/x/denommetadata/types/query.pb.gw.go @@ -0,0 +1,153 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: denommetadata/query.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage +var _ = metadata.Join + +func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := server.Params(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"dymensionxyz", "dymension-rdk", "denommetadata", "params"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_Params_0 = runtime.ForwardResponseMessage +) diff --git a/x/denommetadata/types/tx.pb.go b/x/denommetadata/types/tx.pb.go new file mode 100644 index 00000000..cfa55579 --- /dev/null +++ b/x/denommetadata/types/tx.pb.go @@ -0,0 +1,972 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: denommetadata/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + types "github.com/cosmos/cosmos-sdk/x/bank/types" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/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 + +// MsgCreateDenomMetadata defines a message that create the denom metadata. +type MsgCreateDenomMetadata struct { + // sender_address is the bech32 address of message sender. + SenderAddress string `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"` + TokenMetadata types.Metadata `protobuf:"bytes,2,opt,name=token_metadata,json=tokenMetadata,proto3" json:"token_metadata"` +} + +func (m *MsgCreateDenomMetadata) Reset() { *m = MsgCreateDenomMetadata{} } +func (m *MsgCreateDenomMetadata) String() string { return proto.CompactTextString(m) } +func (*MsgCreateDenomMetadata) ProtoMessage() {} +func (*MsgCreateDenomMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_a5bb4e1c9698e3b7, []int{0} +} +func (m *MsgCreateDenomMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCreateDenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCreateDenomMetadata.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 *MsgCreateDenomMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCreateDenomMetadata.Merge(m, src) +} +func (m *MsgCreateDenomMetadata) XXX_Size() int { + return m.Size() +} +func (m *MsgCreateDenomMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCreateDenomMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCreateDenomMetadata proto.InternalMessageInfo + +func (m *MsgCreateDenomMetadata) GetSenderAddress() string { + if m != nil { + return m.SenderAddress + } + return "" +} + +func (m *MsgCreateDenomMetadata) GetTokenMetadata() types.Metadata { + if m != nil { + return m.TokenMetadata + } + return types.Metadata{} +} + +// MsgCreateDenomMetadataResponse defines the MsgCreateDenomMetadata response +// type +type MsgCreateDenomMetadataResponse struct { +} + +func (m *MsgCreateDenomMetadataResponse) Reset() { *m = MsgCreateDenomMetadataResponse{} } +func (m *MsgCreateDenomMetadataResponse) String() string { return proto.CompactTextString(m) } +func (*MsgCreateDenomMetadataResponse) ProtoMessage() {} +func (*MsgCreateDenomMetadataResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a5bb4e1c9698e3b7, []int{1} +} +func (m *MsgCreateDenomMetadataResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCreateDenomMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCreateDenomMetadataResponse.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 *MsgCreateDenomMetadataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCreateDenomMetadataResponse.Merge(m, src) +} +func (m *MsgCreateDenomMetadataResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgCreateDenomMetadataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCreateDenomMetadataResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCreateDenomMetadataResponse proto.InternalMessageInfo + +// MsgDistributeTokens defines a message that update the denom metadata. +type MsgUpdateDenomMetadata struct { + // sender_address is the bech32 address of message sender. + SenderAddress string `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"` + TokenMetadata types.Metadata `protobuf:"bytes,2,opt,name=token_metadata,json=tokenMetadata,proto3" json:"token_metadata"` +} + +func (m *MsgUpdateDenomMetadata) Reset() { *m = MsgUpdateDenomMetadata{} } +func (m *MsgUpdateDenomMetadata) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateDenomMetadata) ProtoMessage() {} +func (*MsgUpdateDenomMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_a5bb4e1c9698e3b7, []int{2} +} +func (m *MsgUpdateDenomMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateDenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateDenomMetadata.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 *MsgUpdateDenomMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateDenomMetadata.Merge(m, src) +} +func (m *MsgUpdateDenomMetadata) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateDenomMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateDenomMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateDenomMetadata proto.InternalMessageInfo + +func (m *MsgUpdateDenomMetadata) GetSenderAddress() string { + if m != nil { + return m.SenderAddress + } + return "" +} + +func (m *MsgUpdateDenomMetadata) GetTokenMetadata() types.Metadata { + if m != nil { + return m.TokenMetadata + } + return types.Metadata{} +} + +// MsgUpdateDenomMetadataResponse defines the MsgUpdateDenomMetadata response +// type +type MsgUpdateDenomMetadataResponse struct { +} + +func (m *MsgUpdateDenomMetadataResponse) Reset() { *m = MsgUpdateDenomMetadataResponse{} } +func (m *MsgUpdateDenomMetadataResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateDenomMetadataResponse) ProtoMessage() {} +func (*MsgUpdateDenomMetadataResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a5bb4e1c9698e3b7, []int{3} +} +func (m *MsgUpdateDenomMetadataResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateDenomMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateDenomMetadataResponse.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 *MsgUpdateDenomMetadataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateDenomMetadataResponse.Merge(m, src) +} +func (m *MsgUpdateDenomMetadataResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateDenomMetadataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateDenomMetadataResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateDenomMetadataResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgCreateDenomMetadata)(nil), "rollapp.denommetadata.types.MsgCreateDenomMetadata") + proto.RegisterType((*MsgCreateDenomMetadataResponse)(nil), "rollapp.denommetadata.types.MsgCreateDenomMetadataResponse") + proto.RegisterType((*MsgUpdateDenomMetadata)(nil), "rollapp.denommetadata.types.MsgUpdateDenomMetadata") + proto.RegisterType((*MsgUpdateDenomMetadataResponse)(nil), "rollapp.denommetadata.types.MsgUpdateDenomMetadataResponse") +} + +func init() { proto.RegisterFile("denommetadata/tx.proto", fileDescriptor_a5bb4e1c9698e3b7) } + +var fileDescriptor_a5bb4e1c9698e3b7 = []byte{ + // 355 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x93, 0xcf, 0x6a, 0x2a, 0x31, + 0x18, 0xc5, 0x27, 0xde, 0xcb, 0x85, 0x9b, 0xa2, 0x8b, 0x69, 0x11, 0x99, 0xd2, 0x54, 0x84, 0x82, + 0x9b, 0x26, 0xa8, 0x4b, 0x57, 0xb5, 0x5d, 0x15, 0xdc, 0x08, 0x6e, 0xba, 0x91, 0x8c, 0xf9, 0x98, + 0x8a, 0x4e, 0x12, 0x92, 0xb4, 0x68, 0xdf, 0xa0, 0x74, 0xd3, 0x17, 0xe8, 0xfb, 0xb8, 0x74, 0xd9, + 0x55, 0x29, 0xfa, 0x22, 0xc5, 0x19, 0xa7, 0xc5, 0x32, 0x28, 0x74, 0xd5, 0xdd, 0x7c, 0x7f, 0xce, + 0x9c, 0x1f, 0x27, 0x09, 0x2e, 0x0b, 0x90, 0x2a, 0x8e, 0xc1, 0x71, 0xc1, 0x1d, 0x67, 0x6e, 0x4a, + 0xb5, 0x51, 0x4e, 0xf9, 0xc7, 0x46, 0x4d, 0x26, 0x5c, 0x6b, 0xba, 0x35, 0xa7, 0x6e, 0xa6, 0xc1, + 0x06, 0x47, 0x91, 0x8a, 0x54, 0xb2, 0xc7, 0xd6, 0x5f, 0xa9, 0x24, 0x20, 0x43, 0x65, 0x63, 0x65, + 0x59, 0xc8, 0xe5, 0x98, 0xdd, 0x37, 0x42, 0x70, 0xbc, 0x91, 0x14, 0x9b, 0x79, 0xb0, 0x6d, 0xa5, + 0xb9, 0xe1, 0xb1, 0x4d, 0x67, 0xb5, 0x27, 0x84, 0xcb, 0x5d, 0x1b, 0x5d, 0x1a, 0xe0, 0x0e, 0xae, + 0xd6, 0x7b, 0xdd, 0xcd, 0x9e, 0x7f, 0x86, 0x4b, 0x16, 0xa4, 0x00, 0x33, 0xe0, 0x42, 0x18, 0xb0, + 0xb6, 0x82, 0xaa, 0xa8, 0xfe, 0xbf, 0x57, 0x4c, 0xbb, 0x17, 0x69, 0xd3, 0xbf, 0xc6, 0x25, 0xa7, + 0xc6, 0x20, 0x07, 0x99, 0x41, 0xa5, 0x50, 0x45, 0xf5, 0x83, 0xe6, 0x09, 0x4d, 0xb1, 0x68, 0x42, + 0xb2, 0xc1, 0xa2, 0xd9, 0xdf, 0x3b, 0x7f, 0xe7, 0x6f, 0xa7, 0x5e, 0xaf, 0x98, 0x48, 0xb3, 0x66, + 0xad, 0x8a, 0x49, 0x3e, 0x4c, 0x0f, 0xac, 0x56, 0xd2, 0x42, 0xc6, 0xdb, 0xd7, 0xe2, 0xf7, 0xf0, + 0xe6, 0xc0, 0x64, 0xbc, 0xcd, 0x97, 0x02, 0xfe, 0xd3, 0xb5, 0x91, 0xff, 0x88, 0xf0, 0x61, 0x5e, + 0xc8, 0x2d, 0xba, 0xe3, 0xbc, 0x69, 0x7e, 0x18, 0x41, 0xfb, 0x07, 0xa2, 0xcf, 0x04, 0xbd, 0x84, + 0x25, 0x2f, 0xc0, 0xbd, 0x2c, 0x39, 0xa2, 0xfd, 0x2c, 0x3b, 0xd2, 0xa9, 0x79, 0x9d, 0xfe, 0x7c, + 0x49, 0xd0, 0x62, 0x49, 0xd0, 0xfb, 0x92, 0xa0, 0xe7, 0x15, 0xf1, 0x16, 0x2b, 0xe2, 0xbd, 0xae, + 0x88, 0x77, 0xd3, 0x8e, 0x46, 0xee, 0xf6, 0x2e, 0xa4, 0x43, 0x15, 0x33, 0x31, 0x8b, 0x41, 0xda, + 0x91, 0x92, 0xd3, 0xd9, 0xc3, 0x57, 0x71, 0x6e, 0xc4, 0x98, 0x4d, 0xd9, 0xb7, 0x87, 0xb4, 0xf6, + 0x0d, 0xff, 0x25, 0xb7, 0xbb, 0xf5, 0x11, 0x00, 0x00, 0xff, 0xff, 0xca, 0x94, 0x6a, 0xef, 0x66, + 0x03, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + CreateDenomMetadata(ctx context.Context, in *MsgCreateDenomMetadata, opts ...grpc.CallOption) (*MsgCreateDenomMetadataResponse, error) + UpdateDenomMetadata(ctx context.Context, in *MsgUpdateDenomMetadata, opts ...grpc.CallOption) (*MsgUpdateDenomMetadataResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) CreateDenomMetadata(ctx context.Context, in *MsgCreateDenomMetadata, opts ...grpc.CallOption) (*MsgCreateDenomMetadataResponse, error) { + out := new(MsgCreateDenomMetadataResponse) + err := c.cc.Invoke(ctx, "/rollapp.denommetadata.types.Msg/CreateDenomMetadata", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpdateDenomMetadata(ctx context.Context, in *MsgUpdateDenomMetadata, opts ...grpc.CallOption) (*MsgUpdateDenomMetadataResponse, error) { + out := new(MsgUpdateDenomMetadataResponse) + err := c.cc.Invoke(ctx, "/rollapp.denommetadata.types.Msg/UpdateDenomMetadata", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + CreateDenomMetadata(context.Context, *MsgCreateDenomMetadata) (*MsgCreateDenomMetadataResponse, error) + UpdateDenomMetadata(context.Context, *MsgUpdateDenomMetadata) (*MsgUpdateDenomMetadataResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) CreateDenomMetadata(ctx context.Context, req *MsgCreateDenomMetadata) (*MsgCreateDenomMetadataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateDenomMetadata not implemented") +} +func (*UnimplementedMsgServer) UpdateDenomMetadata(ctx context.Context, req *MsgUpdateDenomMetadata) (*MsgUpdateDenomMetadataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateDenomMetadata not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_CreateDenomMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCreateDenomMetadata) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CreateDenomMetadata(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/rollapp.denommetadata.types.Msg/CreateDenomMetadata", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CreateDenomMetadata(ctx, req.(*MsgCreateDenomMetadata)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpdateDenomMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateDenomMetadata) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateDenomMetadata(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/rollapp.denommetadata.types.Msg/UpdateDenomMetadata", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateDenomMetadata(ctx, req.(*MsgUpdateDenomMetadata)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "rollapp.denommetadata.types.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateDenomMetadata", + Handler: _Msg_CreateDenomMetadata_Handler, + }, + { + MethodName: "UpdateDenomMetadata", + Handler: _Msg_UpdateDenomMetadata_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "denommetadata/tx.proto", +} + +func (m *MsgCreateDenomMetadata) 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 *MsgCreateDenomMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCreateDenomMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.TokenMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.SenderAddress) > 0 { + i -= len(m.SenderAddress) + copy(dAtA[i:], m.SenderAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.SenderAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgCreateDenomMetadataResponse) 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 *MsgCreateDenomMetadataResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCreateDenomMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgUpdateDenomMetadata) 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 *MsgUpdateDenomMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateDenomMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.TokenMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.SenderAddress) > 0 { + i -= len(m.SenderAddress) + copy(dAtA[i:], m.SenderAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.SenderAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateDenomMetadataResponse) 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 *MsgUpdateDenomMetadataResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateDenomMetadataResponse) 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 *MsgCreateDenomMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SenderAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.TokenMetadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgCreateDenomMetadataResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateDenomMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SenderAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.TokenMetadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateDenomMetadataResponse) 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 *MsgCreateDenomMetadata) 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: MsgCreateDenomMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateDenomMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TokenMetadata.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 *MsgCreateDenomMetadataResponse) 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: MsgCreateDenomMetadataResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateDenomMetadataResponse: 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 *MsgUpdateDenomMetadata) 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: MsgUpdateDenomMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateDenomMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TokenMetadata.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 *MsgUpdateDenomMetadataResponse) 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: MsgUpdateDenomMetadataResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateDenomMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/epochs/types/query.pb.gw.go b/x/epochs/types/query.pb.gw.go index dbfd60f0..be86b78b 100644 --- a/x/epochs/types/query.pb.gw.go +++ b/x/epochs/types/query.pb.gw.go @@ -20,6 +20,7 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/codes" "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" ) @@ -30,6 +31,7 @@ var _ status.Status var _ = runtime.String var _ = utilities.NewDoubleArray var _ = descriptor.ForMessage +var _ = metadata.Join var ( filter_Query_EpochInfos_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} @@ -142,12 +144,14 @@ func local_request_Query_EpochInfo_0(ctx context.Context, marshaler runtime.Mars // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. -// Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { mux.Handle("GET", pattern_Query_EpochInfos_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 { @@ -155,6 +159,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } resp, md, err := local_request_Query_EpochInfos_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) @@ -168,6 +173,8 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv mux.Handle("GET", pattern_Query_CurrentEpoch_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 { @@ -175,6 +182,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } resp, md, err := local_request_Query_CurrentEpoch_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) @@ -188,6 +196,8 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv mux.Handle("GET", pattern_Query_EpochInfo_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 { @@ -195,6 +205,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } resp, md, err := local_request_Query_EpochInfo_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) diff --git a/x/mint/types/params.go b/x/mint/types/params.go index f94e8f0e..ecea3f09 100644 --- a/x/mint/types/params.go +++ b/x/mint/types/params.go @@ -23,7 +23,7 @@ var ( KeyTargetInflationRate = []byte("TargetInflationRate") ) -// ParamTable for minting module. +// ParamKeyTable for minting module. func ParamKeyTable() paramtypes.KeyTable { return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) } diff --git a/x/mint/types/query.pb.gw.go b/x/mint/types/query.pb.gw.go index c8d4938b..6407c0aa 100644 --- a/x/mint/types/query.pb.gw.go +++ b/x/mint/types/query.pb.gw.go @@ -20,6 +20,7 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/codes" "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" ) @@ -30,6 +31,7 @@ var _ status.Status var _ = runtime.String var _ = utilities.NewDoubleArray var _ = descriptor.ForMessage +var _ = metadata.Join func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryParamsRequest @@ -70,12 +72,14 @@ func local_request_Query_Inflation_0(ctx context.Context, marshaler runtime.Mars // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. -// Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) if err != nil { @@ -83,6 +87,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) diff --git a/x/sequencers/types/query.pb.gw.go b/x/sequencers/types/query.pb.gw.go index 9cd84bf0..a239cff9 100644 --- a/x/sequencers/types/query.pb.gw.go +++ b/x/sequencers/types/query.pb.gw.go @@ -20,6 +20,7 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/codes" "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" ) @@ -30,6 +31,7 @@ var _ status.Status var _ = runtime.String var _ = utilities.NewDoubleArray var _ = descriptor.ForMessage +var _ = metadata.Join var ( filter_Query_Sequencers_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} @@ -196,12 +198,14 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. -// Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { mux.Handle("GET", pattern_Query_Sequencers_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 { @@ -209,6 +213,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } resp, md, err := local_request_Query_Sequencers_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) @@ -222,6 +227,8 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv mux.Handle("GET", pattern_Query_Sequencer_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 { @@ -229,6 +236,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } resp, md, err := local_request_Query_Sequencer_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) @@ -242,6 +250,8 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv mux.Handle("GET", pattern_Query_HistoricalInfo_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 { @@ -249,6 +259,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } resp, md, err := local_request_Query_HistoricalInfo_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) @@ -262,6 +273,8 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) if err != nil { @@ -269,6 +282,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) From 9ba0104faa6890629e3070289084d6b5fd46a874 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C4=90=E1=BB=97=20Vi=E1=BB=87t=20Ho=C3=A0ng?= Date: Fri, 22 Mar 2024 01:35:43 +0700 Subject: [PATCH 2/3] Chores: update workflows and template (#338) --- .github/pull_request_template.md | 5 ++++ .github/workflows/codeql.yml | 41 +++++++++++++++++++++++++++++ .github/workflows/golangci_lint.yml | 23 ++++++++++++++++ .github/workflows/markdown_lint.yml | 19 +++++++++++++ 4 files changed, 88 insertions(+) create mode 100644 .github/workflows/codeql.yml create mode 100644 .github/workflows/golangci_lint.yml create mode 100644 .github/workflows/markdown_lint.yml diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 30357ce0..1d02bc64 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -4,6 +4,11 @@ --- +Closes #XXX + +**All** items are required. Please add a note to the item if the item is not applicable and +please add links to any relevant follow-up issues. + For Author: - [ ] Targeted PR against correct branch diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml new file mode 100644 index 00000000..12226a0f --- /dev/null +++ b/.github/workflows/codeql.yml @@ -0,0 +1,41 @@ +name: "CodeQL" + +on: + pull_request: + paths: + - "**.go" + push: + # The branches below must be a subset of the branches above + branches: + - main + - release/** + paths: + - "**.go" + +jobs: + analyze: + name: Analyze + runs-on: ubuntu-latest + permissions: + actions: read + contents: read + security-events: write + + steps: + - name: Checkout repository + uses: actions/checkout@v3 + - uses: actions/setup-go@v3 + with: + go-version: "1.22" + # Initializes the CodeQL tools for scanning. + - name: Initialize CodeQL + uses: github/codeql-action/init@v2 + with: + languages: "go" + queries: crypto-com/cosmos-sdk-codeql@main,security-and-quality + + - name: Build + run: make build + + - name: Perform CodeQL Analysis + uses: github/codeql-action/analyze@v2 diff --git a/.github/workflows/golangci_lint.yml b/.github/workflows/golangci_lint.yml new file mode 100644 index 00000000..10284610 --- /dev/null +++ b/.github/workflows/golangci_lint.yml @@ -0,0 +1,23 @@ +name: golangci-lint +on: + push: + tags: + - v* + branches: + - main + pull_request: + +jobs: + golangci: + name: golangci-lint + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-go@v5 + with: + go-version: "1.22" + - name: golangci-lint + uses: golangci/golangci-lint-action@v4.0.0 + with: + version: v1.56.2 + skip-cache: true diff --git a/.github/workflows/markdown_lint.yml b/.github/workflows/markdown_lint.yml new file mode 100644 index 00000000..2f1219c6 --- /dev/null +++ b/.github/workflows/markdown_lint.yml @@ -0,0 +1,19 @@ +name: markdown-lint +on: + push: + tags: + - v* + branches: + - main + pull_request: + +jobs: + markdownlint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: markdownlint-cli + uses: nosborn/github-action-markdown-cli@v3.2.0 + with: + files: ./ + config_file: .markdownlint.yaml \ No newline at end of file From 61e2b02ec803a600b85295108daf6bd3f09bd2d2 Mon Sep 17 00:00:00 2001 From: artpav <19916123+artemijspavlovs@users.noreply.github.com> Date: Fri, 22 Mar 2024 12:22:33 +0200 Subject: [PATCH 3/3] chore: add slack notification actions for new and stale PRs (#340) --- .github/workflows/new-pr-notification.yaml | 10 ++++++++++ .github/workflows/stale-pr-notification.yaml | 11 +++++++++++ 2 files changed, 21 insertions(+) create mode 100644 .github/workflows/new-pr-notification.yaml create mode 100644 .github/workflows/stale-pr-notification.yaml diff --git a/.github/workflows/new-pr-notification.yaml b/.github/workflows/new-pr-notification.yaml new file mode 100644 index 00000000..d8bcff94 --- /dev/null +++ b/.github/workflows/new-pr-notification.yaml @@ -0,0 +1,10 @@ +name: new-pr-notification-to-slack +on: + pull_request: + types: [opened] + +jobs: + new-pr-notification: + uses: dymensionxyz/common-workflows/.github/workflows/new-pr-notification.yaml@main + secrets: + WEBHOOK_URL: ${{ secrets.SLACK_NEW_PR_CHANNEL_WEBHOOK }} diff --git a/.github/workflows/stale-pr-notification.yaml b/.github/workflows/stale-pr-notification.yaml new file mode 100644 index 00000000..19b43423 --- /dev/null +++ b/.github/workflows/stale-pr-notification.yaml @@ -0,0 +1,11 @@ +name: stale-pr-notification-to-slack +on: + pull_request: + types: [labeled] + +jobs: + stale-pr-notification: + if: github.event.label.name == 'Stale' + uses: dymensionxyz/common-workflows/.github/workflows/stale-pr-notification.yaml@main + secrets: + WEBHOOK_URL: ${{ secrets.SLACK_STALE_PR_CHANNEL_WEBHOOK }}