From c7eaa817ea024f264f9d95aa784721743d59d164 Mon Sep 17 00:00:00 2001 From: Brandon Weng Date: Mon, 3 Oct 2022 23:09:55 -0700 Subject: [PATCH 1/4] Add gov proposal handler for acl --- proto/cosmos/accesscontrol_x/gov.proto | 49 + proto/cosmos/accesscontrol_x/query.proto | 26 +- x/README.md | 2 +- x/accesscontrol/client/cli/query.go | 114 +++ x/accesscontrol/client/cli/tx.go | 81 ++ x/accesscontrol/client/proposal_handler.go | 9 + x/accesscontrol/client/rest/rest.go | 67 ++ x/accesscontrol/client/utils/utils.go | 21 + .../update-access-dep-mapping-proposal.json | 22 + x/accesscontrol/handler.go | 28 + x/accesscontrol/keeper/genesis.go | 10 +- x/accesscontrol/keeper/grpc_query.go | 12 +- x/accesscontrol/module.go | 8 +- x/accesscontrol/types/codec.go | 24 + x/accesscontrol/types/gov.go | 67 ++ x/accesscontrol/types/gov.pb.go | 888 ++++++++++++++++++ x/accesscontrol/types/keys.go | 2 + x/accesscontrol/types/query.pb.go | 319 ++++--- x/accesscontrol/types/query.pb.gw.go | 56 +- 19 files changed, 1589 insertions(+), 216 deletions(-) create mode 100644 proto/cosmos/accesscontrol_x/gov.proto create mode 100644 x/accesscontrol/client/cli/query.go create mode 100644 x/accesscontrol/client/cli/tx.go create mode 100644 x/accesscontrol/client/proposal_handler.go create mode 100644 x/accesscontrol/client/rest/rest.go create mode 100644 x/accesscontrol/client/utils/utils.go create mode 100644 x/accesscontrol/examples/update-access-dep-mapping-proposal.json create mode 100644 x/accesscontrol/handler.go create mode 100644 x/accesscontrol/types/codec.go create mode 100644 x/accesscontrol/types/gov.go create mode 100644 x/accesscontrol/types/gov.pb.go diff --git a/proto/cosmos/accesscontrol_x/gov.proto b/proto/cosmos/accesscontrol_x/gov.proto new file mode 100644 index 000000000..2a7d75add --- /dev/null +++ b/proto/cosmos/accesscontrol_x/gov.proto @@ -0,0 +1,49 @@ +syntax = "proto3"; +package cosmos.accesscontrol.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/accesscontrol/constants.proto"; +import "cosmos/accesscontrol/accesscontrol.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/accesscontrol/types"; + +message MsgUpdateResourceDependencyMappingProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1 [ + (gogoproto.moretags) = "yaml:\"title\"", + (gogoproto.jsontag) = "title" + ]; + string description = 2 [ + (gogoproto.moretags) = "yaml:\"description\"", + (gogoproto.jsontag) = "description" + ]; + repeated cosmos.accesscontrol.v1beta1.MessageDependencyMapping message_dependency_mapping = 3 [ + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"message_dependency_mapping\"" + ]; +} + +message MsgUpdateResourceDependencyMappingProposalJsonFile { + string title = 1 [ + (gogoproto.moretags) = "yaml:\"title\"", + (gogoproto.jsontag) = "title" + ]; + string description = 2 [ + (gogoproto.moretags) = "yaml:\"description\"", + (gogoproto.jsontag) = "description" + ]; + string deposit = 3 [ + (gogoproto.moretags) = "yaml:\"deposit\"", + (gogoproto.jsontag) = "deposit" + ]; + repeated cosmos.accesscontrol.v1beta1.MessageDependencyMapping message_dependency_mapping = 4 [ + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"message_dependency_mapping\"" + ]; +} + +message MsgUpdateResourceDependencyMappingProposalResponse {} diff --git a/proto/cosmos/accesscontrol_x/query.proto b/proto/cosmos/accesscontrol_x/query.proto index 79d3f4a1f..be197e4dd 100644 --- a/proto/cosmos/accesscontrol_x/query.proto +++ b/proto/cosmos/accesscontrol_x/query.proto @@ -15,16 +15,16 @@ service Query { option (google.api.http).get = "/cosmos/cosmos-sdk/accesscontrol/params"; } - rpc ResourceDepedencyMappingFromMessageKey(ResourceDepedencyMappingFromMessageKeyRequest) - returns (ResourceDepedencyMappingFromMessageKeyResponse) { + rpc ResourceDependencyMappingFromMessageKey(ResourceDependencyMappingFromMessageKeyRequest) + returns (ResourceDependencyMappingFromMessageKeyResponse) { option (google.api.http).get = - "/cosmos/cosmos-sdk/accesscontrol/resource_depedency_mapping_from_message_key/{message_key}"; + "/cosmos/cosmos-sdk/accesscontrol/resource_dependency_mapping_from_message_key/{message_key}"; } - rpc ListResourceDepedencyMapping(ListResourceDepedencyMappingRequest) - returns (ListResourceDepedencyMappingResponse) { + rpc ListResourceDependencyMapping(ListResourceDependencyMappingRequest) + returns (ListResourceDependencyMappingResponse) { option (google.api.http).get = - "/cosmos/cosmos-sdk/accesscontrol/list_resource_depedency_mapping"; + "/cosmos/cosmos-sdk/accesscontrol/list_resource_dependency_mapping"; } } @@ -37,21 +37,21 @@ message QueryParamsResponse { cosmos.accesscontrol_x.v1beta1.Params params = 1 [ (gogoproto.nullable) = false ]; } -message ResourceDepedencyMappingFromMessageKeyRequest { +message ResourceDependencyMappingFromMessageKeyRequest { string message_key = 1 [ (gogoproto.moretags) = "yaml:\"message_key\"" ]; } -message ResourceDepedencyMappingFromMessageKeyResponse { - cosmos.accesscontrol.v1beta1.MessageDependencyMapping message_dependency_mapping = 1 [ +message ResourceDependencyMappingFromMessageKeyResponse { + cosmos.accesscontrol.v1beta1.MessageDependencyMapping message_dependency_mapping = 1 [ (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"message_dependency_mapping\"" ]; } -message ListResourceDepedencyMappingRequest {} - -message ListResourceDepedencyMappingResponse { - repeated cosmos.accesscontrol.v1beta1.MessageDependencyMapping message_dependency_mapping_list = 1 [ +message ListResourceDependencyMappingRequest {} + +message ListResourceDependencyMappingResponse { + repeated cosmos.accesscontrol.v1beta1.MessageDependencyMapping message_dependency_mapping_list = 1 [ (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"message_dependency_mapping_list\"" ]; diff --git a/x/README.md b/x/README.md index 393e16678..86e072524 100644 --- a/x/README.md +++ b/x/README.md @@ -7,7 +7,7 @@ parent: Here are some production-grade modules that can be used in Cosmos SDK applications, along with their respective documentation: -- [Accesscontrol] - Resource depedency access control module used for managing concurrent read/write access to resources. +- [Accesscontrol] - Resource dependency access control module used for managing concurrent read/write access to resources. - [Auth](auth/spec/README.md) - Authentication of accounts and transactions for Cosmos SDK application. - [Authz](authz/spec/README.md) - Authorization for accounts to perform actions on behalf of other accounts. - [Bank](bank/spec/README.md) - Token transfer functionalities. diff --git a/x/accesscontrol/client/cli/query.go b/x/accesscontrol/client/cli/query.go new file mode 100644 index 000000000..5601616ca --- /dev/null +++ b/x/accesscontrol/client/cli/query.go @@ -0,0 +1,114 @@ +package cli + +import ( + "fmt" + + "github.com/spf13/cobra" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/x/accesscontrol/types" +) + +func GetQueryCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: fmt.Sprintf("Querying commands for the %s module", types.ModuleName), + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + cmd.AddCommand( + GetParams(), + GetResourceDependencyMapping(), + ListResourceDependencyMapping(), + ) + + return cmd +} + +// GetParams returns the params for the module +func GetParams() *cobra.Command { + cmd := &cobra.Command{ + Use: "params [flags]", + Short: "Get the params for the x/accesscontrol module", + Args: cobra.ExactArgs(0), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{}) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + +func GetResourceDependencyMapping() *cobra.Command { + cmd := &cobra.Command{ + Use: "resource-dependency-mapping [messageKey] [flags]", + Short: "Get the resource dependency mapping for a specific message key", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.ResourceDependencyMappingFromMessageKey( + cmd.Context(), + &types.ResourceDependencyMappingFromMessageKeyRequest{MessageKey: args[0]}, + ) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + +func ListResourceDependencyMapping() *cobra.Command { + cmd := &cobra.Command{ + Use: "list-resource-dependency-mapping [flags]", + Short: "List all resource dependency mappings", + Args: cobra.ExactArgs(0), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.ListResourceDependencyMapping( + cmd.Context(), + &types.ListResourceDependencyMappingRequest{}, + ) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/accesscontrol/client/cli/tx.go b/x/accesscontrol/client/cli/tx.go new file mode 100644 index 000000000..bcca7e507 --- /dev/null +++ b/x/accesscontrol/client/cli/tx.go @@ -0,0 +1,81 @@ +package cli + +import ( + "fmt" + + "github.com/cosmos/cosmos-sdk/x/accesscontrol/client/utils" + "github.com/cosmos/cosmos-sdk/x/accesscontrol/types" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + sdk "github.com/cosmos/cosmos-sdk/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + + "github.com/spf13/cobra" +) + +func GetTxCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: fmt.Sprintf("%s transactions subcommands", types.ModuleName), + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + updateResourceDependencyMappingProposalCmd := MsgUpdateResourceDependencyMappingProposalCmd() + flags.AddTxFlagsToCmd(updateResourceDependencyMappingProposalCmd) + + cmd.AddCommand( + updateResourceDependencyMappingProposalCmd, + ) + + return cmd +} + +func MsgUpdateResourceDependencyMappingProposalCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "update-resource-dependency-mapping [proposal-file]", + Args: cobra.ExactArgs(1), + Short: "Submit an UpdateResourceDependencyMapping proposal", + RunE: func(cmd *cobra.Command, args []string) error { + println("MsgUpdateResourceDependencyMappingProposalCmd:HANDLING CLI REQUEST") + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + proposal, err := utils.ParseMsgUpdateResourceDependencyMappingProposalFile(clientCtx.Codec, args[0]) + if err != nil { + return err + } + + println("MsgUpdateResourceDependencyMappingProposalCmd:GETTING FROM ADDRESS") + from := clientCtx.GetFromAddress() + + content := types.MsgUpdateResourceDependencyMappingProposal{ + Title: proposal.Title, + Description: proposal.Description, + MessageDependencyMapping: proposal.MessageDependencyMapping, + } + + deposit, err := sdk.ParseCoinsNormalized(proposal.Deposit) + if err != nil { + println("Unable to prase coin from UpdateResourceDependencyMapping from CLI") + return err + } + + println("MsgUpdateResourceDependencyMappingProposalCmd:SUBMITTING PROPOSAL") + msg, err := govtypes.NewMsgSubmitProposal(&content, deposit, from) + if err != nil { + println("Unable to submit proposal for UpdateResourceDependencyMapping from CLI") + return err + } + println("MsgUpdateResourceDependencyMappingProposalCmd:SENDING!") + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + return cmd +} diff --git a/x/accesscontrol/client/proposal_handler.go b/x/accesscontrol/client/proposal_handler.go new file mode 100644 index 000000000..36916edfa --- /dev/null +++ b/x/accesscontrol/client/proposal_handler.go @@ -0,0 +1,9 @@ +package client + +import ( + "github.com/cosmos/cosmos-sdk/x/accesscontrol/client/cli" + "github.com/cosmos/cosmos-sdk/x/accesscontrol/client/rest" + govclient "github.com/cosmos/cosmos-sdk/x/gov/client" +) + +var ProposalHandler = govclient.NewProposalHandler(cli.MsgUpdateResourceDependencyMappingProposalCmd, rest.ProposalRESTHandler) diff --git a/x/accesscontrol/client/rest/rest.go b/x/accesscontrol/client/rest/rest.go new file mode 100644 index 000000000..d3b1d28c6 --- /dev/null +++ b/x/accesscontrol/client/rest/rest.go @@ -0,0 +1,67 @@ +package rest + +import ( + "net/http" + + "github.com/cosmos/cosmos-sdk/client/tx" + + govrest "github.com/cosmos/cosmos-sdk/x/gov/client/rest" + + "github.com/cosmos/cosmos-sdk/client" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/accesscontrol" + "github.com/cosmos/cosmos-sdk/types/rest" + "github.com/cosmos/cosmos-sdk/x/accesscontrol/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +// PlanRequest defines a proposal for a new upgrade plan. +type UpdateResourceDependencyMappingRequest struct { + BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"` + Title string `json:"title" yaml:"title"` + Description string `json:"description" yaml:"description"` + Deposit sdk.Coins `json:"deposit" yaml:"deposit"` + MessageDependencyMapping []accesscontrol.MessageDependencyMapping `json:"message_dependency_mapping" yaml:"message_dependency_mapping"` + +} + +func ProposalRESTHandler(clientCtx client.Context) govrest.ProposalRESTHandler { + return govrest.ProposalRESTHandler{ + SubRoute: "update_resource_dependency_mapping", + Handler: newPostPlanHandler(clientCtx), + } +} + +func newPostPlanHandler(clientCtx client.Context) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + println("HANDLING POST REQUEST") + var req UpdateResourceDependencyMappingRequest + + if !rest.ReadRESTReq(w, r, clientCtx.LegacyAmino, &req) { + return + } + + req.BaseReq = req.BaseReq.Sanitize() + if !req.BaseReq.ValidateBasic(w) { + return + } + + fromAddr, err := sdk.AccAddressFromBech32(req.BaseReq.From) + if rest.CheckBadRequestError(w, err) { + return + } + + content := types.NewMsgUpdateResourceDependencyMappingProposal( + req.Title, req.Description, req.MessageDependencyMapping, + ) + msg, err := govtypes.NewMsgSubmitProposal(content, req.Deposit, fromAddr) + if rest.CheckBadRequestError(w, err) { + return + } + if rest.CheckBadRequestError(w, msg.ValidateBasic()) { + return + } + + tx.WriteGeneratedTxResponse(clientCtx, w, req.BaseReq, msg) + } +} diff --git a/x/accesscontrol/client/utils/utils.go b/x/accesscontrol/client/utils/utils.go new file mode 100644 index 000000000..914ccd7fd --- /dev/null +++ b/x/accesscontrol/client/utils/utils.go @@ -0,0 +1,21 @@ +package utils + +import ( + "io/ioutil" + + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/x/accesscontrol/types" +) + +func ParseMsgUpdateResourceDependencyMappingProposalFile(cdc codec.JSONCodec, proposalFile string) (types.MsgUpdateResourceDependencyMappingProposalJsonFile, error) { + proposal := types.MsgUpdateResourceDependencyMappingProposalJsonFile{} + + contents, err := ioutil.ReadFile(proposalFile) + if err != nil { + return proposal, err + } + + cdc.MustUnmarshalJSON(contents, &proposal) + + return proposal, nil +} diff --git a/x/accesscontrol/examples/update-access-dep-mapping-proposal.json b/x/accesscontrol/examples/update-access-dep-mapping-proposal.json new file mode 100644 index 000000000..1d297c603 --- /dev/null +++ b/x/accesscontrol/examples/update-access-dep-mapping-proposal.json @@ -0,0 +1,22 @@ +{ + "title": "Updating Resource Dependency Mapping", + "description": "Updating mapping for message key 'testing'", + "deposit": "10sei", + "message_dependency_mapping": [ + { + "message_key": "testing", + "access_ops": [ + { + "access_type": "UNKNOWN", + "resource_type": "ANY", + "identifier_template": "*" + }, + { + "access_type": "COMMIT", + "resource_type": "ANY", + "identifier_template": "*" + } + ] + } + ] +} diff --git a/x/accesscontrol/handler.go b/x/accesscontrol/handler.go new file mode 100644 index 000000000..ab07286b9 --- /dev/null +++ b/x/accesscontrol/handler.go @@ -0,0 +1,28 @@ +package accesscontrol + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + + "github.com/cosmos/cosmos-sdk/x/accesscontrol/keeper" + "github.com/cosmos/cosmos-sdk/x/accesscontrol/types" +) + +func HandleMsgUpdateResourceDependencyMappingProposal(ctx sdk.Context, k *keeper.Keeper, p *types.MsgUpdateResourceDependencyMappingProposal) error { + for _, resourceDepMapping := range p.MessageDependencyMapping { + k.SetResourceDependencyMapping(ctx, resourceDepMapping) + } + return nil +} + +func NewProposalHandler(k keeper.Keeper) govtypes.Handler { + return func(ctx sdk.Context, content govtypes.Content) error { + switch c := content.(type) { + case *types.MsgUpdateResourceDependencyMappingProposal: + return HandleMsgUpdateResourceDependencyMappingProposal(ctx, &k, c) + default: + return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized accesscontrol proposal content type: %T", c) + } + } +} diff --git a/x/accesscontrol/keeper/genesis.go b/x/accesscontrol/keeper/genesis.go index 85f01ecf2..764b58f7b 100644 --- a/x/accesscontrol/keeper/genesis.go +++ b/x/accesscontrol/keeper/genesis.go @@ -8,19 +8,19 @@ import ( func (k Keeper) InitGenesis(ctx sdk.Context, genState types.GenesisState) { k.SetParams(ctx, genState.Params) - for _, resourceDepedencyMapping := range genState.GetMessageDependencyMapping() { - k.SetResourceDependencyMapping(ctx, resourceDepedencyMapping) + for _, resourceDependencyMapping := range genState.GetMessageDependencyMapping() { + k.SetResourceDependencyMapping(ctx, resourceDependencyMapping) } } func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState { - resourceDepedencyMappings := []acltypes.MessageDependencyMapping{} + resourceDependencyMappings := []acltypes.MessageDependencyMapping{} k.IterateResourceKeys(ctx, func(dependencyMapping acltypes.MessageDependencyMapping) (stop bool) { - resourceDepedencyMappings = append(resourceDepedencyMappings, dependencyMapping) + resourceDependencyMappings = append(resourceDependencyMappings, dependencyMapping) return false }) return &types.GenesisState{ Params: k.GetParams(ctx), - MessageDependencyMapping: resourceDepedencyMappings, + MessageDependencyMapping: resourceDependencyMappings, } } diff --git a/x/accesscontrol/keeper/grpc_query.go b/x/accesscontrol/keeper/grpc_query.go index 6c48370da..b1b4c8251 100644 --- a/x/accesscontrol/keeper/grpc_query.go +++ b/x/accesscontrol/keeper/grpc_query.go @@ -17,21 +17,21 @@ func (k Keeper) Params(ctx context.Context, req *types.QueryParamsRequest) (*typ return &types.QueryParamsResponse{Params: params}, nil } -func (k Keeper) ResourceDepedencyMappingFromMessageKey(ctx context.Context, req *types.ResourceDepedencyMappingFromMessageKeyRequest) (*types.ResourceDepedencyMappingFromMessageKeyResponse, error) { +func (k Keeper) ResourceDependencyMappingFromMessageKey(ctx context.Context, req *types.ResourceDependencyMappingFromMessageKeyRequest) (*types.ResourceDependencyMappingFromMessageKeyResponse, error) { sdkCtx := sdk.UnwrapSDKContext(ctx) resourceDependency := k.GetResourceDependencyMapping(sdkCtx, req.GetMessageKey()) - return &types.ResourceDepedencyMappingFromMessageKeyResponse{MessageDependencyMapping: resourceDependency}, nil + return &types.ResourceDependencyMappingFromMessageKeyResponse{MessageDependencyMapping: resourceDependency}, nil } -func (k Keeper) ListResourceDepedencyMapping(ctx context.Context, req *types.ListResourceDepedencyMappingRequest) (*types.ListResourceDepedencyMappingResponse, error) { +func (k Keeper) ListResourceDependencyMapping(ctx context.Context, req *types.ListResourceDependencyMappingRequest) (*types.ListResourceDependencyMappingResponse, error) { sdkCtx := sdk.UnwrapSDKContext(ctx) - resourceDepedencyMappings := []acltypes.MessageDependencyMapping{} + resourceDependencyMappings := []acltypes.MessageDependencyMapping{} k.IterateResourceKeys(sdkCtx, func(dependencyMapping acltypes.MessageDependencyMapping) (stop bool) { - resourceDepedencyMappings = append(resourceDepedencyMappings, dependencyMapping) + resourceDependencyMappings = append(resourceDependencyMappings, dependencyMapping) return false }) - return &types.ListResourceDepedencyMappingResponse{MessageDependencyMappingList: resourceDepedencyMappings}, nil + return &types.ListResourceDependencyMappingResponse{MessageDependencyMappingList: resourceDependencyMappings}, nil } diff --git a/x/accesscontrol/module.go b/x/accesscontrol/module.go index f0844fedd..b7d025e30 100644 --- a/x/accesscontrol/module.go +++ b/x/accesscontrol/module.go @@ -16,7 +16,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" - cli "github.com/cosmos/cosmos-sdk/x/accesscontrol/client" + cli "github.com/cosmos/cosmos-sdk/x/accesscontrol/client/cli" "github.com/cosmos/cosmos-sdk/x/accesscontrol/keeper" "github.com/cosmos/cosmos-sdk/x/accesscontrol/types" ) @@ -43,7 +43,9 @@ func (AppModuleBasic) Name() string { func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {} // RegisterInterfaces registers the module's interface types -func (b AppModuleBasic) RegisterInterfaces(_ cdctypes.InterfaceRegistry) {} +func (b AppModuleBasic) RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + types.RegisterInterfaces(registry) +} // DefaultGenesis returns default genesis state as raw bytes for the accesscontrol // module. @@ -69,7 +71,7 @@ func (AppModuleBasic) RegisterRESTRoutes(clientCtx client.Context, rtr *mux.Rout func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) {} // GetTxCmd returns no root tx command for the accesscontrol module. -func (AppModuleBasic) GetTxCmd() *cobra.Command { return nil } +func (AppModuleBasic) GetTxCmd() *cobra.Command { return cli.GetTxCmd() } // GetQueryCmd returns the root query command for the accesscontrol module. func (AppModuleBasic) GetQueryCmd() *cobra.Command { return cli.GetQueryCmd() } diff --git a/x/accesscontrol/types/codec.go b/x/accesscontrol/types/codec.go new file mode 100644 index 000000000..7c933693a --- /dev/null +++ b/x/accesscontrol/types/codec.go @@ -0,0 +1,24 @@ +package types + +import ( + "github.com/cosmos/cosmos-sdk/codec" + cdctypes "github.com/cosmos/cosmos-sdk/codec/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + // this line is used by starport scaffolding # 1 +) + +func RegisterCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete( + &MsgUpdateResourceDependencyMappingProposal{}, + "cosmos-sdk/MsgUpdateResourceDependencyMappingProposal", + nil, + ) +} + +func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + registry.RegisterImplementations((*govtypes.Content)(nil), + &MsgUpdateResourceDependencyMappingProposal{}, + ) +} + +var ModuleCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry()) diff --git a/x/accesscontrol/types/gov.go b/x/accesscontrol/types/gov.go new file mode 100644 index 000000000..8734b7632 --- /dev/null +++ b/x/accesscontrol/types/gov.go @@ -0,0 +1,67 @@ +package types + +import ( + "fmt" + "strings" + + acltypes "github.com/cosmos/cosmos-sdk/types/accesscontrol" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +const ( + ProposalUpdateResourceDependencyMapping = "UpdateResourceDependencyMapping" +) + +func init() { + // for routing + govtypes.RegisterProposalType(ProposalUpdateResourceDependencyMapping) + // for marshal and unmarshal + govtypes.RegisterProposalTypeCodec(&MsgUpdateResourceDependencyMappingProposal{}, "tokenfactory/MsgUpdateResourceDependencyMappingProposal") +} + +var _ govtypes.Content = &MsgUpdateResourceDependencyMappingProposal{} + +func NewRegisterPairsProposal(title, description string, messageDependencyMapping []acltypes.MessageDependencyMapping) MsgUpdateResourceDependencyMappingProposal { + return MsgUpdateResourceDependencyMappingProposal{ + Title: title, + Description: description, + MessageDependencyMapping : messageDependencyMapping, + } +} + +func NewMsgUpdateResourceDependencyMappingProposal(title, description string, messageDependencyMapping []acltypes.MessageDependencyMapping) *MsgUpdateResourceDependencyMappingProposal { + return &MsgUpdateResourceDependencyMappingProposal{title, description, messageDependencyMapping} +} + +func (p *MsgUpdateResourceDependencyMappingProposal) GetTitle() string { return p.Title } + +func (p *MsgUpdateResourceDependencyMappingProposal) GetDescription() string { return p.Description } + +func (p *MsgUpdateResourceDependencyMappingProposal) ProposalRoute() string { return RouterKey } + +func (p *MsgUpdateResourceDependencyMappingProposal) ProposalType() string { + return ProposalUpdateResourceDependencyMapping +} + +func (p *MsgUpdateResourceDependencyMappingProposal) ValidateBasic() error { + err := govtypes.ValidateAbstract(p) + return err +} + +func (p MsgUpdateResourceDependencyMappingProposal) String() string { + var b strings.Builder + b.WriteString( + fmt.Sprintf(`Add Creators to Denom Fee Whitelist Proposal: + Title: %s + Description: %s + Changes: + `, + p.Title, p.Description)) + + for _, depMapping := range p.MessageDependencyMapping { + b.WriteString(fmt.Sprintf(` Change: + MessageDependencyMapping: %s + `, depMapping.String())) + } + return b.String() +} diff --git a/x/accesscontrol/types/gov.pb.go b/x/accesscontrol/types/gov.pb.go new file mode 100644 index 000000000..6e7c348d8 --- /dev/null +++ b/x/accesscontrol/types/gov.pb.go @@ -0,0 +1,888 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: cosmos/accesscontrol_x/gov.proto + +package types + +import ( + fmt "fmt" + accesscontrol "github.com/cosmos/cosmos-sdk/types/accesscontrol" + _ "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 + +type MsgUpdateResourceDependencyMappingProposal struct { + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title" yaml:"title"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description" yaml:"description"` + MessageDependencyMapping []accesscontrol.MessageDependencyMapping `protobuf:"bytes,3,rep,name=message_dependency_mapping,json=messageDependencyMapping,proto3" json:"message_dependency_mapping" yaml:"message_dependency_mapping"` +} + +func (m *MsgUpdateResourceDependencyMappingProposal) Reset() { + *m = MsgUpdateResourceDependencyMappingProposal{} +} +func (*MsgUpdateResourceDependencyMappingProposal) ProtoMessage() {} +func (*MsgUpdateResourceDependencyMappingProposal) Descriptor() ([]byte, []int) { + return fileDescriptor_3e058bfaa38d4c4c, []int{0} +} +func (m *MsgUpdateResourceDependencyMappingProposal) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateResourceDependencyMappingProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateResourceDependencyMappingProposal.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 *MsgUpdateResourceDependencyMappingProposal) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateResourceDependencyMappingProposal.Merge(m, src) +} +func (m *MsgUpdateResourceDependencyMappingProposal) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateResourceDependencyMappingProposal) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateResourceDependencyMappingProposal.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateResourceDependencyMappingProposal proto.InternalMessageInfo + +type MsgUpdateResourceDependencyMappingProposalJsonFile struct { + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title" yaml:"title"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description" yaml:"description"` + Deposit string `protobuf:"bytes,3,opt,name=deposit,proto3" json:"deposit" yaml:"deposit"` + MessageDependencyMapping []accesscontrol.MessageDependencyMapping `protobuf:"bytes,4,rep,name=message_dependency_mapping,json=messageDependencyMapping,proto3" json:"message_dependency_mapping" yaml:"message_dependency_mapping"` +} + +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) Reset() { + *m = MsgUpdateResourceDependencyMappingProposalJsonFile{} +} +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) String() string { + return proto.CompactTextString(m) +} +func (*MsgUpdateResourceDependencyMappingProposalJsonFile) ProtoMessage() {} +func (*MsgUpdateResourceDependencyMappingProposalJsonFile) Descriptor() ([]byte, []int) { + return fileDescriptor_3e058bfaa38d4c4c, []int{1} +} +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateResourceDependencyMappingProposalJsonFile.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 *MsgUpdateResourceDependencyMappingProposalJsonFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateResourceDependencyMappingProposalJsonFile.Merge(m, src) +} +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateResourceDependencyMappingProposalJsonFile.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateResourceDependencyMappingProposalJsonFile proto.InternalMessageInfo + +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) GetTitle() string { + if m != nil { + return m.Title + } + return "" +} + +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) GetDeposit() string { + if m != nil { + return m.Deposit + } + return "" +} + +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) GetMessageDependencyMapping() []accesscontrol.MessageDependencyMapping { + if m != nil { + return m.MessageDependencyMapping + } + return nil +} + +type MsgUpdateResourceDependencyMappingProposalResponse struct { +} + +func (m *MsgUpdateResourceDependencyMappingProposalResponse) Reset() { + *m = MsgUpdateResourceDependencyMappingProposalResponse{} +} +func (m *MsgUpdateResourceDependencyMappingProposalResponse) String() string { + return proto.CompactTextString(m) +} +func (*MsgUpdateResourceDependencyMappingProposalResponse) ProtoMessage() {} +func (*MsgUpdateResourceDependencyMappingProposalResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3e058bfaa38d4c4c, []int{2} +} +func (m *MsgUpdateResourceDependencyMappingProposalResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateResourceDependencyMappingProposalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateResourceDependencyMappingProposalResponse.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 *MsgUpdateResourceDependencyMappingProposalResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateResourceDependencyMappingProposalResponse.Merge(m, src) +} +func (m *MsgUpdateResourceDependencyMappingProposalResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateResourceDependencyMappingProposalResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateResourceDependencyMappingProposalResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateResourceDependencyMappingProposalResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgUpdateResourceDependencyMappingProposal)(nil), "cosmos.accesscontrol.v1beta1.MsgUpdateResourceDependencyMappingProposal") + proto.RegisterType((*MsgUpdateResourceDependencyMappingProposalJsonFile)(nil), "cosmos.accesscontrol.v1beta1.MsgUpdateResourceDependencyMappingProposalJsonFile") + proto.RegisterType((*MsgUpdateResourceDependencyMappingProposalResponse)(nil), "cosmos.accesscontrol.v1beta1.MsgUpdateResourceDependencyMappingProposalResponse") +} + +func init() { proto.RegisterFile("cosmos/accesscontrol_x/gov.proto", fileDescriptor_3e058bfaa38d4c4c) } + +var fileDescriptor_3e058bfaa38d4c4c = []byte{ + // 438 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x93, 0xcf, 0x8b, 0xd3, 0x40, + 0x14, 0xc7, 0x93, 0xad, 0x3f, 0x30, 0x2b, 0x22, 0xc1, 0x43, 0x2c, 0x9a, 0xa9, 0x41, 0xa1, 0x0a, + 0x26, 0x6c, 0x15, 0x85, 0x3d, 0x16, 0x51, 0x10, 0x0b, 0x12, 0xf0, 0xe2, 0xa5, 0x4c, 0x27, 0x8f, + 0x18, 0x4c, 0xe6, 0x0d, 0x79, 0xb3, 0xcb, 0xf6, 0xe6, 0x51, 0x6f, 0x1e, 0xbd, 0xd9, 0x3f, 0x67, + 0x8f, 0x7b, 0x14, 0x91, 0x41, 0xda, 0x8b, 0xf4, 0x98, 0xbf, 0x40, 0xcc, 0x6c, 0xa5, 0xab, 0xbb, + 0xfe, 0x38, 0xed, 0x29, 0xc9, 0x37, 0x9f, 0xef, 0x77, 0xde, 0xbc, 0xc7, 0xf3, 0x7a, 0x02, 0xa9, + 0x42, 0x4a, 0xb8, 0x10, 0x40, 0x24, 0x50, 0xea, 0x1a, 0xcb, 0xf1, 0x5e, 0x92, 0xe3, 0x6e, 0xac, + 0x6a, 0xd4, 0xe8, 0x5f, 0xb3, 0x44, 0x7c, 0x84, 0x88, 0x77, 0xb7, 0x26, 0xa0, 0xf9, 0x56, 0xf7, + 0x4a, 0x8e, 0x39, 0xb6, 0x60, 0xf2, 0xe3, 0xcd, 0x7a, 0xba, 0x37, 0x8f, 0x4b, 0x4d, 0x04, 0x4a, + 0xd2, 0x5c, 0x6a, 0x3a, 0xa4, 0xfa, 0xc7, 0x52, 0x47, 0xcf, 0x69, 0xc9, 0xe8, 0xf3, 0x86, 0x77, + 0x67, 0x44, 0xf9, 0x0b, 0x95, 0x71, 0x0d, 0x29, 0x10, 0xee, 0xd4, 0x02, 0x1e, 0x81, 0x02, 0x99, + 0x81, 0x14, 0xd3, 0x11, 0x57, 0xaa, 0x90, 0xf9, 0xf3, 0x1a, 0x15, 0x12, 0x2f, 0xfd, 0xc4, 0x3b, + 0xab, 0x0b, 0x5d, 0x42, 0xe0, 0xf6, 0xdc, 0xfe, 0x85, 0xe1, 0xd5, 0xa5, 0x61, 0x56, 0x68, 0x0c, + 0xbb, 0x38, 0xe5, 0x55, 0xb9, 0x1d, 0xb5, 0x9f, 0x51, 0x6a, 0x65, 0xff, 0x89, 0xb7, 0x99, 0x01, + 0x89, 0xba, 0x50, 0xba, 0x40, 0x19, 0x6c, 0xb4, 0xb6, 0x5b, 0x4b, 0xc3, 0xd6, 0xe5, 0xc6, 0x30, + 0xdf, 0x9a, 0xd7, 0xc4, 0x28, 0x5d, 0x47, 0xfc, 0x8f, 0xae, 0xd7, 0xad, 0x80, 0x88, 0xe7, 0x30, + 0xce, 0x7e, 0xd6, 0x37, 0xae, 0x6c, 0x81, 0x41, 0xa7, 0xd7, 0xe9, 0x6f, 0x0e, 0x1e, 0xc4, 0x7f, + 0x6a, 0x69, 0x3c, 0xb2, 0xfe, 0xdf, 0xae, 0x37, 0xbc, 0xbd, 0x6f, 0x98, 0xd3, 0x18, 0x76, 0xc3, + 0x56, 0x71, 0xf2, 0x39, 0x51, 0x1a, 0x54, 0x27, 0x84, 0x6c, 0x5f, 0x7e, 0x3b, 0x63, 0xce, 0x87, + 0x19, 0x73, 0xbe, 0xcd, 0x98, 0xf3, 0xe6, 0x4b, 0xcf, 0x89, 0xde, 0x75, 0xbc, 0xc1, 0xbf, 0x37, + 0xf7, 0x29, 0xa1, 0x7c, 0x5c, 0x94, 0x70, 0x8a, 0x4d, 0x7e, 0xe8, 0x9d, 0xcf, 0x40, 0x21, 0x15, + 0x3a, 0xe8, 0xb4, 0x21, 0xd7, 0x97, 0x86, 0xad, 0xa4, 0xc6, 0xb0, 0x4b, 0xab, 0x80, 0x56, 0x88, + 0xd2, 0xd5, 0xaf, 0xbf, 0x4d, 0xe7, 0xcc, 0xa9, 0x4f, 0x27, 0xba, 0xff, 0x3f, 0xa3, 0x48, 0x81, + 0x14, 0x4a, 0x82, 0xe1, 0xb3, 0xfd, 0x79, 0xe8, 0x1e, 0xcc, 0x43, 0xf7, 0xeb, 0x3c, 0x74, 0xdf, + 0x2f, 0x42, 0xe7, 0x60, 0x11, 0x3a, 0x9f, 0x16, 0xa1, 0xf3, 0x72, 0x90, 0x17, 0xfa, 0xd5, 0xce, + 0x24, 0x16, 0x58, 0x25, 0x87, 0xdb, 0x66, 0x1f, 0x77, 0x29, 0x7b, 0x9d, 0xec, 0xfd, 0xb2, 0x7a, + 0x7a, 0xaa, 0x80, 0x26, 0xe7, 0xda, 0x9d, 0xbb, 0xf7, 0x3d, 0x00, 0x00, 0xff, 0xff, 0xf5, 0xbc, + 0x2e, 0x6d, 0x1b, 0x04, 0x00, 0x00, +} + +func (m *MsgUpdateResourceDependencyMappingProposal) 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 *MsgUpdateResourceDependencyMappingProposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateResourceDependencyMappingProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.MessageDependencyMapping) > 0 { + for iNdEx := len(m.MessageDependencyMapping) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MessageDependencyMapping[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGov(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintGov(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x12 + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = encodeVarintGov(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) 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 *MsgUpdateResourceDependencyMappingProposalJsonFile) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.MessageDependencyMapping) > 0 { + for iNdEx := len(m.MessageDependencyMapping) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MessageDependencyMapping[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGov(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.Deposit) > 0 { + i -= len(m.Deposit) + copy(dAtA[i:], m.Deposit) + i = encodeVarintGov(dAtA, i, uint64(len(m.Deposit))) + i-- + dAtA[i] = 0x1a + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintGov(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x12 + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = encodeVarintGov(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateResourceDependencyMappingProposalResponse) 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 *MsgUpdateResourceDependencyMappingProposalResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateResourceDependencyMappingProposalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintGov(dAtA []byte, offset int, v uint64) int { + offset -= sovGov(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgUpdateResourceDependencyMappingProposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + if len(m.MessageDependencyMapping) > 0 { + for _, e := range m.MessageDependencyMapping { + l = e.Size() + n += 1 + l + sovGov(uint64(l)) + } + } + return n +} + +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + l = len(m.Deposit) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + if len(m.MessageDependencyMapping) > 0 { + for _, e := range m.MessageDependencyMapping { + l = e.Size() + n += 1 + l + sovGov(uint64(l)) + } + } + return n +} + +func (m *MsgUpdateResourceDependencyMappingProposalResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovGov(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGov(x uint64) (n int) { + return sovGov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgUpdateResourceDependencyMappingProposal) 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 ErrIntOverflowGov + } + 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: MsgUpdateResourceDependencyMappingProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateResourceDependencyMappingProposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageDependencyMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGov + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageDependencyMapping = append(m.MessageDependencyMapping, accesscontrol.MessageDependencyMapping{}) + if err := m.MessageDependencyMapping[len(m.MessageDependencyMapping)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGov(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGov + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateResourceDependencyMappingProposalJsonFile) 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 ErrIntOverflowGov + } + 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: MsgUpdateResourceDependencyMappingProposalJsonFile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateResourceDependencyMappingProposalJsonFile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Deposit = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageDependencyMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGov + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageDependencyMapping = append(m.MessageDependencyMapping, accesscontrol.MessageDependencyMapping{}) + if err := m.MessageDependencyMapping[len(m.MessageDependencyMapping)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGov(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGov + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateResourceDependencyMappingProposalResponse) 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 ErrIntOverflowGov + } + 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: MsgUpdateResourceDependencyMappingProposalResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateResourceDependencyMappingProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipGov(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGov + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGov(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, ErrIntOverflowGov + } + 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, ErrIntOverflowGov + } + 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, ErrIntOverflowGov + } + 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, ErrInvalidLengthGov + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGov + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGov + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGov = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGov = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGov = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/accesscontrol/types/keys.go b/x/accesscontrol/types/keys.go index 8ac8700d4..998c7a70f 100644 --- a/x/accesscontrol/types/keys.go +++ b/x/accesscontrol/types/keys.go @@ -11,6 +11,8 @@ const ( // Append "acl" to prevent prefix collision with "acc" module StoreKey = "acl" + ModuleName + + RouterKey = ModuleName ) func GetResourceDependencyMappingKey() []byte { diff --git a/x/accesscontrol/types/query.pb.go b/x/accesscontrol/types/query.pb.go index 058e266b1..56df3b5a5 100644 --- a/x/accesscontrol/types/query.pb.go +++ b/x/accesscontrol/types/query.pb.go @@ -112,26 +112,26 @@ func (m *QueryParamsResponse) GetParams() Params { return Params{} } -type ResourceDepedencyMappingFromMessageKeyRequest struct { +type ResourceDependencyMappingFromMessageKeyRequest struct { MessageKey string `protobuf:"bytes,1,opt,name=message_key,json=messageKey,proto3" json:"message_key,omitempty" yaml:"message_key"` } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) Reset() { - *m = ResourceDepedencyMappingFromMessageKeyRequest{} +func (m *ResourceDependencyMappingFromMessageKeyRequest) Reset() { + *m = ResourceDependencyMappingFromMessageKeyRequest{} } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) String() string { +func (m *ResourceDependencyMappingFromMessageKeyRequest) String() string { return proto.CompactTextString(m) } -func (*ResourceDepedencyMappingFromMessageKeyRequest) ProtoMessage() {} -func (*ResourceDepedencyMappingFromMessageKeyRequest) Descriptor() ([]byte, []int) { +func (*ResourceDependencyMappingFromMessageKeyRequest) ProtoMessage() {} +func (*ResourceDependencyMappingFromMessageKeyRequest) Descriptor() ([]byte, []int) { return fileDescriptor_d83f2274e13e6a16, []int{2} } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) XXX_Unmarshal(b []byte) error { +func (m *ResourceDependencyMappingFromMessageKeyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ResourceDependencyMappingFromMessageKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ResourceDepedencyMappingFromMessageKeyRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_ResourceDependencyMappingFromMessageKeyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -141,45 +141,45 @@ func (m *ResourceDepedencyMappingFromMessageKeyRequest) XXX_Marshal(b []byte, de return b[:n], nil } } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ResourceDepedencyMappingFromMessageKeyRequest.Merge(m, src) +func (m *ResourceDependencyMappingFromMessageKeyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResourceDependencyMappingFromMessageKeyRequest.Merge(m, src) } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) XXX_Size() int { +func (m *ResourceDependencyMappingFromMessageKeyRequest) XXX_Size() int { return m.Size() } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ResourceDepedencyMappingFromMessageKeyRequest.DiscardUnknown(m) +func (m *ResourceDependencyMappingFromMessageKeyRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ResourceDependencyMappingFromMessageKeyRequest.DiscardUnknown(m) } -var xxx_messageInfo_ResourceDepedencyMappingFromMessageKeyRequest proto.InternalMessageInfo +var xxx_messageInfo_ResourceDependencyMappingFromMessageKeyRequest proto.InternalMessageInfo -func (m *ResourceDepedencyMappingFromMessageKeyRequest) GetMessageKey() string { +func (m *ResourceDependencyMappingFromMessageKeyRequest) GetMessageKey() string { if m != nil { return m.MessageKey } return "" } -type ResourceDepedencyMappingFromMessageKeyResponse struct { +type ResourceDependencyMappingFromMessageKeyResponse struct { MessageDependencyMapping accesscontrol.MessageDependencyMapping `protobuf:"bytes,1,opt,name=message_dependency_mapping,json=messageDependencyMapping,proto3" json:"message_dependency_mapping" yaml:"message_dependency_mapping"` } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) Reset() { - *m = ResourceDepedencyMappingFromMessageKeyResponse{} +func (m *ResourceDependencyMappingFromMessageKeyResponse) Reset() { + *m = ResourceDependencyMappingFromMessageKeyResponse{} } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) String() string { +func (m *ResourceDependencyMappingFromMessageKeyResponse) String() string { return proto.CompactTextString(m) } -func (*ResourceDepedencyMappingFromMessageKeyResponse) ProtoMessage() {} -func (*ResourceDepedencyMappingFromMessageKeyResponse) Descriptor() ([]byte, []int) { +func (*ResourceDependencyMappingFromMessageKeyResponse) ProtoMessage() {} +func (*ResourceDependencyMappingFromMessageKeyResponse) Descriptor() ([]byte, []int) { return fileDescriptor_d83f2274e13e6a16, []int{3} } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) XXX_Unmarshal(b []byte) error { +func (m *ResourceDependencyMappingFromMessageKeyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ResourceDependencyMappingFromMessageKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ResourceDepedencyMappingFromMessageKeyResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_ResourceDependencyMappingFromMessageKeyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -189,40 +189,40 @@ func (m *ResourceDepedencyMappingFromMessageKeyResponse) XXX_Marshal(b []byte, d return b[:n], nil } } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ResourceDepedencyMappingFromMessageKeyResponse.Merge(m, src) +func (m *ResourceDependencyMappingFromMessageKeyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResourceDependencyMappingFromMessageKeyResponse.Merge(m, src) } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) XXX_Size() int { +func (m *ResourceDependencyMappingFromMessageKeyResponse) XXX_Size() int { return m.Size() } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ResourceDepedencyMappingFromMessageKeyResponse.DiscardUnknown(m) +func (m *ResourceDependencyMappingFromMessageKeyResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ResourceDependencyMappingFromMessageKeyResponse.DiscardUnknown(m) } -var xxx_messageInfo_ResourceDepedencyMappingFromMessageKeyResponse proto.InternalMessageInfo +var xxx_messageInfo_ResourceDependencyMappingFromMessageKeyResponse proto.InternalMessageInfo -func (m *ResourceDepedencyMappingFromMessageKeyResponse) GetMessageDependencyMapping() accesscontrol.MessageDependencyMapping { +func (m *ResourceDependencyMappingFromMessageKeyResponse) GetMessageDependencyMapping() accesscontrol.MessageDependencyMapping { if m != nil { return m.MessageDependencyMapping } return accesscontrol.MessageDependencyMapping{} } -type ListResourceDepedencyMappingRequest struct { +type ListResourceDependencyMappingRequest struct { } -func (m *ListResourceDepedencyMappingRequest) Reset() { *m = ListResourceDepedencyMappingRequest{} } -func (m *ListResourceDepedencyMappingRequest) String() string { return proto.CompactTextString(m) } -func (*ListResourceDepedencyMappingRequest) ProtoMessage() {} -func (*ListResourceDepedencyMappingRequest) Descriptor() ([]byte, []int) { +func (m *ListResourceDependencyMappingRequest) Reset() { *m = ListResourceDependencyMappingRequest{} } +func (m *ListResourceDependencyMappingRequest) String() string { return proto.CompactTextString(m) } +func (*ListResourceDependencyMappingRequest) ProtoMessage() {} +func (*ListResourceDependencyMappingRequest) Descriptor() ([]byte, []int) { return fileDescriptor_d83f2274e13e6a16, []int{4} } -func (m *ListResourceDepedencyMappingRequest) XXX_Unmarshal(b []byte) error { +func (m *ListResourceDependencyMappingRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ListResourceDepedencyMappingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ListResourceDependencyMappingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ListResourceDepedencyMappingRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_ListResourceDependencyMappingRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -232,34 +232,34 @@ func (m *ListResourceDepedencyMappingRequest) XXX_Marshal(b []byte, deterministi return b[:n], nil } } -func (m *ListResourceDepedencyMappingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ListResourceDepedencyMappingRequest.Merge(m, src) +func (m *ListResourceDependencyMappingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListResourceDependencyMappingRequest.Merge(m, src) } -func (m *ListResourceDepedencyMappingRequest) XXX_Size() int { +func (m *ListResourceDependencyMappingRequest) XXX_Size() int { return m.Size() } -func (m *ListResourceDepedencyMappingRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ListResourceDepedencyMappingRequest.DiscardUnknown(m) +func (m *ListResourceDependencyMappingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListResourceDependencyMappingRequest.DiscardUnknown(m) } -var xxx_messageInfo_ListResourceDepedencyMappingRequest proto.InternalMessageInfo +var xxx_messageInfo_ListResourceDependencyMappingRequest proto.InternalMessageInfo -type ListResourceDepedencyMappingResponse struct { +type ListResourceDependencyMappingResponse struct { MessageDependencyMappingList []accesscontrol.MessageDependencyMapping `protobuf:"bytes,1,rep,name=message_dependency_mapping_list,json=messageDependencyMappingList,proto3" json:"message_dependency_mapping_list" yaml:"message_dependency_mapping_list"` } -func (m *ListResourceDepedencyMappingResponse) Reset() { *m = ListResourceDepedencyMappingResponse{} } -func (m *ListResourceDepedencyMappingResponse) String() string { return proto.CompactTextString(m) } -func (*ListResourceDepedencyMappingResponse) ProtoMessage() {} -func (*ListResourceDepedencyMappingResponse) Descriptor() ([]byte, []int) { +func (m *ListResourceDependencyMappingResponse) Reset() { *m = ListResourceDependencyMappingResponse{} } +func (m *ListResourceDependencyMappingResponse) String() string { return proto.CompactTextString(m) } +func (*ListResourceDependencyMappingResponse) ProtoMessage() {} +func (*ListResourceDependencyMappingResponse) Descriptor() ([]byte, []int) { return fileDescriptor_d83f2274e13e6a16, []int{5} } -func (m *ListResourceDepedencyMappingResponse) XXX_Unmarshal(b []byte) error { +func (m *ListResourceDependencyMappingResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ListResourceDepedencyMappingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ListResourceDependencyMappingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ListResourceDepedencyMappingResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_ListResourceDependencyMappingResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -269,19 +269,19 @@ func (m *ListResourceDepedencyMappingResponse) XXX_Marshal(b []byte, determinist return b[:n], nil } } -func (m *ListResourceDepedencyMappingResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ListResourceDepedencyMappingResponse.Merge(m, src) +func (m *ListResourceDependencyMappingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListResourceDependencyMappingResponse.Merge(m, src) } -func (m *ListResourceDepedencyMappingResponse) XXX_Size() int { +func (m *ListResourceDependencyMappingResponse) XXX_Size() int { return m.Size() } -func (m *ListResourceDepedencyMappingResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ListResourceDepedencyMappingResponse.DiscardUnknown(m) +func (m *ListResourceDependencyMappingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListResourceDependencyMappingResponse.DiscardUnknown(m) } -var xxx_messageInfo_ListResourceDepedencyMappingResponse proto.InternalMessageInfo +var xxx_messageInfo_ListResourceDependencyMappingResponse proto.InternalMessageInfo -func (m *ListResourceDepedencyMappingResponse) GetMessageDependencyMappingList() []accesscontrol.MessageDependencyMapping { +func (m *ListResourceDependencyMappingResponse) GetMessageDependencyMappingList() []accesscontrol.MessageDependencyMapping { if m != nil { return m.MessageDependencyMappingList } @@ -291,10 +291,10 @@ func (m *ListResourceDepedencyMappingResponse) GetMessageDependencyMappingList() func init() { proto.RegisterType((*QueryParamsRequest)(nil), "cosmos.accesscontrol_x.v1beta1.QueryParamsRequest") proto.RegisterType((*QueryParamsResponse)(nil), "cosmos.accesscontrol_x.v1beta1.QueryParamsResponse") - proto.RegisterType((*ResourceDepedencyMappingFromMessageKeyRequest)(nil), "cosmos.accesscontrol_x.v1beta1.ResourceDepedencyMappingFromMessageKeyRequest") - proto.RegisterType((*ResourceDepedencyMappingFromMessageKeyResponse)(nil), "cosmos.accesscontrol_x.v1beta1.ResourceDepedencyMappingFromMessageKeyResponse") - proto.RegisterType((*ListResourceDepedencyMappingRequest)(nil), "cosmos.accesscontrol_x.v1beta1.ListResourceDepedencyMappingRequest") - proto.RegisterType((*ListResourceDepedencyMappingResponse)(nil), "cosmos.accesscontrol_x.v1beta1.ListResourceDepedencyMappingResponse") + proto.RegisterType((*ResourceDependencyMappingFromMessageKeyRequest)(nil), "cosmos.accesscontrol_x.v1beta1.ResourceDependencyMappingFromMessageKeyRequest") + proto.RegisterType((*ResourceDependencyMappingFromMessageKeyResponse)(nil), "cosmos.accesscontrol_x.v1beta1.ResourceDependencyMappingFromMessageKeyResponse") + proto.RegisterType((*ListResourceDependencyMappingRequest)(nil), "cosmos.accesscontrol_x.v1beta1.ListResourceDependencyMappingRequest") + proto.RegisterType((*ListResourceDependencyMappingResponse)(nil), "cosmos.accesscontrol_x.v1beta1.ListResourceDependencyMappingResponse") } func init() { @@ -302,45 +302,44 @@ func init() { } var fileDescriptor_d83f2274e13e6a16 = []byte{ - // 593 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xd1, 0x6a, 0x13, 0x4d, - 0x14, 0xc7, 0x33, 0xfd, 0xbe, 0x06, 0x9c, 0xde, 0x8d, 0x45, 0xc2, 0x12, 0x36, 0x75, 0xac, 0xb1, - 0x15, 0xba, 0x4b, 0x53, 0x50, 0xf0, 0x4a, 0x62, 0x10, 0xc1, 0x46, 0x74, 0x2f, 0xab, 0xb0, 0x4c, - 0x36, 0xc7, 0xed, 0xd2, 0xec, 0xce, 0x76, 0x67, 0x23, 0x5d, 0xc4, 0x1b, 0x9f, 0x40, 0xf0, 0x01, - 0x04, 0x6f, 0xc5, 0xf7, 0xe8, 0x65, 0x50, 0x10, 0xaf, 0x82, 0x24, 0x3e, 0x41, 0x7d, 0x01, 0xc9, - 0xec, 0x34, 0x24, 0x69, 0x36, 0x9b, 0x52, 0xaf, 0x92, 0x9d, 0x3d, 0xe7, 0xfc, 0xcf, 0xef, 0xcc, - 0xff, 0x2c, 0xa6, 0x0e, 0x17, 0x3e, 0x17, 0x26, 0x73, 0x1c, 0x10, 0xc2, 0xe1, 0x41, 0x1c, 0xf1, - 0x8e, 0x7d, 0x62, 0x1e, 0x77, 0x21, 0x4a, 0x8c, 0x30, 0xe2, 0x31, 0x27, 0x7a, 0x1a, 0x63, 0xcc, - 0xc4, 0x18, 0x6f, 0x76, 0x5b, 0x10, 0xb3, 0x5d, 0x6d, 0xdd, 0xe5, 0x2e, 0x97, 0xa1, 0xe6, 0xe8, - 0x5f, 0x9a, 0xa5, 0x95, 0x5d, 0xce, 0xdd, 0x0e, 0x98, 0x2c, 0xf4, 0x4c, 0x16, 0x04, 0x3c, 0x66, - 0xb1, 0xc7, 0x03, 0xa1, 0xde, 0xde, 0x55, 0xba, 0x2d, 0x26, 0x20, 0x15, 0x33, 0x55, 0x39, 0x33, - 0x64, 0xae, 0x17, 0xc8, 0x60, 0x15, 0xbb, 0x35, 0xaf, 0xc7, 0xe9, 0x27, 0x15, 0xb9, 0x99, 0x41, - 0xe3, 0x42, 0x00, 0xc2, 0x53, 0xda, 0x74, 0x1d, 0x93, 0x17, 0x23, 0xc5, 0xe7, 0x2c, 0x62, 0xbe, - 0xb0, 0xe0, 0xb8, 0x0b, 0x22, 0xa6, 0x2f, 0xf1, 0xf5, 0xa9, 0x53, 0x11, 0xf2, 0x40, 0x00, 0x69, - 0xe0, 0x62, 0x28, 0x4f, 0x4a, 0x68, 0x03, 0x6d, 0xad, 0xd5, 0xaa, 0xc6, 0xe2, 0x69, 0x18, 0x69, - 0x7e, 0xfd, 0xff, 0xd3, 0x7e, 0xa5, 0x60, 0xa9, 0x5c, 0x7a, 0x88, 0x77, 0x2c, 0x10, 0xbc, 0x1b, - 0x39, 0xd0, 0x80, 0x10, 0xda, 0x10, 0x38, 0x49, 0x93, 0x85, 0xa1, 0x17, 0xb8, 0x8f, 0x23, 0xee, - 0x37, 0x41, 0x08, 0xe6, 0xc2, 0x53, 0x48, 0x54, 0x37, 0xe4, 0x3e, 0x5e, 0xf3, 0xd3, 0x43, 0xfb, - 0x08, 0x12, 0xa9, 0x7d, 0xad, 0x7e, 0xe3, 0xac, 0x5f, 0x21, 0x09, 0xf3, 0x3b, 0x0f, 0xe8, 0xc4, - 0x4b, 0x6a, 0x61, 0x7f, 0x9c, 0x4f, 0xbf, 0x21, 0x6c, 0x2c, 0x2b, 0xa5, 0x10, 0x3f, 0x21, 0xac, - 0x9d, 0xd7, 0x6b, 0x43, 0x08, 0x81, 0xcc, 0xb1, 0xfd, 0x34, 0x49, 0x71, 0xdf, 0x9b, 0xcb, 0x3d, - 0xa6, 0x56, 0x65, 0x1b, 0xe3, 0x74, 0x25, 0x59, 0xdf, 0x1e, 0xcd, 0xe1, 0xac, 0x5f, 0xb9, 0x39, - 0xdd, 0xf7, 0x45, 0x1d, 0x6a, 0x95, 0xfc, 0x8c, 0x22, 0xf4, 0x36, 0xbe, 0xb5, 0xef, 0x89, 0x38, - 0x8b, 0xeb, 0xfc, 0x0a, 0x7f, 0x20, 0xbc, 0xb9, 0x38, 0x4e, 0x11, 0x7f, 0x45, 0xb8, 0x92, 0xdd, - 0x89, 0xdd, 0xf1, 0x44, 0x5c, 0x42, 0x1b, 0xff, 0x5d, 0x01, 0xdb, 0x50, 0xd8, 0xd5, 0x3c, 0x6c, - 0x29, 0x46, 0xad, 0x72, 0x16, 0xfb, 0x88, 0xa7, 0xd6, 0x5b, 0xc5, 0xab, 0xd2, 0x9c, 0xe4, 0x33, - 0xc2, 0xc5, 0xd4, 0x61, 0xa4, 0x96, 0xe7, 0xc4, 0x8b, 0x26, 0xd7, 0xf6, 0x2e, 0x95, 0x93, 0x4e, - 0x8b, 0x9a, 0xef, 0xbf, 0xff, 0xfe, 0xb8, 0xb2, 0x4d, 0xee, 0x98, 0x6a, 0xbd, 0xd2, 0x9f, 0x1d, - 0xd1, 0x3e, 0x9a, 0xd9, 0xc9, 0xd4, 0xed, 0xe4, 0xcb, 0x0a, 0xae, 0x2e, 0xe7, 0x41, 0xd2, 0xcc, - 0x6b, 0xe8, 0x52, 0x6b, 0xa3, 0x3d, 0xfb, 0x57, 0xe5, 0x14, 0x7a, 0x4b, 0xa2, 0xbf, 0x22, 0x07, - 0xb9, 0xe8, 0x91, 0x2a, 0x2c, 0xaf, 0x78, 0xfa, 0x86, 0x5f, 0x47, 0xdc, 0xb7, 0x27, 0x16, 0xd6, - 0x7c, 0x3b, 0xf1, 0xf0, 0x8e, 0xfc, 0x41, 0xb8, 0xbc, 0xc8, 0xb5, 0xe4, 0x51, 0x1e, 0xd4, 0x12, - 0xbb, 0xa1, 0x35, 0xae, 0x56, 0x44, 0xcd, 0xe3, 0x89, 0x9c, 0x47, 0x9d, 0x3c, 0xcc, 0x9d, 0xc7, - 0xc8, 0xd6, 0x76, 0xf6, 0x50, 0xea, 0xfb, 0xa7, 0x03, 0x1d, 0xf5, 0x06, 0x3a, 0xfa, 0x35, 0xd0, - 0xd1, 0x87, 0xa1, 0x5e, 0xe8, 0x0d, 0xf5, 0xc2, 0xcf, 0xa1, 0x5e, 0x38, 0xa8, 0xb9, 0x5e, 0x7c, - 0xd8, 0x6d, 0x19, 0x0e, 0xf7, 0xe7, 0xa8, 0x9c, 0xcc, 0xe8, 0xc4, 0x49, 0x08, 0xa2, 0x55, 0x94, - 0x5f, 0xf6, 0xbd, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x71, 0xbc, 0x36, 0xac, 0xcf, 0x06, 0x00, - 0x00, + // 586 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xcd, 0x6e, 0xd3, 0x40, + 0x10, 0xc7, 0xb3, 0x85, 0x46, 0x62, 0x7b, 0x5b, 0x2a, 0x14, 0x59, 0xc5, 0x29, 0xab, 0x92, 0xb6, + 0x48, 0x78, 0xd5, 0x54, 0x02, 0x89, 0x1b, 0x21, 0x20, 0x21, 0x5a, 0x3e, 0x7c, 0xa4, 0x42, 0xd6, + 0xc6, 0x19, 0x8c, 0xd5, 0xd8, 0xeb, 0x7a, 0x1d, 0x54, 0x0b, 0x71, 0xe1, 0x09, 0x90, 0x78, 0x00, + 0x24, 0xee, 0x88, 0xd7, 0xe8, 0xb1, 0x52, 0x0f, 0xf4, 0x14, 0xa1, 0x84, 0x27, 0xe8, 0x85, 0x2b, + 0x8a, 0xbd, 0x8d, 0xf2, 0xe5, 0x38, 0x55, 0x7b, 0x4a, 0xbc, 0x9e, 0x99, 0xff, 0xfc, 0x66, 0xff, + 0x63, 0x4c, 0x6d, 0x21, 0x3d, 0x21, 0x19, 0xb7, 0x6d, 0x90, 0xd2, 0x16, 0x7e, 0x14, 0x8a, 0x96, + 0x75, 0xc8, 0x0e, 0xda, 0x10, 0xc6, 0x46, 0x10, 0x8a, 0x48, 0x10, 0x3d, 0x8d, 0x31, 0xc6, 0x62, + 0x8c, 0x8f, 0x5b, 0x0d, 0x88, 0xf8, 0x96, 0xb6, 0xec, 0x08, 0x47, 0x24, 0xa1, 0xac, 0xff, 0x2f, + 0xcd, 0xd2, 0x56, 0x1c, 0x21, 0x9c, 0x16, 0x30, 0x1e, 0xb8, 0x8c, 0xfb, 0xbe, 0x88, 0x78, 0xe4, + 0x0a, 0x5f, 0xaa, 0xb7, 0xf7, 0x94, 0x6e, 0x83, 0x4b, 0x48, 0xc5, 0x98, 0x2a, 0xc7, 0x02, 0xee, + 0xb8, 0x7e, 0x12, 0xac, 0x62, 0x37, 0xa6, 0xf5, 0x38, 0xfa, 0xa4, 0x22, 0xd7, 0x32, 0x68, 0x1c, + 0xf0, 0x41, 0xba, 0x4a, 0x9b, 0x2e, 0x63, 0xf2, 0xa6, 0xaf, 0xf8, 0x9a, 0x87, 0xdc, 0x93, 0x26, + 0x1c, 0xb4, 0x41, 0x46, 0x74, 0x0f, 0xdf, 0x1c, 0x39, 0x95, 0x81, 0xf0, 0x25, 0x90, 0x3a, 0x2e, + 0x06, 0xc9, 0x49, 0x09, 0xad, 0xa2, 0x8d, 0xa5, 0x6a, 0xc5, 0x98, 0x3d, 0x0d, 0x23, 0xcd, 0xaf, + 0x5d, 0x3f, 0xea, 0x94, 0x0b, 0xa6, 0xca, 0xa5, 0x2e, 0x36, 0x4c, 0x90, 0xa2, 0x1d, 0xda, 0x50, + 0x87, 0x00, 0xfc, 0x26, 0xf8, 0x76, 0xbc, 0xcb, 0x83, 0xc0, 0xf5, 0x9d, 0x67, 0xa1, 0xf0, 0x76, + 0x41, 0x4a, 0xee, 0xc0, 0x0b, 0x88, 0x55, 0x3b, 0xe4, 0x21, 0x5e, 0xf2, 0xd2, 0x43, 0x6b, 0x1f, + 0xe2, 0x44, 0xfc, 0x46, 0xed, 0xd6, 0x59, 0xa7, 0x4c, 0x62, 0xee, 0xb5, 0x1e, 0xd1, 0xa1, 0x97, + 0xd4, 0xc4, 0xde, 0x20, 0x9f, 0x9e, 0x20, 0xcc, 0xe6, 0xd6, 0x52, 0x90, 0xdf, 0x11, 0xd6, 0xce, + 0x0b, 0x36, 0x07, 0x39, 0x96, 0x97, 0x26, 0x29, 0xf2, 0x07, 0x53, 0xc9, 0x07, 0xdc, 0xaa, 0xec, + 0x84, 0x64, 0x6d, 0xb3, 0x3f, 0x89, 0xb3, 0x4e, 0xf9, 0xce, 0x68, 0xe3, 0x93, 0x3a, 0xd4, 0x2c, + 0x79, 0x19, 0x45, 0x68, 0x05, 0xaf, 0xed, 0xb8, 0x32, 0xca, 0x04, 0x3b, 0xbf, 0xc5, 0xdf, 0x08, + 0xdf, 0xcd, 0x09, 0x54, 0xcc, 0x3f, 0x11, 0x2e, 0x67, 0xf7, 0x62, 0xb5, 0x5c, 0x19, 0x95, 0xd0, + 0xea, 0xb5, 0x4b, 0x80, 0x1b, 0x0a, 0xbc, 0x92, 0x07, 0x9e, 0x88, 0x51, 0x73, 0x25, 0x8b, 0xbe, + 0x0f, 0x54, 0x3d, 0x5d, 0xc4, 0x8b, 0x89, 0x41, 0xc9, 0x0f, 0x84, 0x8b, 0xa9, 0xcb, 0x48, 0x35, + 0xcf, 0x8d, 0x93, 0x46, 0xd7, 0xb6, 0x2f, 0x94, 0x93, 0x4e, 0x8b, 0xb2, 0x2f, 0x27, 0x7f, 0xbf, + 0x2d, 0x6c, 0x92, 0x75, 0xa6, 0x56, 0x2c, 0xfd, 0xb9, 0x2f, 0x9b, 0xfb, 0x63, 0x7b, 0x99, 0x3a, + 0x9e, 0xfc, 0x5a, 0xc0, 0xeb, 0x73, 0xda, 0x90, 0xbc, 0xcc, 0xeb, 0xe8, 0x62, 0xbb, 0xa3, 0xbd, + 0xba, 0xb2, 0x7a, 0x8a, 0xde, 0x4e, 0xe8, 0xdf, 0x91, 0xbd, 0x5c, 0xfa, 0x50, 0x55, 0x9e, 0x76, + 0xcb, 0xef, 0x43, 0xe1, 0x59, 0x43, 0x7b, 0xcb, 0x3e, 0x0d, 0x3d, 0x7c, 0x26, 0xff, 0x10, 0xbe, + 0x3d, 0xd3, 0xba, 0xa4, 0x9e, 0xc7, 0x35, 0xcf, 0x8a, 0x68, 0x4f, 0x2f, 0x59, 0x45, 0xcd, 0xe4, + 0x79, 0x32, 0x93, 0x27, 0xe4, 0x71, 0xee, 0x4c, 0xfa, 0xee, 0xb6, 0x66, 0x0c, 0xa6, 0xb6, 0x73, + 0xd4, 0xd5, 0xd1, 0x71, 0x57, 0x47, 0x7f, 0xba, 0x3a, 0xfa, 0xda, 0xd3, 0x0b, 0xc7, 0x3d, 0xbd, + 0x70, 0xda, 0xd3, 0x0b, 0x6f, 0xab, 0x8e, 0x1b, 0x7d, 0x68, 0x37, 0x0c, 0x5b, 0x78, 0x53, 0x64, + 0x0e, 0xc7, 0x84, 0xa2, 0x38, 0x00, 0xd9, 0x28, 0x26, 0x5f, 0xf9, 0xed, 0xff, 0x01, 0x00, 0x00, + 0xff, 0xff, 0x31, 0x19, 0x2e, 0xf2, 0xdb, 0x06, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -356,8 +355,8 @@ const _ = grpc.SupportPackageIsVersion4 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type QueryClient interface { Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) - ResourceDepedencyMappingFromMessageKey(ctx context.Context, in *ResourceDepedencyMappingFromMessageKeyRequest, opts ...grpc.CallOption) (*ResourceDepedencyMappingFromMessageKeyResponse, error) - ListResourceDepedencyMapping(ctx context.Context, in *ListResourceDepedencyMappingRequest, opts ...grpc.CallOption) (*ListResourceDepedencyMappingResponse, error) + ResourceDependencyMappingFromMessageKey(ctx context.Context, in *ResourceDependencyMappingFromMessageKeyRequest, opts ...grpc.CallOption) (*ResourceDependencyMappingFromMessageKeyResponse, error) + ListResourceDependencyMapping(ctx context.Context, in *ListResourceDependencyMappingRequest, opts ...grpc.CallOption) (*ListResourceDependencyMappingResponse, error) } type queryClient struct { @@ -377,18 +376,18 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts . return out, nil } -func (c *queryClient) ResourceDepedencyMappingFromMessageKey(ctx context.Context, in *ResourceDepedencyMappingFromMessageKeyRequest, opts ...grpc.CallOption) (*ResourceDepedencyMappingFromMessageKeyResponse, error) { - out := new(ResourceDepedencyMappingFromMessageKeyResponse) - err := c.cc.Invoke(ctx, "/cosmos.accesscontrol_x.v1beta1.Query/ResourceDepedencyMappingFromMessageKey", in, out, opts...) +func (c *queryClient) ResourceDependencyMappingFromMessageKey(ctx context.Context, in *ResourceDependencyMappingFromMessageKeyRequest, opts ...grpc.CallOption) (*ResourceDependencyMappingFromMessageKeyResponse, error) { + out := new(ResourceDependencyMappingFromMessageKeyResponse) + err := c.cc.Invoke(ctx, "/cosmos.accesscontrol_x.v1beta1.Query/ResourceDependencyMappingFromMessageKey", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *queryClient) ListResourceDepedencyMapping(ctx context.Context, in *ListResourceDepedencyMappingRequest, opts ...grpc.CallOption) (*ListResourceDepedencyMappingResponse, error) { - out := new(ListResourceDepedencyMappingResponse) - err := c.cc.Invoke(ctx, "/cosmos.accesscontrol_x.v1beta1.Query/ListResourceDepedencyMapping", in, out, opts...) +func (c *queryClient) ListResourceDependencyMapping(ctx context.Context, in *ListResourceDependencyMappingRequest, opts ...grpc.CallOption) (*ListResourceDependencyMappingResponse, error) { + out := new(ListResourceDependencyMappingResponse) + err := c.cc.Invoke(ctx, "/cosmos.accesscontrol_x.v1beta1.Query/ListResourceDependencyMapping", in, out, opts...) if err != nil { return nil, err } @@ -398,8 +397,8 @@ func (c *queryClient) ListResourceDepedencyMapping(ctx context.Context, in *List // QueryServer is the server API for Query service. type QueryServer interface { Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) - ResourceDepedencyMappingFromMessageKey(context.Context, *ResourceDepedencyMappingFromMessageKeyRequest) (*ResourceDepedencyMappingFromMessageKeyResponse, error) - ListResourceDepedencyMapping(context.Context, *ListResourceDepedencyMappingRequest) (*ListResourceDepedencyMappingResponse, error) + ResourceDependencyMappingFromMessageKey(context.Context, *ResourceDependencyMappingFromMessageKeyRequest) (*ResourceDependencyMappingFromMessageKeyResponse, error) + ListResourceDependencyMapping(context.Context, *ListResourceDependencyMappingRequest) (*ListResourceDependencyMappingResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -409,11 +408,11 @@ type UnimplementedQueryServer struct { func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } -func (*UnimplementedQueryServer) ResourceDepedencyMappingFromMessageKey(ctx context.Context, req *ResourceDepedencyMappingFromMessageKeyRequest) (*ResourceDepedencyMappingFromMessageKeyResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResourceDepedencyMappingFromMessageKey not implemented") +func (*UnimplementedQueryServer) ResourceDependencyMappingFromMessageKey(ctx context.Context, req *ResourceDependencyMappingFromMessageKeyRequest) (*ResourceDependencyMappingFromMessageKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResourceDependencyMappingFromMessageKey not implemented") } -func (*UnimplementedQueryServer) ListResourceDepedencyMapping(ctx context.Context, req *ListResourceDepedencyMappingRequest) (*ListResourceDepedencyMappingResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ListResourceDepedencyMapping not implemented") +func (*UnimplementedQueryServer) ListResourceDependencyMapping(ctx context.Context, req *ListResourceDependencyMappingRequest) (*ListResourceDependencyMappingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListResourceDependencyMapping not implemented") } func RegisterQueryServer(s grpc1.Server, srv QueryServer) { @@ -438,38 +437,38 @@ func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interf return interceptor(ctx, in, info, handler) } -func _Query_ResourceDepedencyMappingFromMessageKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ResourceDepedencyMappingFromMessageKeyRequest) +func _Query_ResourceDependencyMappingFromMessageKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResourceDependencyMappingFromMessageKeyRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).ResourceDepedencyMappingFromMessageKey(ctx, in) + return srv.(QueryServer).ResourceDependencyMappingFromMessageKey(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/cosmos.accesscontrol_x.v1beta1.Query/ResourceDepedencyMappingFromMessageKey", + FullMethod: "/cosmos.accesscontrol_x.v1beta1.Query/ResourceDependencyMappingFromMessageKey", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).ResourceDepedencyMappingFromMessageKey(ctx, req.(*ResourceDepedencyMappingFromMessageKeyRequest)) + return srv.(QueryServer).ResourceDependencyMappingFromMessageKey(ctx, req.(*ResourceDependencyMappingFromMessageKeyRequest)) } return interceptor(ctx, in, info, handler) } -func _Query_ListResourceDepedencyMapping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ListResourceDepedencyMappingRequest) +func _Query_ListResourceDependencyMapping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListResourceDependencyMappingRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).ListResourceDepedencyMapping(ctx, in) + return srv.(QueryServer).ListResourceDependencyMapping(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/cosmos.accesscontrol_x.v1beta1.Query/ListResourceDepedencyMapping", + FullMethod: "/cosmos.accesscontrol_x.v1beta1.Query/ListResourceDependencyMapping", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).ListResourceDepedencyMapping(ctx, req.(*ListResourceDepedencyMappingRequest)) + return srv.(QueryServer).ListResourceDependencyMapping(ctx, req.(*ListResourceDependencyMappingRequest)) } return interceptor(ctx, in, info, handler) } @@ -483,12 +482,12 @@ var _Query_serviceDesc = grpc.ServiceDesc{ Handler: _Query_Params_Handler, }, { - MethodName: "ResourceDepedencyMappingFromMessageKey", - Handler: _Query_ResourceDepedencyMappingFromMessageKey_Handler, + MethodName: "ResourceDependencyMappingFromMessageKey", + Handler: _Query_ResourceDependencyMappingFromMessageKey_Handler, }, { - MethodName: "ListResourceDepedencyMapping", - Handler: _Query_ListResourceDepedencyMapping_Handler, + MethodName: "ListResourceDependencyMapping", + Handler: _Query_ListResourceDependencyMapping_Handler, }, }, Streams: []grpc.StreamDesc{}, @@ -551,7 +550,7 @@ func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) Marshal() (dAtA []byte, err error) { +func (m *ResourceDependencyMappingFromMessageKeyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -561,12 +560,12 @@ func (m *ResourceDepedencyMappingFromMessageKeyRequest) Marshal() (dAtA []byte, return dAtA[:n], nil } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *ResourceDependencyMappingFromMessageKeyRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ResourceDependencyMappingFromMessageKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -581,7 +580,7 @@ func (m *ResourceDepedencyMappingFromMessageKeyRequest) MarshalToSizedBuffer(dAt return len(dAtA) - i, nil } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) Marshal() (dAtA []byte, err error) { +func (m *ResourceDependencyMappingFromMessageKeyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -591,12 +590,12 @@ func (m *ResourceDepedencyMappingFromMessageKeyResponse) Marshal() (dAtA []byte, return dAtA[:n], nil } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *ResourceDependencyMappingFromMessageKeyResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ResourceDependencyMappingFromMessageKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -614,7 +613,7 @@ func (m *ResourceDepedencyMappingFromMessageKeyResponse) MarshalToSizedBuffer(dA return len(dAtA) - i, nil } -func (m *ListResourceDepedencyMappingRequest) Marshal() (dAtA []byte, err error) { +func (m *ListResourceDependencyMappingRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -624,12 +623,12 @@ func (m *ListResourceDepedencyMappingRequest) Marshal() (dAtA []byte, err error) return dAtA[:n], nil } -func (m *ListResourceDepedencyMappingRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *ListResourceDependencyMappingRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ListResourceDepedencyMappingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ListResourceDependencyMappingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -637,7 +636,7 @@ func (m *ListResourceDepedencyMappingRequest) MarshalToSizedBuffer(dAtA []byte) return len(dAtA) - i, nil } -func (m *ListResourceDepedencyMappingResponse) Marshal() (dAtA []byte, err error) { +func (m *ListResourceDependencyMappingResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -647,12 +646,12 @@ func (m *ListResourceDepedencyMappingResponse) Marshal() (dAtA []byte, err error return dAtA[:n], nil } -func (m *ListResourceDepedencyMappingResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *ListResourceDependencyMappingResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ListResourceDepedencyMappingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ListResourceDependencyMappingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -705,7 +704,7 @@ func (m *QueryParamsResponse) Size() (n int) { return n } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) Size() (n int) { +func (m *ResourceDependencyMappingFromMessageKeyRequest) Size() (n int) { if m == nil { return 0 } @@ -718,7 +717,7 @@ func (m *ResourceDepedencyMappingFromMessageKeyRequest) Size() (n int) { return n } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) Size() (n int) { +func (m *ResourceDependencyMappingFromMessageKeyResponse) Size() (n int) { if m == nil { return 0 } @@ -729,7 +728,7 @@ func (m *ResourceDepedencyMappingFromMessageKeyResponse) Size() (n int) { return n } -func (m *ListResourceDepedencyMappingRequest) Size() (n int) { +func (m *ListResourceDependencyMappingRequest) Size() (n int) { if m == nil { return 0 } @@ -738,7 +737,7 @@ func (m *ListResourceDepedencyMappingRequest) Size() (n int) { return n } -func (m *ListResourceDepedencyMappingResponse) Size() (n int) { +func (m *ListResourceDependencyMappingResponse) Size() (n int) { if m == nil { return 0 } @@ -892,7 +891,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResourceDepedencyMappingFromMessageKeyRequest) Unmarshal(dAtA []byte) error { +func (m *ResourceDependencyMappingFromMessageKeyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -915,10 +914,10 @@ func (m *ResourceDepedencyMappingFromMessageKeyRequest) Unmarshal(dAtA []byte) e fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResourceDepedencyMappingFromMessageKeyRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ResourceDependencyMappingFromMessageKeyRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResourceDepedencyMappingFromMessageKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResourceDependencyMappingFromMessageKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -974,7 +973,7 @@ func (m *ResourceDepedencyMappingFromMessageKeyRequest) Unmarshal(dAtA []byte) e } return nil } -func (m *ResourceDepedencyMappingFromMessageKeyResponse) Unmarshal(dAtA []byte) error { +func (m *ResourceDependencyMappingFromMessageKeyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -997,10 +996,10 @@ func (m *ResourceDepedencyMappingFromMessageKeyResponse) Unmarshal(dAtA []byte) fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResourceDepedencyMappingFromMessageKeyResponse: wiretype end group for non-group") + return fmt.Errorf("proto: ResourceDependencyMappingFromMessageKeyResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResourceDepedencyMappingFromMessageKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResourceDependencyMappingFromMessageKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1057,7 +1056,7 @@ func (m *ResourceDepedencyMappingFromMessageKeyResponse) Unmarshal(dAtA []byte) } return nil } -func (m *ListResourceDepedencyMappingRequest) Unmarshal(dAtA []byte) error { +func (m *ListResourceDependencyMappingRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1080,10 +1079,10 @@ func (m *ListResourceDepedencyMappingRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ListResourceDepedencyMappingRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ListResourceDependencyMappingRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ListResourceDepedencyMappingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ListResourceDependencyMappingRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -1107,7 +1106,7 @@ func (m *ListResourceDepedencyMappingRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ListResourceDepedencyMappingResponse) Unmarshal(dAtA []byte) error { +func (m *ListResourceDependencyMappingResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1130,10 +1129,10 @@ func (m *ListResourceDepedencyMappingResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ListResourceDepedencyMappingResponse: wiretype end group for non-group") + return fmt.Errorf("proto: ListResourceDependencyMappingResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ListResourceDepedencyMappingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ListResourceDependencyMappingResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: diff --git a/x/accesscontrol/types/query.pb.gw.go b/x/accesscontrol/types/query.pb.gw.go index 1341f50c0..6aeb1dbd5 100644 --- a/x/accesscontrol/types/query.pb.gw.go +++ b/x/accesscontrol/types/query.pb.gw.go @@ -51,8 +51,8 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal } -func request_Query_ResourceDepedencyMappingFromMessageKey_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ResourceDepedencyMappingFromMessageKeyRequest +func request_Query_ResourceDependencyMappingFromMessageKey_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ResourceDependencyMappingFromMessageKeyRequest var metadata runtime.ServerMetadata var ( @@ -73,13 +73,13 @@ func request_Query_ResourceDepedencyMappingFromMessageKey_0(ctx context.Context, return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_key", err) } - msg, err := client.ResourceDepedencyMappingFromMessageKey(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.ResourceDependencyMappingFromMessageKey(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_ResourceDepedencyMappingFromMessageKey_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ResourceDepedencyMappingFromMessageKeyRequest +func local_request_Query_ResourceDependencyMappingFromMessageKey_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ResourceDependencyMappingFromMessageKeyRequest var metadata runtime.ServerMetadata var ( @@ -100,25 +100,25 @@ func local_request_Query_ResourceDepedencyMappingFromMessageKey_0(ctx context.Co return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_key", err) } - msg, err := server.ResourceDepedencyMappingFromMessageKey(ctx, &protoReq) + msg, err := server.ResourceDependencyMappingFromMessageKey(ctx, &protoReq) return msg, metadata, err } -func request_Query_ListResourceDepedencyMapping_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListResourceDepedencyMappingRequest +func request_Query_ListResourceDependencyMapping_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ListResourceDependencyMappingRequest var metadata runtime.ServerMetadata - msg, err := client.ListResourceDepedencyMapping(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.ListResourceDependencyMapping(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_ListResourceDepedencyMapping_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListResourceDepedencyMappingRequest +func local_request_Query_ListResourceDependencyMapping_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ListResourceDependencyMappingRequest var metadata runtime.ServerMetadata - msg, err := server.ListResourceDepedencyMapping(ctx, &protoReq) + msg, err := server.ListResourceDependencyMapping(ctx, &protoReq) return msg, metadata, err } @@ -152,7 +152,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) - mux.Handle("GET", pattern_Query_ResourceDepedencyMappingFromMessageKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_ResourceDependencyMappingFromMessageKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -163,7 +163,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_ResourceDepedencyMappingFromMessageKey_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_ResourceDependencyMappingFromMessageKey_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 { @@ -171,11 +171,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } - forward_Query_ResourceDepedencyMappingFromMessageKey_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_ResourceDependencyMappingFromMessageKey_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_ListResourceDepedencyMapping_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_ListResourceDependencyMapping_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -186,7 +186,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_ListResourceDepedencyMapping_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_ListResourceDependencyMapping_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 { @@ -194,7 +194,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } - forward_Query_ListResourceDepedencyMapping_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_ListResourceDependencyMapping_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -259,7 +259,7 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) - mux.Handle("GET", pattern_Query_ResourceDepedencyMappingFromMessageKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_ResourceDependencyMappingFromMessageKey_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) @@ -268,18 +268,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_ResourceDepedencyMappingFromMessageKey_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_ResourceDependencyMappingFromMessageKey_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_ResourceDepedencyMappingFromMessageKey_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_ResourceDependencyMappingFromMessageKey_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_ListResourceDepedencyMapping_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_ListResourceDependencyMapping_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) @@ -288,14 +288,14 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_ListResourceDepedencyMapping_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_ListResourceDependencyMapping_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_ListResourceDepedencyMapping_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_ListResourceDependencyMapping_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -305,15 +305,15 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie var ( pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "cosmos-sdk", "accesscontrol", "params"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_ResourceDepedencyMappingFromMessageKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "cosmos-sdk", "accesscontrol", "resource_depedency_mapping_from_message_key", "message_key"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_ResourceDependencyMappingFromMessageKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "cosmos-sdk", "accesscontrol", "resource_dependency_mapping_from_message_key", "message_key"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_ListResourceDepedencyMapping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "cosmos-sdk", "accesscontrol", "list_resource_depedency_mapping"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_ListResourceDependencyMapping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "cosmos-sdk", "accesscontrol", "list_resource_dependency_mapping"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( forward_Query_Params_0 = runtime.ForwardResponseMessage - forward_Query_ResourceDepedencyMappingFromMessageKey_0 = runtime.ForwardResponseMessage + forward_Query_ResourceDependencyMappingFromMessageKey_0 = runtime.ForwardResponseMessage - forward_Query_ListResourceDepedencyMapping_0 = runtime.ForwardResponseMessage + forward_Query_ListResourceDependencyMapping_0 = runtime.ForwardResponseMessage ) From 04b35667adf98413dc37ec5e575fbc7e7b86b3bf Mon Sep 17 00:00:00 2001 From: Brandon Weng Date: Mon, 3 Oct 2022 23:45:56 -0700 Subject: [PATCH 2/4] done --- x/accesscontrol/client/query.go | 115 -------------------------------- 1 file changed, 115 deletions(-) delete mode 100644 x/accesscontrol/client/query.go diff --git a/x/accesscontrol/client/query.go b/x/accesscontrol/client/query.go deleted file mode 100644 index c0c5313d9..000000000 --- a/x/accesscontrol/client/query.go +++ /dev/null @@ -1,115 +0,0 @@ -package cli - -import ( - "fmt" - - "github.com/spf13/cobra" - - "github.com/cosmos/cosmos-sdk/client" - "github.com/cosmos/cosmos-sdk/client/flags" - "github.com/cosmos/cosmos-sdk/x/accesscontrol/types" -) - -func GetQueryCmd() *cobra.Command { - cmd := &cobra.Command{ - Use: types.ModuleName, - Short: fmt.Sprintf("Querying commands for the %s module", types.ModuleName), - DisableFlagParsing: true, - SuggestionsMinimumDistance: 2, - RunE: client.ValidateCmd, - } - - cmd.AddCommand( - GetParams(), - GetResourceDependencyMapping(), - ListResourceDependencyMapping(), - ) - - return cmd -} - -// GetParams returns the params for the module -func GetParams() *cobra.Command { - cmd := &cobra.Command{ - Use: "params [flags]", - Short: "Get the params for the x/accesscontrol module", - Args: cobra.ExactArgs(0), - RunE: func(cmd *cobra.Command, args []string) error { - clientCtx, err := client.GetClientQueryContext(cmd) - if err != nil { - return err - } - queryClient := types.NewQueryClient(clientCtx) - - res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{}) - if err != nil { - return err - } - - return clientCtx.PrintProto(res) - }, - } - - flags.AddQueryFlagsToCmd(cmd) - - return cmd -} - -func GetResourceDependencyMapping() *cobra.Command { - cmd := &cobra.Command{ - Use: "resource-dependency-mapping [messageKey] [flags]", - Short: "Get the resource dependency mapping for a specific message key", - Args: cobra.ExactArgs(1), - RunE: func(cmd *cobra.Command, args []string) error { - clientCtx, err := client.GetClientQueryContext(cmd) - if err != nil { - return err - } - queryClient := types.NewQueryClient(clientCtx) - - res, err := queryClient.ResourceDepedencyMappingFromMessageKey( - cmd.Context(), - &types.ResourceDepedencyMappingFromMessageKeyRequest{MessageKey: args[0]}, - ) - if err != nil { - return err - } - - return clientCtx.PrintProto(res) - }, - } - - flags.AddQueryFlagsToCmd(cmd) - - return cmd -} - - -func ListResourceDependencyMapping() *cobra.Command { - cmd := &cobra.Command{ - Use: "list-resource-dependency-mapping [flags]", - Short: "List all resource dependency mappings", - Args: cobra.ExactArgs(0), - RunE: func(cmd *cobra.Command, args []string) error { - clientCtx, err := client.GetClientQueryContext(cmd) - if err != nil { - return err - } - queryClient := types.NewQueryClient(clientCtx) - - res, err := queryClient.ListResourceDepedencyMapping( - cmd.Context(), - &types.ListResourceDepedencyMappingRequest{}, - ) - if err != nil { - return err - } - - return clientCtx.PrintProto(res) - }, - } - - flags.AddQueryFlagsToCmd(cmd) - - return cmd -} From e90f0b73f97fcc9c858c9e506bdf7ab6efc7ef1f Mon Sep 17 00:00:00 2001 From: Brandon Weng <18161326+BrandonWeng@users.noreply.github.com> Date: Tue, 4 Oct 2022 15:44:33 -0700 Subject: [PATCH 3/4] Update tx.go --- x/accesscontrol/client/cli/tx.go | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/x/accesscontrol/client/cli/tx.go b/x/accesscontrol/client/cli/tx.go index bcca7e507..c0b884b69 100644 --- a/x/accesscontrol/client/cli/tx.go +++ b/x/accesscontrol/client/cli/tx.go @@ -40,7 +40,6 @@ func MsgUpdateResourceDependencyMappingProposalCmd() *cobra.Command { Args: cobra.ExactArgs(1), Short: "Submit an UpdateResourceDependencyMapping proposal", RunE: func(cmd *cobra.Command, args []string) error { - println("MsgUpdateResourceDependencyMappingProposalCmd:HANDLING CLI REQUEST") clientCtx, err := client.GetClientTxContext(cmd) if err != nil { return err @@ -51,7 +50,6 @@ func MsgUpdateResourceDependencyMappingProposalCmd() *cobra.Command { return err } - println("MsgUpdateResourceDependencyMappingProposalCmd:GETTING FROM ADDRESS") from := clientCtx.GetFromAddress() content := types.MsgUpdateResourceDependencyMappingProposal{ @@ -62,17 +60,15 @@ func MsgUpdateResourceDependencyMappingProposalCmd() *cobra.Command { deposit, err := sdk.ParseCoinsNormalized(proposal.Deposit) if err != nil { - println("Unable to prase coin from UpdateResourceDependencyMapping from CLI") return err } - println("MsgUpdateResourceDependencyMappingProposalCmd:SUBMITTING PROPOSAL") msg, err := govtypes.NewMsgSubmitProposal(&content, deposit, from) if err != nil { - println("Unable to submit proposal for UpdateResourceDependencyMapping from CLI") + return err } - println("MsgUpdateResourceDependencyMappingProposalCmd:SENDING!") + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) }, } From 3b6f925811fcde70eda7eff1b0186ba4452107a6 Mon Sep 17 00:00:00 2001 From: Brandon Weng <18161326+BrandonWeng@users.noreply.github.com> Date: Tue, 4 Oct 2022 15:44:49 -0700 Subject: [PATCH 4/4] Update rest.go --- x/accesscontrol/client/rest/rest.go | 1 - 1 file changed, 1 deletion(-) diff --git a/x/accesscontrol/client/rest/rest.go b/x/accesscontrol/client/rest/rest.go index d3b1d28c6..416dd24e5 100644 --- a/x/accesscontrol/client/rest/rest.go +++ b/x/accesscontrol/client/rest/rest.go @@ -34,7 +34,6 @@ func ProposalRESTHandler(clientCtx client.Context) govrest.ProposalRESTHandler { func newPostPlanHandler(clientCtx client.Context) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { - println("HANDLING POST REQUEST") var req UpdateResourceDependencyMappingRequest if !rest.ReadRESTReq(w, r, clientCtx.LegacyAmino, &req) {