package cli

import (
        "github.com/spf13/cobra"

        "github.com/InjectiveLabs/injective-core/cli"
        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

// GetQueryCmd returns the cli query commands for this module
func GetQueryCmd() *cobra.Command {
        cmd := cli.ModuleRootCommand(types.ModuleName, true)

        cmd.AddCommand(
                GetParams(),
                GetNamespaces(),
                GetNamespaceByDenom(),
                GetNamespaceRoleActors(),
                GetNamespaceAddressRoles(),
                GetVouchersForAddress(),
        )

        return cmd
}

func GetParams() *cobra.Command {
        return cli.QueryCmd("params",
                "Gets module params",
                types.NewQueryClient,
                &types.QueryParamsRequest{}, nil, nil,
        )
}

func GetNamespaces() *cobra.Command {
        return cli.QueryCmd("namespaces",
                "Returns all created namespaces in the module",
                types.NewQueryClient,
                &types.QueryNamespacesRequest{}, nil, nil,
        )
}

func GetNamespaceByDenom() *cobra.Command {
        return cli.QueryCmd("namespace <denom>",
                "Returns the namespace associated with denom",
                types.NewQueryClient,
                &types.QueryNamespaceRequest{}, nil, nil,
        )
}

func GetNamespaceRoleActors() *cobra.Command {
        return cli.QueryCmd("actors <denom> <role>",
                "Returns the actors associated with a given role in the namespace for a denom",
                types.NewQueryClient,
                &types.QueryActorsByRoleRequest{}, nil, nil,
        )
}

func GetNamespaceAddressRoles() *cobra.Command {
        return cli.QueryCmd("roles <denom> <actor>",
                "Returns the roles associated with the actor in denom's namespace",
                types.NewQueryClient,
                &types.QueryRolesByActorRequest{}, nil, nil,
        )
}

func GetVouchersForAddress() *cobra.Command {
        return cli.QueryCmd("vouchers <denom>",
                "Returns the vouchers held for this denom inside the module",
                types.NewQueryClient,
                &types.QueryVouchersRequest{}, nil, nil,
        )
}

package cli

import (
        "encoding/json"
        "os"

        "github.com/cosmos/cosmos-sdk/client"
        "github.com/cosmos/cosmos-sdk/client/tx"
        "github.com/spf13/cobra"

        "github.com/InjectiveLabs/injective-core/cli"
        cliflags "github.com/InjectiveLabs/injective-core/cli/flags"
        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

func GetTxCmd() *cobra.Command {
        cmd := cli.ModuleRootCommand(types.ModuleName, false)

        cmd.AddCommand(
                CreateNamespaceCmd(),
                UpdateNamespaceCmd(),
                UpdateNamespaceRolesCmd(),
                ClaimVoucherCmd(),
        )

        return cmd
}

func CreateNamespaceCmd() *cobra.Command {
        cmd := &cobra.Command{
                Use:   "create-namespace <namespace.json>",
                Args:  cobra.ExactArgs(1),
                Short: "Create a namespace from a json file",
                Long: `Create a namespace from a json file.

                Example:
                $ %s tx permissions create-namespace namespace.json \

                        Where namespace.json contains:
                        {
                                "denom": "inj",
                                "contract_hook": "inj1dzqd00lfd4y4qy2pxa0dsdwzfnmsu27hgttswz",
                                "role_permissions": [
                                        {
                                                "role": "EVERYONE",
                                                "role_id": 0,
                                                "permissions": 14,
                                        },
                                        {
                                                "role": "minter",
                                                "role_id": 1,
                                                "permissions": 15
                                        }
                                ],
                                "actor_roles": [
                                        {
                                                "actor": "inj122qtfcjfx9suvgr5s7rtqgfy8xvtjhm8uc4x9f",
                                                "roles": ["minter"]
                                        },
                                ]
                        }
                `,

                RunE: func(cmd *cobra.Command, args []string) error {
                        clientCtx, err := client.GetClientTxContext(cmd)
                        if err != nil {
                                return err
                        }

                        file, err := os.ReadFile(args[0])
                        if err != nil {
                                return err
                        }

                        var ns types.Namespace
                        if err := json.Unmarshal(file, &ns); err != nil {
                                return err
                        }

                        msg := &types.MsgCreateNamespace{
                                Sender:    clientCtx.GetFromAddress().String(),
                                Namespace: ns,
                        }

                        if err := msg.ValidateBasic(); err != nil {
                                return err
                        }

                        return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
                },
        }
        cliflags.AddTxFlagsToCmd(cmd)
        return cmd
}

func UpdateNamespaceCmd() *cobra.Command {
        cmd := &cobra.Command{
                Use:   "update-namespace <namespace-update.json> [flags]",
                Args:  cobra.ExactArgs(1),
                Short: "Update existing namespace params with new values",
                Long:  `Update existing namespace params with new values`,
                RunE: func(cmd *cobra.Command, args []string) error {
                        clientCtx, err := client.GetClientTxContext(cmd)
                        if err != nil {
                                return err
                        }

                        file, err := os.ReadFile(args[0])
                        if err != nil {
                                return err
                        }

                        var msg types.MsgUpdateNamespace
                        if err := json.Unmarshal(file, &msg); err != nil {
                                return err
                        }

                        msg.Sender = clientCtx.GetFromAddress().String()

                        if err := msg.ValidateBasic(); err != nil {
                                return err
                        }

                        return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
                },
        }

        cmd.Example = `injectived tx permissions update-namespace namespace-update.json`

        cliflags.AddTxFlagsToCmd(cmd)

        return cmd
}

func UpdateNamespaceRolesCmd() *cobra.Command {
        cmd := &cobra.Command{
                Use:   "update-namespace-roles <roles.json>",
                Args:  cobra.ExactArgs(1),
                Short: "Update the namespace roles and permissions",
                Long: `"Update the namespace roles and permissions by adding or updating roles and new addresses.

                Example:
                $ %s tx permissions update-namespace-roles roles.json \

                        Where roles.json contains:
                        {
                                "denom": "inj",
                                "role_actors_to_add": [
                                        {
                                                "role": "whitelisted"
                                                "actors": ["inj122qtfcjfx9suvgr5s7rtqgfy8xvtjhm8uc4x9f"],
                                        },
                                ],
                                "role_actors_to_revoke": [
                                        {
                                                "role": "whitelisted"
                                                "actors": ["inj1cml96vmptgw99syqrrz8az79xer2pcgp0a885r"],
                                        },
                                ],

                        }
                `,

                RunE: func(cmd *cobra.Command, args []string) error {
                        clientCtx, err := client.GetClientTxContext(cmd)
                        if err != nil {
                                return err
                        }

                        file, err := os.ReadFile(args[0])
                        if err != nil {
                                return err
                        }

                        msg := &types.MsgUpdateActorRoles{}
                        if err := json.Unmarshal(file, &msg); err != nil {
                                return err
                        }

                        msg.Sender = clientCtx.GetFromAddress().String()

                        if err := msg.ValidateBasic(); err != nil {
                                return err
                        }

                        return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
                },
        }

        cliflags.AddTxFlagsToCmd(cmd)

        return cmd
}

func ClaimVoucherCmd() *cobra.Command {
        cmd := cli.TxCmd(
                "claim-voucher <originator_address>",
                "Claims the voucher from originator",
                &types.MsgClaimVoucher{}, nil, nil,
        )

        cmd.Example = `injectived tx permissions claim-voucher injEXCHANGEMODULEADDRESS`

        return cmd
}

package utils

import (
        "fmt"
        "reflect"
        "strings"

        "github.com/gogo/protobuf/proto"
)

// Generic function to serialize a slice of protobuf messages
func ConvertToString[T proto.Message](msgs []T) string {
        var sb strings.Builder
        for _, msg := range msgs {
                // Use reflection to get the fields and their values
                v := reflect.ValueOf(msg).Elem()
                typeOfMsg := v.Type()

                for i := 0; i < v.NumField(); i++ {
                        field := v.Field(i)
                        fieldName := typeOfMsg.Field(i).Name
                        fieldValue := field.Interface()

                        sb.WriteString(fmt.Sprintf("%s:%v ", fieldName, fieldValue))
                }
                sb.WriteString("\n") // Add a newline separator between messages
        }
        return sb.String()
}

package keeper

import (
        "slices"

        "cosmossdk.io/errors"
        sdk "github.com/cosmos/cosmos-sdk/types"
        "github.com/cosmos/gogoproto/proto"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

type ActionBitMask uint32

func (a ActionBitMask) Has(action types.Action) bool {
        return a&ActionBitMask(action) != 0
}

func (a ActionBitMask) Add(actions uint32) ActionBitMask {
        return ActionBitMask(uint32(a) | actions)
}

// HasPermissionsForAction checks if the actor has permission for the given action for the given denom
func (k Keeper) HasPermissionsForAction(ctx sdk.Context, denom string, actor sdk.AccAddress, action types.Action) bool {
        return k.CheckPermissionsForAction(ctx, denom, actor, action) == nil
}

func (k Keeper) CheckPermissionsForAction(ctx sdk.Context, denom string, actor sdk.AccAddress, action types.Action) error {
        if k.IsActionDisabledByPolicy(ctx, denom, action) {
                return errors.Wrapf(types.ErrRestrictedAction, "action %s on %s is disabled", action, denom)
        }

        totalAllowedActions, err := k.getTotalAllowedActionsForAddress(ctx, denom, actor)
        if err != nil {
                return err
        }

        if !totalAllowedActions.Has(action) {
                return errors.Wrapf(types.ErrRestrictedAction, "action %s on %s is not allowed for %s", action, denom, actor)
        }

        return nil
}

// getTotalAllowedActionsForAddress returns the total allowed actions for the given address and denom
func (k Keeper) getTotalAllowedActionsForAddress(ctx sdk.Context, denom string, actor sdk.AccAddress) (ActionBitMask, error) {
        // check that action is allowed for address
        roleIDs, err := k.GetActorRoleIDs(ctx, denom, actor)
        if err != nil {
                return 0, err
        }

        // if no explicit roles are assigned to the actor, then the EVERYONE role applies
        if len(roleIDs) == 0 {
                everyoneRoleId, _ := k.GetRoleID(ctx, denom, types.EVERYONE)
                roleIDs = []uint32{everyoneRoleId}
        }

        var totalAllowedActions ActionBitMask

        for _, roleID := range roleIDs {
                role, err := k.GetRoleByID(ctx, denom, roleID)
                if err != nil {
                        return 0, types.ErrRestrictedAction.Wrap(err.Error())
                }
                totalAllowedActions = totalAllowedActions.Add(role.Permissions)

                // if the actor has a role that explicitly has no permissions (blacklisted), override the total allowed actions to 0
                if role.Permissions == uint32(0) {
                        return 0, nil
                }
        }

        return totalAllowedActions, nil
}

// GetAddressRoleNames returns all the assigned roles for this address. Returns EVERYONE role if no roles found for this address.
func (k Keeper) GetAddressRoleNames(ctx sdk.Context, denom string, addr sdk.AccAddress) ([]string, error) {
        store := k.getActorRolesStore(ctx, denom)
        bz := store.Get(addr.Bytes())
        if len(bz) == 0 {
                return []string{types.EVERYONE}, nil
        }
        roleIDs := &types.RoleIDs{}

        if err := proto.Unmarshal(bz, roleIDs); err != nil {
                return nil, err
        }

        if len(roleIDs.RoleIds) == 0 {
                return []string{types.EVERYONE}, nil
        }

        roleNames := make([]string, 0, len(roleIDs.RoleIds))

        for _, roleID := range roleIDs.RoleIds {
                role, _ := k.GetRoleByID(ctx, denom, roleID)
                roleNames = append(roleNames, role.Name)
        }

        return roleNames, nil
}

// GetActorRoleIDs returns all the assigned role ids for this address. Returns EVERYONE role id if no roles found for this address.
func (k Keeper) GetActorRoleIDs(ctx sdk.Context, denom string, addr sdk.AccAddress) ([]uint32, error) {
        store := k.getActorRolesStore(ctx, denom)
        bz := store.Get(addr.Bytes())
        if len(bz) == 0 {
                return []uint32{}, nil
        }
        roleIDs := &types.RoleIDs{}

        if err := proto.Unmarshal(bz, roleIDs); err != nil {
                return nil, err
        }

        return roleIDs.RoleIds, nil
}

// GetAllActorRoles gathers all actor roles inside namespace for this denom
func (k Keeper) GetAllActorRoles(ctx sdk.Context, denom string) ([]*types.ActorRoles, error) {
        var actorRoles []*types.ActorRoles
        roleIDToName := make(map[uint32]string)

        err := k.IterateActorRoles(ctx, denom, func(actor sdk.AccAddress, roleIDs []uint32) error {
                roleNames := make([]string, 0, len(roleIDs))
                for _, roleID := range roleIDs {
                        if _, ok := roleIDToName[roleID]; !ok {
                                role, err := k.GetRoleByID(ctx, denom, roleID)
                                if err != nil {
                                        return err
                                }
                                roleIDToName[roleID] = role.Name
                        }

                        roleNames = append(roleNames, roleIDToName[roleID])
                }
                actorRoles = append(actorRoles, &types.ActorRoles{
                        Actor: actor.String(),
                        Roles: roleNames,
                })
                return nil
        })

        if err != nil {
                return nil, err
        }

        return actorRoles, nil
}

func (k Keeper) IterateActorRoles(ctx sdk.Context, denom string, cb func(actor sdk.AccAddress, roleIDs []uint32) error) error {
        store := k.getActorRolesStore(ctx, denom)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        for ; iter.Valid(); iter.Next() {
                bz := iter.Value()
                if bz == nil {
                        continue
                }

                roleIDs := &types.RoleIDs{}
                if err := proto.Unmarshal(bz, roleIDs); err != nil {
                        return err
                }

                actor := sdk.AccAddress(iter.Key())
                if err := cb(actor, roleIDs.RoleIds); err != nil {
                        return err
                }
        }
        return nil
}

// HasRoleName returns true if the role name exists
func (k Keeper) HasRoleName(ctx sdk.Context, denom, role string) bool {
        rolesStore := k.getRoleNamesStore(ctx, denom)
        return rolesStore.Has([]byte(role))

}

// HasRoleID returns true if the role ID exists
func (k Keeper) HasRoleID(ctx sdk.Context, denom string, roleID uint32) bool {
        roleIDsStore := k.getRolesStore(ctx, denom)
        return roleIDsStore.Has(types.Uint32ToLittleEndian(roleID))
}

// GetRoleByName returns a role by it's name
func (k Keeper) GetRoleByName(ctx sdk.Context, denom, role string) (*types.Role, error) {
        roleId, ok := k.GetRoleID(ctx, denom, role)
        if !ok {
                return nil, types.ErrUnknownRole
        }
        return k.GetRoleByID(ctx, denom, roleId)
}

// GetRoleByID returns a role by its id
func (k Keeper) GetRoleByID(ctx sdk.Context, denom string, roleID uint32) (*types.Role, error) {
        store := k.getRolesStore(ctx, denom)
        key := types.Uint32ToLittleEndian(roleID)
        bz := store.Get(key)

        if len(bz) == 0 {
                return nil, types.ErrUnknownRole
        }

        role := &types.Role{}
        if err := proto.Unmarshal(bz, role); err != nil {
                return nil, err
        }

        return role, nil
}

// GetRoleID returns role id by its name
func (k Keeper) GetRoleID(ctx sdk.Context, denom, roleName string) (id uint32, ok bool) {
        store := k.getRoleNamesStore(ctx, denom)
        bz := store.Get([]byte(roleName))

        if len(bz) == 0 {
                return 0, false
        }

        return types.LittleEndianToUint32(bz), true
}

// GetAllRoles returns all defined roles and permissions for them inside namespace
// Returns map [role_id] => Role{}
func (k Keeper) GetAllRoles(ctx sdk.Context, denom string) ([]*types.Role, error) {
        roles := make([]*types.Role, 0)
        store := k.getRolesStore(ctx, denom)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        for ; iter.Valid(); iter.Next() {
                role := &types.Role{}
                if err := proto.Unmarshal(iter.Value(), role); err != nil {
                        return nil, err
                }
                roles = append(roles, role)
        }
        return roles, nil
}

// setActorRoles converts all role names into its respective ids and stores them for address
func (k Keeper) setActorRoles(ctx sdk.Context, denom string, addr sdk.AccAddress, roleIDs []uint32) error {
        store := k.getActorRolesStore(ctx, denom)

        // if no roles are assigned to the actor, delete the entry
        if len(roleIDs) == 0 {
                store.Delete(addr.Bytes())
                return nil
        }

        roleIDsObj := &types.RoleIDs{
                RoleIds: roleIDs,
        }
        bz, err := proto.Marshal(roleIDsObj)
        if err != nil {
                return err
        }

        store.Set(addr.Bytes(), bz)
        return nil
}

func (k Keeper) addActorRoles(ctx sdk.Context, denom string, addr sdk.AccAddress, roleIDs []uint32) error {
        existingRoleIDs, err := k.GetActorRoleIDs(ctx, denom, addr)
        if err != nil {
                return err
        }

        mergedRoles := existingRoleIDs
        mergedRoles = append(mergedRoles, roleIDs...)
        mergedRoles = slices.Compact(mergedRoles)
        return k.setActorRoles(ctx, denom, addr, mergedRoles)
}

func (k Keeper) revokeActorRoles(ctx sdk.Context, denom string, addr sdk.AccAddress, roleIDs []uint32) error {
        existingRoleIDs, err := k.GetActorRoleIDs(ctx, denom, addr)
        if err != nil {
                return err
        }

        // remove roleIDs from existingRoleIDs
        newRoleIDs := slices.DeleteFunc(existingRoleIDs, func(roleId uint32) bool {
                return slices.Contains(roleIDs, roleId)
        })

        return k.setActorRoles(ctx, denom, addr, newRoleIDs)
}

// setRole sets the role and role name index in store
func (k Keeper) setRole(ctx sdk.Context, denom string, role *types.Role) error {
        // store role first
        store := k.getRolesStore(ctx, denom)
        key := types.Uint32ToLittleEndian(role.RoleId)

        bz, err := proto.Marshal(role)
        if err != nil {
                return err
        }
        store.Set(key, bz)

        // store role name => id association
        store = k.getRoleNamesStore(ctx, denom)
        store.Set([]byte(role.Name), key)

        return nil
}

// updateRole creates or updates the role in the store
func (k Keeper) updateRole(ctx sdk.Context, denom string, role *types.Role) error {
        existsRoleName := k.HasRoleName(ctx, denom, role.Name)
        existsRoleID := k.HasRoleID(ctx, denom, role.RoleId)

        // If role does not exist, create it.
        if !existsRoleName && !existsRoleID {
                return k.setRole(ctx, denom, role)
        }

        // check that the role id matches the role name
        oldRole, err := k.GetRoleByName(ctx, denom, role.Name)
        if err != nil {
                return err
        }

        if existsRoleName != existsRoleID || oldRole.RoleId != role.RoleId {
                return types.ErrUnknownRole.Wrapf("role id mismatch: %s doesn't have role id %d", role.Name, role.RoleId)
        }

        // Otherwise, update the existing role.
        return k.setRole(ctx, denom, role)
}

// func (k Keeper) deleteActorRoles(ctx sdk.Context, denom string, addr sdk.AccAddress) {
//         store := k.getActorRolesStore(ctx, denom)
//         store.Delete(addr.Bytes())
// }

// func (k Keeper) deleteAllActorRoles(ctx sdk.Context, denom string) {
//         store := k.getRolesStore(ctx, denom)
//         iter := store.Iterator(nil, nil)
//         keysToRemove := [][]byte{}
//         for ; iter.Valid(); iter.Next() {
//                 keysToRemove = append(keysToRemove, iter.Key())
//         }
//         iter.Close()
//         for _, key := range keysToRemove {
//                 store.Delete(key)
//         }
// }

// func (k Keeper) deleteRoles(ctx sdk.Context, denom string) {
//         deleteAllKeysInStore := func(store storetypes.KVStore) {
//                 iter := store.Iterator(nil, nil)
//                 keysToRemove := [][]byte{}
//                 for ; iter.Valid(); iter.Next() {
//                         keysToRemove = append(keysToRemove, iter.Key())
//                 }
//                 iter.Close()
//                 for _, key := range keysToRemove {
//                         store.Delete(key)
//                 }
//         }
//         rolesStore := k.getRolesStore(ctx, denom)
//         deleteAllKeysInStore(rolesStore)
//         roleNamesStore := k.getRoleNamesStore(ctx, denom)
//         deleteAllKeysInStore(roleNamesStore)
// }

package keeper

import (
        "context"
        "encoding/json"
        "strings"

        "cosmossdk.io/errors"
        "cosmossdk.io/math"
        storetypes "cosmossdk.io/store/types"
        wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
        sdk "github.com/cosmos/cosmos-sdk/types"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

// validateWasmHook checks that contract exists and satisfies the expected interface
func (k Keeper) validateWasmHook(ctx context.Context, contract sdk.AccAddress) error {
        sdkCtx := sdk.UnwrapSDKContext(ctx)
        if !k.wasmKeeper.HasContractInfo(ctx, contract) {
                return types.ErrUnknownWasmHook
        }

        userAddr := sdk.MustAccAddressFromBech32("inj1cml96vmptgw99syqrrz8az79xer2pcgp0a885r")
        wasmHookMsg := struct {
                SendRestriction types.WasmHookMsg `json:"send_restriction"`
        }{types.WasmHookMsg{
                From:    userAddr,
                To:      userAddr,
                Action:  types.Action_UNSPECIFIED.String(),
                Amounts: sdk.NewCoins(sdk.NewCoin("inj", math.NewInt(1))),
        }}
        bz, err := json.Marshal(wasmHookMsg)
        if err != nil {
                return err
        }

        sdkCtxMetered := sdkCtx.WithGasMeter(storetypes.NewGasMeter(k.GetParams(sdkCtx).WasmHookQueryMaxGas))

        if _, err := k.wasmKeeper.QuerySmart(sdkCtxMetered, contract, bz); errors.IsOf(err, wasmtypes.ErrQueryFailed) && strings.HasPrefix(err.Error(), "Error parsing into type") {
                return types.ErrInvalidContractHook
        }

        sdkCtx.GasMeter().ConsumeGas(sdkCtxMetered.GasMeter().GasConsumed(), "permissions wasm hook")

        return nil
}

func (k Keeper) executeWasmHook(sdkCtx sdk.Context, namespace *types.Namespace, fromAddr, toAddr sdk.AccAddress, action types.Action, amount sdk.Coin) error {
        if namespace.ContractHook == "" {
                return nil
        }

        contractAddr, err := sdk.AccAddressFromBech32(namespace.ContractHook)
        if err != nil { // defensive programming
                return types.ErrWasmHookError.Wrapf("WasmHook address is incorrect: %s (%s)", namespace.ContractHook, err.Error())
        }

        bz, err := types.GetWasmHookMsgBytes(fromAddr, toAddr, action, amount)
        if err != nil {
                return types.ErrWasmHookError.Wrap(err.Error())
        }

        // since transfer hook can be called in EndBlocker, which is not gas metered, we need to enforce MaxGas limits
        // during QuerySmart call to prevent DoS
        params := k.GetParams(sdkCtx)
        sdkCtxMetered := sdkCtx.WithGasMeter(storetypes.NewGasMeter(params.WasmHookQueryMaxGas))

        // call wasm hook contract inside a closure to catch out of gas panics, if any
        func() {
                defer func() {
                        if panicErr := recover(); panicErr != nil {
                                if _, ok := panicErr.(storetypes.ErrorOutOfGas); ok {
                                        err = errors.Wrapf(types.ErrWasmHookError, "panic during wasm hook: out of gas, gas used = %d, gas limit = %d", sdkCtxMetered.GasMeter().GasConsumed(), params.WasmHookQueryMaxGas)
                                } else {
                                        err = errors.Wrapf(types.ErrWasmHookError, "panic during wasm hook: %v", panicErr)
                                }
                        }
                }()

                // ignore query response for now, in future this could be used for more complex logic (e.g. rerouting)
                _, err = k.wasmKeeper.QuerySmart(sdkCtxMetered, contractAddr, bz)
        }()

        sdkCtx.GasMeter().ConsumeGas(sdkCtxMetered.GasMeter().GasConsumed(), "permissions wasm hook: "+amount.Denom)

        if err != nil {
                if errors.IsOf(err, wasmtypes.ErrQueryFailed) { // if query returns error -> means permissions check failed
                        return errors.Wrap(types.ErrRestrictedAction, err.Error())
                }
                return errors.Wrap(types.ErrWasmHookError, err.Error())
        }

        return nil
}

package keeper

import (
        sdk "github.com/cosmos/cosmos-sdk/types"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

// InitGenesis initializes the permissions module's state from a provided genesis
// state.
func (k Keeper) InitGenesis(ctx sdk.Context, genState types.GenesisState) {
        if err := genState.Params.Validate(); err != nil {
                panic(err)
        }

        k.SetParams(ctx, genState.Params)

        for idx := range genState.Namespaces {
                err := k.createNamespace(ctx, genState.Namespaces[idx])
                if err != nil {
                        panic(err)
                }
        }

        for _, voucher := range genState.Vouchers {
                address := sdk.MustAccAddressFromBech32(voucher.Address)
                if err := k.setVoucher(ctx, address, voucher.Voucher); err != nil {
                        panic(err)
                }
        }
}

// ExportGenesis returns the permissions module's exported genesis.
func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
        namespaces, err := k.GetAllNamespaces(ctx)
        if err != nil {
                panic(err)
        }

        gs := &types.GenesisState{
                Params: k.GetParams(ctx),
        }

        for _, ns := range namespaces {
                gs.Namespaces = append(gs.Namespaces, *ns)
        }

        vouchers, err := k.getAllVouchers(ctx)
        if err != nil {
                panic(err)
        }

        gs.Vouchers = vouchers
        return gs
}

package keeper

import (
        "context"

        sdk "github.com/cosmos/cosmos-sdk/types"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

var _ types.QueryServer = queryServer{}

type queryServer struct {
        Keeper
}

func NewQueryServerImpl(k Keeper) types.QueryServer {
        return queryServer{Keeper: k}
}

func (q queryServer) Params(c context.Context, _ *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
        return &types.QueryParamsResponse{Params: q.GetParams(sdk.UnwrapSDKContext(c))}, nil
}

func (q queryServer) NamespaceDenoms(c context.Context, _ *types.QueryNamespaceDenomsRequest) (*types.QueryNamespaceDenomsResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        return &types.QueryNamespaceDenomsResponse{Denoms: q.GetAllNamespaceDenoms(ctx)}, nil
}

func (q queryServer) Namespaces(c context.Context, _ *types.QueryNamespacesRequest) (*types.QueryNamespacesResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)

        namespaces, err := q.GetAllNamespaces(ctx)
        if err != nil {
                return nil, err
        }

        return &types.QueryNamespacesResponse{Namespaces: namespaces}, nil
}

func (q queryServer) Namespace(c context.Context, req *types.QueryNamespaceRequest) (*types.QueryNamespaceResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)

        namespace, err := q.GetNamespace(ctx, req.Denom, true)
        if err != nil {
                return nil, err
        }

        return &types.QueryNamespaceResponse{Namespace: namespace}, nil
}

func (q queryServer) RolesByActor(c context.Context, req *types.QueryRolesByActorRequest) (*types.QueryRolesByActorResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        addr, err := sdk.AccAddressFromBech32(req.Actor)
        if err != nil {
                return nil, err
        }

        roles, err := q.GetAddressRoleNames(ctx, req.Denom, addr)
        if err != nil {
                return nil, err
        }
        return &types.QueryRolesByActorResponse{Roles: roles}, nil
}

func (q queryServer) ActorsByRole(c context.Context, req *types.QueryActorsByRoleRequest) (*types.QueryActorsByRoleResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        if !q.HasNamespace(ctx, req.Denom) {
                return nil, types.ErrUnknownDenom
        }

        role, err := q.GetRoleByName(ctx, req.Denom, req.Role)
        if err != nil {
                return nil, err
        }

        actors := make([]string, 0)

        // inefficient but the only way for now since we don't index actors by roleID
        err = q.IterateActorRoles(ctx, req.Denom, func(actor sdk.AccAddress, roleIDs []uint32) error {
                for _, roleID := range roleIDs {
                        if roleID != role.RoleId {
                                continue
                        }
                        actors = append(actors, actor.String())
                        return nil
                }
                return nil
        })

        if err != nil {
                return nil, err
        }

        return &types.QueryActorsByRoleResponse{
                Actors: actors,
        }, nil
}

func (q queryServer) RoleManagers(c context.Context, req *types.QueryRoleManagersRequest) (*types.QueryRoleManagersResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)

        if !q.HasNamespace(ctx, req.Denom) {
                return nil, types.ErrUnknownDenom
        }

        managers, err := q.GetAllRoleManagers(ctx, req.Denom)
        if err != nil {
                return nil, err
        }

        return &types.QueryRoleManagersResponse{RoleManagers: managers}, nil
}

func (q queryServer) RoleManager(c context.Context, req *types.QueryRoleManagerRequest) (*types.QueryRoleManagerResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        if !q.HasNamespace(ctx, req.Denom) {
                return nil, types.ErrUnknownDenom
        }

        manager, err := sdk.AccAddressFromBech32(req.Manager)
        if err != nil {
                return nil, err
        }

        roleIDs := q.getAllRolesIDsForManager(ctx, req.Denom, manager)

        roles := make([]string, 0, len(roleIDs))
        for _, roleID := range roleIDs {
                role, err := q.GetRoleByID(ctx, req.Denom, roleID)
                if err != nil {
                        return nil, err
                }
                roles = append(roles, role.Name)
        }
        roleManager := types.NewRoleManager(manager, roles)

        return &types.QueryRoleManagerResponse{RoleManager: roleManager}, nil
}

func (q queryServer) PolicyStatuses(c context.Context, req *types.QueryPolicyStatusesRequest) (*types.QueryPolicyStatusesResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        if !q.HasNamespace(ctx, req.Denom) {
                return nil, types.ErrUnknownDenom
        }

        statuses, err := q.GetAllPolicyStatuses(ctx, req.Denom)
        if err != nil {
                return nil, err
        }

        return &types.QueryPolicyStatusesResponse{
                PolicyStatuses: statuses,
        }, nil
}

func (q queryServer) PolicyManagerCapabilities(c context.Context, req *types.QueryPolicyManagerCapabilitiesRequest) (*types.QueryPolicyManagerCapabilitiesResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        if !q.HasNamespace(ctx, req.Denom) {
                return nil, types.ErrUnknownDenom
        }

        capabilities, err := q.GetAllPolicyManagerCapabilities(ctx, req.Denom)
        if err != nil {
                return nil, err
        }

        return &types.QueryPolicyManagerCapabilitiesResponse{
                PolicyManagerCapabilities: capabilities,
        }, nil
}

func (q queryServer) Vouchers(c context.Context, req *types.QueryVouchersRequest) (*types.QueryVouchersResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)

        var vouchers []*types.AddressVoucher
        var err error
        if req.Denom == "" {
                vouchers, err = q.getAllVouchers(ctx)
        } else {
                vouchers, err = q.getVouchersForDenom(ctx, req.Denom)
        }

        if err != nil {
                return nil, err
        }

        return &types.QueryVouchersResponse{
                Vouchers: vouchers,
        }, nil
}

func (q queryServer) Voucher(c context.Context, req *types.QueryVoucherRequest) (*types.QueryVoucherResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        addr, err := sdk.AccAddressFromBech32(req.Address)
        if err != nil {
                return nil, err
        }

        voucher, err := q.GetVoucherForAddress(ctx, req.Denom, addr)
        if err != nil {
                return nil, err
        }

        return &types.QueryVoucherResponse{
                Voucher: voucher,
        }, nil
}

func (q queryServer) PermissionsModuleState(c context.Context, req *types.QueryModuleStateRequest) (*types.QueryModuleStateResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        return &types.QueryModuleStateResponse{State: q.ExportGenesis(ctx)}, nil
}

package keeper

import (
        "fmt"

        "cosmossdk.io/log"
        storetypes "cosmossdk.io/store/types"
        sdk "github.com/cosmos/cosmos-sdk/types"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

type Keeper struct {
        storeKey storetypes.StoreKey

        bankKeeper types.BankKeeper
        tfKeeper   types.TokenFactoryKeeper
        wasmKeeper types.WasmKeeper

        tfModuleAddress string
        moduleAccounts  map[string]bool
        authority       string
}

// NewKeeper returns a new instance of the x/tokenfactory keeper
func NewKeeper(
        storeKey storetypes.StoreKey,
        bankKeeper types.BankKeeper,
        tfKeeper types.TokenFactoryKeeper,
        wasmKeeper types.WasmKeeper,
        tfModuleAddress string,
        moduleAccounts map[string]bool,
        authority string,
) Keeper {
        return Keeper{
                storeKey:        storeKey,
                bankKeeper:      bankKeeper,
                tfKeeper:        tfKeeper,
                wasmKeeper:      wasmKeeper,
                tfModuleAddress: tfModuleAddress,
                moduleAccounts:  moduleAccounts,
                authority:       authority,
        }
}

// Logger returns a logger for the x/permissions module
func (k Keeper) Logger(ctx sdk.Context) log.Logger {
        return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
}

package keeper

import (
        "cosmossdk.io/store/prefix"
        storetypes "cosmossdk.io/store/types"
        sdk "github.com/cosmos/cosmos-sdk/types"
)

var (
        paramsKey                    = []byte{0x01}
        namespacesKey                = []byte{0x02} // denom => Namespace
        rolesKey                     = []byte{0x03} // denom + role_id => Role
        roleNamesKey                 = []byte{0x04} // denom + role_name => role_id
        actorRolesKey                = []byte{0x05} // denom + address => []role_id
        roleManagersKey              = []byte{0x06} // denom + roleManager + role_id => role_id
        policyStatusKey              = []byte{0x07} // denom + action => PolicyStatus
        policyManagerCapabilitiesKey = []byte{0x08} // denom + policyManager + Action => PolicyCapability
        vouchersKey                  = []byte{0x09} // toAddr + fromAddr => Coins
        delim                        = []byte("|")
)

func denomWithDelim(denom string) []byte {
        return append([]byte(denom), delim...)
}

// getNamespacesStore returns the store prefix where all the namespaces reside
func (k Keeper) getNamespacesStore(ctx sdk.Context) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        return prefix.NewStore(store, namespacesKey)
}

// getRolesStore returns the store prefix where all the roles are stored
func (k Keeper) getRolesStore(ctx sdk.Context, denom string) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        keyPrefix := rolesKey
        keyPrefix = append(keyPrefix, denomWithDelim(denom)...)
        return prefix.NewStore(store, keyPrefix)
}

// getRoleManagerStore returns the role manager store prefix
func (k Keeper) getRoleManagerStoreForManager(ctx sdk.Context, denom string, manager sdk.AccAddress) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        keyPrefix := getRoleManagerPrefixKey(denom)
        keyPrefix = append(keyPrefix, manager.Bytes()...)
        return prefix.NewStore(store, keyPrefix)
}

func getRoleManagerPrefixKey(denom string) []byte {
        return append(roleManagersKey, denomWithDelim(denom)...)
}

// getRoleManagerStore returns the role manager store prefix
func (k Keeper) getRoleManagerStore(ctx sdk.Context, denom string) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        keyPrefix := getRoleManagerPrefixKey(denom)
        return prefix.NewStore(store, keyPrefix)
}

// getPolicyStatusStore returns the policy status store prefix
func (k Keeper) getPolicyStatusStore(ctx sdk.Context, denom string) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        keyPrefix := policyStatusKey
        keyPrefix = append(keyPrefix, denomWithDelim(denom)...)
        return prefix.NewStore(store, keyPrefix)
}

// getPolicyManagerCapabilitiesStore returns the policy manager capabilities store prefix
func (k Keeper) getPolicyManagerCapabilitiesStore(ctx sdk.Context, denom string) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        keyPrefix := policyManagerCapabilitiesKey
        keyPrefix = append(keyPrefix, denomWithDelim(denom)...)
        return prefix.NewStore(store, keyPrefix)
}

// getActorRolesStore returns the store prefix where all the address roles reside for specified denom
func (k Keeper) getActorRolesStore(ctx sdk.Context, denom string) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        keyPrefix := actorRolesKey
        keyPrefix = append(keyPrefix, denomWithDelim(denom)...)
        return prefix.NewStore(store, keyPrefix)
}

// getRoleNamesStore returns the store prefix where all the role names reside
func (k Keeper) getRoleNamesStore(ctx sdk.Context, denom string) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        keyPrefix := roleNamesKey
        keyPrefix = append(keyPrefix, denomWithDelim(denom)...)
        return prefix.NewStore(store, keyPrefix)
}

// getVouchersStore returns the store prefix where all vouchers reside
func (k Keeper) getVouchersStore(ctx sdk.Context) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        return prefix.NewStore(store, vouchersKey)
}

// getVouchersStoreForDenom returns the store prefix where all vouchers for an address reside
func (k Keeper) getVouchersStoreForDenom(ctx sdk.Context, denom string) storetypes.KVStore {
        store := ctx.KVStore(k.storeKey)
        keyPrefix := vouchersKey
        keyPrefix = append(keyPrefix, denomWithDelim(denom)...)
        return prefix.NewStore(store, keyPrefix)
}

func getVoucherKey(denom string, address sdk.AccAddress) []byte {
        return append(denomWithDelim(denom), address.Bytes()...)
}

package keeper

import (
        "context"

        "cosmossdk.io/errors"
        sdk "github.com/cosmos/cosmos-sdk/types"
        govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

type msgServer struct {
        Keeper
}

// NewMsgServerImpl returns an implementation of the MsgServer interface
// for the provided Keeper.
func NewMsgServerImpl(keeper Keeper) types.MsgServer {
        return &msgServer{Keeper: keeper}
}

var _ types.MsgServer = msgServer{}

func (k msgServer) UpdateParams(c context.Context, msg *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
        if msg.Authority != k.authority {
                return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority: expected %s, got %s", k.authority, msg.Authority)
        }

        k.SetParams(sdk.UnwrapSDKContext(c), msg.Params)

        return &types.MsgUpdateParamsResponse{}, nil
}

func (k msgServer) checkSenderPermissions(sender, denomAdmin sdk.AccAddress) error {
        if sender.String() != k.authority && !sender.Equals(denomAdmin) {
                return errors.Wrapf(types.ErrUnauthorized, "only denom admin authorized, sender: %s, admin: %s", sender, denomAdmin)
        }
        return nil
}

func (k msgServer) CreateNamespace(c context.Context, msg *types.MsgCreateNamespace) (*types.MsgCreateNamespaceResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)

        sender := sdk.MustAccAddressFromBech32(msg.Sender)
        namespace := msg.Namespace
        denom := namespace.Denom

        // validate that the namespace doesn't already exist
        if k.HasNamespace(ctx, denom) {
                return nil, errors.Wrapf(types.ErrDenomNamespaceExists, "namespace for denom %s already exists", denom)
        }

        // validate denom admin authority permissions
        admin, err := k.tfKeeper.GetDenomAdmin(ctx, denom)
        if err != nil {
                return nil, types.ErrUnauthorized.Wrapf("denom admin for %s doesn't exist", denom)
        }

        if err := k.checkSenderPermissions(sender, admin); err != nil {
                return nil, err
        }

        // existing wasm hook contract that satisfies the expected interface
        contractHook := namespace.ContractHook
        if contractHook != "" {
                wasmContract := sdk.MustAccAddressFromBech32(contractHook)
                if err := k.validateWasmHook(c, wasmContract); err != nil {
                        return nil, err
                }
        }

        // pre-populate the namespace with permissive default values in the event role managers, policy statuses and/or
        // policy manager capabilities are unspecified
        namespace.PopulateEmptyValuesWithDefaults(sender)

        if err := k.createNamespace(ctx, namespace); err != nil {
                return nil, errors.Wrap(err, "can't store namespace")
        }

        return &types.MsgCreateNamespaceResponse{}, nil
}

func (k msgServer) UpdateNamespace(c context.Context, msg *types.MsgUpdateNamespace) (*types.MsgUpdateNamespaceResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)

        sender := sdk.MustAccAddressFromBech32(msg.Sender)
        denom := msg.Denom

        if !k.HasNamespace(ctx, denom) {
                return nil, errors.Wrapf(types.ErrUnknownDenom, "namespace for %s does not exist", denom)
        }

        namespaceChanges := msg.GetNamespaceUpdates()

        if err := k.Keeper.ValidateNamespaceUpdatePermissions(ctx, sender, denom, namespaceChanges); err != nil {
                return nil, err
        }

        if namespaceChanges.HasContractHookChange {
                wasmContract := sdk.MustAccAddressFromBech32(msg.ContractHook.NewValue)
                if err := k.validateWasmHook(c, wasmContract); err != nil {
                        return nil, err
                }

                namespace, err := k.GetNamespace(ctx, denom, false)
                if err != nil {
                        return nil, err
                }

                namespace.ContractHook = wasmContract.String()
                err = k.setNamespace(ctx, *namespace)
                if err != nil {
                        return nil, errors.Wrap(err, "can't store updated namespace")
                }
        }

        if namespaceChanges.HasRolePermissionsChange {
                for _, role := range msg.RolePermissions {
                        if err := k.updateRole(ctx, denom, role); err != nil {
                                return nil, err
                        }
                }
        }

        if namespaceChanges.HasRoleManagersChange {
                for _, roleManager := range msg.RoleManagers {
                        manager := sdk.MustAccAddressFromBech32(roleManager.Manager)
                        if err := k.updateManagerRoles(ctx, denom, manager, roleManager.Roles); err != nil {
                                return nil, err
                        }
                }
        }

        if namespaceChanges.HasPolicyStatusesChange {
                for _, policyStatus := range msg.PolicyStatuses {
                        if err := k.TryUpdatePolicyStatus(ctx, sender, denom, policyStatus); err != nil {
                                return nil, err
                        }
                }
        }

        if namespaceChanges.HasPolicyManagersChange {
                for _, policyManagerCapability := range msg.PolicyManagerCapabilities {
                        if err := k.updatePolicyManagerCapability(ctx, denom, policyManagerCapability); err != nil {
                                return nil, err
                        }
                }
        }

        return &types.MsgUpdateNamespaceResponse{}, nil
}

func (k msgServer) UpdateActorRoles(c context.Context, msg *types.MsgUpdateActorRoles) (*types.MsgUpdateActorRolesResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)
        sender := sdk.MustAccAddressFromBech32(msg.Sender)
        denom := msg.Denom

        if !k.HasNamespace(ctx, denom) {
                return nil, errors.Wrapf(types.ErrUnknownDenom, "namespace for %s does not exist", denom)
        }

        roleIDs, err := k.verifySenderIsRoleManagerForAffectedRoles(ctx, denom, sender, msg.GetAffectedRoles())
        if err != nil {
                return nil, err
        }

        actorRolesToAdd := types.RoleActorsToActorRoles(msg.RoleActorsToAdd)

        for _, roleActors := range actorRolesToAdd {
                actor := sdk.MustAccAddressFromBech32(roleActors.Actor)
                actorRoleIDs := make([]uint32, 0, len(roleActors.Roles))
                for _, role := range roleActors.Roles {
                        actorRoleIDs = append(actorRoleIDs, roleIDs[role])
                }

                if err := k.addActorRoles(ctx, denom, actor, actorRoleIDs); err != nil {
                        return nil, err
                }
        }

        actorRolesToRevoke := types.RoleActorsToActorRoles(msg.RoleActorsToRevoke)

        for _, roleActors := range actorRolesToRevoke {
                actor := sdk.MustAccAddressFromBech32(roleActors.Actor)
                actorRoleIDs := make([]uint32, 0, len(roleActors.Roles))
                for _, role := range roleActors.Roles {
                        actorRoleIDs = append(actorRoleIDs, roleIDs[role])
                }

                if err := k.revokeActorRoles(ctx, denom, actor, actorRoleIDs); err != nil {
                        return nil, err
                }
        }

        return &types.MsgUpdateActorRolesResponse{}, nil
}

func (k msgServer) ClaimVoucher(c context.Context, msg *types.MsgClaimVoucher) (*types.MsgClaimVoucherResponse, error) {
        ctx := sdk.UnwrapSDKContext(c)

        receiver := sdk.MustAccAddressFromBech32(msg.Sender)

        voucher, err := k.GetVoucherForAddress(ctx, msg.Denom, receiver)
        if err != nil {
                return nil, err
        }
        if voucher.IsZero() {
                return nil, types.ErrVoucherNotFound
        }

        // now claim voucher by sending funds from permissions module to receiver and then removing the voucher
        // please note the user will not be able to claim if he still does not have permissions, since transfer hook will be called on this send again
        if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, receiver, sdk.NewCoins(voucher)); err != nil {
                return nil, err
        }
        k.deleteVoucher(ctx, receiver, msg.Denom)

        return &types.MsgClaimVoucherResponse{}, nil
}

package keeper

import (
        "cosmossdk.io/errors"
        sdk "github.com/cosmos/cosmos-sdk/types"
        "github.com/cosmos/gogoproto/proto"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

func (k Keeper) HasNamespace(ctx sdk.Context, denom string) bool {
        store := k.getNamespacesStore(ctx)
        return store.Has([]byte(denom))
}

// GetNamespace return namespace for the denom. If includeFull is true, then it also populates AddressRoles and RolePermissions fields inside namespace.
// You can query those roles separately via corresponding methods.
func (k Keeper) GetNamespace(ctx sdk.Context, denom string, includeFull bool) (*types.Namespace, error) {
        namespace, err := k.getNamespace(ctx, denom)
        if err != nil {
                return nil, err
        }

        if namespace == nil {
                return nil, nil
        }

        if !includeFull {
                return namespace, nil
        }

        roles, err := k.GetAllRoles(ctx, denom)
        if err != nil {
                return nil, err
        }

        actorRoles, err := k.GetAllActorRoles(ctx, denom)
        if err != nil {
                return nil, err
        }

        roleManagers, err := k.GetAllRoleManagers(ctx, denom)
        if err != nil {
                return nil, err
        }

        policyStatuses, err := k.GetAllPolicyStatuses(ctx, denom)
        if err != nil {
                return nil, err
        }

        policyManagerCapabilities, err := k.GetAllPolicyManagerCapabilities(ctx, denom)
        if err != nil {
                return nil, err
        }

        namespace.RolePermissions = roles
        namespace.ActorRoles = actorRoles
        namespace.RoleManagers = roleManagers
        namespace.PolicyStatuses = policyStatuses
        namespace.PolicyManagerCapabilities = policyManagerCapabilities
        return namespace, nil
}

func (k Keeper) getNamespace(ctx sdk.Context, denom string) (*types.Namespace, error) {
        store := k.getNamespacesStore(ctx)
        bz := store.Get([]byte(denom))
        if bz == nil {
                return nil, nil
        }
        var namespace types.Namespace
        if err := proto.Unmarshal(bz, &namespace); err != nil {
                return nil, err
        }
        return &namespace, nil
}

func (k Keeper) createNamespace(ctx sdk.Context, ns types.Namespace) error {
        denom := ns.Denom
        roleNameToRoleID := make(map[string]uint32)

        // store new roles
        for _, role := range ns.RolePermissions {
                if err := k.setRole(ctx, denom, role); err != nil {
                        return err
                }
                roleNameToRoleID[role.Name] = role.RoleId
        }

        // store new actor roles
        for _, actorRole := range ns.ActorRoles {
                actor := sdk.MustAccAddressFromBech32(actorRole.Actor)

                // obtain roleIDs for the actor roles
                roleIDs := make([]uint32, 0, len(actorRole.Roles))
                for _, roleName := range actorRole.Roles {
                        roleID, ok := roleNameToRoleID[roleName]
                        if !ok {
                                return types.ErrUnknownRole.Wrapf("role %s not found", roleName)
                        }
                        roleIDs = append(roleIDs, roleID)
                }

                if err := k.setActorRoles(ctx, denom, actor, roleIDs); err != nil {
                        return err
                }
        }

        // store manager roles
        for _, managerRoles := range ns.RoleManagers {
                manager := sdk.MustAccAddressFromBech32(managerRoles.Manager)
                for _, roleName := range managerRoles.Roles {
                        roleID, ok := roleNameToRoleID[roleName]
                        if !ok {
                                return types.ErrUnknownRole.Wrapf("role %s not found", roleName)
                        }
                        k.setRoleManager(ctx, denom, manager, roleID)
                }
        }

        // store policy statuses
        for _, policyStatus := range ns.PolicyStatuses {
                if err := k.setPolicyStatus(ctx, denom, policyStatus); err != nil {
                        return err
                }
        }

        // store policy manager capabilities
        for _, policyManagerCapability := range ns.PolicyManagerCapabilities {
                if err := k.setPolicyManagerCapability(ctx, denom, policyManagerCapability); err != nil {
                        return err
                }
        }

        // nil the values to not store it inside namespace storage
        ns.RolePermissions = nil
        ns.ActorRoles = nil
        ns.RoleManagers = nil
        ns.PolicyStatuses = nil
        ns.PolicyManagerCapabilities = nil

        // store namespace itself
        return k.setNamespace(ctx, ns)
}

// func (k Keeper) deleteNamespace(ctx sdk.Context, denom string) {
//         // remove address roles
//         k.deleteAllActorRoles(ctx, denom)
//         // remove roles
//         k.deleteRoles(ctx, denom)
//         // remove namespace
//         store := k.getNamespacesStore(ctx)
//         store.Delete([]byte(denom))
// }

func (k Keeper) setNamespace(ctx sdk.Context, ns types.Namespace) error {
        store := k.getNamespacesStore(ctx)
        bz, err := proto.Marshal(&ns)
        if err != nil {
                return err
        }

        store.Set([]byte(ns.Denom), bz)
        return nil
}

// GetAllNamespaces returns all namespaces with roles and permissions
func (k Keeper) GetAllNamespaces(ctx sdk.Context) ([]*types.Namespace, error) {
        namespaces := make([]*types.Namespace, 0)
        store := k.getNamespacesStore(ctx)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        for ; iter.Valid(); iter.Next() {
                denom := string(iter.Key())
                namespace, err := k.GetNamespace(ctx, denom, true)
                if err != nil {
                        return nil, err
                }
                namespaces = append(namespaces, namespace)
        }
        return namespaces, nil
}

// GetAllNamespaceDenoms returns all namespace denoms
func (k Keeper) GetAllNamespaceDenoms(ctx sdk.Context) []string {
        denoms := make([]string, 0)
        store := k.getNamespacesStore(ctx)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        for ; iter.Valid(); iter.Next() {
                denom := string(iter.Key())
                denoms = append(denoms, denom)
        }
        return denoms
}

func (k Keeper) ValidateNamespaceUpdatePermissions(ctx sdk.Context, sender sdk.AccAddress, denom string, namespaceChanges types.NamespaceUpdates) error {
        for _, action := range namespaceChanges.ChangeActions {
                if !k.HasPermissionsForAction(ctx, denom, sender, action) {
                        return errors.Wrapf(types.ErrUnauthorized, "sender %s unauthorized for action %s", sender, action)
                }
        }
        return nil
}

package keeper

import (
        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"

        "github.com/cosmos/gogoproto/proto"

        sdk "github.com/cosmos/cosmos-sdk/types"
)

// GetParams returns the total set params.
func (k Keeper) GetParams(ctx sdk.Context) types.Params {
        store := ctx.KVStore(k.storeKey)
        bz := store.Get(paramsKey)
        if bz == nil {
                return types.Params{}
        }

        var params types.Params
        if err := proto.Unmarshal(bz, &params); err != nil {
                panic(err)
        }

        return params
}

// SetParams sets the total set of params.
func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
        store := ctx.KVStore(k.storeKey)

        bz, _ := proto.Marshal(&params)
        store.Set(paramsKey, bz)
}

package keeper

import (
        sdk "github.com/cosmos/cosmos-sdk/types"
        "github.com/cosmos/gogoproto/proto"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

func (k Keeper) GetAllPolicyStatuses(ctx sdk.Context, denom string) ([]*types.PolicyStatus, error) {
        store := k.getPolicyStatusStore(ctx, denom)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        policyStatuses := make([]*types.PolicyStatus, 0)
        for ; iter.Valid(); iter.Next() {
                var policyStatus types.PolicyStatus
                if err := proto.Unmarshal(iter.Value(), &policyStatus); err != nil {
                        return nil, err
                }
                policyStatuses = append(policyStatuses, &policyStatus)
        }

        return policyStatuses, nil
}

func (k Keeper) GetPolicyStatus(ctx sdk.Context, denom string, action types.Action) (*types.PolicyStatus, error) {
        store := k.getPolicyStatusStore(ctx, denom)
        key := types.Uint32ToLittleEndian(uint32(action))

        bz := store.Get(key)
        if bz == nil {
                return nil, types.ErrUnknownPolicy
        }

        var policyStatus types.PolicyStatus
        if err := proto.Unmarshal(bz, &policyStatus); err != nil {
                return nil, err
        }

        return &policyStatus, nil
}

func (k Keeper) TryUpdatePolicyStatus(ctx sdk.Context, sender sdk.AccAddress, denom string, newPolicyStatus *types.PolicyStatus) error {
        action := newPolicyStatus.Action
        oldPolicyStatus, err := k.GetPolicyStatus(ctx, denom, action)
        if err != nil {
                return err
        }

        if oldPolicyStatus.IsSealed {
                return types.ErrUnauthorizedPolicyChange.Wrapf("policy for %s is sealed", action)
        }

        capability, err := k.getPolicyManagerCapability(ctx, denom, sender, action)
        if err != nil {
                return err
        }

        if !capability.CanDisable && newPolicyStatus.IsDisabled != oldPolicyStatus.IsDisabled {
                return types.ErrUnauthorizedPolicyChange.Wrapf("policy manager %s cannot enable %s policy", sender, action)
        }

        if !capability.CanSeal && newPolicyStatus.IsSealed {
                return types.ErrUnauthorizedPolicyChange.Wrapf("policy manager %s cannot seal %s policy", sender, action)
        }

        return k.setPolicyStatus(ctx, denom, newPolicyStatus)
}

// setPolicyStatus sets the policy status for a given action
func (k Keeper) setPolicyStatus(ctx sdk.Context, denom string, policyStatus *types.PolicyStatus) error {
        store := k.getPolicyStatusStore(ctx, denom)
        key := types.Uint32ToLittleEndian(uint32(policyStatus.Action))

        bz, err := proto.Marshal(policyStatus)
        if err != nil {
                return err
        }

        store.Set(key, bz)
        return nil
}

func (k Keeper) IsActionDisabledByPolicy(ctx sdk.Context, denom string, action types.Action) bool {
        policyStatus, err := k.GetPolicyStatus(ctx, denom, action)
        if err != nil {
                // should never happen, defensive programming
                return true
        }

        return policyStatus.IsDisabled
}

func (k Keeper) updatePolicyManagerCapability(ctx sdk.Context, denom string, capability *types.PolicyManagerCapability) error {
        if !capability.CanSeal && !capability.CanDisable {
                manager := sdk.MustAccAddressFromBech32(capability.Manager)
                k.deletePolicyManagerCapability(ctx, denom, manager, capability.Action)
                return nil
        }
        return k.setPolicyManagerCapability(ctx, denom, capability)
}

// setPolicyManagerCapability sets the policy manager capability for a given action
func (k Keeper) setPolicyManagerCapability(ctx sdk.Context, denom string, capability *types.PolicyManagerCapability) error {
        store := k.getPolicyManagerCapabilitiesStore(ctx, denom)
        manager := sdk.MustAccAddressFromBech32(capability.Manager)
        // This is defined as key = manager + Action
        key := append(manager.Bytes(), types.Uint32ToLittleEndian(uint32(capability.Action))...)

        bz, err := proto.Marshal(capability)
        if err != nil {
                return err
        }

        store.Set(key, bz)
        return nil
}

func (k Keeper) deletePolicyManagerCapability(ctx sdk.Context, denom string, manager sdk.AccAddress, action types.Action) {
        store := k.getPolicyManagerCapabilitiesStore(ctx, denom)
        key := append(manager.Bytes(), types.Uint32ToLittleEndian(uint32(action))...)
        store.Delete(key)
}

func (k Keeper) getPolicyManagerCapability(ctx sdk.Context, denom string, manager sdk.AccAddress, action types.Action) (*types.PolicyManagerCapability, error) {
        store := k.getPolicyManagerCapabilitiesStore(ctx, denom)
        key := append(manager.Bytes(), types.Uint32ToLittleEndian(uint32(action))...)

        bz := store.Get(key)
        if bz == nil {
                return nil, types.ErrUnauthorized.Wrapf("%s is not a policy manager for action %s", manager, action)
        }

        var capability types.PolicyManagerCapability
        if err := proto.Unmarshal(bz, &capability); err != nil {
                return nil, err
        }

        return &capability, nil
}

func (k Keeper) GetAllPolicyManagerCapabilities(ctx sdk.Context, denom string) ([]*types.PolicyManagerCapability, error) {
        store := k.getPolicyManagerCapabilitiesStore(ctx, denom)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        capabilities := make([]*types.PolicyManagerCapability, 0)
        for ; iter.Valid(); iter.Next() {
                var capability types.PolicyManagerCapability
                if err := proto.Unmarshal(iter.Value(), &capability); err != nil {
                        return nil, err
                }
                capabilities = append(capabilities, &capability)
        }

        return capabilities, nil
}

package keeper

import (
        "sort"

        "cosmossdk.io/errors"
        sdk "github.com/cosmos/cosmos-sdk/types"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

// setRoleManager sets the role manager for the given role
func (k Keeper) setRoleManager(ctx sdk.Context, denom string, manager sdk.AccAddress, roleID uint32) {
        store := k.getRoleManagerStore(ctx, denom)

        roleIDBz := types.Uint32ToLittleEndian(roleID)
        key := append(manager.Bytes(), roleIDBz...)
        value := roleIDBz

        store.Set(key, value)
}

func (k Keeper) isRoleManager(ctx sdk.Context, denom string, manager sdk.AccAddress, roleID uint32) bool {
        store := k.getRoleManagerStore(ctx, denom)

        roleIDBz := types.Uint32ToLittleEndian(roleID)
        key := append(manager.Bytes(), roleIDBz...)

        return store.Has(key)
}

func (k Keeper) updateManagerRoles(ctx sdk.Context, denom string, manager sdk.AccAddress, roles []string) error {
        // remove manager from all roles if roles is empty
        if len(roles) == 0 {
                k.deleteManagerFromAllRoles(ctx, denom, manager)
                return nil
        }

        for _, roleName := range roles {
                role, err := k.GetRoleByName(ctx, denom, roleName)
                if err != nil {
                        return err
                }
                k.setRoleManager(ctx, denom, manager, role.RoleId)
        }
        return nil
}

// deleteManagerFromAllRoles deletes all roles for the given role manager
func (k Keeper) deleteManagerFromAllRoles(ctx sdk.Context, denom string, manager sdk.AccAddress) {
        roleIDs := k.getAllRolesIDsForManager(ctx, denom, manager)

        for _, roleID := range roleIDs {
                k.deleteManagerRole(ctx, denom, manager, roleID)
        }
}

func (k Keeper) deleteManagerRole(ctx sdk.Context, denom string, manager sdk.AccAddress, roleID uint32) {
        store := k.getRoleManagerStore(ctx, denom)
        key := append(manager.Bytes(), types.Uint32ToLittleEndian(roleID)...)
        store.Delete(key)
}

func (k Keeper) getAllRolesIDsForManager(ctx sdk.Context, denom string, manager sdk.AccAddress) []uint32 {
        store := k.getRoleManagerStoreForManager(ctx, denom, manager)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        roleIDs := make([]uint32, 0)
        for ; iter.Valid(); iter.Next() {
                roleID := types.LittleEndianToUint32(iter.Value())
                roleIDs = append(roleIDs, roleID)
        }
        return roleIDs
}

func (k Keeper) GetAllRoleManagers(ctx sdk.Context, denom string) ([]*types.RoleManager, error) {
        store := k.getRoleManagerStore(ctx, denom)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        roleManagerMap := make(map[string]*types.RoleManager)
        roleIDToName := make(map[uint32]string)

        for ; iter.Valid(); iter.Next() {
                key := iter.Key()
                manager := sdk.AccAddress(key[:20]).String()
                roleID := types.LittleEndianToUint32(iter.Value())

                if _, exists := roleManagerMap[manager]; !exists {
                        roleManagerMap[manager] = &types.RoleManager{
                                Manager: manager,
                                Roles:   []string{},
                        }
                }

                roleName, ok := roleIDToName[roleID]
                if !ok {
                        role, err := k.GetRoleByID(ctx, denom, roleID)
                        if err != nil {
                                return nil, err
                        }
                        roleName = role.Name
                        roleIDToName[roleID] = roleName
                }

                roleManagerMap[manager].Roles = append(roleManagerMap[manager].Roles, roleName)
        }

        roleManagers := make([]*types.RoleManager, 0, len(roleManagerMap))
        managers := make([]string, 0, len(roleManagerMap))

        for manager := range roleManagerMap {
                managers = append(managers, manager)
        }
        sort.Strings(managers)

        for _, manager := range managers {
                roleManagers = append(roleManagers, roleManagerMap[manager])
        }

        return roleManagers, nil
}

func (k Keeper) verifySenderIsRoleManagerForAffectedRoles(
        ctx sdk.Context,
        denom string,
        sender sdk.AccAddress,
        affectedRoles []string,
) (map[string]uint32, error) {
        roleIDs := make(map[string]uint32)

        for _, roleName := range affectedRoles {
                roleID, ok := k.GetRoleID(ctx, denom, roleName)
                if !ok || !k.isRoleManager(ctx, denom, sender, roleID) {
                        return nil, errors.Wrapf(types.ErrUnauthorized, "%s is not a role manager of %s", sender, roleName)
                }

                roleIDs[roleName] = roleID
        }

        return roleIDs, nil
}

package keeper

import (
        "context"

        "cosmossdk.io/errors"
        sdk "github.com/cosmos/cosmos-sdk/types"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

// SendRestrictionFn this is the main hooking point for permissions module to invoke its logic.
// Many errors can be returned from this fn, but one is intercepted (ErrRestrictedAction)
// and SOMETIMES converted into voucher (when DoNotFailFast context var is set), overriding the err to nil.
// Rest of the errors (and sometimes ErrRestrictedAction) will bubble up from here to x/bank SendCoins fn (or InputOutputCoins) and should be handled gracefully by the caller.
// Caller should always keep in mind that even when one of the tokens inside the send fails to be sent, the whole send is failed.
// Example: auction module sending a basket of tokens to the winner, malicious actor can put one bad token in the basket
// thus preventing all the tokens to be sent to the winner.
//
// Contract: SendCoins can fail and caller should handle the error and never panic in Begin/EndBlocker
func (k Keeper) SendRestrictionFn(ctx context.Context, fromAddr, toAddr sdk.AccAddress, amount sdk.Coin) (newToAddr sdk.AccAddress, err error) {
        sdkCtx := sdk.UnwrapSDKContext(ctx)

        // this is a hot-patch to not break contracts defined in exchange and insurance / etc modules that do not expect bank transfer to fail
        // only reroute in case of restricted error or wasm query error (should also be the case only for permissions check failure)
        defer func() {
                if errors.IsOf(err, types.ErrRestrictedAction) {
                        newToAddr, err = k.rerouteToVoucherOnFail(ctx, newToAddr, amount, err) // should replace address with permissions module address and error with nil
                }
        }()

        // module to module sends should not be restricted
        if k.IsModuleAcc(fromAddr) && k.IsModuleAcc(toAddr) {
                return toAddr, nil
        }

        // find namespace for denom
        namespace, _ := k.GetNamespace(sdkCtx, amount.Denom, false)

        // if namespace doesn't exist, then no restrictions are applied
        if namespace == nil {
                return toAddr, nil
        }

        // tokenfactory module should always be allowed to receive tokens, since it's required in the event of a forced burn
        // module accounts shouldn't be blocked from sending tokens (but recipient may be restricted later)
        isRecipientTfModule := toAddr.String() == k.tfModuleAddress
        canSkipSendPermissionsCheck := isRecipientTfModule || k.IsModuleAcc(fromAddr)

        if !canSkipSendPermissionsCheck {
                if err := k.CheckPermissionsForAction(sdkCtx, namespace.Denom, fromAddr, types.Action_SEND); err != nil {
                        return toAddr, err
                }
        }

        if !isRecipientTfModule {
                if err := k.CheckPermissionsForAction(sdkCtx, namespace.Denom, toAddr, types.Action_RECEIVE); err != nil {
                        return toAddr, err
                }
        }

        // invoke wasm hook
        if err := k.executeWasmHook(sdkCtx, namespace, fromAddr, toAddr, types.Action_RECEIVE, amount); err != nil {
                return toAddr, err
        }

        return toAddr, nil
}

// IsModuleAcc checks if a given address is a module account address
func (k Keeper) IsModuleAcc(addr sdk.AccAddress) bool {
        _, exists := k.moduleAccounts[addr.String()]
        return exists
}

package keeper

import (
        "context"

        "cosmossdk.io/store/prefix"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"

        "github.com/cosmos/cosmos-sdk/baseapp"
        sdk "github.com/cosmos/cosmos-sdk/types"
        authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"

        "cosmossdk.io/errors"
        "github.com/cosmos/gogoproto/proto"
)

// rerouteToVoucherOnFail is used to reroute any failed transfers (due to insufficient permissions)
// to vouchers that can be claimed by the original receiver later
// when their permissions allow the claim.
// This is needed to not fail bank transfers from module to accounts and couple other cases in consensus code,
// since our old codebase does not expect it to fail.
func (k Keeper) rerouteToVoucherOnFail(ctx context.Context, toAddr sdk.AccAddress, amount sdk.Coin, origErr error) (newToAddr sdk.AccAddress, err error) {
        sdkCtx := sdk.UnwrapSDKContext(ctx)

        if doNotFailFast := ctx.Value(baseapp.DoNotFailFastSendContextKey); doNotFailFast == nil {
                return toAddr, origErr
        }

        voucher, err := k.GetVoucherForAddress(sdkCtx, amount.Denom, toAddr)
        if err != nil {
                return toAddr, errors.Wrapf(err, "can't get existing voucher for address, tried to reroute token send after error: %s", origErr.Error())
        }

        // add new amounts to voucher
        voucher = voucher.Add(amount)

        if err := k.setVoucher(sdkCtx, toAddr, voucher); err != nil {
                return toAddr, errors.Wrapf(err, "can't set voucher for address, tried to reroute token send after error: %s", origErr.Error())
        }

        return authtypes.NewModuleAddress(types.ModuleName), nil
}

func (k Keeper) GetVoucherForAddress(ctx sdk.Context, denom string, addr sdk.AccAddress) (sdk.Coin, error) {
        store := k.getVouchersStore(ctx)
        key := getVoucherKey(denom, addr)
        bz := store.Get(key)
        if len(bz) == 0 {
                return types.NewEmptyVoucher(denom), nil
        }
        var voucher sdk.Coin
        if err := proto.Unmarshal(bz, &voucher); err != nil {
                return types.NewEmptyVoucher(denom), err
        }
        return voucher, nil
}

func (k Keeper) setVoucher(ctx sdk.Context, addr sdk.AccAddress, voucher sdk.Coin) error {
        store := k.getVouchersStore(ctx)
        bz, err := proto.Marshal(&voucher)
        if err != nil {
                return err
        }

        key := getVoucherKey(voucher.Denom, addr)
        store.Set(key, bz)

        // nolint:errcheck //ignored on purpose
        ctx.EventManager().EmitTypedEvent(&types.EventSetVoucher{
                Addr:    addr.String(),
                Voucher: voucher,
        })
        return nil
}

func (k Keeper) deleteVoucher(ctx sdk.Context, addr sdk.AccAddress, denom string) {
        store := k.getVouchersStore(ctx)
        key := getVoucherKey(denom, addr)
        store.Delete(key)

        // nolint:errcheck //ignored on purpose
        ctx.EventManager().EmitTypedEvent(&types.EventSetVoucher{
                Addr:    addr.String(),
                Voucher: types.NewEmptyVoucher(denom),
        })
}

func (k Keeper) getAllVouchers(ctx sdk.Context) ([]*types.AddressVoucher, error) {
        store := prefix.NewStore(ctx.KVStore(k.storeKey), vouchersKey)

        iter := store.Iterator(nil, nil)
        defer iter.Close()

        addressLen := 20

        vouchers := make([]*types.AddressVoucher, 0)
        for ; iter.Valid(); iter.Next() {
                var voucher sdk.Coin

                if err := proto.Unmarshal(iter.Value(), &voucher); err != nil {
                        return nil, err
                }

                addrBz := iter.Key()[len(iter.Key())-addressLen:]
                address := sdk.AccAddress(addrBz)
                vouchers = append(vouchers, &types.AddressVoucher{
                        Address: address.String(),
                        Voucher: voucher,
                })
        }
        return vouchers, nil
}

func (k Keeper) getVouchersForDenom(ctx sdk.Context, denom string) ([]*types.AddressVoucher, error) {
        store := k.getVouchersStoreForDenom(ctx, denom)
        iter := store.Iterator(nil, nil)
        defer iter.Close()

        vouchers := make([]*types.AddressVoucher, 0)
        for ; iter.Valid(); iter.Next() {
                var voucher sdk.Coin

                if err := proto.Unmarshal(iter.Value(), &voucher); err != nil {
                        return nil, err
                }

                address := sdk.AccAddress(iter.Key())
                vouchers = append(vouchers, &types.AddressVoucher{
                        Address: address.String(),
                        Voucher: voucher,
                })
        }
        return vouchers, nil
}

package module

import (
        "context"
        "encoding/json"
        "fmt"

        "cosmossdk.io/core/appmodule"
        "github.com/cosmos/cosmos-sdk/client"
        "github.com/cosmos/cosmos-sdk/codec"
        cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
        sdk "github.com/cosmos/cosmos-sdk/types"
        "github.com/cosmos/cosmos-sdk/types/module"
        "github.com/grpc-ecosystem/grpc-gateway/runtime"
        "github.com/spf13/cobra"

        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/client/cli"
        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/exported"
        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/keeper"
        "github.com/InjectiveLabs/injective-core/injective-chain/modules/permissions/types"
)

const (
        // ModuleName defines the module name
        ModuleName = types.ModuleName
        // QuerierRoute defines the module's query routing key
        QuerierRoute = ModuleName
        // StoreKey defines the primary module store key
        StoreKey = ModuleName
        // MemStoreKey defines the in-memory store key
        MemStoreKey = "mem_" + StoreKey
)

var (
        _ module.AppModuleBasic      = AppModule{}
        _ module.HasGenesis          = AppModule{}
        _ module.HasServices         = AppModule{}
        _ module.HasConsensusVersion = AppModule{}

        _ appmodule.AppModule = AppModule{}
)

const ConsensusVersion = 1

// ----------------------------------------------------------------------------
// AppModuleBasic
// ----------------------------------------------------------------------------

// AppModuleBasic implements the AppModuleBasic interface for the capability module.
type AppModuleBasic struct{}

func NewAppModuleBasic() AppModuleBasic {
        return AppModuleBasic{}
}

// Name returns the x/permissions module's name.
func (AppModuleBasic) Name() string {
        return ModuleName
}

func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
        types.RegisterCodec(cdc)
}

// RegisterInterfaces registers the module's interface types
func (a AppModuleBasic) RegisterInterfaces(reg cdctypes.InterfaceRegistry) {
        types.RegisterInterfaces(reg)
}

// DefaultGenesis returns the x/permissions module's default genesis state.
func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage {
        return cdc.MustMarshalJSON(types.DefaultGenesis())
}

// ValidateGenesis performs genesis state validation for the x/permissions module.
func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error {
        var genState types.GenesisState
        if err := cdc.UnmarshalJSON(bz, &genState); err != nil {
                return fmt.Errorf("failed to unmarshal %s genesis state: %w", ModuleName, err)
        }

        return genState.Validate()
}

// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the module.
func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, muxServer *runtime.ServeMux) {
        types.RegisterQueryHandlerClient(context.Background(), muxServer, types.NewQueryClient(clientCtx)) // nolint:errcheck //we don't care
}

// GetTxCmd returns the x/permissions module's root tx command.
func (a AppModuleBasic) GetTxCmd() *cobra.Command {
        return cli.GetTxCmd()
}

// GetQueryCmd returns the x/permissions module's root query command.
func (AppModuleBasic) GetQueryCmd() *cobra.Command {
        return cli.GetQueryCmd()
}

// ----------------------------------------------------------------------------
// AppModule
// ----------------------------------------------------------------------------

// AppModule implements the AppModule interface for the capability module.
type AppModule struct {
        AppModuleBasic

        keeper keeper.Keeper

        bankKeeper types.BankKeeper
        tfKeeper   types.TokenFactoryKeeper
        wasmKeeper types.WasmKeeper

        legacySubspace exported.Subspace
}

func NewAppModule(
        k keeper.Keeper,
        bankKeeper types.BankKeeper,
        tfKeeper types.TokenFactoryKeeper,
        wasmKeeper types.WasmKeeper,
        legacySubspace exported.Subspace,
) AppModule {
        // set global bank transfer hook
        bankKeeper.AppendSendRestriction(k.SendRestrictionFn)

        return AppModule{
                AppModuleBasic: NewAppModuleBasic(),
                keeper:         k,
                bankKeeper:     bankKeeper,
                tfKeeper:       tfKeeper,
                wasmKeeper:     wasmKeeper,
                legacySubspace: legacySubspace,
        }
}

// IsOnePerModuleType implements the depinject.OnePerModuleType interface.
func (am AppModule) IsOnePerModuleType() {}

// IsAppModule implements the appmodule.AppModule interface.
func (am AppModule) IsAppModule() {}

// QuerierRoute returns the x/permissions module's query routing key.
func (AppModule) QuerierRoute() string { return QuerierRoute }

// RegisterServices registers a GRPC query service to respond to the
// module-specific GRPC queries.
func (am AppModule) RegisterServices(cfg module.Configurator) {
        types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper))
        types.RegisterQueryServer(cfg.QueryServer(), keeper.NewQueryServerImpl(am.keeper))
}

// InitGenesis performs the x/permissions module's genesis initialization. It
// returns no validator updates.
func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, gs json.RawMessage) {
        var genState types.GenesisState
        cdc.MustUnmarshalJSON(gs, &genState)

        am.keeper.InitGenesis(ctx, genState)
}

// ExportGenesis returns the x/permissions module's exported genesis state as raw
// JSON bytes.
func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {
        genState := am.keeper.ExportGenesis(ctx)
        return cdc.MustMarshalJSON(genState)
}

// ConsensusVersion implements ConsensusVersion.
func (AppModule) ConsensusVersion() uint64 { return ConsensusVersion }

package types

import (
        "github.com/cosmos/cosmos-sdk/codec"
        cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
        sdk "github.com/cosmos/cosmos-sdk/types"
        authzcdc "github.com/cosmos/cosmos-sdk/x/authz/codec"
        // this line is used by starport scaffolding # 1
        "github.com/cosmos/cosmos-sdk/types/msgservice"
)

const ModuleName = "permissions"

func RegisterCodec(cdc *codec.LegacyAmino) {
        cdc.RegisterConcrete(&MsgUpdateParams{}, "permissions/MsgUpdateParams", nil)
        cdc.RegisterConcrete(&MsgCreateNamespace{}, "permissions/MsgCreateNamespace", nil)
        cdc.RegisterConcrete(&MsgUpdateNamespace{}, "permissions/MsgUpdateNamespace", nil)
        cdc.RegisterConcrete(&MsgClaimVoucher{}, "permissions/MsgClaimVoucher", nil)
}

func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
        registry.RegisterImplementations((*sdk.Msg)(nil),
                &MsgUpdateParams{},
                &MsgCreateNamespace{},
                &MsgUpdateNamespace{},
                &MsgClaimVoucher{},
        )

        msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
}

var (
        ModuleCdc = codec.NewLegacyAmino()
)

func init() {
        RegisterCodec(ModuleCdc)
        // Register all Amino interfaces and concrete types on the authz Amino codec so that this can later be
        // used to properly serialize MsgGrant and MsgExec instances
        sdk.RegisterLegacyAminoCodec(ModuleCdc)
        RegisterCodec(authzcdc.Amino)
        ModuleCdc.Seal()
}

package types

import (
        "encoding/binary"
)

// Uint32ToLittleEndian - marshals uint32 to a little endian byte slice so it can be sorted
func Uint32ToLittleEndian(i uint32) []byte {
        b := make([]byte, 4)
        binary.LittleEndian.PutUint32(b, i)
        return b
}

// LittleEndianToUint32 returns an uint32 from little endian encoded bytes. If encoding
// is empty, zero is returned.
func LittleEndianToUint32(bz []byte) uint32 {
        if len(bz) == 0 {
                return 0
        }

        return binary.LittleEndian.Uint32(bz)
}

package types

import (
        sdk "github.com/cosmos/cosmos-sdk/types"
)

// NewDefaultPolicyStatuses returns a list of permissive default policy statuses for all actions
func NewDefaultPolicyStatuses() []*PolicyStatus {
        policyStatuses := make([]*PolicyStatus, 0, len(Actions))
        for _, action := range Actions {
                status := NewPolicyStatus(action, false, false)
                policyStatuses = append(policyStatuses, status)
        }

        return policyStatuses
}

// NewDefaultPolicyManagerCapabilities returns a list of permissive default policy manager capabilities for all actions
// for the given creator
func NewDefaultPolicyManagerCapabilities(creator sdk.AccAddress) []*PolicyManagerCapability {
        capabilities := make([]*PolicyManagerCapability, 0, len(Actions))

        for _, action := range Actions {
                capability := NewPolicyManagerCapability(creator, action, true, true)
                capabilities = append(capabilities, capability)
        }
        return capabilities
}

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: injective/permissions/v1beta1/events.proto

package types

import (
        fmt "fmt"
        types "github.com/cosmos/cosmos-sdk/types"
        _ "github.com/cosmos/cosmos-sdk/x/bank/types"
        _ "github.com/cosmos/gogoproto/gogoproto"
        proto "github.com/cosmos/gogoproto/proto"
        io "io"
        math "math"
        math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// 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 EventSetVoucher struct {
        Addr    string     `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
        Voucher types.Coin `protobuf:"bytes,2,opt,name=voucher,proto3" json:"voucher"`
}

func (m *EventSetVoucher) Reset()         { *m = EventSetVoucher{} }
func (m *EventSetVoucher) String() string { return proto.CompactTextString(m) }
func (*EventSetVoucher) ProtoMessage()    {}
func (*EventSetVoucher) Descriptor() ([]byte, []int) {
        return fileDescriptor_705c3e21b20426fa, []int{0}
}
func (m *EventSetVoucher) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *EventSetVoucher) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_EventSetVoucher.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 *EventSetVoucher) XXX_Merge(src proto.Message) {
        xxx_messageInfo_EventSetVoucher.Merge(m, src)
}
func (m *EventSetVoucher) XXX_Size() int {
        return m.Size()
}
func (m *EventSetVoucher) XXX_DiscardUnknown() {
        xxx_messageInfo_EventSetVoucher.DiscardUnknown(m)
}

var xxx_messageInfo_EventSetVoucher proto.InternalMessageInfo

func (m *EventSetVoucher) GetAddr() string {
        if m != nil {
                return m.Addr
        }
        return ""
}

func (m *EventSetVoucher) GetVoucher() types.Coin {
        if m != nil {
                return m.Voucher
        }
        return types.Coin{}
}

func init() {
        proto.RegisterType((*EventSetVoucher)(nil), "injective.permissions.v1beta1.EventSetVoucher")
}

func init() {
        proto.RegisterFile("injective/permissions/v1beta1/events.proto", fileDescriptor_705c3e21b20426fa)
}

var fileDescriptor_705c3e21b20426fa = []byte{
        // 272 bytes of a gzipped FileDescriptorProto
        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xb1, 0x4a, 0xc4, 0x40,
        0x10, 0x86, 0xb3, 0x72, 0x28, 0xc6, 0x42, 0x08, 0x16, 0xe7, 0x81, 0xeb, 0x61, 0x75, 0x08, 0xee,
        0x72, 0x5a, 0xd9, 0x9e, 0x58, 0x08, 0x36, 0x9e, 0x60, 0x61, 0x65, 0xb2, 0x19, 0x92, 0xf5, 0xcc,
        0x4e, 0xd8, 0xd9, 0x04, 0x7c, 0x0b, 0x1f, 0xeb, 0xca, 0x2b, 0xad, 0x44, 0x92, 0x17, 0x91, 0x24,
        0x26, 0x9c, 0xd8, 0xcd, 0xf0, 0x7d, 0x3b, 0x3b, 0xf3, 0xfb, 0xe7, 0xda, 0xbc, 0x82, 0x72, 0xba,
        0x04, 0x99, 0x83, 0xcd, 0x34, 0x91, 0x46, 0x43, 0xb2, 0x9c, 0x47, 0xe0, 0xc2, 0xb9, 0x84, 0x12,
        0x8c, 0x23, 0x91, 0x5b, 0x74, 0x18, 0x9c, 0x0c, 0xae, 0xd8, 0x72, 0xc5, 0xaf, 0x3b, 0x39, 0x4a,
        0x30, 0xc1, 0xd6, 0x94, 0x4d, 0xd5, 0x3d, 0x9a, 0x70, 0x85, 0x94, 0x21, 0xc9, 0x28, 0x24, 0x18,
        0xc6, 0x2a, 0xd4, 0xe6, 0x1f, 0x37, 0xab, 0x81, 0x37, 0x4d, 0xc7, 0xcf, 0x5e, 0xfc, 0xc3, 0xdb,
        0x66, 0x89, 0x47, 0x70, 0x4f, 0x58, 0xa8, 0x14, 0x6c, 0x10, 0xf8, 0xa3, 0x30, 0x8e, 0xed, 0x98,
        0x4d, 0xd9, 0x6c, 0x7f, 0xd9, 0xd6, 0xc1, 0xb5, 0xbf, 0x57, 0x76, 0x78, 0xbc, 0x33, 0x65, 0xb3,
        0x83, 0xcb, 0x63, 0xd1, 0x0d, 0x16, 0xcd, 0xc7, 0xfd, 0x8e, 0xe2, 0x06, 0xb5, 0x59, 0x8c, 0xd6,
        0x5f, 0xa7, 0xde, 0xb2, 0xf7, 0x17, 0xab, 0x75, 0xc5, 0xd9, 0xa6, 0xe2, 0xec, 0xbb, 0xe2, 0xec,
        0xa3, 0xe6, 0xde, 0xa6, 0xe6, 0xde, 0x67, 0xcd, 0xbd, 0xe7, 0x87, 0x44, 0xbb, 0xb4, 0x88, 0x84,
        0xc2, 0x4c, 0xde, 0xf5, 0xb7, 0xdf, 0x87, 0x11, 0xc9, 0x21, 0x89, 0x0b, 0x85, 0x16, 0xb6, 0xdb,
        0x34, 0xd4, 0x46, 0x66, 0x18, 0x17, 0x6f, 0x40, 0x7f, 0x22, 0x75, 0xef, 0x39, 0x50, 0xb4, 0xdb,
        0x5e, 0x75, 0xf5, 0x13, 0x00, 0x00, 0xff, 0xff, 0x74, 0x79, 0xe1, 0x33, 0x78, 0x01, 0x00, 0x00,
}

func (m *EventSetVoucher) 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 *EventSetVoucher) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSetVoucher) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        {
                size, err := m.Voucher.MarshalToSizedBuffer(dAtA[:i])
                if err != nil {
                        return 0, err
                }
                i -= size
                i = encodeVarintEvents(dAtA, i, uint64(size))
        }
        i--
        dAtA[i] = 0x12
        if len(m.Addr) > 0 {
                i -= len(m.Addr)
                copy(dAtA[i:], m.Addr)
                i = encodeVarintEvents(dAtA, i, uint64(len(m.Addr)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
        offset -= sovEvents(v)
        base := offset
        for v >= 1<<7 {
                dAtA[offset] = uint8(v&0x7f | 0x80)
                v >>= 7
                offset++
        }
        dAtA[offset] = uint8(v)
        return base
}
func (m *EventSetVoucher) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Addr)
        if l > 0 {
                n += 1 + l + sovEvents(uint64(l))
        }
        l = m.Voucher.Size()
        n += 1 + l + sovEvents(uint64(l))
        return n
}

func sovEvents(x uint64) (n int) {
        return (math_bits.Len64(x|1) + 6) / 7
}
func sozEvents(x uint64) (n int) {
        return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *EventSetVoucher) 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 ErrIntOverflowEvents
                        }
                        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: EventSetVoucher: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: EventSetVoucher: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowEvents
                                }
                                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 ErrInvalidLengthEvents
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthEvents
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Addr = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Voucher", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowEvents
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthEvents
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthEvents
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if err := m.Voucher.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipEvents(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthEvents
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func skipEvents(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, ErrIntOverflowEvents
                        }
                        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, ErrIntOverflowEvents
                                }
                                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, ErrIntOverflowEvents
                                }
                                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, ErrInvalidLengthEvents
                        }
                        iNdEx += length
                case 3:
                        depth++
                case 4:
                        if depth == 0 {
                                return 0, ErrUnexpectedEndOfGroupEvents
                        }
                        depth--
                case 5:
                        iNdEx += 4
                default:
                        return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
                }
                if iNdEx < 0 {
                        return 0, ErrInvalidLengthEvents
                }
                if depth == 0 {
                        return iNdEx, nil
                }
        }
        return 0, io.ErrUnexpectedEOF
}

var (
        ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
        ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
        ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
)

package types

import (
        "cosmossdk.io/errors"
)

// DefaultGenesis returns the default Permissions genesis state
func DefaultGenesis() *GenesisState {
        return &GenesisState{
                Params:     DefaultParams(),
                Namespaces: []Namespace{},
                Vouchers:   []*AddressVoucher{},
        }
}

// Validate performs basic genesis state validation returning an error upon any
// failure.
func (gs GenesisState) Validate() error {
        err := gs.Params.Validate()
        if err != nil {
                return err
        }

        seenDenoms := map[string]struct{}{}

        for i := range gs.GetNamespaces() {
                ns := gs.GetNamespaces()[i]
                if _, ok := seenDenoms[ns.GetDenom()]; ok {
                        return errors.Wrapf(ErrInvalidGenesis, "duplicate denom: %s", ns.GetDenom())
                }
                seenDenoms[ns.GetDenom()] = struct{}{}
        }

        return nil
}

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: injective/permissions/v1beta1/genesis.proto

package types

import (
        fmt "fmt"
        _ "github.com/cosmos/gogoproto/gogoproto"
        proto "github.com/cosmos/gogoproto/proto"
        io "io"
        math "math"
        math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// GenesisState defines the permissions module's genesis state.
type GenesisState struct {
        // params defines the parameters of the module.
        Params     Params            `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
        Namespaces []Namespace       `protobuf:"bytes,2,rep,name=namespaces,proto3" json:"namespaces"`
        Vouchers   []*AddressVoucher `protobuf:"bytes,3,rep,name=vouchers,proto3" json:"vouchers,omitempty"`
}

func (m *GenesisState) Reset()         { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage()    {}
func (*GenesisState) Descriptor() ([]byte, []int) {
        return fileDescriptor_5ff1982ce1793022, []int{0}
}
func (m *GenesisState) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
        } else {
                b = b[:cap(b)]
                n, err := m.MarshalToSizedBuffer(b)
                if err != nil {
                        return nil, err
                }
                return b[:n], nil
        }
}
func (m *GenesisState) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GenesisState.Merge(m, src)
}
func (m *GenesisState) XXX_Size() int {
        return m.Size()
}
func (m *GenesisState) XXX_DiscardUnknown() {
        xxx_messageInfo_GenesisState.DiscardUnknown(m)
}

var xxx_messageInfo_GenesisState proto.InternalMessageInfo

func (m *GenesisState) GetParams() Params {
        if m != nil {
                return m.Params
        }
        return Params{}
}

func (m *GenesisState) GetNamespaces() []Namespace {
        if m != nil {
                return m.Namespaces
        }
        return nil
}

func (m *GenesisState) GetVouchers() []*AddressVoucher {
        if m != nil {
                return m.Vouchers
        }
        return nil
}

func init() {
        proto.RegisterType((*GenesisState)(nil), "injective.permissions.v1beta1.GenesisState")
}

func init() {
        proto.RegisterFile("injective/permissions/v1beta1/genesis.proto", fileDescriptor_5ff1982ce1793022)
}

var fileDescriptor_5ff1982ce1793022 = []byte{
        // 299 bytes of a gzipped FileDescriptorProto
        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x90, 0x41, 0x4b, 0xc3, 0x30,
        0x14, 0x80, 0x1b, 0x27, 0x43, 0x32, 0x4f, 0xc5, 0xc3, 0x18, 0x18, 0x87, 0x20, 0x0c, 0x65, 0x09,
        0x9b, 0xbf, 0xc0, 0x79, 0x90, 0x81, 0x0c, 0x9d, 0xe0, 0xc1, 0x5b, 0xda, 0x3d, 0xba, 0xa8, 0x6d,
        0x4a, 0x5e, 0x5a, 0xf0, 0x5f, 0xf8, 0xb3, 0x76, 0xdc, 0xd1, 0x93, 0x48, 0x7b, 0xf7, 0x37, 0x88,
        0x6d, 0x37, 0xeb, 0x65, 0xbd, 0x25, 0xf0, 0x7d, 0xdf, 0x7b, 0x3c, 0x7a, 0xa1, 0xa2, 0x67, 0xf0,
        0xad, 0x4a, 0x41, 0xc4, 0x60, 0x42, 0x85, 0xa8, 0x74, 0x84, 0x22, 0x1d, 0x79, 0x60, 0xe5, 0x48,
        0x04, 0x10, 0x01, 0x2a, 0xe4, 0xb1, 0xd1, 0x56, 0xbb, 0xc7, 0x5b, 0x98, 0xd7, 0x60, 0x5e, 0xc1,
        0xbd, 0xa3, 0x40, 0x07, 0xba, 0x20, 0xc5, 0xef, 0xab, 0x94, 0x7a, 0xe7, 0xbb, 0x27, 0xc4, 0xd2,
        0xc8, 0xb0, 0x1a, 0xd0, 0x13, 0x0d, 0x6c, 0x6d, 0x68, 0x21, 0x9c, 0x7e, 0x13, 0x7a, 0x78, 0x53,
        0xee, 0xf8, 0x60, 0xa5, 0x05, 0xf7, 0x9a, 0xb6, 0xcb, 0x62, 0x97, 0xf4, 0xc9, 0xa0, 0x33, 0x3e,
        0xe3, 0x3b, 0x77, 0xe6, 0x77, 0x05, 0x3c, 0xd9, 0x5f, 0x7d, 0x9e, 0x38, 0xf3, 0x4a, 0x75, 0x67,
        0x94, 0x46, 0x32, 0x04, 0x8c, 0xa5, 0x0f, 0xd8, 0xdd, 0xeb, 0xb7, 0x06, 0x9d, 0xf1, 0xa0, 0x21,
        0x34, 0xdb, 0x08, 0x55, 0xab, 0x56, 0x70, 0xa7, 0xf4, 0x20, 0xd5, 0x89, 0xbf, 0x04, 0x83, 0xdd,
        0x56, 0x51, 0x1b, 0x36, 0xd4, 0xae, 0x16, 0x0b, 0x03, 0x88, 0x8f, 0xa5, 0x35, 0xdf, 0xea, 0x93,
        0x97, 0x55, 0xc6, 0xc8, 0x3a, 0x63, 0xe4, 0x2b, 0x63, 0xe4, 0x3d, 0x67, 0xce, 0x3a, 0x67, 0xce,
        0x47, 0xce, 0x9c, 0xa7, 0xfb, 0x40, 0xd9, 0x65, 0xe2, 0x71, 0x5f, 0x87, 0x62, 0xba, 0x89, 0xdf,
        0x4a, 0x0f, 0xff, 0x8e, 0x3a, 0xf4, 0xb5, 0x81, 0xfa, 0x77, 0x29, 0x55, 0x24, 0x42, 0xbd, 0x48,
        0x5e, 0x01, 0xff, 0x5d, 0xdc, 0xbe, 0xc5, 0x80, 0x5e, 0xbb, 0x38, 0xf2, 0xe5, 0x4f, 0x00, 0x00,
        0x00, 0xff, 0xff, 0x83, 0x97, 0x25, 0xeb, 0x25, 0x02, 0x00, 0x00,
}

func (m *GenesisState) Marshal() (dAtA []byte, err error) {
        size := m.Size()
        dAtA = make([]byte, size)
        n, err := m.MarshalToSizedBuffer(dAtA[:size])
        if err != nil {
                return nil, err
        }
        return dAtA[:n], nil
}

func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Vouchers) > 0 {
                for iNdEx := len(m.Vouchers) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.Vouchers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintGenesis(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x1a
                }
        }
        if len(m.Namespaces) > 0 {
                for iNdEx := len(m.Namespaces) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.Namespaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintGenesis(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x12
                }
        }
        {
                size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
                if err != nil {
                        return 0, err
                }
                i -= size
                i = encodeVarintGenesis(dAtA, i, uint64(size))
        }
        i--
        dAtA[i] = 0xa
        return len(dAtA) - i, nil
}

func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
        offset -= sovGenesis(v)
        base := offset
        for v >= 1<<7 {
                dAtA[offset] = uint8(v&0x7f | 0x80)
                v >>= 7
                offset++
        }
        dAtA[offset] = uint8(v)
        return base
}
func (m *GenesisState) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = m.Params.Size()
        n += 1 + l + sovGenesis(uint64(l))
        if len(m.Namespaces) > 0 {
                for _, e := range m.Namespaces {
                        l = e.Size()
                        n += 1 + l + sovGenesis(uint64(l))
                }
        }
        if len(m.Vouchers) > 0 {
                for _, e := range m.Vouchers {
                        l = e.Size()
                        n += 1 + l + sovGenesis(uint64(l))
                }
        }
        return n
}

func sovGenesis(x uint64) (n int) {
        return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenesis(x uint64) (n int) {
        return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GenesisState) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowGenesis
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowGenesis
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthGenesis
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthGenesis
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowGenesis
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthGenesis
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthGenesis
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Namespaces = append(m.Namespaces, Namespace{})
                        if err := m.Namespaces[len(m.Namespaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 3:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Vouchers", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowGenesis
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthGenesis
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthGenesis
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Vouchers = append(m.Vouchers, &AddressVoucher{})
                        if err := m.Vouchers[len(m.Vouchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipGenesis(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthGenesis
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func skipGenesis(dAtA []byte) (n int, err error) {
        l := len(dAtA)
        iNdEx := 0
        depth := 0
        for iNdEx < l {
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return 0, ErrIntOverflowGenesis
                        }
                        if iNdEx >= l {
                                return 0, io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= (uint64(b) & 0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                wireType := int(wire & 0x7)
                switch wireType {
                case 0:
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return 0, ErrIntOverflowGenesis
                                }
                                if iNdEx >= l {
                                        return 0, io.ErrUnexpectedEOF
                                }
                                iNdEx++
                                if dAtA[iNdEx-1] < 0x80 {
                                        break
                                }
                        }
                case 1:
                        iNdEx += 8
                case 2:
                        var length int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return 0, ErrIntOverflowGenesis
                                }
                                if iNdEx >= l {
                                        return 0, io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                length |= (int(b) & 0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if length < 0 {
                                return 0, ErrInvalidLengthGenesis
                        }
                        iNdEx += length
                case 3:
                        depth++
                case 4:
                        if depth == 0 {
                                return 0, ErrUnexpectedEndOfGroupGenesis
                        }
                        depth--
                case 5:
                        iNdEx += 4
                default:
                        return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
                }
                if iNdEx < 0 {
                        return 0, ErrInvalidLengthGenesis
                }
                if depth == 0 {
                        return iNdEx, nil
                }
        }
        return 0, io.ErrUnexpectedEOF
}

var (
        ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
        ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
        ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)

package types

import (
        "fmt"

        chaintypes "github.com/InjectiveLabs/injective-core/injective-chain/types"

        sdk "github.com/cosmos/cosmos-sdk/types"
)

// constants
const (
        // RouterKey is the message route for slashing
        routerKey = ModuleName

        TypeMsgUpdateParams    = "update_params"
        TypeMsgCreateNamespace = "create_namespace"
        TypeUpdateNamespace    = "update_namespace"
        TypeMsgClaimVoucher    = "claim_voucher"
)

var (
        _ sdk.Msg = &MsgUpdateParams{}
        _ sdk.Msg = &MsgCreateNamespace{}
        _ sdk.Msg = &MsgUpdateNamespace{}
        _ sdk.Msg = &MsgUpdateActorRoles{}
        _ sdk.Msg = &MsgClaimVoucher{}
)

func (m MsgUpdateParams) Route() string { return routerKey }

func (m MsgUpdateParams) Type() string { return TypeMsgUpdateParams }

func (m MsgUpdateParams) ValidateBasic() error {
        if _, err := sdk.AccAddressFromBech32(m.Authority); err != nil {
                return err
        }

        if err := m.Params.Validate(); err != nil {
                return err
        }
        return nil
}

func (m *MsgUpdateParams) GetSignBytes() []byte {
        return sdk.MustSortJSON(ModuleCdc.MustMarshal(m))
}

func (m MsgUpdateParams) GetSigners() []sdk.AccAddress {
        addr, _ := sdk.AccAddressFromBech32(m.Authority)
        return []sdk.AccAddress{addr}
}

func (msg MsgCreateNamespace) Route() string { return routerKey }

func (msg MsgCreateNamespace) Type() string { return TypeMsgCreateNamespace }

func (msg MsgCreateNamespace) ValidateBasic() error {
        if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
                return err
        }

        n := msg.Namespace

        if n.Denom == "" {
                return ErrUnknownDenom
        }

        // existing contract hook contract
        if n.ContractHook != "" {
                if _, err := sdk.AccAddressFromBech32(n.ContractHook); err != nil {
                        return ErrInvalidContractHook
                }
        }

        if err := n.ValidateRoles(false); err != nil {
                return err
        }

        if err := n.ValidatePolicies(); err != nil {
                return err
        }
        return nil
}

func (msg *MsgCreateNamespace) GetSignBytes() []byte {
        return sdk.MustSortJSON(ModuleCdc.MustMarshal(msg))
}

func (msg MsgCreateNamespace) GetSigners() []sdk.AccAddress {
        addr, _ := sdk.AccAddressFromBech32(msg.Sender)
        return []sdk.AccAddress{addr}
}

func (msg MsgUpdateNamespace) Route() string { return routerKey }

func (msg MsgUpdateNamespace) Type() string { return TypeUpdateNamespace }

func (msg MsgUpdateNamespace) ValidateBasic() error {
        if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
                return err
        }

        if msg.ContractHook != nil {
                if _, err := sdk.AccAddressFromBech32(msg.ContractHook.NewValue); err != nil {
                        return ErrInvalidContractHook
                }
        }

        namespace := Namespace{
                Denom:                     msg.Denom,
                ContractHook:              "",
                RolePermissions:           msg.RolePermissions,
                ActorRoles:                nil,
                RoleManagers:              msg.RoleManagers,
                PolicyStatuses:            msg.PolicyStatuses,
                PolicyManagerCapabilities: msg.PolicyManagerCapabilities,
        }

        if err := namespace.ValidateRoles(true); err != nil {
                return err
        }

        if err := namespace.ValidatePolicies(); err != nil {
                return err
        }
        return nil
}

func (msg *MsgUpdateNamespace) GetSignBytes() []byte {
        return sdk.MustSortJSON(ModuleCdc.MustMarshal(msg))
}

func (msg MsgUpdateNamespace) GetSigners() []sdk.AccAddress {
        addr, _ := sdk.AccAddressFromBech32(msg.Sender)
        return []sdk.AccAddress{addr}
}

type NamespaceUpdates struct {
        HasContractHookChange    bool
        HasRolePermissionsChange bool
        HasRoleManagersChange    bool
        HasPolicyStatusesChange  bool
        HasPolicyManagersChange  bool
        ChangeActions            []Action
}

func (msg MsgUpdateNamespace) GetNamespaceUpdates() NamespaceUpdates {
        actions := make([]Action, 0, 4)

        changes := NamespaceUpdates{
                HasContractHookChange:    false,
                HasRolePermissionsChange: false,
                HasRoleManagersChange:    false,
                HasPolicyStatusesChange:  len(msg.PolicyStatuses) > 0,
                HasPolicyManagersChange:  false,
        }

        if msg.ContractHook != nil {
                actions = append(actions, Action_MODIFY_CONTRACT_HOOK)
                changes.HasContractHookChange = true
        }

        if len(msg.RolePermissions) > 0 {
                actions = append(actions, Action_MODIFY_ROLE_PERMISSIONS)
                changes.HasRolePermissionsChange = true
        }

        if len(msg.RoleManagers) > 0 {
                actions = append(actions, Action_MODIFY_ROLE_MANAGERS)
                changes.HasRoleManagersChange = true
        }

        if len(msg.PolicyManagerCapabilities) > 0 {
                actions = append(actions, Action_MODIFY_POLICY_MANAGERS)
                changes.HasPolicyManagersChange = true
        }

        changes.ChangeActions = actions
        return changes
}

func (msg MsgUpdateActorRoles) ValidateBasic() error {
        if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
                return err
        }

        if msg.Denom == "" {
                return ErrUnknownDenom
        }

        if len(msg.RoleActorsToAdd) == 0 && len(msg.RoleActorsToRevoke) == 0 {
                return ErrUnknownRole
        }

        roles := make(map[string]struct{})
        for _, role := range msg.RoleActorsToAdd {
                roleName := role.Role
                if roleName == "" {
                        return ErrInvalidRole.Wrap("role name cannot be empty")
                }

                if roleName == EVERYONE {
                        return ErrInvalidRole.Wrapf("actors cannot be explicitly assigned to the %s role", EVERYONE)
                }

                if _, ok := roles[roleName]; ok {
                        return ErrInvalidRole.Wrapf("repeated role %s", roleName)
                }
                roles[roleName] = struct{}{}

                for _, actor := range role.Actors {
                        if _, err := sdk.AccAddressFromBech32(actor); err != nil {
                                return err
                        }

                        if chaintypes.HasDuplicate(role.Actors) {
                                return ErrInvalidRole.Wrapf("repeated actor %s for role %s to add", actor, roleName)
                        }
                }
        }

        roles = make(map[string]struct{})

        for _, role := range msg.RoleActorsToRevoke {
                roleName := role.Role
                if roleName == "" {
                        return ErrInvalidRole.Wrap("role name cannot be empty")
                }

                if roleName == EVERYONE {
                        return ErrInvalidRole.Wrapf("actors cannot be explicitly revoked from the %s role", EVERYONE)
                }

                if _, ok := roles[roleName]; ok {
                        return ErrInvalidRole.Wrapf("repeated role %s", roleName)
                }
                roles[roleName] = struct{}{}

                for _, actor := range role.Actors {
                        if _, err := sdk.AccAddressFromBech32(actor); err != nil {
                                return err
                        }

                        if chaintypes.HasDuplicate(role.Actors) {
                                return ErrInvalidRole.Wrapf("repeated actor %s for role %s to revoke", actor, roleName)
                        }
                }
        }

        return nil
}
func (msg MsgUpdateActorRoles) GetAffectedRoles() []string {
        rolesMap := map[string]struct{}{}
        roles := make([]string, 0)

        for _, role := range msg.RoleActorsToAdd {
                if _, ok := rolesMap[role.Role]; !ok {
                        rolesMap[role.Role] = struct{}{}
                        roles = append(roles, role.Role)
                }
        }

        for _, role := range msg.RoleActorsToRevoke {
                if _, ok := rolesMap[role.Role]; !ok {
                        rolesMap[role.Role] = struct{}{}
                        roles = append(roles, role.Role)
                }
        }

        return roles
}

// func (msg MsgRevokeNamespaceRoles) ValidateBasic() error {
//         if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
//                 return err
//         }
//         // address_roles
//         foundAddresses := make(map[string]struct{}, len(msg.AddressRolesToRevoke))
//         for _, addrRoles := range msg.AddressRolesToRevoke {
//                 if _, err := sdk.AccAddressFromBech32(addrRoles.Address); err != nil {
//                         return errors.Wrapf(err, "invalid address %s", addrRoles.Address)
//                 }
//                 if _, ok := foundAddresses[addrRoles.Address]; ok {
//                         return errors.Wrapf(ErrInvalidRole, "address %s - revoking roles multiple times?", addrRoles.Address)
//                 }
//                 for _, role := range addrRoles.Roles {
//                         if role == EVERYONE {
//                                 return errors.Wrapf(ErrInvalidRole, "role %s can not be set / revoked", EVERYONE)
//                         }
//                 }
//                 foundAddresses[addrRoles.Address] = struct{}{}
//         }
//         return nil
// }

func (m MsgClaimVoucher) Route() string { return routerKey }

func (m MsgClaimVoucher) Type() string { return TypeMsgClaimVoucher }

func (msg MsgClaimVoucher) ValidateBasic() error {
        if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
                return err
        }

        if msg.Denom == "" {
                return fmt.Errorf("invalid denom")
        }
        return nil
}

func (m *MsgClaimVoucher) GetSignBytes() []byte {
        return sdk.MustSortJSON(ModuleCdc.MustMarshal(m))
}

func (m MsgClaimVoucher) GetSigners() []sdk.AccAddress {
        addr, _ := sdk.AccAddressFromBech32(m.Sender)
        return []sdk.AccAddress{addr}
}

package types

import (
        "cosmossdk.io/errors"
        sdk "github.com/cosmos/cosmos-sdk/types"

        chaintypes "github.com/InjectiveLabs/injective-core/injective-chain/types"
)

func (n *Namespace) PopulateEmptyValuesWithDefaults(creator sdk.AccAddress) {
        hasEmptyRoleManagers := len(n.RoleManagers) == 0
        hasEmptyPolicyStatuses := len(n.PolicyStatuses) == 0
        hasEmptyPolicyManagerCapabilities := len(n.PolicyManagerCapabilities) == 0

        // if unspecified, initialize the creator as the role manager for all roles
        if hasEmptyRoleManagers {
                roles := make([]string, 0, len(n.RolePermissions))
                for _, rolePerm := range n.RolePermissions {
                        roles = append(roles, rolePerm.Name)
                }

                n.RoleManagers = []*RoleManager{NewRoleManager(creator, roles)}
        }

        // initialize any unspecified policy statuses with permissive defaults
        if hasEmptyPolicyStatuses {
                n.PolicyStatuses = NewDefaultPolicyStatuses()
        } else {
                specifiedActionPolicies := make(map[Action]struct{}, len(n.PolicyStatuses))
                for _, policyStatus := range n.PolicyStatuses {
                        specifiedActionPolicies[policyStatus.Action] = struct{}{}
                }

                for _, action := range Actions {
                        if _, ok := specifiedActionPolicies[action]; !ok {
                                policy := NewPolicyStatus(action, false, false)
                                n.PolicyStatuses = append(n.PolicyStatuses, policy)
                        }
                }
        }

        // if unspecified, populate policy manager capabilities for the creator
        if hasEmptyPolicyManagerCapabilities {
                n.PolicyManagerCapabilities = NewDefaultPolicyManagerCapabilities(creator)
        }
}

func (n *Namespace) ValidateRoles(isForUpdate bool) error {
        if err := n.validateEveryoneRole(isForUpdate); err != nil {
                return err
        }

        foundRoleNames := make(map[string]struct{}, len(n.RolePermissions))
        foundRoleIDs := make(map[uint32]struct{}, len(n.RolePermissions))
        foundRolePermissions := make(map[uint32]struct{}, len(n.RolePermissions))

        for _, role := range n.RolePermissions {
                perm := role.Permissions
                name := role.Name
                roleID := role.RoleId

                if !IsValidPermission(perm) {
                        return ErrInvalidPermission.Wrapf("permissions %d does not correspond to a known action", perm)
                }

                if role.Name == "" || len(role.Name) > MaxRoleNameLength {
                        return ErrInvalidRole.Wrapf("role name %s must be between 1-%d characters", role.Name, MaxRoleNameLength)
                }

                if _, ok := foundRoleNames[name]; ok {
                        return errors.Wrapf(ErrInvalidRole, "role name %s must be unique", name)
                }

                if _, ok := foundRoleIDs[roleID]; ok {
                        return errors.Wrapf(ErrInvalidRole, "role ID %d must be unique", roleID)
                }

                if _, ok := foundRolePermissions[perm]; ok {
                        return errors.Wrapf(ErrInvalidRole, "role permissions %d must be unique", perm)
                }

                foundRoleNames[name] = struct{}{}
                foundRoleIDs[roleID] = struct{}{}
                foundRolePermissions[perm] = struct{}{}
        }

        foundActors := make(map[string]struct{}, len(n.ActorRoles))
        for _, actorRoles := range n.ActorRoles {
                actor, err := sdk.AccAddressFromBech32(actorRoles.Actor)
                if err != nil {
                        return errors.Wrapf(err, "invalid actor address %s", actorRoles.Actor)
                }

                if chaintypes.HasDuplicate(actorRoles.Roles) {
                        return errors.Wrapf(ErrInvalidRole, "duplicate roles for actor %s", actor)
                }

                if _, ok := foundActors[actor.String()]; ok {
                        return errors.Wrapf(ErrInvalidRole, "duplicate actor %s", actor)
                }
                foundActors[actor.String()] = struct{}{}

                for _, role := range actorRoles.Roles {
                        if _, ok := foundRoleNames[role]; !ok {
                                return errors.Wrapf(ErrUnknownRole, "role %s must be defined", role)
                        }

                        if role == EVERYONE {
                                return errors.Wrapf(ErrInvalidRole, "actors cannot be explicitly assigned to the %s role", EVERYONE)
                        }
                }
        }

        foundRoleManagers := make(map[string]struct{}, len(n.RoleManagers))
        for _, roleManager := range n.RoleManagers {
                manager, err := sdk.AccAddressFromBech32(roleManager.Manager)
                if err != nil {
                        return errors.Wrapf(err, "invalid manager address %s", roleManager.Manager)
                }

                if _, ok := foundRoleManagers[manager.String()]; ok {
                        return errors.Wrapf(ErrInvalidNamespace, "repeated role manager %s", manager)
                }

                foundRoleManagers[manager.String()] = struct{}{}

                if chaintypes.HasDuplicate(roleManager.Roles) {
                        return errors.Wrapf(ErrInvalidRole, "duplicate roles for manager %s", manager)
                }

                // during namespace creation, enforce that the role must exist and therefore be pre-defined
                if !isForUpdate {
                        for _, role := range roleManager.Roles {
                                if _, ok := foundRoleNames[role]; !ok {
                                        return errors.Wrapf(ErrUnknownRole, "role %s must be defined", role)
                                }
                        }
                }
        }

        return nil
}

func (n *Namespace) ValidatePolicies() error {
        foundPolicyStatuses := make(map[Action]struct{}, len(n.PolicyStatuses))

        for _, policyStatus := range n.PolicyStatuses {
                action := policyStatus.Action
                if !IsValidPolicyActionPermission(uint32(action)) {
                        return ErrInvalidPermission.Wrapf("policy status action %d does not correspond to a known action", action)
                }

                if _, ok := foundPolicyStatuses[action]; ok {
                        return errors.Wrapf(ErrInvalidNamespace, "repeated policy status for action %s", action)
                }

                foundPolicyStatuses[action] = struct{}{}
        }

        foundCapabilities := make(map[string]map[Action]struct{}, len(n.PolicyManagerCapabilities))

        for _, capability := range n.PolicyManagerCapabilities {
                manager, err := sdk.AccAddressFromBech32(capability.Manager)
                if err != nil {
                        return errors.Wrapf(err, "invalid manager address %s", capability.Manager)
                }

                action := capability.Action
                if !IsValidPolicyActionPermission(uint32(action)) {
                        return ErrInvalidPermission.Wrapf("policy manager capability action %d does not correspond to a known action", action)
                }

                foundActions, ok := foundCapabilities[manager.String()]
                if !ok {
                        foundActions = make(map[Action]struct{})
                        foundCapabilities[manager.String()] = foundActions
                }

                _, exists := foundActions[action]
                if exists {
                        return errors.Wrapf(ErrInvalidNamespace, "repeated policy manager capability for %s on action %s", manager, action)
                }
                foundActions[action] = struct{}{}
        }

        return nil
}

func (n *Namespace) validateEveryoneRole(isForUpdate bool) error {
        // role_permissions
        for _, rolePerm := range n.RolePermissions {
                if rolePerm.Name == EVERYONE {
                        perm := rolePerm.Permissions

                        if perm&DisallowedEveryoneActions != 0 {
                                return ErrInvalidPermission.Wrapf("%s role with permissions %d cannot contain administrative actions", rolePerm.Name, perm)
                        }
                        return nil
                }
        }

        // during namespace creation, enforce that the Everyone role must exist and therefore be pre-defined
        if !isForUpdate {
                return errors.Wrapf(ErrInvalidPermission, "permissions for role %s should be explicitly set", EVERYONE)
        }
        return nil
}

package types

import (
        paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
)

// ParamTable
func ParamKeyTable() paramtypes.KeyTable {
        return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
}

func NewParams(wasmHookQueryMaxGas uint64) Params {
        return Params{
                WasmHookQueryMaxGas: wasmHookQueryMaxGas,
        }
}

// default module parameters.
func DefaultParams() Params {
        return Params{
                WasmHookQueryMaxGas: 200_000,
        }
}

// validate params.
func (p Params) Validate() error {
        return nil
}

// Implements params.ParamSet.
func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
        return paramtypes.ParamSetPairs{}
}

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: injective/permissions/v1beta1/params.proto

package types

import (
        fmt "fmt"
        _ "github.com/cosmos/cosmos-proto"
        _ "github.com/cosmos/cosmos-sdk/types"
        _ "github.com/cosmos/cosmos-sdk/types/tx/amino"
        _ "github.com/cosmos/gogoproto/gogoproto"
        proto "github.com/cosmos/gogoproto/proto"
        io "io"
        math "math"
        math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Params defines the parameters for the permissions module.
type Params struct {
        WasmHookQueryMaxGas uint64 `protobuf:"varint,1,opt,name=wasm_hook_query_max_gas,json=wasmHookQueryMaxGas,proto3" json:"wasm_hook_query_max_gas,omitempty"`
}

func (m *Params) Reset()         { *m = Params{} }
func (m *Params) String() string { return proto.CompactTextString(m) }
func (*Params) ProtoMessage()    {}
func (*Params) Descriptor() ([]byte, []int) {
        return fileDescriptor_4a7ea0496163621f, []int{0}
}
func (m *Params) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_Params.Marshal(b, m, deterministic)
        } else {
                b = b[:cap(b)]
                n, err := m.MarshalToSizedBuffer(b)
                if err != nil {
                        return nil, err
                }
                return b[:n], nil
        }
}
func (m *Params) XXX_Merge(src proto.Message) {
        xxx_messageInfo_Params.Merge(m, src)
}
func (m *Params) XXX_Size() int {
        return m.Size()
}
func (m *Params) XXX_DiscardUnknown() {
        xxx_messageInfo_Params.DiscardUnknown(m)
}

var xxx_messageInfo_Params proto.InternalMessageInfo

func (m *Params) GetWasmHookQueryMaxGas() uint64 {
        if m != nil {
                return m.WasmHookQueryMaxGas
        }
        return 0
}

func init() {
        proto.RegisterType((*Params)(nil), "injective.permissions.v1beta1.Params")
}

func init() {
        proto.RegisterFile("injective/permissions/v1beta1/params.proto", fileDescriptor_4a7ea0496163621f)
}

var fileDescriptor_4a7ea0496163621f = []byte{
        // 287 bytes of a gzipped FileDescriptorProto
        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0x31, 0x4e, 0xc3, 0x30,
        0x14, 0x86, 0x6b, 0x09, 0x75, 0xc8, 0x46, 0x40, 0x02, 0x8a, 0x30, 0x88, 0x09, 0x55, 0x22, 0x56,
        0x05, 0x13, 0x23, 0x0b, 0x20, 0x81, 0x44, 0x19, 0x61, 0x88, 0x5e, 0x82, 0x95, 0x98, 0xe0, 0xbc,
        0x90, 0xe7, 0x94, 0xf6, 0x0a, 0x4c, 0x1c, 0x81, 0x23, 0x70, 0x0c, 0xc6, 0x8e, 0x8c, 0x28, 0x19,
        0xe0, 0x18, 0x28, 0x71, 0x88, 0xc2, 0x62, 0xf9, 0xf7, 0xf7, 0xdb, 0x7e, 0xff, 0xef, 0x8c, 0x55,
        0xfa, 0x20, 0x43, 0xa3, 0x66, 0x52, 0x64, 0x32, 0xd7, 0x8a, 0x48, 0x61, 0x4a, 0x62, 0x36, 0x09,
        0xa4, 0x81, 0x89, 0xc8, 0x20, 0x07, 0x4d, 0x5e, 0x96, 0xa3, 0x41, 0x77, 0xa7, 0xf3, 0x7a, 0x3d,
        0xaf, 0xd7, 0x7a, 0x47, 0xeb, 0x11, 0x46, 0xd8, 0x38, 0x45, 0xbd, 0xb3, 0x97, 0x46, 0x5b, 0x21,
        0x92, 0x46, 0xf2, 0x2d, 0xb0, 0xa2, 0x45, 0xdc, 0x2a, 0x11, 0x00, 0xc9, 0xee, 0xc7, 0x10, 0x55,
        0xda, 0xf2, 0x55, 0xd0, 0x2a, 0x45, 0xd1, 0xac, 0xf6, 0x68, 0xff, 0xce, 0x19, 0x5e, 0x37, 0x23,
        0xb9, 0xc7, 0xce, 0xc6, 0x33, 0x90, 0xf6, 0x63, 0xc4, 0xc4, 0x7f, 0x2a, 0x64, 0xbe, 0xf0, 0x35,
        0xcc, 0xfd, 0x08, 0x68, 0x93, 0xed, 0xb1, 0x83, 0x95, 0x9b, 0xb5, 0x1a, 0x9f, 0x23, 0x26, 0xd3,
        0x1a, 0x5e, 0xc1, 0xfc, 0x0c, 0xe8, 0x64, 0xfb, 0xe7, 0x6d, 0x97, 0xbd, 0x7c, 0xbf, 0x8f, 0xdd,
        0x7e, 0x5a, 0xfb, 0xe4, 0x69, 0xf2, 0x51, 0x72, 0xb6, 0x2c, 0x39, 0xfb, 0x2a, 0x39, 0x7b, 0xad,
        0xf8, 0x60, 0x59, 0xf1, 0xc1, 0x67, 0xc5, 0x07, 0xb7, 0xd3, 0x48, 0x99, 0xb8, 0x08, 0xbc, 0x10,
        0xb5, 0xb8, 0xf8, 0x2b, 0xe1, 0x12, 0x02, 0x12, 0x5d, 0x25, 0x87, 0x21, 0xe6, 0xb2, 0x2f, 0x63,
        0x50, 0xa9, 0xd0, 0x78, 0x5f, 0x3c, 0x4a, 0xfa, 0xd7, 0xad, 0x59, 0x64, 0x92, 0x82, 0x61, 0x13,
        0xe8, 0xe8, 0x37, 0x00, 0x00, 0xff, 0xff, 0xc7, 0x42, 0x3f, 0x45, 0x81, 0x01, 0x00, 0x00,
}

func (this *Params) Equal(that interface{}) bool {
        if that == nil {
                return this == nil
        }

        that1, ok := that.(*Params)
        if !ok {
                that2, ok := that.(Params)
                if ok {
                        that1 = &that2
                } else {
                        return false
                }
        }
        if that1 == nil {
                return this == nil
        } else if this == nil {
                return false
        }
        if this.WasmHookQueryMaxGas != that1.WasmHookQueryMaxGas {
                return false
        }
        return true
}
func (m *Params) Marshal() (dAtA []byte, err error) {
        size := m.Size()
        dAtA = make([]byte, size)
        n, err := m.MarshalToSizedBuffer(dAtA[:size])
        if err != nil {
                return nil, err
        }
        return dAtA[:n], nil
}

func (m *Params) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if m.WasmHookQueryMaxGas != 0 {
                i = encodeVarintParams(dAtA, i, uint64(m.WasmHookQueryMaxGas))
                i--
                dAtA[i] = 0x8
        }
        return len(dAtA) - i, nil
}

func encodeVarintParams(dAtA []byte, offset int, v uint64) int {
        offset -= sovParams(v)
        base := offset
        for v >= 1<<7 {
                dAtA[offset] = uint8(v&0x7f | 0x80)
                v >>= 7
                offset++
        }
        dAtA[offset] = uint8(v)
        return base
}
func (m *Params) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if m.WasmHookQueryMaxGas != 0 {
                n += 1 + sovParams(uint64(m.WasmHookQueryMaxGas))
        }
        return n
}

func sovParams(x uint64) (n int) {
        return (math_bits.Len64(x|1) + 6) / 7
}
func sozParams(x uint64) (n int) {
        return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowParams
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: Params: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field WasmHookQueryMaxGas", wireType)
                        }
                        m.WasmHookQueryMaxGas = 0
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowParams
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                m.WasmHookQueryMaxGas |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                default:
                        iNdEx = preIndex
                        skippy, err := skipParams(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthParams
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func skipParams(dAtA []byte) (n int, err error) {
        l := len(dAtA)
        iNdEx := 0
        depth := 0
        for iNdEx < l {
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return 0, ErrIntOverflowParams
                        }
                        if iNdEx >= l {
                                return 0, io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= (uint64(b) & 0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                wireType := int(wire & 0x7)
                switch wireType {
                case 0:
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return 0, ErrIntOverflowParams
                                }
                                if iNdEx >= l {
                                        return 0, io.ErrUnexpectedEOF
                                }
                                iNdEx++
                                if dAtA[iNdEx-1] < 0x80 {
                                        break
                                }
                        }
                case 1:
                        iNdEx += 8
                case 2:
                        var length int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return 0, ErrIntOverflowParams
                                }
                                if iNdEx >= l {
                                        return 0, io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                length |= (int(b) & 0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if length < 0 {
                                return 0, ErrInvalidLengthParams
                        }
                        iNdEx += length
                case 3:
                        depth++
                case 4:
                        if depth == 0 {
                                return 0, ErrUnexpectedEndOfGroupParams
                        }
                        depth--
                case 5:
                        iNdEx += 4
                default:
                        return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
                }
                if iNdEx < 0 {
                        return 0, ErrInvalidLengthParams
                }
                if depth == 0 {
                        return iNdEx, nil
                }
        }
        return 0, io.ErrUnexpectedEOF
}

var (
        ErrInvalidLengthParams        = fmt.Errorf("proto: negative length found during unmarshaling")
        ErrIntOverflowParams          = fmt.Errorf("proto: integer overflow")
        ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group")
)

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: injective/permissions/v1beta1/permissions.proto

package types

import (
        fmt "fmt"
        _ "github.com/cosmos/cosmos-sdk/types"
        github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
        _ "github.com/cosmos/gogoproto/gogoproto"
        proto "github.com/cosmos/gogoproto/proto"
        io "io"
        math "math"
        math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// 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

// each Action enum value should be a power of two
type Action int32

const (
        // 0 is reserved for ACTION_UNSPECIFIED
        Action_UNSPECIFIED Action = 0
        // 1 is reserved for MINT
        Action_MINT Action = 1
        // 2 is reserved for RECEIVE
        Action_RECEIVE Action = 2
        // 4 is reserved for BURN
        Action_BURN Action = 4
        // 8 is reserved for SEND
        Action_SEND Action = 8
        // 16 is reserved for SUPER_BURN
        Action_SUPER_BURN Action = 16
        // 2^27 is reserved for MODIFY_POLICY_MANAGERS
        Action_MODIFY_POLICY_MANAGERS Action = 134217728
        // 2^28 is reserved for MODIFY_CONTRACT_HOOK
        Action_MODIFY_CONTRACT_HOOK Action = 268435456
        // 2^29 is reserved for MODIFY_ROLE_PERMISSIONS
        Action_MODIFY_ROLE_PERMISSIONS Action = 536870912
        // 2^30 is reserved for MODIFY_ROLE_MANAGERS
        Action_MODIFY_ROLE_MANAGERS Action = 1073741824
)

var Action_name = map[int32]string{
        0:          "UNSPECIFIED",
        1:          "MINT",
        2:          "RECEIVE",
        4:          "BURN",
        8:          "SEND",
        16:         "SUPER_BURN",
        134217728:  "MODIFY_POLICY_MANAGERS",
        268435456:  "MODIFY_CONTRACT_HOOK",
        536870912:  "MODIFY_ROLE_PERMISSIONS",
        1073741824: "MODIFY_ROLE_MANAGERS",
}

var Action_value = map[string]int32{
        "UNSPECIFIED":             0,
        "MINT":                    1,
        "RECEIVE":                 2,
        "BURN":                    4,
        "SEND":                    8,
        "SUPER_BURN":              16,
        "MODIFY_POLICY_MANAGERS":  134217728,
        "MODIFY_CONTRACT_HOOK":    268435456,
        "MODIFY_ROLE_PERMISSIONS": 536870912,
        "MODIFY_ROLE_MANAGERS":    1073741824,
}

func (x Action) String() string {
        return proto.EnumName(Action_name, int32(x))
}

func (Action) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{0}
}

// Namespace defines a permissions namespace
type Namespace struct {
        Denom                     string                     `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
        ContractHook              string                     `protobuf:"bytes,2,opt,name=contract_hook,json=contractHook,proto3" json:"contract_hook,omitempty"`
        RolePermissions           []*Role                    `protobuf:"bytes,3,rep,name=role_permissions,json=rolePermissions,proto3" json:"role_permissions,omitempty"`
        ActorRoles                []*ActorRoles              `protobuf:"bytes,4,rep,name=actor_roles,json=actorRoles,proto3" json:"actor_roles,omitempty"`
        RoleManagers              []*RoleManager             `protobuf:"bytes,5,rep,name=role_managers,json=roleManagers,proto3" json:"role_managers,omitempty"`
        PolicyStatuses            []*PolicyStatus            `protobuf:"bytes,6,rep,name=policy_statuses,json=policyStatuses,proto3" json:"policy_statuses,omitempty"`
        PolicyManagerCapabilities []*PolicyManagerCapability `protobuf:"bytes,7,rep,name=policy_manager_capabilities,json=policyManagerCapabilities,proto3" json:"policy_manager_capabilities,omitempty"`
}

func (m *Namespace) Reset()         { *m = Namespace{} }
func (m *Namespace) String() string { return proto.CompactTextString(m) }
func (*Namespace) ProtoMessage()    {}
func (*Namespace) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{0}
}
func (m *Namespace) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *Namespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_Namespace.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 *Namespace) XXX_Merge(src proto.Message) {
        xxx_messageInfo_Namespace.Merge(m, src)
}
func (m *Namespace) XXX_Size() int {
        return m.Size()
}
func (m *Namespace) XXX_DiscardUnknown() {
        xxx_messageInfo_Namespace.DiscardUnknown(m)
}

var xxx_messageInfo_Namespace proto.InternalMessageInfo

func (m *Namespace) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

func (m *Namespace) GetContractHook() string {
        if m != nil {
                return m.ContractHook
        }
        return ""
}

func (m *Namespace) GetRolePermissions() []*Role {
        if m != nil {
                return m.RolePermissions
        }
        return nil
}

func (m *Namespace) GetActorRoles() []*ActorRoles {
        if m != nil {
                return m.ActorRoles
        }
        return nil
}

func (m *Namespace) GetRoleManagers() []*RoleManager {
        if m != nil {
                return m.RoleManagers
        }
        return nil
}

func (m *Namespace) GetPolicyStatuses() []*PolicyStatus {
        if m != nil {
                return m.PolicyStatuses
        }
        return nil
}

func (m *Namespace) GetPolicyManagerCapabilities() []*PolicyManagerCapability {
        if m != nil {
                return m.PolicyManagerCapabilities
        }
        return nil
}

// AddressRoles defines roles for an actor
type ActorRoles struct {
        Actor string   `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"`
        Roles []string `protobuf:"bytes,2,rep,name=roles,proto3" json:"roles,omitempty"`
}

func (m *ActorRoles) Reset()         { *m = ActorRoles{} }
func (m *ActorRoles) String() string { return proto.CompactTextString(m) }
func (*ActorRoles) ProtoMessage()    {}
func (*ActorRoles) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{1}
}
func (m *ActorRoles) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *ActorRoles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_ActorRoles.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 *ActorRoles) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ActorRoles.Merge(m, src)
}
func (m *ActorRoles) XXX_Size() int {
        return m.Size()
}
func (m *ActorRoles) XXX_DiscardUnknown() {
        xxx_messageInfo_ActorRoles.DiscardUnknown(m)
}

var xxx_messageInfo_ActorRoles proto.InternalMessageInfo

func (m *ActorRoles) GetActor() string {
        if m != nil {
                return m.Actor
        }
        return ""
}

func (m *ActorRoles) GetRoles() []string {
        if m != nil {
                return m.Roles
        }
        return nil
}

// RoleActors defines actors for a role
type RoleActors struct {
        Role   string   `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
        Actors []string `protobuf:"bytes,2,rep,name=actors,proto3" json:"actors,omitempty"`
}

func (m *RoleActors) Reset()         { *m = RoleActors{} }
func (m *RoleActors) String() string { return proto.CompactTextString(m) }
func (*RoleActors) ProtoMessage()    {}
func (*RoleActors) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{2}
}
func (m *RoleActors) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *RoleActors) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_RoleActors.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 *RoleActors) XXX_Merge(src proto.Message) {
        xxx_messageInfo_RoleActors.Merge(m, src)
}
func (m *RoleActors) XXX_Size() int {
        return m.Size()
}
func (m *RoleActors) XXX_DiscardUnknown() {
        xxx_messageInfo_RoleActors.DiscardUnknown(m)
}

var xxx_messageInfo_RoleActors proto.InternalMessageInfo

func (m *RoleActors) GetRole() string {
        if m != nil {
                return m.Role
        }
        return ""
}

func (m *RoleActors) GetActors() []string {
        if m != nil {
                return m.Actors
        }
        return nil
}

// RoleManager defines roles for a manager address
type RoleManager struct {
        Manager string   `protobuf:"bytes,1,opt,name=manager,proto3" json:"manager,omitempty"`
        Roles   []string `protobuf:"bytes,2,rep,name=roles,proto3" json:"roles,omitempty"`
}

func (m *RoleManager) Reset()         { *m = RoleManager{} }
func (m *RoleManager) String() string { return proto.CompactTextString(m) }
func (*RoleManager) ProtoMessage()    {}
func (*RoleManager) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{3}
}
func (m *RoleManager) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *RoleManager) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_RoleManager.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 *RoleManager) XXX_Merge(src proto.Message) {
        xxx_messageInfo_RoleManager.Merge(m, src)
}
func (m *RoleManager) XXX_Size() int {
        return m.Size()
}
func (m *RoleManager) XXX_DiscardUnknown() {
        xxx_messageInfo_RoleManager.DiscardUnknown(m)
}

var xxx_messageInfo_RoleManager proto.InternalMessageInfo

func (m *RoleManager) GetManager() string {
        if m != nil {
                return m.Manager
        }
        return ""
}

func (m *RoleManager) GetRoles() []string {
        if m != nil {
                return m.Roles
        }
        return nil
}

// PolicyStatus defines the status of a policy
type PolicyStatus struct {
        Action     Action `protobuf:"varint,1,opt,name=action,proto3,enum=injective.permissions.v1beta1.Action" json:"action,omitempty"`
        IsDisabled bool   `protobuf:"varint,2,opt,name=is_disabled,json=isDisabled,proto3" json:"is_disabled,omitempty"`
        IsSealed   bool   `protobuf:"varint,3,opt,name=is_sealed,json=isSealed,proto3" json:"is_sealed,omitempty"`
}

func (m *PolicyStatus) Reset()         { *m = PolicyStatus{} }
func (m *PolicyStatus) String() string { return proto.CompactTextString(m) }
func (*PolicyStatus) ProtoMessage()    {}
func (*PolicyStatus) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{4}
}
func (m *PolicyStatus) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *PolicyStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_PolicyStatus.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 *PolicyStatus) XXX_Merge(src proto.Message) {
        xxx_messageInfo_PolicyStatus.Merge(m, src)
}
func (m *PolicyStatus) XXX_Size() int {
        return m.Size()
}
func (m *PolicyStatus) XXX_DiscardUnknown() {
        xxx_messageInfo_PolicyStatus.DiscardUnknown(m)
}

var xxx_messageInfo_PolicyStatus proto.InternalMessageInfo

func (m *PolicyStatus) GetAction() Action {
        if m != nil {
                return m.Action
        }
        return Action_UNSPECIFIED
}

func (m *PolicyStatus) GetIsDisabled() bool {
        if m != nil {
                return m.IsDisabled
        }
        return false
}

func (m *PolicyStatus) GetIsSealed() bool {
        if m != nil {
                return m.IsSealed
        }
        return false
}

// Role is only used for storage
type Role struct {
        Name        string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
        RoleId      uint32 `protobuf:"varint,2,opt,name=role_id,json=roleId,proto3" json:"role_id,omitempty"`
        Permissions uint32 `protobuf:"varint,3,opt,name=permissions,proto3" json:"permissions,omitempty"`
}

func (m *Role) Reset()         { *m = Role{} }
func (m *Role) String() string { return proto.CompactTextString(m) }
func (*Role) ProtoMessage()    {}
func (*Role) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{5}
}
func (m *Role) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *Role) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_Role.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 *Role) XXX_Merge(src proto.Message) {
        xxx_messageInfo_Role.Merge(m, src)
}
func (m *Role) XXX_Size() int {
        return m.Size()
}
func (m *Role) XXX_DiscardUnknown() {
        xxx_messageInfo_Role.DiscardUnknown(m)
}

var xxx_messageInfo_Role proto.InternalMessageInfo

func (m *Role) GetName() string {
        if m != nil {
                return m.Name
        }
        return ""
}

func (m *Role) GetRoleId() uint32 {
        if m != nil {
                return m.RoleId
        }
        return 0
}

func (m *Role) GetPermissions() uint32 {
        if m != nil {
                return m.Permissions
        }
        return 0
}

// PolicyManagerCapability defines the capabilities of a manager for a policy
type PolicyManagerCapability struct {
        Manager    string `protobuf:"bytes,1,opt,name=manager,proto3" json:"manager,omitempty"`
        Action     Action `protobuf:"varint,2,opt,name=action,proto3,enum=injective.permissions.v1beta1.Action" json:"action,omitempty"`
        CanDisable bool   `protobuf:"varint,3,opt,name=can_disable,json=canDisable,proto3" json:"can_disable,omitempty"`
        CanSeal    bool   `protobuf:"varint,4,opt,name=can_seal,json=canSeal,proto3" json:"can_seal,omitempty"`
}

func (m *PolicyManagerCapability) Reset()         { *m = PolicyManagerCapability{} }
func (m *PolicyManagerCapability) String() string { return proto.CompactTextString(m) }
func (*PolicyManagerCapability) ProtoMessage()    {}
func (*PolicyManagerCapability) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{6}
}
func (m *PolicyManagerCapability) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *PolicyManagerCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_PolicyManagerCapability.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 *PolicyManagerCapability) XXX_Merge(src proto.Message) {
        xxx_messageInfo_PolicyManagerCapability.Merge(m, src)
}
func (m *PolicyManagerCapability) XXX_Size() int {
        return m.Size()
}
func (m *PolicyManagerCapability) XXX_DiscardUnknown() {
        xxx_messageInfo_PolicyManagerCapability.DiscardUnknown(m)
}

var xxx_messageInfo_PolicyManagerCapability proto.InternalMessageInfo

func (m *PolicyManagerCapability) GetManager() string {
        if m != nil {
                return m.Manager
        }
        return ""
}

func (m *PolicyManagerCapability) GetAction() Action {
        if m != nil {
                return m.Action
        }
        return Action_UNSPECIFIED
}

func (m *PolicyManagerCapability) GetCanDisable() bool {
        if m != nil {
                return m.CanDisable
        }
        return false
}

func (m *PolicyManagerCapability) GetCanSeal() bool {
        if m != nil {
                return m.CanSeal
        }
        return false
}

// used in storage
type RoleIDs struct {
        RoleIds []uint32 `protobuf:"varint,1,rep,packed,name=role_ids,json=roleIds,proto3" json:"role_ids,omitempty"`
}

func (m *RoleIDs) Reset()         { *m = RoleIDs{} }
func (m *RoleIDs) String() string { return proto.CompactTextString(m) }
func (*RoleIDs) ProtoMessage()    {}
func (*RoleIDs) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{7}
}
func (m *RoleIDs) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *RoleIDs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_RoleIDs.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 *RoleIDs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_RoleIDs.Merge(m, src)
}
func (m *RoleIDs) XXX_Size() int {
        return m.Size()
}
func (m *RoleIDs) XXX_DiscardUnknown() {
        xxx_messageInfo_RoleIDs.DiscardUnknown(m)
}

var xxx_messageInfo_RoleIDs proto.InternalMessageInfo

func (m *RoleIDs) GetRoleIds() []uint32 {
        if m != nil {
                return m.RoleIds
        }
        return nil
}

// AddressVoucher is used to represent a voucher for a specific address
type AddressVoucher struct {
        Address string                                  `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
        Voucher github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,2,opt,name=voucher,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Coin" json:"voucher,omitempty"`
}

func (m *AddressVoucher) Reset()         { *m = AddressVoucher{} }
func (m *AddressVoucher) String() string { return proto.CompactTextString(m) }
func (*AddressVoucher) ProtoMessage()    {}
func (*AddressVoucher) Descriptor() ([]byte, []int) {
        return fileDescriptor_6d25f3ecf3806c6c, []int{8}
}
func (m *AddressVoucher) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *AddressVoucher) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_AddressVoucher.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 *AddressVoucher) XXX_Merge(src proto.Message) {
        xxx_messageInfo_AddressVoucher.Merge(m, src)
}
func (m *AddressVoucher) XXX_Size() int {
        return m.Size()
}
func (m *AddressVoucher) XXX_DiscardUnknown() {
        xxx_messageInfo_AddressVoucher.DiscardUnknown(m)
}

var xxx_messageInfo_AddressVoucher proto.InternalMessageInfo

func (m *AddressVoucher) GetAddress() string {
        if m != nil {
                return m.Address
        }
        return ""
}

func init() {
        proto.RegisterEnum("injective.permissions.v1beta1.Action", Action_name, Action_value)
        proto.RegisterType((*Namespace)(nil), "injective.permissions.v1beta1.Namespace")
        proto.RegisterType((*ActorRoles)(nil), "injective.permissions.v1beta1.ActorRoles")
        proto.RegisterType((*RoleActors)(nil), "injective.permissions.v1beta1.RoleActors")
        proto.RegisterType((*RoleManager)(nil), "injective.permissions.v1beta1.RoleManager")
        proto.RegisterType((*PolicyStatus)(nil), "injective.permissions.v1beta1.PolicyStatus")
        proto.RegisterType((*Role)(nil), "injective.permissions.v1beta1.Role")
        proto.RegisterType((*PolicyManagerCapability)(nil), "injective.permissions.v1beta1.PolicyManagerCapability")
        proto.RegisterType((*RoleIDs)(nil), "injective.permissions.v1beta1.RoleIDs")
        proto.RegisterType((*AddressVoucher)(nil), "injective.permissions.v1beta1.AddressVoucher")
}

func init() {
        proto.RegisterFile("injective/permissions/v1beta1/permissions.proto", fileDescriptor_6d25f3ecf3806c6c)
}

var fileDescriptor_6d25f3ecf3806c6c = []byte{
        // 871 bytes of a gzipped FileDescriptorProto
        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0x4d, 0x6f, 0xdb, 0x46,
        0x10, 0x15, 0x25, 0x45, 0x92, 0x47, 0xfe, 0x50, 0x17, 0x46, 0x4c, 0x27, 0x8d, 0x24, 0x28, 0x2d,
        0xea, 0xa6, 0x8d, 0x84, 0xb8, 0x40, 0xd1, 0x4b, 0x80, 0xca, 0x12, 0xd3, 0xb0, 0xb5, 0x28, 0x75,
        0x65, 0x07, 0x48, 0x2f, 0xc4, 0x8a, 0x5a, 0xd8, 0x5b, 0x8b, 0x5c, 0x82, 0x4b, 0x0b, 0xd0, 0x4d,
        0x3d, 0xf7, 0xd2, 0x3f, 0xd1, 0x6b, 0x7f, 0x47, 0x8e, 0x3e, 0x16, 0x3d, 0x18, 0x85, 0x7d, 0xeb,
        0xaf, 0x28, 0x76, 0xb9, 0x94, 0x18, 0xa0, 0x89, 0x83, 0x9e, 0x34, 0x33, 0x6f, 0xdf, 0xdb, 0x99,
        0xc7, 0x11, 0x09, 0x1d, 0x16, 0xfc, 0x4c, 0xbd, 0x98, 0xcd, 0x69, 0x27, 0xa4, 0x91, 0xcf, 0x84,
        0x60, 0x3c, 0x10, 0x9d, 0xf9, 0xb3, 0x09, 0x8d, 0xc9, 0xb3, 0x6c, 0xad, 0x1d, 0x46, 0x3c, 0xe6,
        0xe8, 0xd1, 0x8a, 0xd0, 0xce, 0x82, 0x9a, 0xf0, 0xa0, 0xee, 0x71, 0xe1, 0x73, 0xd1, 0x99, 0x10,
        0x41, 0x57, 0x2a, 0x1e, 0x67, 0x41, 0x42, 0x7f, 0xb0, 0x7b, 0xc6, 0xcf, 0xb8, 0x0a, 0x3b, 0x32,
        0x4a, 0xaa, 0xad, 0x5f, 0x8a, 0xb0, 0xe1, 0x10, 0x9f, 0x8a, 0x90, 0x78, 0x14, 0xed, 0xc2, 0xbd,
        0x29, 0x0d, 0xb8, 0x6f, 0x1a, 0x4d, 0xe3, 0x60, 0x03, 0x27, 0x09, 0x7a, 0x0c, 0x5b, 0x1e, 0x0f,
        0xe2, 0x88, 0x78, 0xb1, 0x7b, 0xce, 0xf9, 0x85, 0x99, 0x57, 0xe8, 0x66, 0x5a, 0x7c, 0xc9, 0xf9,
        0x05, 0x72, 0xa0, 0x16, 0xf1, 0x19, 0x75, 0x33, 0xad, 0x99, 0x85, 0x66, 0xe1, 0xa0, 0x7a, 0xf8,
        0xb8, 0xfd, 0xde, 0xc6, 0xdb, 0x98, 0xcf, 0x28, 0xde, 0x91, 0xe4, 0xd1, 0x1a, 0x45, 0xdf, 0x43,
        0x95, 0x78, 0x31, 0x8f, 0x5c, 0x09, 0x08, 0xb3, 0xa8, 0xa4, 0x3e, 0xbf, 0x43, 0xaa, 0x2b, 0x19,
        0x52, 0x4f, 0x60, 0x20, 0xab, 0x18, 0x0d, 0x61, 0x4b, 0xf5, 0xe6, 0x93, 0x80, 0x9c, 0xd1, 0x48,
        0x98, 0xf7, 0x94, 0xda, 0x93, 0x0f, 0x68, 0x6c, 0x90, 0x50, 0xf0, 0x66, 0xb4, 0x4e, 0x04, 0x3a,
        0x81, 0x9d, 0x90, 0xcf, 0x98, 0xb7, 0x70, 0x45, 0x4c, 0xe2, 0x4b, 0x41, 0x85, 0x59, 0x52, 0x92,
        0x5f, 0xdc, 0x21, 0x39, 0x52, 0xac, 0xb1, 0x22, 0xe1, 0xed, 0x30, 0x93, 0x51, 0x81, 0xe6, 0xf0,
        0x50, 0xab, 0xea, 0x46, 0x5d, 0x8f, 0x84, 0x64, 0xc2, 0x66, 0x2c, 0x66, 0x54, 0x98, 0x65, 0x75,
        0xc3, 0xd7, 0x1f, 0x74, 0x83, 0xee, 0xb4, 0x97, 0xf2, 0x17, 0x78, 0x3f, 0xfc, 0x4f, 0x80, 0x51,
        0xd1, 0xfa, 0x06, 0x60, 0x6d, 0x9c, 0xdc, 0x01, 0x65, 0x5d, 0xba, 0x03, 0x2a, 0x91, 0xd5, 0xe4,
        0x41, 0xe4, 0x9b, 0x05, 0x59, 0x55, 0x89, 0x64, 0x4a, 0x92, 0x62, 0x0b, 0x84, 0xa0, 0x28, 0xcb,
        0x9a, 0xa8, 0x62, 0x74, 0x1f, 0x4a, 0x4a, 0x20, 0x25, 0xea, 0xac, 0xf5, 0x1c, 0xaa, 0x19, 0x7b,
        0x91, 0x09, 0x65, 0x3d, 0xb3, 0x66, 0xa7, 0xe9, 0x3b, 0x2e, 0xfe, 0xd5, 0x80, 0xcd, 0xac, 0x97,
        0xe8, 0xb9, 0xba, 0x87, 0xf1, 0x40, 0xf1, 0xb7, 0x0f, 0x3f, 0xbd, 0x7b, 0x53, 0x18, 0x0f, 0xb0,
        0x26, 0xa1, 0x06, 0x54, 0x99, 0x70, 0xa7, 0x4c, 0x90, 0xc9, 0x8c, 0x4e, 0xd5, 0x82, 0x57, 0x30,
        0x30, 0xd1, 0xd7, 0x15, 0xf4, 0x10, 0x36, 0x98, 0x70, 0x05, 0x25, 0x12, 0x2e, 0x28, 0xb8, 0xc2,
        0xc4, 0x58, 0xe5, 0xad, 0x53, 0x28, 0xca, 0x61, 0xa4, 0x01, 0x01, 0xf1, 0x57, 0x06, 0xc8, 0x18,
        0xed, 0x41, 0x59, 0xed, 0x1e, 0x4b, 0x54, 0xb7, 0x70, 0x49, 0xa6, 0xf6, 0x14, 0x35, 0xa1, 0xfa,
        0xf6, 0x7f, 0x45, 0x82, 0xd9, 0x52, 0xeb, 0x0f, 0x03, 0xf6, 0xde, 0xf1, 0x38, 0xdf, 0x63, 0xd8,
        0xda, 0x89, 0xfc, 0xff, 0x74, 0xc2, 0x23, 0x41, 0x6a, 0x85, 0x1e, 0x15, 0x3c, 0x12, 0x68, 0x2b,
        0xd0, 0x3e, 0x54, 0xe4, 0x01, 0x69, 0x85, 0x59, 0x54, 0x68, 0xd9, 0x23, 0x81, 0x74, 0xa2, 0xf5,
        0x09, 0x94, 0xa5, 0x0f, 0x76, 0x5f, 0xc8, 0x53, 0x7a, 0x6c, 0x61, 0x1a, 0xcd, 0xc2, 0xc1, 0x16,
        0x2e, 0x27, 0x73, 0x8b, 0xd6, 0xef, 0x06, 0x6c, 0x77, 0xa7, 0xd3, 0x88, 0x0a, 0xf1, 0x8a, 0x5f,
        0x7a, 0xe7, 0xc9, 0xe3, 0x27, 0x49, 0x25, 0x9d, 0x46, 0xa7, 0x68, 0x01, 0xe5, 0x79, 0x72, 0x48,
        0x8d, 0x53, 0x3d, 0xdc, 0x6f, 0x27, 0xef, 0xb9, 0xb6, 0x7c, 0xcf, 0xad, 0x86, 0xe8, 0x71, 0x16,
        0x1c, 0xf5, 0xdf, 0x5c, 0x37, 0x72, 0x7f, 0x5d, 0x37, 0x3e, 0x3b, 0x63, 0xf1, 0xf9, 0xe5, 0xa4,
        0xed, 0x71, 0xbf, 0xa3, 0x5f, 0x8a, 0xc9, 0xcf, 0x53, 0x31, 0xbd, 0xe8, 0xc4, 0x8b, 0x90, 0x0a,
        0x45, 0xf8, 0xe7, 0xba, 0xf1, 0x91, 0x16, 0xff, 0x92, 0xfb, 0x2c, 0xa6, 0x7e, 0x18, 0x2f, 0x70,
        0x7a, 0xdf, 0x93, 0x2b, 0x03, 0x4a, 0x89, 0x39, 0x68, 0x07, 0xaa, 0xa7, 0xce, 0x78, 0x64, 0xf5,
        0xec, 0x17, 0xb6, 0xd5, 0xaf, 0xe5, 0x50, 0x05, 0x8a, 0x03, 0xdb, 0x39, 0xa9, 0x19, 0xa8, 0x0a,
        0x65, 0x6c, 0xf5, 0x2c, 0xfb, 0x95, 0x55, 0xcb, 0xcb, 0xf2, 0xd1, 0x29, 0x76, 0x6a, 0x45, 0x19,
        0x8d, 0x2d, 0xa7, 0x5f, 0xab, 0xa0, 0x6d, 0x80, 0xf1, 0xe9, 0xc8, 0xc2, 0xae, 0x42, 0x6a, 0xe8,
        0x11, 0xdc, 0x1f, 0x0c, 0xfb, 0xf6, 0x8b, 0xd7, 0xee, 0x68, 0x78, 0x6c, 0xf7, 0x5e, 0xbb, 0x83,
        0xae, 0xd3, 0xfd, 0xce, 0xc2, 0xe3, 0xda, 0x72, 0xb9, 0xfc, 0x16, 0x7d, 0x0c, 0xbb, 0x1a, 0xee,
        0x0d, 0x9d, 0x13, 0xdc, 0xed, 0x9d, 0xb8, 0x2f, 0x87, 0xc3, 0x1f, 0x24, 0xb8, 0x34, 0x50, 0x03,
        0xf6, 0x34, 0x8a, 0x87, 0xc7, 0x96, 0x3b, 0xb2, 0xf0, 0xc0, 0x1e, 0x8f, 0xed, 0xa1, 0xa3, 0xd8,
        0xcb, 0x7c, 0x86, 0xae, 0x0e, 0x64, 0xb5, 0x97, 0xc5, 0xa3, 0x8b, 0x37, 0x37, 0x75, 0xe3, 0xea,
        0xa6, 0x6e, 0xfc, 0x7d, 0x53, 0x37, 0x7e, 0xbb, 0xad, 0xe7, 0xae, 0x6e, 0xeb, 0xb9, 0x3f, 0x6f,
        0xeb, 0xb9, 0x9f, 0x7e, 0xcc, 0x78, 0x66, 0xa7, 0xfb, 0x72, 0x4c, 0x26, 0x62, 0xfd, 0x99, 0x7a,
        0xea, 0xf1, 0x88, 0x66, 0xd3, 0x73, 0xc2, 0x82, 0x8e, 0xcf, 0xa7, 0x97, 0x33, 0x2a, 0xde, 0xfa,
        0x86, 0x29, 0x8b, 0x27, 0x25, 0xf5, 0x85, 0xf9, 0xea, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x62,
        0x3a, 0xbf, 0x78, 0xe9, 0x06, 0x00, 0x00,
}

func (m *Namespace) 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 *Namespace) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Namespace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.PolicyManagerCapabilities) > 0 {
                for iNdEx := len(m.PolicyManagerCapabilities) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.PolicyManagerCapabilities[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintPermissions(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x3a
                }
        }
        if len(m.PolicyStatuses) > 0 {
                for iNdEx := len(m.PolicyStatuses) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.PolicyStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintPermissions(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x32
                }
        }
        if len(m.RoleManagers) > 0 {
                for iNdEx := len(m.RoleManagers) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.RoleManagers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintPermissions(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x2a
                }
        }
        if len(m.ActorRoles) > 0 {
                for iNdEx := len(m.ActorRoles) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.ActorRoles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintPermissions(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x22
                }
        }
        if len(m.RolePermissions) > 0 {
                for iNdEx := len(m.RolePermissions) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.RolePermissions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintPermissions(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x1a
                }
        }
        if len(m.ContractHook) > 0 {
                i -= len(m.ContractHook)
                copy(dAtA[i:], m.ContractHook)
                i = encodeVarintPermissions(dAtA, i, uint64(len(m.ContractHook)))
                i--
                dAtA[i] = 0x12
        }
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintPermissions(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *ActorRoles) 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 *ActorRoles) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ActorRoles) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Roles) > 0 {
                for iNdEx := len(m.Roles) - 1; iNdEx >= 0; iNdEx-- {
                        i -= len(m.Roles[iNdEx])
                        copy(dAtA[i:], m.Roles[iNdEx])
                        i = encodeVarintPermissions(dAtA, i, uint64(len(m.Roles[iNdEx])))
                        i--
                        dAtA[i] = 0x12
                }
        }
        if len(m.Actor) > 0 {
                i -= len(m.Actor)
                copy(dAtA[i:], m.Actor)
                i = encodeVarintPermissions(dAtA, i, uint64(len(m.Actor)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *RoleActors) 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 *RoleActors) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RoleActors) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Actors) > 0 {
                for iNdEx := len(m.Actors) - 1; iNdEx >= 0; iNdEx-- {
                        i -= len(m.Actors[iNdEx])
                        copy(dAtA[i:], m.Actors[iNdEx])
                        i = encodeVarintPermissions(dAtA, i, uint64(len(m.Actors[iNdEx])))
                        i--
                        dAtA[i] = 0x12
                }
        }
        if len(m.Role) > 0 {
                i -= len(m.Role)
                copy(dAtA[i:], m.Role)
                i = encodeVarintPermissions(dAtA, i, uint64(len(m.Role)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *RoleManager) 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 *RoleManager) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RoleManager) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Roles) > 0 {
                for iNdEx := len(m.Roles) - 1; iNdEx >= 0; iNdEx-- {
                        i -= len(m.Roles[iNdEx])
                        copy(dAtA[i:], m.Roles[iNdEx])
                        i = encodeVarintPermissions(dAtA, i, uint64(len(m.Roles[iNdEx])))
                        i--
                        dAtA[i] = 0x12
                }
        }
        if len(m.Manager) > 0 {
                i -= len(m.Manager)
                copy(dAtA[i:], m.Manager)
                i = encodeVarintPermissions(dAtA, i, uint64(len(m.Manager)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *PolicyStatus) 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 *PolicyStatus) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PolicyStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if m.IsSealed {
                i--
                if m.IsSealed {
                        dAtA[i] = 1
                } else {
                        dAtA[i] = 0
                }
                i--
                dAtA[i] = 0x18
        }
        if m.IsDisabled {
                i--
                if m.IsDisabled {
                        dAtA[i] = 1
                } else {
                        dAtA[i] = 0
                }
                i--
                dAtA[i] = 0x10
        }
        if m.Action != 0 {
                i = encodeVarintPermissions(dAtA, i, uint64(m.Action))
                i--
                dAtA[i] = 0x8
        }
        return len(dAtA) - i, nil
}

func (m *Role) 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 *Role) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Role) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if m.Permissions != 0 {
                i = encodeVarintPermissions(dAtA, i, uint64(m.Permissions))
                i--
                dAtA[i] = 0x18
        }
        if m.RoleId != 0 {
                i = encodeVarintPermissions(dAtA, i, uint64(m.RoleId))
                i--
                dAtA[i] = 0x10
        }
        if len(m.Name) > 0 {
                i -= len(m.Name)
                copy(dAtA[i:], m.Name)
                i = encodeVarintPermissions(dAtA, i, uint64(len(m.Name)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *PolicyManagerCapability) 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 *PolicyManagerCapability) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PolicyManagerCapability) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if m.CanSeal {
                i--
                if m.CanSeal {
                        dAtA[i] = 1
                } else {
                        dAtA[i] = 0
                }
                i--
                dAtA[i] = 0x20
        }
        if m.CanDisable {
                i--
                if m.CanDisable {
                        dAtA[i] = 1
                } else {
                        dAtA[i] = 0
                }
                i--
                dAtA[i] = 0x18
        }
        if m.Action != 0 {
                i = encodeVarintPermissions(dAtA, i, uint64(m.Action))
                i--
                dAtA[i] = 0x10
        }
        if len(m.Manager) > 0 {
                i -= len(m.Manager)
                copy(dAtA[i:], m.Manager)
                i = encodeVarintPermissions(dAtA, i, uint64(len(m.Manager)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *RoleIDs) 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 *RoleIDs) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RoleIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.RoleIds) > 0 {
                dAtA2 := make([]byte, len(m.RoleIds)*10)
                var j1 int
                for _, num := range m.RoleIds {
                        for num >= 1<<7 {
                                dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
                                num >>= 7
                                j1++
                        }
                        dAtA2[j1] = uint8(num)
                        j1++
                }
                i -= j1
                copy(dAtA[i:], dAtA2[:j1])
                i = encodeVarintPermissions(dAtA, i, uint64(j1))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *AddressVoucher) 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 *AddressVoucher) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddressVoucher) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        {
                size := m.Voucher.Size()
                i -= size
                if _, err := m.Voucher.MarshalTo(dAtA[i:]); err != nil {
                        return 0, err
                }
                i = encodeVarintPermissions(dAtA, i, uint64(size))
        }
        i--
        dAtA[i] = 0x12
        if len(m.Address) > 0 {
                i -= len(m.Address)
                copy(dAtA[i:], m.Address)
                i = encodeVarintPermissions(dAtA, i, uint64(len(m.Address)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func encodeVarintPermissions(dAtA []byte, offset int, v uint64) int {
        offset -= sovPermissions(v)
        base := offset
        for v >= 1<<7 {
                dAtA[offset] = uint8(v&0x7f | 0x80)
                v >>= 7
                offset++
        }
        dAtA[offset] = uint8(v)
        return base
}
func (m *Namespace) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovPermissions(uint64(l))
        }
        l = len(m.ContractHook)
        if l > 0 {
                n += 1 + l + sovPermissions(uint64(l))
        }
        if len(m.RolePermissions) > 0 {
                for _, e := range m.RolePermissions {
                        l = e.Size()
                        n += 1 + l + sovPermissions(uint64(l))
                }
        }
        if len(m.ActorRoles) > 0 {
                for _, e := range m.ActorRoles {
                        l = e.Size()
                        n += 1 + l + sovPermissions(uint64(l))
                }
        }
        if len(m.RoleManagers) > 0 {
                for _, e := range m.RoleManagers {
                        l = e.Size()
                        n += 1 + l + sovPermissions(uint64(l))
                }
        }
        if len(m.PolicyStatuses) > 0 {
                for _, e := range m.PolicyStatuses {
                        l = e.Size()
                        n += 1 + l + sovPermissions(uint64(l))
                }
        }
        if len(m.PolicyManagerCapabilities) > 0 {
                for _, e := range m.PolicyManagerCapabilities {
                        l = e.Size()
                        n += 1 + l + sovPermissions(uint64(l))
                }
        }
        return n
}

func (m *ActorRoles) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Actor)
        if l > 0 {
                n += 1 + l + sovPermissions(uint64(l))
        }
        if len(m.Roles) > 0 {
                for _, s := range m.Roles {
                        l = len(s)
                        n += 1 + l + sovPermissions(uint64(l))
                }
        }
        return n
}

func (m *RoleActors) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Role)
        if l > 0 {
                n += 1 + l + sovPermissions(uint64(l))
        }
        if len(m.Actors) > 0 {
                for _, s := range m.Actors {
                        l = len(s)
                        n += 1 + l + sovPermissions(uint64(l))
                }
        }
        return n
}

func (m *RoleManager) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Manager)
        if l > 0 {
                n += 1 + l + sovPermissions(uint64(l))
        }
        if len(m.Roles) > 0 {
                for _, s := range m.Roles {
                        l = len(s)
                        n += 1 + l + sovPermissions(uint64(l))
                }
        }
        return n
}

func (m *PolicyStatus) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if m.Action != 0 {
                n += 1 + sovPermissions(uint64(m.Action))
        }
        if m.IsDisabled {
                n += 2
        }
        if m.IsSealed {
                n += 2
        }
        return n
}

func (m *Role) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Name)
        if l > 0 {
                n += 1 + l + sovPermissions(uint64(l))
        }
        if m.RoleId != 0 {
                n += 1 + sovPermissions(uint64(m.RoleId))
        }
        if m.Permissions != 0 {
                n += 1 + sovPermissions(uint64(m.Permissions))
        }
        return n
}

func (m *PolicyManagerCapability) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Manager)
        if l > 0 {
                n += 1 + l + sovPermissions(uint64(l))
        }
        if m.Action != 0 {
                n += 1 + sovPermissions(uint64(m.Action))
        }
        if m.CanDisable {
                n += 2
        }
        if m.CanSeal {
                n += 2
        }
        return n
}

func (m *RoleIDs) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.RoleIds) > 0 {
                l = 0
                for _, e := range m.RoleIds {
                        l += sovPermissions(uint64(e))
                }
                n += 1 + sovPermissions(uint64(l)) + l
        }
        return n
}

func (m *AddressVoucher) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Address)
        if l > 0 {
                n += 1 + l + sovPermissions(uint64(l))
        }
        l = m.Voucher.Size()
        n += 1 + l + sovPermissions(uint64(l))
        return n
}

func sovPermissions(x uint64) (n int) {
        return (math_bits.Len64(x|1) + 6) / 7
}
func sozPermissions(x uint64) (n int) {
        return sovPermissions(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Namespace) 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 ErrIntOverflowPermissions
                        }
                        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: Namespace: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: Namespace: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field ContractHook", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.ContractHook = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 3:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RolePermissions", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.RolePermissions = append(m.RolePermissions, &Role{})
                        if err := m.RolePermissions[len(m.RolePermissions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 4:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field ActorRoles", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.ActorRoles = append(m.ActorRoles, &ActorRoles{})
                        if err := m.ActorRoles[len(m.ActorRoles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 5:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RoleManagers", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.RoleManagers = append(m.RoleManagers, &RoleManager{})
                        if err := m.RoleManagers[len(m.RoleManagers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 6:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field PolicyStatuses", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.PolicyStatuses = append(m.PolicyStatuses, &PolicyStatus{})
                        if err := m.PolicyStatuses[len(m.PolicyStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 7:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field PolicyManagerCapabilities", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.PolicyManagerCapabilities = append(m.PolicyManagerCapabilities, &PolicyManagerCapability{})
                        if err := m.PolicyManagerCapabilities[len(m.PolicyManagerCapabilities)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *ActorRoles) 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 ErrIntOverflowPermissions
                        }
                        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: ActorRoles: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: ActorRoles: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Actor", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Actor = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *RoleActors) 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 ErrIntOverflowPermissions
                        }
                        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: RoleActors: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: RoleActors: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Role = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Actors", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Actors = append(m.Actors, string(dAtA[iNdEx:postIndex]))
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *RoleManager) 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 ErrIntOverflowPermissions
                        }
                        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: RoleManager: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: RoleManager: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Manager", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Manager = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *PolicyStatus) 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 ErrIntOverflowPermissions
                        }
                        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: PolicyStatus: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: PolicyStatus: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
                        }
                        m.Action = 0
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                m.Action |= Action(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                case 2:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field IsDisabled", wireType)
                        }
                        var v int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                v |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        m.IsDisabled = bool(v != 0)
                case 3:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field IsSealed", wireType)
                        }
                        var v int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                v |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        m.IsSealed = bool(v != 0)
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *Role) 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 ErrIntOverflowPermissions
                        }
                        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: Role: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: Role: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Name = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RoleId", wireType)
                        }
                        m.RoleId = 0
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                m.RoleId |= uint32(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                case 3:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
                        }
                        m.Permissions = 0
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                m.Permissions |= uint32(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *PolicyManagerCapability) 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 ErrIntOverflowPermissions
                        }
                        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: PolicyManagerCapability: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: PolicyManagerCapability: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Manager", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Manager = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
                        }
                        m.Action = 0
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                m.Action |= Action(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                case 3:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field CanDisable", wireType)
                        }
                        var v int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                v |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        m.CanDisable = bool(v != 0)
                case 4:
                        if wireType != 0 {
                                return fmt.Errorf("proto: wrong wireType = %d for field CanSeal", wireType)
                        }
                        var v int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                v |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        m.CanSeal = bool(v != 0)
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *RoleIDs) 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 ErrIntOverflowPermissions
                        }
                        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: RoleIDs: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: RoleIDs: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType == 0 {
                                var v uint32
                                for shift := uint(0); ; shift += 7 {
                                        if shift >= 64 {
                                                return ErrIntOverflowPermissions
                                        }
                                        if iNdEx >= l {
                                                return io.ErrUnexpectedEOF
                                        }
                                        b := dAtA[iNdEx]
                                        iNdEx++
                                        v |= uint32(b&0x7F) << shift
                                        if b < 0x80 {
                                                break
                                        }
                                }
                                m.RoleIds = append(m.RoleIds, v)
                        } else if wireType == 2 {
                                var packedLen int
                                for shift := uint(0); ; shift += 7 {
                                        if shift >= 64 {
                                                return ErrIntOverflowPermissions
                                        }
                                        if iNdEx >= l {
                                                return io.ErrUnexpectedEOF
                                        }
                                        b := dAtA[iNdEx]
                                        iNdEx++
                                        packedLen |= int(b&0x7F) << shift
                                        if b < 0x80 {
                                                break
                                        }
                                }
                                if packedLen < 0 {
                                        return ErrInvalidLengthPermissions
                                }
                                postIndex := iNdEx + packedLen
                                if postIndex < 0 {
                                        return ErrInvalidLengthPermissions
                                }
                                if postIndex > l {
                                        return io.ErrUnexpectedEOF
                                }
                                var elementCount int
                                var count int
                                for _, integer := range dAtA[iNdEx:postIndex] {
                                        if integer < 128 {
                                                count++
                                        }
                                }
                                elementCount = count
                                if elementCount != 0 && len(m.RoleIds) == 0 {
                                        m.RoleIds = make([]uint32, 0, elementCount)
                                }
                                for iNdEx < postIndex {
                                        var v uint32
                                        for shift := uint(0); ; shift += 7 {
                                                if shift >= 64 {
                                                        return ErrIntOverflowPermissions
                                                }
                                                if iNdEx >= l {
                                                        return io.ErrUnexpectedEOF
                                                }
                                                b := dAtA[iNdEx]
                                                iNdEx++
                                                v |= uint32(b&0x7F) << shift
                                                if b < 0x80 {
                                                        break
                                                }
                                        }
                                        m.RoleIds = append(m.RoleIds, v)
                                }
                        } else {
                                return fmt.Errorf("proto: wrong wireType = %d for field RoleIds", wireType)
                        }
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *AddressVoucher) 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 ErrIntOverflowPermissions
                        }
                        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: AddressVoucher: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: AddressVoucher: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                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 ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Address = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Voucher", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowPermissions
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if err := m.Voucher.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipPermissions(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthPermissions
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func skipPermissions(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, ErrIntOverflowPermissions
                        }
                        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, ErrIntOverflowPermissions
                                }
                                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, ErrIntOverflowPermissions
                                }
                                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, ErrInvalidLengthPermissions
                        }
                        iNdEx += length
                case 3:
                        depth++
                case 4:
                        if depth == 0 {
                                return 0, ErrUnexpectedEndOfGroupPermissions
                        }
                        depth--
                case 5:
                        iNdEx += 4
                default:
                        return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
                }
                if iNdEx < 0 {
                        return 0, ErrInvalidLengthPermissions
                }
                if depth == 0 {
                        return iNdEx, nil
                }
        }
        return 0, io.ErrUnexpectedEOF
}

var (
        ErrInvalidLengthPermissions        = fmt.Errorf("proto: negative length found during unmarshaling")
        ErrIntOverflowPermissions          = fmt.Errorf("proto: integer overflow")
        ErrUnexpectedEndOfGroupPermissions = fmt.Errorf("proto: unexpected end of group")
)

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: injective/permissions/v1beta1/query.proto

package types

import (
        context "context"
        fmt "fmt"
        _ "github.com/cosmos/cosmos-sdk/types"
        github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
        _ "github.com/cosmos/cosmos-sdk/types/query"
        _ "github.com/cosmos/gogoproto/gogoproto"
        grpc1 "github.com/cosmos/gogoproto/grpc"
        proto "github.com/cosmos/gogoproto/proto"
        _ "google.golang.org/genproto/googleapis/api/annotations"
        grpc "google.golang.org/grpc"
        codes "google.golang.org/grpc/codes"
        status "google.golang.org/grpc/status"
        io "io"
        math "math"
        math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// QueryParamsRequest is the request type for the Query/Params RPC method.
type QueryParamsRequest struct {
}

func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParamsRequest) ProtoMessage()    {}
func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{0}
}
func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic)
        } else {
                b = b[:cap(b)]
                n, err := m.MarshalToSizedBuffer(b)
                if err != nil {
                        return nil, err
                }
                return b[:n], nil
        }
}
func (m *QueryParamsRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryParamsRequest.Merge(m, src)
}
func (m *QueryParamsRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryParamsRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse is the response type for the Query/Params RPC method.
type QueryParamsResponse struct {
        // params defines the parameters of the module.
        Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParamsResponse) ProtoMessage()    {}
func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{1}
}
func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
        } else {
                b = b[:cap(b)]
                n, err := m.MarshalToSizedBuffer(b)
                if err != nil {
                        return nil, err
                }
                return b[:n], nil
        }
}
func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryParamsResponse.Merge(m, src)
}
func (m *QueryParamsResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryParamsResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

func (m *QueryParamsResponse) GetParams() Params {
        if m != nil {
                return m.Params
        }
        return Params{}
}

// QueryNamespaceDenomsRequest is the request type for the Query/NamespaceDenoms RPC
// method.
type QueryNamespaceDenomsRequest struct {
}

func (m *QueryNamespaceDenomsRequest) Reset()         { *m = QueryNamespaceDenomsRequest{} }
func (m *QueryNamespaceDenomsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryNamespaceDenomsRequest) ProtoMessage()    {}
func (*QueryNamespaceDenomsRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{2}
}
func (m *QueryNamespaceDenomsRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryNamespaceDenomsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryNamespaceDenomsRequest.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 *QueryNamespaceDenomsRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryNamespaceDenomsRequest.Merge(m, src)
}
func (m *QueryNamespaceDenomsRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryNamespaceDenomsRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryNamespaceDenomsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNamespaceDenomsRequest proto.InternalMessageInfo

// QueryNamespaceDenomsResponse is the response type for the Query/NamespaceDenoms
// RPC method.
type QueryNamespaceDenomsResponse struct {
        Denoms []string `protobuf:"bytes,1,rep,name=denoms,proto3" json:"denoms,omitempty"`
}

func (m *QueryNamespaceDenomsResponse) Reset()         { *m = QueryNamespaceDenomsResponse{} }
func (m *QueryNamespaceDenomsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryNamespaceDenomsResponse) ProtoMessage()    {}
func (*QueryNamespaceDenomsResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{3}
}
func (m *QueryNamespaceDenomsResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryNamespaceDenomsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryNamespaceDenomsResponse.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 *QueryNamespaceDenomsResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryNamespaceDenomsResponse.Merge(m, src)
}
func (m *QueryNamespaceDenomsResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryNamespaceDenomsResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryNamespaceDenomsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNamespaceDenomsResponse proto.InternalMessageInfo

func (m *QueryNamespaceDenomsResponse) GetDenoms() []string {
        if m != nil {
                return m.Denoms
        }
        return nil
}

// QueryNamespacesRequest is the request type for the Query/Namespaces RPC
// method.
type QueryNamespacesRequest struct {
}

func (m *QueryNamespacesRequest) Reset()         { *m = QueryNamespacesRequest{} }
func (m *QueryNamespacesRequest) String() string { return proto.CompactTextString(m) }
func (*QueryNamespacesRequest) ProtoMessage()    {}
func (*QueryNamespacesRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{4}
}
func (m *QueryNamespacesRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryNamespacesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryNamespacesRequest.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 *QueryNamespacesRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryNamespacesRequest.Merge(m, src)
}
func (m *QueryNamespacesRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryNamespacesRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryNamespacesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNamespacesRequest proto.InternalMessageInfo

// QueryNamespacesResponse is the response type for the Query/Namespaces
// RPC method.
type QueryNamespacesResponse struct {
        Namespaces []*Namespace `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces,omitempty"`
}

func (m *QueryNamespacesResponse) Reset()         { *m = QueryNamespacesResponse{} }
func (m *QueryNamespacesResponse) String() string { return proto.CompactTextString(m) }
func (*QueryNamespacesResponse) ProtoMessage()    {}
func (*QueryNamespacesResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{5}
}
func (m *QueryNamespacesResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryNamespacesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryNamespacesResponse.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 *QueryNamespacesResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryNamespacesResponse.Merge(m, src)
}
func (m *QueryNamespacesResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryNamespacesResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryNamespacesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNamespacesResponse proto.InternalMessageInfo

func (m *QueryNamespacesResponse) GetNamespaces() []*Namespace {
        if m != nil {
                return m.Namespaces
        }
        return nil
}

// QueryNamespaceRequest is the request type for the
// Query/Namespace RPC method.
type QueryNamespaceRequest struct {
        Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

func (m *QueryNamespaceRequest) Reset()         { *m = QueryNamespaceRequest{} }
func (m *QueryNamespaceRequest) String() string { return proto.CompactTextString(m) }
func (*QueryNamespaceRequest) ProtoMessage()    {}
func (*QueryNamespaceRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{6}
}
func (m *QueryNamespaceRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryNamespaceRequest.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 *QueryNamespaceRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryNamespaceRequest.Merge(m, src)
}
func (m *QueryNamespaceRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryNamespaceRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryNamespaceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNamespaceRequest proto.InternalMessageInfo

func (m *QueryNamespaceRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

// QueryNamespaceResponse is the response type for the
// Query/NamespaceByDenom RPC method.
type QueryNamespaceResponse struct {
        Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
}

func (m *QueryNamespaceResponse) Reset()         { *m = QueryNamespaceResponse{} }
func (m *QueryNamespaceResponse) String() string { return proto.CompactTextString(m) }
func (*QueryNamespaceResponse) ProtoMessage()    {}
func (*QueryNamespaceResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{7}
}
func (m *QueryNamespaceResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryNamespaceResponse.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 *QueryNamespaceResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryNamespaceResponse.Merge(m, src)
}
func (m *QueryNamespaceResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryNamespaceResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryNamespaceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNamespaceResponse proto.InternalMessageInfo

func (m *QueryNamespaceResponse) GetNamespace() *Namespace {
        if m != nil {
                return m.Namespace
        }
        return nil
}

// QueryAddressesByRoleRequest is the request type for the Query/AddressesByRole
// RPC method.
type QueryActorsByRoleRequest struct {
        Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
        Role  string `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
}

func (m *QueryActorsByRoleRequest) Reset()         { *m = QueryActorsByRoleRequest{} }
func (m *QueryActorsByRoleRequest) String() string { return proto.CompactTextString(m) }
func (*QueryActorsByRoleRequest) ProtoMessage()    {}
func (*QueryActorsByRoleRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{8}
}
func (m *QueryActorsByRoleRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryActorsByRoleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryActorsByRoleRequest.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 *QueryActorsByRoleRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryActorsByRoleRequest.Merge(m, src)
}
func (m *QueryActorsByRoleRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryActorsByRoleRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryActorsByRoleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryActorsByRoleRequest proto.InternalMessageInfo

func (m *QueryActorsByRoleRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

func (m *QueryActorsByRoleRequest) GetRole() string {
        if m != nil {
                return m.Role
        }
        return ""
}

// QueryAddressesByRoleResponse is the response type for the
// Query/AddressesByRole RPC method.
type QueryActorsByRoleResponse struct {
        Actors []string `protobuf:"bytes,1,rep,name=actors,proto3" json:"actors,omitempty"`
}

func (m *QueryActorsByRoleResponse) Reset()         { *m = QueryActorsByRoleResponse{} }
func (m *QueryActorsByRoleResponse) String() string { return proto.CompactTextString(m) }
func (*QueryActorsByRoleResponse) ProtoMessage()    {}
func (*QueryActorsByRoleResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{9}
}
func (m *QueryActorsByRoleResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryActorsByRoleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryActorsByRoleResponse.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 *QueryActorsByRoleResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryActorsByRoleResponse.Merge(m, src)
}
func (m *QueryActorsByRoleResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryActorsByRoleResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryActorsByRoleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryActorsByRoleResponse proto.InternalMessageInfo

func (m *QueryActorsByRoleResponse) GetActors() []string {
        if m != nil {
                return m.Actors
        }
        return nil
}

// QueryRolesByActorRequest is the request type for the
// Query/RolesByActor RPC method.
type QueryRolesByActorRequest struct {
        Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
        Actor string `protobuf:"bytes,2,opt,name=actor,proto3" json:"actor,omitempty"`
}

func (m *QueryRolesByActorRequest) Reset()         { *m = QueryRolesByActorRequest{} }
func (m *QueryRolesByActorRequest) String() string { return proto.CompactTextString(m) }
func (*QueryRolesByActorRequest) ProtoMessage()    {}
func (*QueryRolesByActorRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{10}
}
func (m *QueryRolesByActorRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryRolesByActorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryRolesByActorRequest.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 *QueryRolesByActorRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryRolesByActorRequest.Merge(m, src)
}
func (m *QueryRolesByActorRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryRolesByActorRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryRolesByActorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRolesByActorRequest proto.InternalMessageInfo

func (m *QueryRolesByActorRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

func (m *QueryRolesByActorRequest) GetActor() string {
        if m != nil {
                return m.Actor
        }
        return ""
}

// QueryRolesByActorResponse is the response type for the
// Query/RolesByActor RPC method.
type QueryRolesByActorResponse struct {
        Roles []string `protobuf:"bytes,1,rep,name=roles,proto3" json:"roles,omitempty"`
}

func (m *QueryRolesByActorResponse) Reset()         { *m = QueryRolesByActorResponse{} }
func (m *QueryRolesByActorResponse) String() string { return proto.CompactTextString(m) }
func (*QueryRolesByActorResponse) ProtoMessage()    {}
func (*QueryRolesByActorResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{11}
}
func (m *QueryRolesByActorResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryRolesByActorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryRolesByActorResponse.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 *QueryRolesByActorResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryRolesByActorResponse.Merge(m, src)
}
func (m *QueryRolesByActorResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryRolesByActorResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryRolesByActorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRolesByActorResponse proto.InternalMessageInfo

func (m *QueryRolesByActorResponse) GetRoles() []string {
        if m != nil {
                return m.Roles
        }
        return nil
}

// QueryRoleManagersRequest is the request type for the Query/RoleManagers
// RPC method.
type QueryRoleManagersRequest struct {
        Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

func (m *QueryRoleManagersRequest) Reset()         { *m = QueryRoleManagersRequest{} }
func (m *QueryRoleManagersRequest) String() string { return proto.CompactTextString(m) }
func (*QueryRoleManagersRequest) ProtoMessage()    {}
func (*QueryRoleManagersRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{12}
}
func (m *QueryRoleManagersRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryRoleManagersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryRoleManagersRequest.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 *QueryRoleManagersRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryRoleManagersRequest.Merge(m, src)
}
func (m *QueryRoleManagersRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryRoleManagersRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryRoleManagersRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRoleManagersRequest proto.InternalMessageInfo

func (m *QueryRoleManagersRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

// QueryRoleManagersResponse is the response type for the
// Query/RoleManagers RPC method.
type QueryRoleManagersResponse struct {
        RoleManagers []*RoleManager `protobuf:"bytes,1,rep,name=role_managers,json=roleManagers,proto3" json:"role_managers,omitempty"`
}

func (m *QueryRoleManagersResponse) Reset()         { *m = QueryRoleManagersResponse{} }
func (m *QueryRoleManagersResponse) String() string { return proto.CompactTextString(m) }
func (*QueryRoleManagersResponse) ProtoMessage()    {}
func (*QueryRoleManagersResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{13}
}
func (m *QueryRoleManagersResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryRoleManagersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryRoleManagersResponse.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 *QueryRoleManagersResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryRoleManagersResponse.Merge(m, src)
}
func (m *QueryRoleManagersResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryRoleManagersResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryRoleManagersResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRoleManagersResponse proto.InternalMessageInfo

func (m *QueryRoleManagersResponse) GetRoleManagers() []*RoleManager {
        if m != nil {
                return m.RoleManagers
        }
        return nil
}

// QueryRoleManagerRequest is the request type for the Query/RoleManager
// RPC method.
type QueryRoleManagerRequest struct {
        Denom   string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
        Manager string `protobuf:"bytes,2,opt,name=manager,proto3" json:"manager,omitempty"`
}

func (m *QueryRoleManagerRequest) Reset()         { *m = QueryRoleManagerRequest{} }
func (m *QueryRoleManagerRequest) String() string { return proto.CompactTextString(m) }
func (*QueryRoleManagerRequest) ProtoMessage()    {}
func (*QueryRoleManagerRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{14}
}
func (m *QueryRoleManagerRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryRoleManagerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryRoleManagerRequest.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 *QueryRoleManagerRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryRoleManagerRequest.Merge(m, src)
}
func (m *QueryRoleManagerRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryRoleManagerRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryRoleManagerRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRoleManagerRequest proto.InternalMessageInfo

func (m *QueryRoleManagerRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

func (m *QueryRoleManagerRequest) GetManager() string {
        if m != nil {
                return m.Manager
        }
        return ""
}

// QueryRoleManagerResponse is the response type for the
// Query/RoleManager RPC method.
type QueryRoleManagerResponse struct {
        RoleManager *RoleManager `protobuf:"bytes,1,opt,name=role_manager,json=roleManager,proto3" json:"role_manager,omitempty"`
}

func (m *QueryRoleManagerResponse) Reset()         { *m = QueryRoleManagerResponse{} }
func (m *QueryRoleManagerResponse) String() string { return proto.CompactTextString(m) }
func (*QueryRoleManagerResponse) ProtoMessage()    {}
func (*QueryRoleManagerResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{15}
}
func (m *QueryRoleManagerResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryRoleManagerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryRoleManagerResponse.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 *QueryRoleManagerResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryRoleManagerResponse.Merge(m, src)
}
func (m *QueryRoleManagerResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryRoleManagerResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryRoleManagerResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRoleManagerResponse proto.InternalMessageInfo

func (m *QueryRoleManagerResponse) GetRoleManager() *RoleManager {
        if m != nil {
                return m.RoleManager
        }
        return nil
}

// QueryPolicyStatusesRequest is the request type for the Query/PolicyStatuses
// RPC method.
type QueryPolicyStatusesRequest struct {
        Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

func (m *QueryPolicyStatusesRequest) Reset()         { *m = QueryPolicyStatusesRequest{} }
func (m *QueryPolicyStatusesRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPolicyStatusesRequest) ProtoMessage()    {}
func (*QueryPolicyStatusesRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{16}
}
func (m *QueryPolicyStatusesRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryPolicyStatusesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryPolicyStatusesRequest.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 *QueryPolicyStatusesRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryPolicyStatusesRequest.Merge(m, src)
}
func (m *QueryPolicyStatusesRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryPolicyStatusesRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryPolicyStatusesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPolicyStatusesRequest proto.InternalMessageInfo

func (m *QueryPolicyStatusesRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

// QueryRoleManagerResponse is the response type for the
// Query/RoleManager RPC method.
type QueryPolicyStatusesResponse struct {
        PolicyStatuses []*PolicyStatus `protobuf:"bytes,1,rep,name=policy_statuses,json=policyStatuses,proto3" json:"policy_statuses,omitempty"`
}

func (m *QueryPolicyStatusesResponse) Reset()         { *m = QueryPolicyStatusesResponse{} }
func (m *QueryPolicyStatusesResponse) String() string { return proto.CompactTextString(m) }
func (*QueryPolicyStatusesResponse) ProtoMessage()    {}
func (*QueryPolicyStatusesResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{17}
}
func (m *QueryPolicyStatusesResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryPolicyStatusesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryPolicyStatusesResponse.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 *QueryPolicyStatusesResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryPolicyStatusesResponse.Merge(m, src)
}
func (m *QueryPolicyStatusesResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryPolicyStatusesResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryPolicyStatusesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPolicyStatusesResponse proto.InternalMessageInfo

func (m *QueryPolicyStatusesResponse) GetPolicyStatuses() []*PolicyStatus {
        if m != nil {
                return m.PolicyStatuses
        }
        return nil
}

// QueryPolicyManagerCapabilitiesRequest is the request type for the Query/PolicyManagerCapabilities
// RPC method.
type QueryPolicyManagerCapabilitiesRequest struct {
        Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

func (m *QueryPolicyManagerCapabilitiesRequest) Reset()         { *m = QueryPolicyManagerCapabilitiesRequest{} }
func (m *QueryPolicyManagerCapabilitiesRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPolicyManagerCapabilitiesRequest) ProtoMessage()    {}
func (*QueryPolicyManagerCapabilitiesRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{18}
}
func (m *QueryPolicyManagerCapabilitiesRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryPolicyManagerCapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryPolicyManagerCapabilitiesRequest.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 *QueryPolicyManagerCapabilitiesRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryPolicyManagerCapabilitiesRequest.Merge(m, src)
}
func (m *QueryPolicyManagerCapabilitiesRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryPolicyManagerCapabilitiesRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryPolicyManagerCapabilitiesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPolicyManagerCapabilitiesRequest proto.InternalMessageInfo

func (m *QueryPolicyManagerCapabilitiesRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

// QueryPolicyManagerCapabilitiesResponse is the response type for the
// Query/PolicyManagerCapabilities RPC method.
type QueryPolicyManagerCapabilitiesResponse struct {
        PolicyManagerCapabilities []*PolicyManagerCapability `protobuf:"bytes,1,rep,name=policy_manager_capabilities,json=policyManagerCapabilities,proto3" json:"policy_manager_capabilities,omitempty"`
}

func (m *QueryPolicyManagerCapabilitiesResponse) Reset() {
        *m = QueryPolicyManagerCapabilitiesResponse{}
}
func (m *QueryPolicyManagerCapabilitiesResponse) String() string { return proto.CompactTextString(m) }
func (*QueryPolicyManagerCapabilitiesResponse) ProtoMessage()    {}
func (*QueryPolicyManagerCapabilitiesResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{19}
}
func (m *QueryPolicyManagerCapabilitiesResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryPolicyManagerCapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryPolicyManagerCapabilitiesResponse.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 *QueryPolicyManagerCapabilitiesResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryPolicyManagerCapabilitiesResponse.Merge(m, src)
}
func (m *QueryPolicyManagerCapabilitiesResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryPolicyManagerCapabilitiesResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryPolicyManagerCapabilitiesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPolicyManagerCapabilitiesResponse proto.InternalMessageInfo

func (m *QueryPolicyManagerCapabilitiesResponse) GetPolicyManagerCapabilities() []*PolicyManagerCapability {
        if m != nil {
                return m.PolicyManagerCapabilities
        }
        return nil
}

type QueryVouchersRequest struct {
        Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

func (m *QueryVouchersRequest) Reset()         { *m = QueryVouchersRequest{} }
func (m *QueryVouchersRequest) String() string { return proto.CompactTextString(m) }
func (*QueryVouchersRequest) ProtoMessage()    {}
func (*QueryVouchersRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{20}
}
func (m *QueryVouchersRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryVouchersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryVouchersRequest.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 *QueryVouchersRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryVouchersRequest.Merge(m, src)
}
func (m *QueryVouchersRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryVouchersRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryVouchersRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryVouchersRequest proto.InternalMessageInfo

func (m *QueryVouchersRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

type QueryVouchersResponse struct {
        Vouchers []*AddressVoucher `protobuf:"bytes,1,rep,name=vouchers,proto3" json:"vouchers,omitempty"`
}

func (m *QueryVouchersResponse) Reset()         { *m = QueryVouchersResponse{} }
func (m *QueryVouchersResponse) String() string { return proto.CompactTextString(m) }
func (*QueryVouchersResponse) ProtoMessage()    {}
func (*QueryVouchersResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{21}
}
func (m *QueryVouchersResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryVouchersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryVouchersResponse.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 *QueryVouchersResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryVouchersResponse.Merge(m, src)
}
func (m *QueryVouchersResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryVouchersResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryVouchersResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryVouchersResponse proto.InternalMessageInfo

func (m *QueryVouchersResponse) GetVouchers() []*AddressVoucher {
        if m != nil {
                return m.Vouchers
        }
        return nil
}

type QueryVoucherRequest struct {
        Denom   string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
        Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *QueryVoucherRequest) Reset()         { *m = QueryVoucherRequest{} }
func (m *QueryVoucherRequest) String() string { return proto.CompactTextString(m) }
func (*QueryVoucherRequest) ProtoMessage()    {}
func (*QueryVoucherRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{22}
}
func (m *QueryVoucherRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryVoucherRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryVoucherRequest.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 *QueryVoucherRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryVoucherRequest.Merge(m, src)
}
func (m *QueryVoucherRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryVoucherRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryVoucherRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryVoucherRequest proto.InternalMessageInfo

func (m *QueryVoucherRequest) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

func (m *QueryVoucherRequest) GetAddress() string {
        if m != nil {
                return m.Address
        }
        return ""
}

type QueryVoucherResponse struct {
        Voucher github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,1,opt,name=voucher,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Coin" json:"voucher,omitempty"`
}

func (m *QueryVoucherResponse) Reset()         { *m = QueryVoucherResponse{} }
func (m *QueryVoucherResponse) String() string { return proto.CompactTextString(m) }
func (*QueryVoucherResponse) ProtoMessage()    {}
func (*QueryVoucherResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{23}
}
func (m *QueryVoucherResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryVoucherResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryVoucherResponse.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 *QueryVoucherResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryVoucherResponse.Merge(m, src)
}
func (m *QueryVoucherResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryVoucherResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryVoucherResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryVoucherResponse proto.InternalMessageInfo

// QueryModuleStateRequest is the request type for the Query/PermissionsModuleState
// RPC method.
type QueryModuleStateRequest struct {
}

func (m *QueryModuleStateRequest) Reset()         { *m = QueryModuleStateRequest{} }
func (m *QueryModuleStateRequest) String() string { return proto.CompactTextString(m) }
func (*QueryModuleStateRequest) ProtoMessage()    {}
func (*QueryModuleStateRequest) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{24}
}
func (m *QueryModuleStateRequest) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryModuleStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryModuleStateRequest.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 *QueryModuleStateRequest) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryModuleStateRequest.Merge(m, src)
}
func (m *QueryModuleStateRequest) XXX_Size() int {
        return m.Size()
}
func (m *QueryModuleStateRequest) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryModuleStateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryModuleStateRequest proto.InternalMessageInfo

// QueryModuleStateResponse is the response type for the Query/PermissionsModuleState
// RPC method.
type QueryModuleStateResponse struct {
        State *GenesisState `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
}

func (m *QueryModuleStateResponse) Reset()         { *m = QueryModuleStateResponse{} }
func (m *QueryModuleStateResponse) String() string { return proto.CompactTextString(m) }
func (*QueryModuleStateResponse) ProtoMessage()    {}
func (*QueryModuleStateResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_e0ae50f1018498b3, []int{25}
}
func (m *QueryModuleStateResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *QueryModuleStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_QueryModuleStateResponse.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 *QueryModuleStateResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_QueryModuleStateResponse.Merge(m, src)
}
func (m *QueryModuleStateResponse) XXX_Size() int {
        return m.Size()
}
func (m *QueryModuleStateResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_QueryModuleStateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryModuleStateResponse proto.InternalMessageInfo

func (m *QueryModuleStateResponse) GetState() *GenesisState {
        if m != nil {
                return m.State
        }
        return nil
}

func init() {
        proto.RegisterType((*QueryParamsRequest)(nil), "injective.permissions.v1beta1.QueryParamsRequest")
        proto.RegisterType((*QueryParamsResponse)(nil), "injective.permissions.v1beta1.QueryParamsResponse")
        proto.RegisterType((*QueryNamespaceDenomsRequest)(nil), "injective.permissions.v1beta1.QueryNamespaceDenomsRequest")
        proto.RegisterType((*QueryNamespaceDenomsResponse)(nil), "injective.permissions.v1beta1.QueryNamespaceDenomsResponse")
        proto.RegisterType((*QueryNamespacesRequest)(nil), "injective.permissions.v1beta1.QueryNamespacesRequest")
        proto.RegisterType((*QueryNamespacesResponse)(nil), "injective.permissions.v1beta1.QueryNamespacesResponse")
        proto.RegisterType((*QueryNamespaceRequest)(nil), "injective.permissions.v1beta1.QueryNamespaceRequest")
        proto.RegisterType((*QueryNamespaceResponse)(nil), "injective.permissions.v1beta1.QueryNamespaceResponse")
        proto.RegisterType((*QueryActorsByRoleRequest)(nil), "injective.permissions.v1beta1.QueryActorsByRoleRequest")
        proto.RegisterType((*QueryActorsByRoleResponse)(nil), "injective.permissions.v1beta1.QueryActorsByRoleResponse")
        proto.RegisterType((*QueryRolesByActorRequest)(nil), "injective.permissions.v1beta1.QueryRolesByActorRequest")
        proto.RegisterType((*QueryRolesByActorResponse)(nil), "injective.permissions.v1beta1.QueryRolesByActorResponse")
        proto.RegisterType((*QueryRoleManagersRequest)(nil), "injective.permissions.v1beta1.QueryRoleManagersRequest")
        proto.RegisterType((*QueryRoleManagersResponse)(nil), "injective.permissions.v1beta1.QueryRoleManagersResponse")
        proto.RegisterType((*QueryRoleManagerRequest)(nil), "injective.permissions.v1beta1.QueryRoleManagerRequest")
        proto.RegisterType((*QueryRoleManagerResponse)(nil), "injective.permissions.v1beta1.QueryRoleManagerResponse")
        proto.RegisterType((*QueryPolicyStatusesRequest)(nil), "injective.permissions.v1beta1.QueryPolicyStatusesRequest")
        proto.RegisterType((*QueryPolicyStatusesResponse)(nil), "injective.permissions.v1beta1.QueryPolicyStatusesResponse")
        proto.RegisterType((*QueryPolicyManagerCapabilitiesRequest)(nil), "injective.permissions.v1beta1.QueryPolicyManagerCapabilitiesRequest")
        proto.RegisterType((*QueryPolicyManagerCapabilitiesResponse)(nil), "injective.permissions.v1beta1.QueryPolicyManagerCapabilitiesResponse")
        proto.RegisterType((*QueryVouchersRequest)(nil), "injective.permissions.v1beta1.QueryVouchersRequest")
        proto.RegisterType((*QueryVouchersResponse)(nil), "injective.permissions.v1beta1.QueryVouchersResponse")
        proto.RegisterType((*QueryVoucherRequest)(nil), "injective.permissions.v1beta1.QueryVoucherRequest")
        proto.RegisterType((*QueryVoucherResponse)(nil), "injective.permissions.v1beta1.QueryVoucherResponse")
        proto.RegisterType((*QueryModuleStateRequest)(nil), "injective.permissions.v1beta1.QueryModuleStateRequest")
        proto.RegisterType((*QueryModuleStateResponse)(nil), "injective.permissions.v1beta1.QueryModuleStateResponse")
}

func init() {
        proto.RegisterFile("injective/permissions/v1beta1/query.proto", fileDescriptor_e0ae50f1018498b3)
}

var fileDescriptor_e0ae50f1018498b3 = []byte{
        // 1263 bytes of a gzipped FileDescriptorProto
        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x98, 0x4f, 0x6f, 0x1b, 0xc5,
        0x1b, 0xc7, 0xb3, 0xfd, 0x35, 0x49, 0xf3, 0x24, 0xbf, 0x56, 0x4c, 0x4d, 0x70, 0xdc, 0xd6, 0xa9,
        0x46, 0x0a, 0x4d, 0x9b, 0xda, 0x5b, 0x3b, 0xa9, 0x13, 0x42, 0x5b, 0x88, 0xe3, 0x14, 0x82, 0x08,
        0xb4, 0x0b, 0xe2, 0x50, 0x09, 0x99, 0xf5, 0x7a, 0xe4, 0x2c, 0xb5, 0x77, 0xb6, 0x9e, 0x75, 0x24,
        0xab, 0xca, 0x85, 0x57, 0x00, 0xe2, 0x8e, 0x78, 0x05, 0x3d, 0x20, 0xce, 0x70, 0x40, 0x88, 0x1c,
        0x2b, 0x71, 0x41, 0x48, 0x44, 0x28, 0xe1, 0xc4, 0x99, 0x17, 0x80, 0x76, 0xf6, 0xd9, 0xf5, 0xda,
        0x71, 0xbc, 0xbb, 0xe1, 0x14, 0xcf, 0x9f, 0xe7, 0xfb, 0x7c, 0x9e, 0x99, 0xd9, 0x99, 0xaf, 0x02,
        0x37, 0x4d, 0xeb, 0x73, 0x66, 0x38, 0xe6, 0x1e, 0x53, 0x6d, 0xd6, 0x6e, 0x99, 0x42, 0x98, 0xdc,
        0x12, 0xea, 0x5e, 0xa1, 0xc6, 0x1c, 0xbd, 0xa0, 0x3e, 0xeb, 0xb0, 0x76, 0x37, 0x6f, 0xb7, 0xb9,
        0xc3, 0xc9, 0xb5, 0x60, 0x6a, 0x3e, 0x34, 0x35, 0x8f, 0x53, 0x33, 0xa9, 0x06, 0x6f, 0x70, 0x39,
        0x53, 0x75, 0x7f, 0x79, 0x41, 0x99, 0xab, 0x0d, 0xce, 0x1b, 0x4d, 0xa6, 0xea, 0xb6, 0xa9, 0xea,
        0x96, 0xc5, 0x1d, 0xdd, 0x91, 0x51, 0xde, 0x68, 0xd6, 0xe0, 0xa2, 0xc5, 0x85, 0x5a, 0xd3, 0x05,
        0x0b, 0x72, 0x1a, 0xdc, 0xb4, 0x70, 0xfc, 0x56, 0x78, 0x5c, 0xb2, 0x04, 0xb3, 0x6c, 0xbd, 0x61,
        0x5a, 0x52, 0xcc, 0x9f, 0x3b, 0xba, 0x12, 0x5b, 0x6f, 0xeb, 0x2d, 0x3f, 0xef, 0xd2, 0xe8, 0xb9,
        0x0d, 0x66, 0x31, 0x61, 0xfa, 0x93, 0xd5, 0x08, 0xe1, 0xd0, 0x5a, 0xc8, 0x00, 0x9a, 0x02, 0xf2,
        0xd8, 0x65, 0x7d, 0x24, 0x53, 0x6a, 0xec, 0x59, 0x87, 0x09, 0x87, 0x3e, 0x81, 0xcb, 0x7d, 0xbd,
        0xc2, 0xe6, 0x96, 0x60, 0x64, 0x13, 0x26, 0x3c, 0xb4, 0xb4, 0x72, 0x5d, 0x59, 0x9c, 0x2e, 0x2e,
        0xe4, 0x47, 0x2e, 0x73, 0xde, 0x0b, 0x2f, 0x9f, 0x3f, 0x38, 0x9c, 0x1f, 0xd3, 0x30, 0x94, 0x5e,
        0x83, 0x2b, 0x52, 0xfb, 0x03, 0xbd, 0xc5, 0x84, 0xad, 0x1b, 0xac, 0xc2, 0x2c, 0xde, 0x4b, 0x5d,
        0x82, 0xab, 0xc3, 0x87, 0x91, 0x61, 0x16, 0x26, 0xea, 0xb2, 0x27, 0xad, 0x5c, 0xff, 0xdf, 0xe2,
        0x94, 0x86, 0x2d, 0x9a, 0x86, 0xd9, 0xfe, 0xb8, 0x40, 0xd1, 0x80, 0xd7, 0x4e, 0x8c, 0xa0, 0xd8,
        0xbb, 0x00, 0x56, 0xd0, 0x2b, 0x05, 0xa7, 0x8b, 0x8b, 0x11, 0x45, 0x05, 0x32, 0x5a, 0x28, 0x96,
        0xe6, 0xe0, 0xd5, 0xfe, 0x24, 0x98, 0x9d, 0xa4, 0x60, 0x5c, 0x12, 0xca, 0x25, 0x9b, 0xd2, 0xbc,
        0x06, 0xfd, 0x6c, 0x90, 0x36, 0x40, 0x7a, 0x08, 0x53, 0x81, 0x2c, 0x2e, 0x73, 0x7c, 0xa2, 0x5e,
        0x28, 0xad, 0x40, 0x5a, 0x66, 0xd8, 0x30, 0x1c, 0xde, 0x16, 0xe5, 0xae, 0xc6, 0x9b, 0xa3, 0x99,
        0x08, 0x81, 0xf3, 0x6d, 0xde, 0x64, 0xe9, 0x73, 0xb2, 0x53, 0xfe, 0xa6, 0xcb, 0x30, 0x37, 0x44,
        0xa5, 0xb7, 0x15, 0xba, 0xec, 0xf7, 0xb7, 0xc2, 0x6b, 0xd1, 0x87, 0x98, 0xda, 0x9d, 0x2c, 0xca,
        0x5e, 0xec, 0xe8, 0xd4, 0x29, 0x18, 0x97, 0xb1, 0x98, 0xdb, 0x6b, 0xd0, 0x02, 0x26, 0xef, 0xd7,
        0xc1, 0xe4, 0x29, 0x18, 0x77, 0x09, 0xfd, 0xdc, 0x5e, 0x83, 0xde, 0x09, 0xa5, 0xde, 0xd1, 0x2d,
        0xbd, 0xc1, 0xda, 0x62, 0xf4, 0x4e, 0x34, 0x43, 0x49, 0x7a, 0x11, 0x98, 0xe4, 0x43, 0xf8, 0xbf,
        0xab, 0x5b, 0x6d, 0xe1, 0x00, 0x1e, 0x91, 0x5b, 0x11, 0x1b, 0x12, 0xd2, 0xd2, 0x66, 0xda, 0x21,
        0x61, 0xba, 0x8d, 0x67, 0x31, 0x3c, 0x63, 0xe4, 0xca, 0xa4, 0x61, 0x12, 0x93, 0xe3, 0xda, 0xf8,
        0x4d, 0x6a, 0x9e, 0x2c, 0x35, 0xe0, 0xde, 0x81, 0x99, 0x30, 0x37, 0x9e, 0xa3, 0x24, 0xd8, 0xd3,
        0x21, 0x6c, 0x5a, 0x84, 0x8c, 0x77, 0x1d, 0xf0, 0xa6, 0x69, 0x74, 0x3f, 0x72, 0x74, 0xa7, 0x23,
        0x58, 0xc4, 0xba, 0x0a, 0xfc, 0xcc, 0x07, 0x63, 0x90, 0xf0, 0x63, 0xb8, 0x64, 0xcb, 0x91, 0xaa,
        0xc0, 0x21, 0x5c, 0xdb, 0xa5, 0xa8, 0x3b, 0x25, 0xa4, 0xa7, 0x5d, 0xb4, 0xfb, 0xd4, 0xe9, 0x7d,
        0x58, 0x08, 0x25, 0x45, 0xfc, 0x4d, 0xdd, 0xd6, 0x6b, 0x66, 0xd3, 0x74, 0xcc, 0x28, 0xe6, 0x6f,
        0x15, 0x78, 0x3d, 0x2a, 0x1e, 0xf9, 0xf7, 0xe0, 0x0a, 0xf2, 0xe3, 0x1a, 0x57, 0x8d, 0xd0, 0x34,
        0xac, 0xa5, 0x14, 0xab, 0x96, 0xc1, 0x34, 0x5d, 0x6d, 0xce, 0x3e, 0x2d, 0x3f, 0xbd, 0x0d, 0x29,
        0x49, 0xf8, 0x09, 0xef, 0x18, 0xbb, 0x91, 0x87, 0xbb, 0x86, 0xb7, 0x52, 0x6f, 0x36, 0xe2, 0x6f,
        0xc3, 0x85, 0x3d, 0xec, 0x43, 0xd6, 0x5c, 0x04, 0xeb, 0x46, 0xbd, 0xde, 0x66, 0x42, 0xa0, 0x92,
        0x16, 0x84, 0xd3, 0x2d, 0x7c, 0x2b, 0xfc, 0x91, 0xa8, 0xe3, 0xac, 0x7b, 0x42, 0xfe, 0x71, 0xc6,
        0x26, 0xfd, 0x4a, 0xe9, 0xaf, 0x2c, 0x40, 0xed, 0xc2, 0x24, 0xe6, 0xc2, 0x63, 0x3c, 0x97, 0xf7,
        0x5e, 0xda, 0xbc, 0xfb, 0xd2, 0x06, 0x7c, 0x9b, 0xdc, 0xb4, 0xca, 0x15, 0xf7, 0xa5, 0xf9, 0xfd,
        0x70, 0xfe, 0x46, 0xc3, 0x74, 0x76, 0x3b, 0xb5, 0xbc, 0xc1, 0x5b, 0x2a, 0x3e, 0xcb, 0xde, 0x9f,
        0x9c, 0xa8, 0x3f, 0x55, 0x9d, 0xae, 0xcd, 0x84, 0x0c, 0xf8, 0xfb, 0x70, 0xfe, 0x15, 0x14, 0xbf,
        0xcd, 0x5b, 0xa6, 0xc3, 0x5a, 0xb6, 0xd3, 0xd5, 0xfc, 0x7c, 0x74, 0x0e, 0xbf, 0xd6, 0x1d, 0x5e,
        0xef, 0x34, 0x99, 0x7b, 0xca, 0xfc, 0x2b, 0x94, 0x7e, 0x8a, 0x5f, 0x5f, 0xdf, 0x10, 0x12, 0x6f,
        0xc0, 0xb8, 0x7b, 0xa8, 0xfd, 0xeb, 0x3b, 0xea, 0x44, 0xbf, 0xe3, 0xbd, 0xe0, 0x9e, 0x86, 0x17,
        0x59, 0xfc, 0xe3, 0x32, 0x8c, 0x4b, 0x7d, 0xf2, 0x8d, 0x02, 0x13, 0xde, 0x3b, 0x4a, 0x0a, 0x11,
        0x42, 0x27, 0x1f, 0xf2, 0x4c, 0x31, 0x49, 0x88, 0x87, 0x4f, 0x73, 0x5f, 0xfc, 0xfa, 0xd7, 0xd7,
        0xe7, 0x6e, 0x90, 0x05, 0x35, 0x8e, 0x4b, 0x21, 0x3f, 0x29, 0x70, 0x69, 0xe0, 0xb1, 0x26, 0xeb,
        0x71, 0xd2, 0x0e, 0x37, 0x00, 0x99, 0x37, 0xcf, 0x14, 0x8b, 0xec, 0xab, 0x92, 0xbd, 0x40, 0xd4,
        0x08, 0xf6, 0xe0, 0x9d, 0xac, 0x7a, 0xf6, 0x81, 0xbc, 0x50, 0x00, 0x7a, 0x06, 0x81, 0xdc, 0x4d,
        0x04, 0x11, 0xb0, 0x97, 0x92, 0x86, 0x21, 0x76, 0x41, 0x62, 0x2f, 0x91, 0x9b, 0x71, 0xb1, 0x05,
        0xf9, 0x4e, 0x81, 0xa9, 0x40, 0x89, 0xac, 0x24, 0x4a, 0xec, 0xe3, 0xde, 0x4d, 0x18, 0x85, 0xb4,
        0x6b, 0x92, 0xb6, 0x48, 0xee, 0xc4, 0xa5, 0x55, 0x9f, 0xcb, 0x55, 0xde, 0x27, 0x07, 0x0a, 0xcc,
        0x84, 0x5f, 0x73, 0xb2, 0x1a, 0x87, 0x60, 0x88, 0x8f, 0xc8, 0xac, 0x25, 0x0f, 0x44, 0xfa, 0x2d,
        0x49, 0xff, 0x16, 0xb9, 0x1f, 0x41, 0x2f, 0x0d, 0x45, 0xb5, 0xd6, 0xad, 0x4a, 0x33, 0xe2, 0x97,
        0xa0, 0x3e, 0x97, 0xcd, 0x7d, 0xf2, 0x8b, 0x02, 0x33, 0x61, 0x57, 0x14, 0xaf, 0x94, 0x21, 0x6e,
        0x2c, 0x5e, 0x29, 0xc3, 0x0c, 0x18, 0xad, 0xc8, 0x52, 0x1e, 0x90, 0x7b, 0x11, 0xa5, 0x78, 0xbe,
        0xcc, 0xad, 0xc5, 0x2d, 0xaa, 0x57, 0x8a, 0xdb, 0xda, 0x27, 0x3f, 0xe2, 0xa6, 0xf8, 0x26, 0x25,
        0xfe, 0xa6, 0x0c, 0x38, 0xac, 0xf8, 0x9b, 0x32, 0x68, 0xb4, 0xe8, 0x3d, 0x59, 0x49, 0x89, 0xac,
        0xc4, 0xd8, 0x94, 0xc0, 0x8d, 0x05, 0xc7, 0xea, 0x67, 0x05, 0xa6, 0x43, 0xb2, 0xa4, 0x94, 0x90,
        0xc3, 0xe7, 0x5f, 0x4d, 0x1c, 0x77, 0x86, 0x33, 0xe5, 0xe3, 0xf7, 0xb6, 0x01, 0x3b, 0xe4, 0x99,
        0xba, 0xd8, 0xef, 0x97, 0xc8, 0x1b, 0xb1, 0x2e, 0xf0, 0x61, 0xbe, 0x2c, 0xb3, 0x7e, 0x96, 0x50,
        0x2c, 0xe8, 0x81, 0x2c, 0x68, 0x8d, 0x94, 0xa2, 0xde, 0x80, 0x7e, 0x0f, 0x17, 0xec, 0xc8, 0x3f,
        0x0a, 0xcc, 0x9d, 0x6a, 0xa2, 0x48, 0x25, 0x3e, 0xd9, 0xe9, 0x1e, 0x2e, 0xb3, 0xf5, 0x1f, 0x55,
        0xb0, 0xd4, 0xf7, 0x64, 0xa9, 0x15, 0x52, 0x8e, 0x57, 0xea, 0x30, 0xbb, 0x17, 0x94, 0xfd, 0x42,
        0x81, 0x0b, 0xbe, 0xd7, 0x22, 0xcb, 0x71, 0xf8, 0x06, 0x7c, 0x5c, 0x66, 0x25, 0x59, 0x50, 0xc2,
        0x67, 0xcf, 0x37, 0x6d, 0x01, 0xf0, 0xf7, 0x0a, 0x4c, 0xa2, 0x1a, 0x29, 0x26, 0x48, 0xed, 0xe3,
        0x2e, 0x27, 0x8a, 0x41, 0xda, 0xb7, 0x25, 0xed, 0x3a, 0x59, 0x8b, 0x47, 0x1b, 0xba, 0x7a, 0x3d,
        0xaf, 0xb8, 0x4f, 0x7e, 0x50, 0x60, 0xf6, 0x51, 0x2f, 0x22, 0x64, 0xc2, 0xe2, 0x7d, 0xfb, 0x27,
        0x0d, 0x5d, 0xbc, 0x6f, 0x7f, 0x88, 0xdb, 0xa3, 0xcb, 0xb2, 0x9a, 0x1c, 0x59, 0x8a, 0xa8, 0xa6,
        0x25, 0x63, 0xe5, 0xa7, 0xc2, 0xca, 0x4f, 0x0f, 0x8e, 0xb2, 0xca, 0xcb, 0xa3, 0xac, 0xf2, 0xe7,
        0x51, 0x56, 0xf9, 0xf2, 0x38, 0x3b, 0xf6, 0xf2, 0x38, 0x3b, 0xf6, 0xdb, 0x71, 0x76, 0xec, 0xc9,
        0xe3, 0x90, 0x75, 0xdd, 0xf6, 0x05, 0xdf, 0xd7, 0x6b, 0xa2, 0x27, 0x9f, 0x33, 0x78, 0x9b, 0x85,
        0x9b, 0xbb, 0xba, 0x69, 0xa1, 0xbe, 0xe8, 0xcb, 0x2d, 0x9d, 0x6e, 0x6d, 0x42, 0xfe, 0xab, 0x67,
        0xf9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x36, 0x6c, 0x4e, 0x0d, 0x40, 0x13, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
        // Params defines a gRPC query method that returns the permissions module's
        // parameters.
        Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
        // NamespaceDenoms defines a gRPC query method that returns the denoms for which a namespace exists
        NamespaceDenoms(ctx context.Context, in *QueryNamespaceDenomsRequest, opts ...grpc.CallOption) (*QueryNamespaceDenomsResponse, error)
        // Namespaces defines a gRPC query method that returns the permissions
        // module's created namespaces.
        Namespaces(ctx context.Context, in *QueryNamespacesRequest, opts ...grpc.CallOption) (*QueryNamespacesResponse, error)
        // Namespace defines a gRPC query method that returns the permissions
        // module's namespace associated with the provided denom.
        Namespace(ctx context.Context, in *QueryNamespaceRequest, opts ...grpc.CallOption) (*QueryNamespaceResponse, error)
        // RolesByActor defines a gRPC query method that returns roles for the actor in the namespace
        RolesByActor(ctx context.Context, in *QueryRolesByActorRequest, opts ...grpc.CallOption) (*QueryRolesByActorResponse, error)
        // ActorsByRole defines a gRPC query method that returns a namespace's roles associated with the provided actor.
        ActorsByRole(ctx context.Context, in *QueryActorsByRoleRequest, opts ...grpc.CallOption) (*QueryActorsByRoleResponse, error)
        // RoleManagers defines a gRPC query method that returns a namespace's role managers
        RoleManagers(ctx context.Context, in *QueryRoleManagersRequest, opts ...grpc.CallOption) (*QueryRoleManagersResponse, error)
        // RoleManager defines a gRPC query method that returns the roles a given role manager manages for a given namespace
        RoleManager(ctx context.Context, in *QueryRoleManagerRequest, opts ...grpc.CallOption) (*QueryRoleManagerResponse, error)
        // PolicyStatuses defines a gRPC query method that returns a namespace's policy statuses
        PolicyStatuses(ctx context.Context, in *QueryPolicyStatusesRequest, opts ...grpc.CallOption) (*QueryPolicyStatusesResponse, error)
        // PolicyManagerCapabilities defines a gRPC query method that returns a namespace's policy manager capabilities
        PolicyManagerCapabilities(ctx context.Context, in *QueryPolicyManagerCapabilitiesRequest, opts ...grpc.CallOption) (*QueryPolicyManagerCapabilitiesResponse, error)
        // Vouchers defines a gRPC query method for the vouchers for a given denom
        Vouchers(ctx context.Context, in *QueryVouchersRequest, opts ...grpc.CallOption) (*QueryVouchersResponse, error)
        // Voucher defines a gRPC query method for the vouchers for a given denom and address
        Voucher(ctx context.Context, in *QueryVoucherRequest, opts ...grpc.CallOption) (*QueryVoucherResponse, error)
        // Retrieves the entire permissions module's state
        PermissionsModuleState(ctx context.Context, in *QueryModuleStateRequest, opts ...grpc.CallOption) (*QueryModuleStateResponse, error)
}

type queryClient struct {
        cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
        return &queryClient{cc}
}

func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
        out := new(QueryParamsResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/Params", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) NamespaceDenoms(ctx context.Context, in *QueryNamespaceDenomsRequest, opts ...grpc.CallOption) (*QueryNamespaceDenomsResponse, error) {
        out := new(QueryNamespaceDenomsResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/NamespaceDenoms", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) Namespaces(ctx context.Context, in *QueryNamespacesRequest, opts ...grpc.CallOption) (*QueryNamespacesResponse, error) {
        out := new(QueryNamespacesResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/Namespaces", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) Namespace(ctx context.Context, in *QueryNamespaceRequest, opts ...grpc.CallOption) (*QueryNamespaceResponse, error) {
        out := new(QueryNamespaceResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/Namespace", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) RolesByActor(ctx context.Context, in *QueryRolesByActorRequest, opts ...grpc.CallOption) (*QueryRolesByActorResponse, error) {
        out := new(QueryRolesByActorResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/RolesByActor", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) ActorsByRole(ctx context.Context, in *QueryActorsByRoleRequest, opts ...grpc.CallOption) (*QueryActorsByRoleResponse, error) {
        out := new(QueryActorsByRoleResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/ActorsByRole", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) RoleManagers(ctx context.Context, in *QueryRoleManagersRequest, opts ...grpc.CallOption) (*QueryRoleManagersResponse, error) {
        out := new(QueryRoleManagersResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/RoleManagers", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) RoleManager(ctx context.Context, in *QueryRoleManagerRequest, opts ...grpc.CallOption) (*QueryRoleManagerResponse, error) {
        out := new(QueryRoleManagerResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/RoleManager", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) PolicyStatuses(ctx context.Context, in *QueryPolicyStatusesRequest, opts ...grpc.CallOption) (*QueryPolicyStatusesResponse, error) {
        out := new(QueryPolicyStatusesResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/PolicyStatuses", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) PolicyManagerCapabilities(ctx context.Context, in *QueryPolicyManagerCapabilitiesRequest, opts ...grpc.CallOption) (*QueryPolicyManagerCapabilitiesResponse, error) {
        out := new(QueryPolicyManagerCapabilitiesResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/PolicyManagerCapabilities", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) Vouchers(ctx context.Context, in *QueryVouchersRequest, opts ...grpc.CallOption) (*QueryVouchersResponse, error) {
        out := new(QueryVouchersResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/Vouchers", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) Voucher(ctx context.Context, in *QueryVoucherRequest, opts ...grpc.CallOption) (*QueryVoucherResponse, error) {
        out := new(QueryVoucherResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/Voucher", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *queryClient) PermissionsModuleState(ctx context.Context, in *QueryModuleStateRequest, opts ...grpc.CallOption) (*QueryModuleStateResponse, error) {
        out := new(QueryModuleStateResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Query/PermissionsModuleState", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
        // Params defines a gRPC query method that returns the permissions module's
        // parameters.
        Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
        // NamespaceDenoms defines a gRPC query method that returns the denoms for which a namespace exists
        NamespaceDenoms(context.Context, *QueryNamespaceDenomsRequest) (*QueryNamespaceDenomsResponse, error)
        // Namespaces defines a gRPC query method that returns the permissions
        // module's created namespaces.
        Namespaces(context.Context, *QueryNamespacesRequest) (*QueryNamespacesResponse, error)
        // Namespace defines a gRPC query method that returns the permissions
        // module's namespace associated with the provided denom.
        Namespace(context.Context, *QueryNamespaceRequest) (*QueryNamespaceResponse, error)
        // RolesByActor defines a gRPC query method that returns roles for the actor in the namespace
        RolesByActor(context.Context, *QueryRolesByActorRequest) (*QueryRolesByActorResponse, error)
        // ActorsByRole defines a gRPC query method that returns a namespace's roles associated with the provided actor.
        ActorsByRole(context.Context, *QueryActorsByRoleRequest) (*QueryActorsByRoleResponse, error)
        // RoleManagers defines a gRPC query method that returns a namespace's role managers
        RoleManagers(context.Context, *QueryRoleManagersRequest) (*QueryRoleManagersResponse, error)
        // RoleManager defines a gRPC query method that returns the roles a given role manager manages for a given namespace
        RoleManager(context.Context, *QueryRoleManagerRequest) (*QueryRoleManagerResponse, error)
        // PolicyStatuses defines a gRPC query method that returns a namespace's policy statuses
        PolicyStatuses(context.Context, *QueryPolicyStatusesRequest) (*QueryPolicyStatusesResponse, error)
        // PolicyManagerCapabilities defines a gRPC query method that returns a namespace's policy manager capabilities
        PolicyManagerCapabilities(context.Context, *QueryPolicyManagerCapabilitiesRequest) (*QueryPolicyManagerCapabilitiesResponse, error)
        // Vouchers defines a gRPC query method for the vouchers for a given denom
        Vouchers(context.Context, *QueryVouchersRequest) (*QueryVouchersResponse, error)
        // Voucher defines a gRPC query method for the vouchers for a given denom and address
        Voucher(context.Context, *QueryVoucherRequest) (*QueryVoucherResponse, error)
        // Retrieves the entire permissions module's state
        PermissionsModuleState(context.Context, *QueryModuleStateRequest) (*QueryModuleStateResponse, error)
}

// UnimplementedQueryServer can be embedded to have forward compatible implementations.
type UnimplementedQueryServer struct {
}

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) NamespaceDenoms(ctx context.Context, req *QueryNamespaceDenomsRequest) (*QueryNamespaceDenomsResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method NamespaceDenoms not implemented")
}
func (*UnimplementedQueryServer) Namespaces(ctx context.Context, req *QueryNamespacesRequest) (*QueryNamespacesResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method Namespaces not implemented")
}
func (*UnimplementedQueryServer) Namespace(ctx context.Context, req *QueryNamespaceRequest) (*QueryNamespaceResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method Namespace not implemented")
}
func (*UnimplementedQueryServer) RolesByActor(ctx context.Context, req *QueryRolesByActorRequest) (*QueryRolesByActorResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method RolesByActor not implemented")
}
func (*UnimplementedQueryServer) ActorsByRole(ctx context.Context, req *QueryActorsByRoleRequest) (*QueryActorsByRoleResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method ActorsByRole not implemented")
}
func (*UnimplementedQueryServer) RoleManagers(ctx context.Context, req *QueryRoleManagersRequest) (*QueryRoleManagersResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method RoleManagers not implemented")
}
func (*UnimplementedQueryServer) RoleManager(ctx context.Context, req *QueryRoleManagerRequest) (*QueryRoleManagerResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method RoleManager not implemented")
}
func (*UnimplementedQueryServer) PolicyStatuses(ctx context.Context, req *QueryPolicyStatusesRequest) (*QueryPolicyStatusesResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method PolicyStatuses not implemented")
}
func (*UnimplementedQueryServer) PolicyManagerCapabilities(ctx context.Context, req *QueryPolicyManagerCapabilitiesRequest) (*QueryPolicyManagerCapabilitiesResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method PolicyManagerCapabilities not implemented")
}
func (*UnimplementedQueryServer) Vouchers(ctx context.Context, req *QueryVouchersRequest) (*QueryVouchersResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method Vouchers not implemented")
}
func (*UnimplementedQueryServer) Voucher(ctx context.Context, req *QueryVoucherRequest) (*QueryVoucherResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method Voucher not implemented")
}
func (*UnimplementedQueryServer) PermissionsModuleState(ctx context.Context, req *QueryModuleStateRequest) (*QueryModuleStateResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method PermissionsModuleState not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
        s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryParamsRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).Params(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/Params",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_NamespaceDenoms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryNamespaceDenomsRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).NamespaceDenoms(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/NamespaceDenoms",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).NamespaceDenoms(ctx, req.(*QueryNamespaceDenomsRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_Namespaces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryNamespacesRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).Namespaces(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/Namespaces",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).Namespaces(ctx, req.(*QueryNamespacesRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_Namespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryNamespaceRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).Namespace(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/Namespace",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).Namespace(ctx, req.(*QueryNamespaceRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_RolesByActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryRolesByActorRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).RolesByActor(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/RolesByActor",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).RolesByActor(ctx, req.(*QueryRolesByActorRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_ActorsByRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryActorsByRoleRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).ActorsByRole(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/ActorsByRole",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).ActorsByRole(ctx, req.(*QueryActorsByRoleRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_RoleManagers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryRoleManagersRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).RoleManagers(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/RoleManagers",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).RoleManagers(ctx, req.(*QueryRoleManagersRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_RoleManager_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryRoleManagerRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).RoleManager(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/RoleManager",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).RoleManager(ctx, req.(*QueryRoleManagerRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_PolicyStatuses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryPolicyStatusesRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).PolicyStatuses(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/PolicyStatuses",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).PolicyStatuses(ctx, req.(*QueryPolicyStatusesRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_PolicyManagerCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryPolicyManagerCapabilitiesRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).PolicyManagerCapabilities(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/PolicyManagerCapabilities",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).PolicyManagerCapabilities(ctx, req.(*QueryPolicyManagerCapabilitiesRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_Vouchers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryVouchersRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).Vouchers(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/Vouchers",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).Vouchers(ctx, req.(*QueryVouchersRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_Voucher_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryVoucherRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).Voucher(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/Voucher",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).Voucher(ctx, req.(*QueryVoucherRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Query_PermissionsModuleState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(QueryModuleStateRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(QueryServer).PermissionsModuleState(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Query/PermissionsModuleState",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(QueryServer).PermissionsModuleState(ctx, req.(*QueryModuleStateRequest))
        }
        return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
        ServiceName: "injective.permissions.v1beta1.Query",
        HandlerType: (*QueryServer)(nil),
        Methods: []grpc.MethodDesc{
                {
                        MethodName: "Params",
                        Handler:    _Query_Params_Handler,
                },
                {
                        MethodName: "NamespaceDenoms",
                        Handler:    _Query_NamespaceDenoms_Handler,
                },
                {
                        MethodName: "Namespaces",
                        Handler:    _Query_Namespaces_Handler,
                },
                {
                        MethodName: "Namespace",
                        Handler:    _Query_Namespace_Handler,
                },
                {
                        MethodName: "RolesByActor",
                        Handler:    _Query_RolesByActor_Handler,
                },
                {
                        MethodName: "ActorsByRole",
                        Handler:    _Query_ActorsByRole_Handler,
                },
                {
                        MethodName: "RoleManagers",
                        Handler:    _Query_RoleManagers_Handler,
                },
                {
                        MethodName: "RoleManager",
                        Handler:    _Query_RoleManager_Handler,
                },
                {
                        MethodName: "PolicyStatuses",
                        Handler:    _Query_PolicyStatuses_Handler,
                },
                {
                        MethodName: "PolicyManagerCapabilities",
                        Handler:    _Query_PolicyManagerCapabilities_Handler,
                },
                {
                        MethodName: "Vouchers",
                        Handler:    _Query_Vouchers_Handler,
                },
                {
                        MethodName: "Voucher",
                        Handler:    _Query_Voucher_Handler,
                },
                {
                        MethodName: "PermissionsModuleState",
                        Handler:    _Query_PermissionsModuleState_Handler,
                },
        },
        Streams:  []grpc.StreamDesc{},
        Metadata: "injective/permissions/v1beta1/query.proto",
}

func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
        size := m.Size()
        dAtA = make([]byte, size)
        n, err := m.MarshalToSizedBuffer(dAtA[:size])
        if err != nil {
                return nil, err
        }
        return dAtA[:n], nil
}

func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) {
        size := m.Size()
        dAtA = make([]byte, size)
        n, err := m.MarshalToSizedBuffer(dAtA[:size])
        if err != nil {
                return nil, err
        }
        return dAtA[:n], nil
}

func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        {
                size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
                if err != nil {
                        return 0, err
                }
                i -= size
                i = encodeVarintQuery(dAtA, i, uint64(size))
        }
        i--
        dAtA[i] = 0xa
        return len(dAtA) - i, nil
}

func (m *QueryNamespaceDenomsRequest) 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 *QueryNamespaceDenomsRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryNamespaceDenomsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func (m *QueryNamespaceDenomsResponse) 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 *QueryNamespaceDenomsResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryNamespaceDenomsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Denoms) > 0 {
                for iNdEx := len(m.Denoms) - 1; iNdEx >= 0; iNdEx-- {
                        i -= len(m.Denoms[iNdEx])
                        copy(dAtA[i:], m.Denoms[iNdEx])
                        i = encodeVarintQuery(dAtA, i, uint64(len(m.Denoms[iNdEx])))
                        i--
                        dAtA[i] = 0xa
                }
        }
        return len(dAtA) - i, nil
}

func (m *QueryNamespacesRequest) 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 *QueryNamespacesRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryNamespacesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func (m *QueryNamespacesResponse) 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 *QueryNamespacesResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryNamespacesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Namespaces) > 0 {
                for iNdEx := len(m.Namespaces) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.Namespaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintQuery(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0xa
                }
        }
        return len(dAtA) - i, nil
}

func (m *QueryNamespaceRequest) 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 *QueryNamespaceRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryNamespaceResponse) 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 *QueryNamespaceResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if m.Namespace != nil {
                {
                        size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i])
                        if err != nil {
                                return 0, err
                        }
                        i -= size
                        i = encodeVarintQuery(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryActorsByRoleRequest) 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 *QueryActorsByRoleRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryActorsByRoleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Role) > 0 {
                i -= len(m.Role)
                copy(dAtA[i:], m.Role)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Role)))
                i--
                dAtA[i] = 0x12
        }
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryActorsByRoleResponse) 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 *QueryActorsByRoleResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryActorsByRoleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Actors) > 0 {
                for iNdEx := len(m.Actors) - 1; iNdEx >= 0; iNdEx-- {
                        i -= len(m.Actors[iNdEx])
                        copy(dAtA[i:], m.Actors[iNdEx])
                        i = encodeVarintQuery(dAtA, i, uint64(len(m.Actors[iNdEx])))
                        i--
                        dAtA[i] = 0xa
                }
        }
        return len(dAtA) - i, nil
}

func (m *QueryRolesByActorRequest) 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 *QueryRolesByActorRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRolesByActorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Actor) > 0 {
                i -= len(m.Actor)
                copy(dAtA[i:], m.Actor)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Actor)))
                i--
                dAtA[i] = 0x12
        }
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryRolesByActorResponse) 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 *QueryRolesByActorResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRolesByActorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Roles) > 0 {
                for iNdEx := len(m.Roles) - 1; iNdEx >= 0; iNdEx-- {
                        i -= len(m.Roles[iNdEx])
                        copy(dAtA[i:], m.Roles[iNdEx])
                        i = encodeVarintQuery(dAtA, i, uint64(len(m.Roles[iNdEx])))
                        i--
                        dAtA[i] = 0xa
                }
        }
        return len(dAtA) - i, nil
}

func (m *QueryRoleManagersRequest) 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 *QueryRoleManagersRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRoleManagersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryRoleManagersResponse) 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 *QueryRoleManagersResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRoleManagersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.RoleManagers) > 0 {
                for iNdEx := len(m.RoleManagers) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.RoleManagers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintQuery(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0xa
                }
        }
        return len(dAtA) - i, nil
}

func (m *QueryRoleManagerRequest) 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 *QueryRoleManagerRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRoleManagerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Manager) > 0 {
                i -= len(m.Manager)
                copy(dAtA[i:], m.Manager)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Manager)))
                i--
                dAtA[i] = 0x12
        }
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryRoleManagerResponse) 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 *QueryRoleManagerResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRoleManagerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if m.RoleManager != nil {
                {
                        size, err := m.RoleManager.MarshalToSizedBuffer(dAtA[:i])
                        if err != nil {
                                return 0, err
                        }
                        i -= size
                        i = encodeVarintQuery(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryPolicyStatusesRequest) 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 *QueryPolicyStatusesRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryPolicyStatusesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryPolicyStatusesResponse) 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 *QueryPolicyStatusesResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryPolicyStatusesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.PolicyStatuses) > 0 {
                for iNdEx := len(m.PolicyStatuses) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.PolicyStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintQuery(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0xa
                }
        }
        return len(dAtA) - i, nil
}

func (m *QueryPolicyManagerCapabilitiesRequest) 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 *QueryPolicyManagerCapabilitiesRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryPolicyManagerCapabilitiesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryPolicyManagerCapabilitiesResponse) 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 *QueryPolicyManagerCapabilitiesResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryPolicyManagerCapabilitiesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.PolicyManagerCapabilities) > 0 {
                for iNdEx := len(m.PolicyManagerCapabilities) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.PolicyManagerCapabilities[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintQuery(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0xa
                }
        }
        return len(dAtA) - i, nil
}

func (m *QueryVouchersRequest) 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 *QueryVouchersRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryVouchersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryVouchersResponse) 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 *QueryVouchersResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryVouchersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Vouchers) > 0 {
                for iNdEx := len(m.Vouchers) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.Vouchers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintQuery(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0xa
                }
        }
        return len(dAtA) - i, nil
}

func (m *QueryVoucherRequest) 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 *QueryVoucherRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryVoucherRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Address) > 0 {
                i -= len(m.Address)
                copy(dAtA[i:], m.Address)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Address)))
                i--
                dAtA[i] = 0x12
        }
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *QueryVoucherResponse) 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 *QueryVoucherResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryVoucherResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        {
                size := m.Voucher.Size()
                i -= size
                if _, err := m.Voucher.MarshalTo(dAtA[i:]); err != nil {
                        return 0, err
                }
                i = encodeVarintQuery(dAtA, i, uint64(size))
        }
        i--
        dAtA[i] = 0xa
        return len(dAtA) - i, nil
}

func (m *QueryModuleStateRequest) 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 *QueryModuleStateRequest) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryModuleStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func (m *QueryModuleStateResponse) 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 *QueryModuleStateResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryModuleStateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if m.State != nil {
                {
                        size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
                        if err != nil {
                                return 0, err
                        }
                        i -= size
                        i = encodeVarintQuery(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
        offset -= sovQuery(v)
        base := offset
        for v >= 1<<7 {
                dAtA[offset] = uint8(v&0x7f | 0x80)
                v >>= 7
                offset++
        }
        dAtA[offset] = uint8(v)
        return base
}
func (m *QueryParamsRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func (m *QueryParamsResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = m.Params.Size()
        n += 1 + l + sovQuery(uint64(l))
        return n
}

func (m *QueryNamespaceDenomsRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func (m *QueryNamespaceDenomsResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.Denoms) > 0 {
                for _, s := range m.Denoms {
                        l = len(s)
                        n += 1 + l + sovQuery(uint64(l))
                }
        }
        return n
}

func (m *QueryNamespacesRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func (m *QueryNamespacesResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.Namespaces) > 0 {
                for _, e := range m.Namespaces {
                        l = e.Size()
                        n += 1 + l + sovQuery(uint64(l))
                }
        }
        return n
}

func (m *QueryNamespaceRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryNamespaceResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if m.Namespace != nil {
                l = m.Namespace.Size()
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryActorsByRoleRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        l = len(m.Role)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryActorsByRoleResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.Actors) > 0 {
                for _, s := range m.Actors {
                        l = len(s)
                        n += 1 + l + sovQuery(uint64(l))
                }
        }
        return n
}

func (m *QueryRolesByActorRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        l = len(m.Actor)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryRolesByActorResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.Roles) > 0 {
                for _, s := range m.Roles {
                        l = len(s)
                        n += 1 + l + sovQuery(uint64(l))
                }
        }
        return n
}

func (m *QueryRoleManagersRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryRoleManagersResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.RoleManagers) > 0 {
                for _, e := range m.RoleManagers {
                        l = e.Size()
                        n += 1 + l + sovQuery(uint64(l))
                }
        }
        return n
}

func (m *QueryRoleManagerRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        l = len(m.Manager)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryRoleManagerResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if m.RoleManager != nil {
                l = m.RoleManager.Size()
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryPolicyStatusesRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryPolicyStatusesResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.PolicyStatuses) > 0 {
                for _, e := range m.PolicyStatuses {
                        l = e.Size()
                        n += 1 + l + sovQuery(uint64(l))
                }
        }
        return n
}

func (m *QueryPolicyManagerCapabilitiesRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryPolicyManagerCapabilitiesResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.PolicyManagerCapabilities) > 0 {
                for _, e := range m.PolicyManagerCapabilities {
                        l = e.Size()
                        n += 1 + l + sovQuery(uint64(l))
                }
        }
        return n
}

func (m *QueryVouchersRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryVouchersResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if len(m.Vouchers) > 0 {
                for _, e := range m.Vouchers {
                        l = e.Size()
                        n += 1 + l + sovQuery(uint64(l))
                }
        }
        return n
}

func (m *QueryVoucherRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        l = len(m.Address)
        if l > 0 {
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func (m *QueryVoucherResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = m.Voucher.Size()
        n += 1 + l + sovQuery(uint64(l))
        return n
}

func (m *QueryModuleStateRequest) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func (m *QueryModuleStateResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        if m.State != nil {
                l = m.State.Size()
                n += 1 + l + sovQuery(uint64(l))
        }
        return n
}

func sovQuery(x uint64) (n int) {
        return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
        return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryNamespaceDenomsRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryNamespaceDenomsRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryNamespaceDenomsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryNamespaceDenomsResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryNamespaceDenomsResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryNamespaceDenomsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denoms", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denoms = append(m.Denoms, string(dAtA[iNdEx:postIndex]))
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryNamespacesRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryNamespacesRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryNamespacesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryNamespacesResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryNamespacesResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryNamespacesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Namespaces = append(m.Namespaces, &Namespace{})
                        if err := m.Namespaces[len(m.Namespaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryNamespaceRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryNamespaceRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryNamespaceResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryNamespaceResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if m.Namespace == nil {
                                m.Namespace = &Namespace{}
                        }
                        if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryActorsByRoleRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryActorsByRoleRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryActorsByRoleRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Role = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryActorsByRoleResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryActorsByRoleResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryActorsByRoleResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Actors", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Actors = append(m.Actors, string(dAtA[iNdEx:postIndex]))
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryRolesByActorRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryRolesByActorRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryRolesByActorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Actor", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Actor = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryRolesByActorResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryRolesByActorResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryRolesByActorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryRoleManagersRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryRoleManagersRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryRoleManagersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryRoleManagersResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryRoleManagersResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryRoleManagersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RoleManagers", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.RoleManagers = append(m.RoleManagers, &RoleManager{})
                        if err := m.RoleManagers[len(m.RoleManagers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryRoleManagerRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryRoleManagerRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryRoleManagerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Manager", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Manager = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryRoleManagerResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryRoleManagerResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryRoleManagerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RoleManager", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if m.RoleManager == nil {
                                m.RoleManager = &RoleManager{}
                        }
                        if err := m.RoleManager.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryPolicyStatusesRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryPolicyStatusesRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryPolicyStatusesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryPolicyStatusesResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryPolicyStatusesResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryPolicyStatusesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field PolicyStatuses", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.PolicyStatuses = append(m.PolicyStatuses, &PolicyStatus{})
                        if err := m.PolicyStatuses[len(m.PolicyStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryPolicyManagerCapabilitiesRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryPolicyManagerCapabilitiesRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryPolicyManagerCapabilitiesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryPolicyManagerCapabilitiesResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryPolicyManagerCapabilitiesResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryPolicyManagerCapabilitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field PolicyManagerCapabilities", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.PolicyManagerCapabilities = append(m.PolicyManagerCapabilities, &PolicyManagerCapability{})
                        if err := m.PolicyManagerCapabilities[len(m.PolicyManagerCapabilities)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryVouchersRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryVouchersRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryVouchersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryVouchersResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryVouchersResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryVouchersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Vouchers", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Vouchers = append(m.Vouchers, &AddressVoucher{})
                        if err := m.Vouchers[len(m.Vouchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryVoucherRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryVoucherRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryVoucherRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Address = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryVoucherResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryVoucherResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryVoucherResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Voucher", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if err := m.Voucher.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryModuleStateRequest) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryModuleStateRequest: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryModuleStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *QueryModuleStateResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: QueryModuleStateResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: QueryModuleStateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthQuery
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if m.State == nil {
                                m.State = &GenesisState{}
                        }
                        if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipQuery(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthQuery
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func skipQuery(dAtA []byte) (n int, err error) {
        l := len(dAtA)
        iNdEx := 0
        depth := 0
        for iNdEx < l {
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return 0, ErrIntOverflowQuery
                        }
                        if iNdEx >= l {
                                return 0, io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= (uint64(b) & 0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                wireType := int(wire & 0x7)
                switch wireType {
                case 0:
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return 0, ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return 0, io.ErrUnexpectedEOF
                                }
                                iNdEx++
                                if dAtA[iNdEx-1] < 0x80 {
                                        break
                                }
                        }
                case 1:
                        iNdEx += 8
                case 2:
                        var length int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return 0, ErrIntOverflowQuery
                                }
                                if iNdEx >= l {
                                        return 0, io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                length |= (int(b) & 0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if length < 0 {
                                return 0, ErrInvalidLengthQuery
                        }
                        iNdEx += length
                case 3:
                        depth++
                case 4:
                        if depth == 0 {
                                return 0, ErrUnexpectedEndOfGroupQuery
                        }
                        depth--
                case 5:
                        iNdEx += 4
                default:
                        return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
                }
                if iNdEx < 0 {
                        return 0, ErrInvalidLengthQuery
                }
                if depth == 0 {
                        return iNdEx, nil
                }
        }
        return 0, io.ErrUnexpectedEOF
}

var (
        ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
        ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
        ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)

// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
// source: injective/permissions/v1beta1/query.proto

/*
Package types is a reverse proxy.

It translates gRPC into RESTful JSON APIs.
*/
package types

import (
        "context"
        "io"
        "net/http"

        "github.com/golang/protobuf/descriptor"
        "github.com/golang/protobuf/proto"
        "github.com/grpc-ecosystem/grpc-gateway/runtime"
        "github.com/grpc-ecosystem/grpc-gateway/utilities"
        "google.golang.org/grpc"
        "google.golang.org/grpc/codes"
        "google.golang.org/grpc/grpclog"
        "google.golang.org/grpc/metadata"
        "google.golang.org/grpc/status"
)

// Suppress "imported and not used" errors
var _ codes.Code
var _ io.Reader
var _ status.Status
var _ = runtime.String
var _ = utilities.NewDoubleArray
var _ = descriptor.ForMessage
var _ = metadata.Join

func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryParamsRequest
        var metadata runtime.ServerMetadata

        msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryParamsRequest
        var metadata runtime.ServerMetadata

        msg, err := server.Params(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_NamespaceDenoms_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryNamespaceDenomsRequest
        var metadata runtime.ServerMetadata

        msg, err := client.NamespaceDenoms(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_NamespaceDenoms_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryNamespaceDenomsRequest
        var metadata runtime.ServerMetadata

        msg, err := server.NamespaceDenoms(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_Namespaces_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryNamespacesRequest
        var metadata runtime.ServerMetadata

        msg, err := client.Namespaces(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_Namespaces_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryNamespacesRequest
        var metadata runtime.ServerMetadata

        msg, err := server.Namespaces(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_Namespace_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryNamespaceRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := client.Namespace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_Namespace_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryNamespaceRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := server.Namespace(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_RolesByActor_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryRolesByActorRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        val, ok = pathParams["actor"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "actor")
        }

        protoReq.Actor, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "actor", err)
        }

        msg, err := client.RolesByActor(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_RolesByActor_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryRolesByActorRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        val, ok = pathParams["actor"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "actor")
        }

        protoReq.Actor, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "actor", err)
        }

        msg, err := server.RolesByActor(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_ActorsByRole_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryActorsByRoleRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        val, ok = pathParams["role"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "role")
        }

        protoReq.Role, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "role", err)
        }

        msg, err := client.ActorsByRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_ActorsByRole_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryActorsByRoleRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        val, ok = pathParams["role"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "role")
        }

        protoReq.Role, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "role", err)
        }

        msg, err := server.ActorsByRole(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_RoleManagers_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryRoleManagersRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := client.RoleManagers(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_RoleManagers_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryRoleManagersRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := server.RoleManagers(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_RoleManager_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryRoleManagerRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        val, ok = pathParams["manager"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "manager")
        }

        protoReq.Manager, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "manager", err)
        }

        msg, err := client.RoleManager(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_RoleManager_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryRoleManagerRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        val, ok = pathParams["manager"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "manager")
        }

        protoReq.Manager, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "manager", err)
        }

        msg, err := server.RoleManager(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_PolicyStatuses_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryPolicyStatusesRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := client.PolicyStatuses(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_PolicyStatuses_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryPolicyStatusesRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := server.PolicyStatuses(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_PolicyManagerCapabilities_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryPolicyManagerCapabilitiesRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := client.PolicyManagerCapabilities(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_PolicyManagerCapabilities_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryPolicyManagerCapabilitiesRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := server.PolicyManagerCapabilities(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_Vouchers_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryVouchersRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := client.Vouchers(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_Vouchers_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryVouchersRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        msg, err := server.Vouchers(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_Voucher_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryVoucherRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        val, ok = pathParams["address"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address")
        }

        protoReq.Address, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
        }

        msg, err := client.Voucher(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_Voucher_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryVoucherRequest
        var metadata runtime.ServerMetadata

        var (
                val string
                ok  bool
                err error
                _   = err
        )

        val, ok = pathParams["denom"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
        }

        protoReq.Denom, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
        }

        val, ok = pathParams["address"]
        if !ok {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address")
        }

        protoReq.Address, err = runtime.String(val)

        if err != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
        }

        msg, err := server.Voucher(ctx, &protoReq)
        return msg, metadata, err

}

func request_Query_PermissionsModuleState_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryModuleStateRequest
        var metadata runtime.ServerMetadata

        msg, err := client.PermissionsModuleState(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
        return msg, metadata, err

}

func local_request_Query_PermissionsModuleState_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq QueryModuleStateRequest
        var metadata runtime.ServerMetadata

        msg, err := server.PermissionsModuleState(ctx, &protoReq)
        return msg, metadata, err

}

// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
// UnaryRPC     :call QueryServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.
func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error {

        mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_NamespaceDenoms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_NamespaceDenoms_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_NamespaceDenoms_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_Namespaces_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_Namespaces_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_Namespaces_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_Namespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_Namespace_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_Namespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_RolesByActor_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_RolesByActor_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_RolesByActor_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_ActorsByRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_ActorsByRole_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_ActorsByRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_RoleManagers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_RoleManagers_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_RoleManagers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_RoleManager_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_RoleManager_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_RoleManager_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_PolicyStatuses_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_PolicyStatuses_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_PolicyStatuses_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_PolicyManagerCapabilities_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_PolicyManagerCapabilities_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_PolicyManagerCapabilities_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_Vouchers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_Vouchers_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_Vouchers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_Voucher_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_Voucher_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_Voucher_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_PermissionsModuleState_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Query_PermissionsModuleState_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_PermissionsModuleState_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        return nil
}

// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
        conn, err := grpc.Dial(endpoint, opts...)
        if err != nil {
                return err
        }
        defer func() {
                if err != nil {
                        if cerr := conn.Close(); cerr != nil {
                                grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
                        }
                        return
                }
                go func() {
                        <-ctx.Done()
                        if cerr := conn.Close(); cerr != nil {
                                grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
                        }
                }()
        }()

        return RegisterQueryHandler(ctx, mux, conn)
}

// RegisterQueryHandler registers the http handlers for service Query to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
        return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn))
}

// RegisterQueryHandlerClient registers the http handlers for service Query
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "QueryClient" to call the correct interceptors.
func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error {

        mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

                forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_NamespaceDenoms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_NamespaceDenoms_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_NamespaceDenoms_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_Namespaces_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_Namespaces_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_Namespaces_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_Namespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_Namespace_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_Namespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_RolesByActor_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_RolesByActor_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_RolesByActor_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_ActorsByRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_ActorsByRole_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_ActorsByRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_RoleManagers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_RoleManagers_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_RoleManagers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_RoleManager_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_RoleManager_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_RoleManager_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_PolicyStatuses_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_PolicyStatuses_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_PolicyStatuses_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_PolicyManagerCapabilities_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_PolicyManagerCapabilities_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_PolicyManagerCapabilities_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_Vouchers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_Vouchers_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_Vouchers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_Voucher_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_Voucher_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_Voucher_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        mux.Handle("GET", pattern_Query_PermissionsModuleState_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Query_PermissionsModuleState_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_PermissionsModuleState_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

        })

        return nil
}

var (
        pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"injective", "permissions", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_NamespaceDenoms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"injective", "permissions", "v1beta1", "namespace_denoms"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_Namespaces_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"injective", "permissions", "v1beta1", "namespaces"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_Namespace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"injective", "permissions", "v1beta1", "namespace", "denom"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_RolesByActor_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"injective", "permissions", "v1beta1", "roles_by_actor", "denom", "actor"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_ActorsByRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"injective", "permissions", "v1beta1", "actors_by_role", "denom", "role"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_RoleManagers_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"injective", "permissions", "v1beta1", "role_managers", "denom"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_RoleManager_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"injective", "permissions", "v1beta1", "role_manager", "denom", "manager"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_PolicyStatuses_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"injective", "permissions", "v1beta1", "policy_statuses", "denom"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_PolicyManagerCapabilities_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"injective", "permissions", "v1beta1", "policy_manager_capabilities", "denom"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_Vouchers_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"injective", "permissions", "v1beta1", "vouchers", "denom"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_Voucher_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"injective", "permissions", "v1beta1", "voucher", "denom", "address"}, "", runtime.AssumeColonVerbOpt(false)))

        pattern_Query_PermissionsModuleState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"injective", "permissions", "v1beta1", "module_state"}, "", runtime.AssumeColonVerbOpt(false)))
)

var (
        forward_Query_Params_0 = runtime.ForwardResponseMessage

        forward_Query_NamespaceDenoms_0 = runtime.ForwardResponseMessage

        forward_Query_Namespaces_0 = runtime.ForwardResponseMessage

        forward_Query_Namespace_0 = runtime.ForwardResponseMessage

        forward_Query_RolesByActor_0 = runtime.ForwardResponseMessage

        forward_Query_ActorsByRole_0 = runtime.ForwardResponseMessage

        forward_Query_RoleManagers_0 = runtime.ForwardResponseMessage

        forward_Query_RoleManager_0 = runtime.ForwardResponseMessage

        forward_Query_PolicyStatuses_0 = runtime.ForwardResponseMessage

        forward_Query_PolicyManagerCapabilities_0 = runtime.ForwardResponseMessage

        forward_Query_Vouchers_0 = runtime.ForwardResponseMessage

        forward_Query_Voucher_0 = runtime.ForwardResponseMessage

        forward_Query_PermissionsModuleState_0 = runtime.ForwardResponseMessage
)

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: injective/permissions/v1beta1/tx.proto

package types

import (
        context "context"
        fmt "fmt"
        _ "github.com/cosmos/cosmos-proto"
        _ "github.com/cosmos/cosmos-sdk/types"
        _ "github.com/cosmos/cosmos-sdk/types/msgservice"
        _ "github.com/cosmos/cosmos-sdk/types/tx/amino"
        _ "github.com/cosmos/cosmos-sdk/x/bank/types"
        _ "github.com/cosmos/gogoproto/gogoproto"
        grpc1 "github.com/cosmos/gogoproto/grpc"
        proto "github.com/cosmos/gogoproto/proto"
        grpc "google.golang.org/grpc"
        codes "google.golang.org/grpc/codes"
        status "google.golang.org/grpc/status"
        io "io"
        math "math"
        math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type MsgUpdateParams struct {
        // authority is the address of the governance account.
        Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
        // params defines the permissions parameters to update.
        //
        // NOTE: All parameters must be supplied.
        Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"`
}

func (m *MsgUpdateParams) Reset()         { *m = MsgUpdateParams{} }
func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateParams) ProtoMessage()    {}
func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{0}
}
func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgUpdateParams.Marshal(b, m, deterministic)
        } else {
                b = b[:cap(b)]
                n, err := m.MarshalToSizedBuffer(b)
                if err != nil {
                        return nil, err
                }
                return b[:n], nil
        }
}
func (m *MsgUpdateParams) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgUpdateParams.Merge(m, src)
}
func (m *MsgUpdateParams) XXX_Size() int {
        return m.Size()
}
func (m *MsgUpdateParams) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo

func (m *MsgUpdateParams) GetAuthority() string {
        if m != nil {
                return m.Authority
        }
        return ""
}

func (m *MsgUpdateParams) GetParams() Params {
        if m != nil {
                return m.Params
        }
        return Params{}
}

type MsgUpdateParamsResponse struct {
}

func (m *MsgUpdateParamsResponse) Reset()         { *m = MsgUpdateParamsResponse{} }
func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateParamsResponse) ProtoMessage()    {}
func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{1}
}
func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgUpdateParamsResponse.Marshal(b, m, deterministic)
        } else {
                b = b[:cap(b)]
                n, err := m.MarshalToSizedBuffer(b)
                if err != nil {
                        return nil, err
                }
                return b[:n], nil
        }
}
func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src)
}
func (m *MsgUpdateParamsResponse) XXX_Size() int {
        return m.Size()
}
func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo

type MsgCreateNamespace struct {
        Sender    string    `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
        Namespace Namespace `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace"`
}

func (m *MsgCreateNamespace) Reset()         { *m = MsgCreateNamespace{} }
func (m *MsgCreateNamespace) String() string { return proto.CompactTextString(m) }
func (*MsgCreateNamespace) ProtoMessage()    {}
func (*MsgCreateNamespace) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{2}
}
func (m *MsgCreateNamespace) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgCreateNamespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgCreateNamespace.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 *MsgCreateNamespace) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgCreateNamespace.Merge(m, src)
}
func (m *MsgCreateNamespace) XXX_Size() int {
        return m.Size()
}
func (m *MsgCreateNamespace) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgCreateNamespace.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateNamespace proto.InternalMessageInfo

func (m *MsgCreateNamespace) GetSender() string {
        if m != nil {
                return m.Sender
        }
        return ""
}

func (m *MsgCreateNamespace) GetNamespace() Namespace {
        if m != nil {
                return m.Namespace
        }
        return Namespace{}
}

type MsgCreateNamespaceResponse struct {
}

func (m *MsgCreateNamespaceResponse) Reset()         { *m = MsgCreateNamespaceResponse{} }
func (m *MsgCreateNamespaceResponse) String() string { return proto.CompactTextString(m) }
func (*MsgCreateNamespaceResponse) ProtoMessage()    {}
func (*MsgCreateNamespaceResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{3}
}
func (m *MsgCreateNamespaceResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgCreateNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgCreateNamespaceResponse.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 *MsgCreateNamespaceResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgCreateNamespaceResponse.Merge(m, src)
}
func (m *MsgCreateNamespaceResponse) XXX_Size() int {
        return m.Size()
}
func (m *MsgCreateNamespaceResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgCreateNamespaceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateNamespaceResponse proto.InternalMessageInfo

type MsgUpdateNamespace struct {
        Sender                    string                              `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
        Denom                     string                              `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
        ContractHook              *MsgUpdateNamespace_SetContractHook `protobuf:"bytes,3,opt,name=contract_hook,json=contractHook,proto3" json:"contract_hook,omitempty"`
        RolePermissions           []*Role                             `protobuf:"bytes,4,rep,name=role_permissions,json=rolePermissions,proto3" json:"role_permissions,omitempty"`
        RoleManagers              []*RoleManager                      `protobuf:"bytes,5,rep,name=role_managers,json=roleManagers,proto3" json:"role_managers,omitempty"`
        PolicyStatuses            []*PolicyStatus                     `protobuf:"bytes,6,rep,name=policy_statuses,json=policyStatuses,proto3" json:"policy_statuses,omitempty"`
        PolicyManagerCapabilities []*PolicyManagerCapability          `protobuf:"bytes,7,rep,name=policy_manager_capabilities,json=policyManagerCapabilities,proto3" json:"policy_manager_capabilities,omitempty"`
}

func (m *MsgUpdateNamespace) Reset()         { *m = MsgUpdateNamespace{} }
func (m *MsgUpdateNamespace) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateNamespace) ProtoMessage()    {}
func (*MsgUpdateNamespace) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{4}
}
func (m *MsgUpdateNamespace) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgUpdateNamespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgUpdateNamespace.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 *MsgUpdateNamespace) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgUpdateNamespace.Merge(m, src)
}
func (m *MsgUpdateNamespace) XXX_Size() int {
        return m.Size()
}
func (m *MsgUpdateNamespace) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgUpdateNamespace.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateNamespace proto.InternalMessageInfo

func (m *MsgUpdateNamespace) GetSender() string {
        if m != nil {
                return m.Sender
        }
        return ""
}

func (m *MsgUpdateNamespace) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

func (m *MsgUpdateNamespace) GetContractHook() *MsgUpdateNamespace_SetContractHook {
        if m != nil {
                return m.ContractHook
        }
        return nil
}

func (m *MsgUpdateNamespace) GetRolePermissions() []*Role {
        if m != nil {
                return m.RolePermissions
        }
        return nil
}

func (m *MsgUpdateNamespace) GetRoleManagers() []*RoleManager {
        if m != nil {
                return m.RoleManagers
        }
        return nil
}

func (m *MsgUpdateNamespace) GetPolicyStatuses() []*PolicyStatus {
        if m != nil {
                return m.PolicyStatuses
        }
        return nil
}

func (m *MsgUpdateNamespace) GetPolicyManagerCapabilities() []*PolicyManagerCapability {
        if m != nil {
                return m.PolicyManagerCapabilities
        }
        return nil
}

type MsgUpdateNamespace_SetContractHook struct {
        NewValue string `protobuf:"bytes,1,opt,name=new_value,json=newValue,proto3" json:"new_value,omitempty"`
}

func (m *MsgUpdateNamespace_SetContractHook) Reset()         { *m = MsgUpdateNamespace_SetContractHook{} }
func (m *MsgUpdateNamespace_SetContractHook) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateNamespace_SetContractHook) ProtoMessage()    {}
func (*MsgUpdateNamespace_SetContractHook) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{4, 0}
}
func (m *MsgUpdateNamespace_SetContractHook) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgUpdateNamespace_SetContractHook) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgUpdateNamespace_SetContractHook.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 *MsgUpdateNamespace_SetContractHook) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgUpdateNamespace_SetContractHook.Merge(m, src)
}
func (m *MsgUpdateNamespace_SetContractHook) XXX_Size() int {
        return m.Size()
}
func (m *MsgUpdateNamespace_SetContractHook) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgUpdateNamespace_SetContractHook.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateNamespace_SetContractHook proto.InternalMessageInfo

func (m *MsgUpdateNamespace_SetContractHook) GetNewValue() string {
        if m != nil {
                return m.NewValue
        }
        return ""
}

type MsgUpdateNamespaceResponse struct {
}

func (m *MsgUpdateNamespaceResponse) Reset()         { *m = MsgUpdateNamespaceResponse{} }
func (m *MsgUpdateNamespaceResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateNamespaceResponse) ProtoMessage()    {}
func (*MsgUpdateNamespaceResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{5}
}
func (m *MsgUpdateNamespaceResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgUpdateNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgUpdateNamespaceResponse.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 *MsgUpdateNamespaceResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgUpdateNamespaceResponse.Merge(m, src)
}
func (m *MsgUpdateNamespaceResponse) XXX_Size() int {
        return m.Size()
}
func (m *MsgUpdateNamespaceResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgUpdateNamespaceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateNamespaceResponse proto.InternalMessageInfo

type MsgUpdateActorRoles struct {
        Sender             string        `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
        Denom              string        `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
        RoleActorsToAdd    []*RoleActors `protobuf:"bytes,3,rep,name=role_actors_to_add,json=roleActorsToAdd,proto3" json:"role_actors_to_add,omitempty"`
        RoleActorsToRevoke []*RoleActors `protobuf:"bytes,5,rep,name=role_actors_to_revoke,json=roleActorsToRevoke,proto3" json:"role_actors_to_revoke,omitempty"`
}

func (m *MsgUpdateActorRoles) Reset()         { *m = MsgUpdateActorRoles{} }
func (m *MsgUpdateActorRoles) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateActorRoles) ProtoMessage()    {}
func (*MsgUpdateActorRoles) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{6}
}
func (m *MsgUpdateActorRoles) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgUpdateActorRoles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgUpdateActorRoles.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 *MsgUpdateActorRoles) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgUpdateActorRoles.Merge(m, src)
}
func (m *MsgUpdateActorRoles) XXX_Size() int {
        return m.Size()
}
func (m *MsgUpdateActorRoles) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgUpdateActorRoles.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateActorRoles proto.InternalMessageInfo

func (m *MsgUpdateActorRoles) GetSender() string {
        if m != nil {
                return m.Sender
        }
        return ""
}

func (m *MsgUpdateActorRoles) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

func (m *MsgUpdateActorRoles) GetRoleActorsToAdd() []*RoleActors {
        if m != nil {
                return m.RoleActorsToAdd
        }
        return nil
}

func (m *MsgUpdateActorRoles) GetRoleActorsToRevoke() []*RoleActors {
        if m != nil {
                return m.RoleActorsToRevoke
        }
        return nil
}

type MsgUpdateActorRolesResponse struct {
}

func (m *MsgUpdateActorRolesResponse) Reset()         { *m = MsgUpdateActorRolesResponse{} }
func (m *MsgUpdateActorRolesResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateActorRolesResponse) ProtoMessage()    {}
func (*MsgUpdateActorRolesResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{7}
}
func (m *MsgUpdateActorRolesResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgUpdateActorRolesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgUpdateActorRolesResponse.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 *MsgUpdateActorRolesResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgUpdateActorRolesResponse.Merge(m, src)
}
func (m *MsgUpdateActorRolesResponse) XXX_Size() int {
        return m.Size()
}
func (m *MsgUpdateActorRolesResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgUpdateActorRolesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateActorRolesResponse proto.InternalMessageInfo

type MsgClaimVoucher struct {
        Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
        Denom  string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
}

func (m *MsgClaimVoucher) Reset()         { *m = MsgClaimVoucher{} }
func (m *MsgClaimVoucher) String() string { return proto.CompactTextString(m) }
func (*MsgClaimVoucher) ProtoMessage()    {}
func (*MsgClaimVoucher) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{8}
}
func (m *MsgClaimVoucher) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgClaimVoucher) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgClaimVoucher.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 *MsgClaimVoucher) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgClaimVoucher.Merge(m, src)
}
func (m *MsgClaimVoucher) XXX_Size() int {
        return m.Size()
}
func (m *MsgClaimVoucher) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgClaimVoucher.DiscardUnknown(m)
}

var xxx_messageInfo_MsgClaimVoucher proto.InternalMessageInfo

func (m *MsgClaimVoucher) GetSender() string {
        if m != nil {
                return m.Sender
        }
        return ""
}

func (m *MsgClaimVoucher) GetDenom() string {
        if m != nil {
                return m.Denom
        }
        return ""
}

type MsgClaimVoucherResponse struct {
}

func (m *MsgClaimVoucherResponse) Reset()         { *m = MsgClaimVoucherResponse{} }
func (m *MsgClaimVoucherResponse) String() string { return proto.CompactTextString(m) }
func (*MsgClaimVoucherResponse) ProtoMessage()    {}
func (*MsgClaimVoucherResponse) Descriptor() ([]byte, []int) {
        return fileDescriptor_ab9bfdcab1d9b6fa, []int{9}
}
func (m *MsgClaimVoucherResponse) XXX_Unmarshal(b []byte) error {
        return m.Unmarshal(b)
}
func (m *MsgClaimVoucherResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        if deterministic {
                return xxx_messageInfo_MsgClaimVoucherResponse.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 *MsgClaimVoucherResponse) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MsgClaimVoucherResponse.Merge(m, src)
}
func (m *MsgClaimVoucherResponse) XXX_Size() int {
        return m.Size()
}
func (m *MsgClaimVoucherResponse) XXX_DiscardUnknown() {
        xxx_messageInfo_MsgClaimVoucherResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgClaimVoucherResponse proto.InternalMessageInfo

func init() {
        proto.RegisterType((*MsgUpdateParams)(nil), "injective.permissions.v1beta1.MsgUpdateParams")
        proto.RegisterType((*MsgUpdateParamsResponse)(nil), "injective.permissions.v1beta1.MsgUpdateParamsResponse")
        proto.RegisterType((*MsgCreateNamespace)(nil), "injective.permissions.v1beta1.MsgCreateNamespace")
        proto.RegisterType((*MsgCreateNamespaceResponse)(nil), "injective.permissions.v1beta1.MsgCreateNamespaceResponse")
        proto.RegisterType((*MsgUpdateNamespace)(nil), "injective.permissions.v1beta1.MsgUpdateNamespace")
        proto.RegisterType((*MsgUpdateNamespace_SetContractHook)(nil), "injective.permissions.v1beta1.MsgUpdateNamespace.SetContractHook")
        proto.RegisterType((*MsgUpdateNamespaceResponse)(nil), "injective.permissions.v1beta1.MsgUpdateNamespaceResponse")
        proto.RegisterType((*MsgUpdateActorRoles)(nil), "injective.permissions.v1beta1.MsgUpdateActorRoles")
        proto.RegisterType((*MsgUpdateActorRolesResponse)(nil), "injective.permissions.v1beta1.MsgUpdateActorRolesResponse")
        proto.RegisterType((*MsgClaimVoucher)(nil), "injective.permissions.v1beta1.MsgClaimVoucher")
        proto.RegisterType((*MsgClaimVoucherResponse)(nil), "injective.permissions.v1beta1.MsgClaimVoucherResponse")
}

func init() {
        proto.RegisterFile("injective/permissions/v1beta1/tx.proto", fileDescriptor_ab9bfdcab1d9b6fa)
}

var fileDescriptor_ab9bfdcab1d9b6fa = []byte{
        // 889 bytes of a gzipped FileDescriptorProto
        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcf, 0x6f, 0x1b, 0x45,
        0x14, 0xce, 0x36, 0x75, 0xc0, 0xd3, 0x04, 0xb7, 0x43, 0x50, 0x37, 0x0e, 0x75, 0x22, 0x23, 0x50,
        0xea, 0xaa, 0xbb, 0x72, 0x90, 0x22, 0xe1, 0x5b, 0xe2, 0x0b, 0x48, 0x4d, 0x29, 0x9b, 0x92, 0x03,
        0x42, 0xb2, 0xc6, 0xbb, 0x8f, 0xf5, 0x60, 0xef, 0xce, 0x6a, 0x66, 0xec, 0xe2, 0x53, 0x51, 0xb9,
        0x21, 0x0e, 0xfc, 0x29, 0x39, 0x70, 0x85, 0x73, 0x8f, 0x15, 0x27, 0x4e, 0x15, 0x4a, 0x0e, 0xb9,
        0xf3, 0x17, 0x20, 0xcf, 0x8c, 0xbd, 0x9b, 0x8d, 0xa9, 0xd7, 0xf4, 0x92, 0xf8, 0xfd, 0xfa, 0xde,
        0xf7, 0xbd, 0x79, 0x3b, 0xbb, 0xe8, 0x13, 0x1a, 0x7f, 0x0f, 0xbe, 0xa4, 0x23, 0x70, 0x13, 0xe0,
        0x11, 0x15, 0x82, 0xb2, 0x58, 0xb8, 0xa3, 0x66, 0x17, 0x24, 0x69, 0xba, 0xf2, 0x07, 0x27, 0xe1,
        0x4c, 0x32, 0x7c, 0x6f, 0x96, 0xe7, 0x64, 0xf2, 0x1c, 0x93, 0x57, 0xdd, 0x0c, 0x59, 0xc8, 0x54,
        0xa6, 0x3b, 0xf9, 0xa5, 0x8b, 0xaa, 0x35, 0x9f, 0x89, 0x88, 0x09, 0xb7, 0x4b, 0x04, 0xcc, 0x20,
        0x7d, 0x46, 0xe3, 0x6b, 0xf1, 0xb8, 0x3f, 0x8b, 0x4f, 0x0c, 0x13, 0xbf, 0x6b, 0xe2, 0x91, 0x08,
        0xdd, 0x51, 0x73, 0xf2, 0xcf, 0x04, 0xb6, 0x74, 0xa0, 0xa3, 0x3b, 0x6a, 0xc3, 0x84, 0x1a, 0x6f,
        0x16, 0x94, 0x10, 0x4e, 0xa2, 0x69, 0xae, 0xbb, 0x20, 0x37, 0x23, 0x54, 0x17, 0xdc, 0x21, 0x11,
        0x8d, 0x99, 0xab, 0xfe, 0x6a, 0x57, 0xfd, 0x0f, 0x0b, 0x55, 0x8e, 0x45, 0xf8, 0x75, 0x12, 0x10,
        0x09, 0x4f, 0x14, 0x3a, 0x3e, 0x40, 0x65, 0x32, 0x94, 0x3d, 0xc6, 0xa9, 0x1c, 0xdb, 0xd6, 0xae,
        0xb5, 0x57, 0x3e, 0xb2, 0xff, 0xfc, 0xed, 0xe1, 0xa6, 0x21, 0x7a, 0x18, 0x04, 0x1c, 0x84, 0x38,
        0x91, 0x9c, 0xc6, 0xa1, 0x97, 0xa6, 0xe2, 0x36, 0x5a, 0xd3, 0xfc, 0xec, 0x1b, 0xbb, 0xd6, 0xde,
        0xad, 0xfd, 0x8f, 0x9d, 0x37, 0x4e, 0xdd, 0xd1, 0xed, 0x8e, 0x6e, 0xbe, 0x7c, 0xbd, 0xb3, 0xe2,
        0x99, 0xd2, 0x96, 0xf3, 0xe2, 0xf2, 0xac, 0x91, 0x82, 0xfe, 0x7c, 0x79, 0xd6, 0xd8, 0xce, 0xaa,
        0xcb, 0x91, 0xad, 0x6f, 0xa1, 0xbb, 0x39, 0x97, 0x07, 0x22, 0x61, 0xb1, 0x80, 0xfa, 0xef, 0x16,
        0xc2, 0xc7, 0x22, 0x6c, 0x73, 0x20, 0x12, 0x1e, 0x93, 0x08, 0x44, 0x42, 0x7c, 0xc0, 0xf7, 0xd1,
        0x9a, 0x80, 0x38, 0x00, 0x6e, 0xb4, 0xdd, 0xf9, 0xe7, 0xf5, 0xce, 0xc6, 0x98, 0x44, 0x83, 0x56,
        0x5d, 0xfb, 0xeb, 0x9e, 0x49, 0xc0, 0x8f, 0x50, 0x39, 0x9e, 0xd6, 0x19, 0x51, 0x7b, 0x0b, 0x44,
        0xcd, 0xfa, 0x18, 0x5d, 0x29, 0x80, 0x96, 0x66, 0xa0, 0x27, 0xba, 0x6a, 0x39, 0x5d, 0x39, 0xa2,
        0xf5, 0x0f, 0x51, 0xf5, 0xba, 0x77, 0xa6, 0xee, 0x97, 0x92, 0x52, 0xa7, 0x95, 0xff, 0x2f, 0x75,
        0x9b, 0xa8, 0x14, 0x40, 0xcc, 0x22, 0xa5, 0xac, 0xec, 0x69, 0x03, 0x7f, 0x87, 0x36, 0x7c, 0x16,
        0x4b, 0x4e, 0x7c, 0xd9, 0xe9, 0x31, 0xd6, 0xb7, 0x57, 0x95, 0xee, 0xc3, 0x05, 0xba, 0xaf, 0x53,
        0x71, 0x4e, 0x40, 0xb6, 0x0d, 0xd2, 0xe7, 0x8c, 0xf5, 0xbd, 0x75, 0x3f, 0x63, 0xe1, 0xc7, 0xe8,
        0x36, 0x67, 0x03, 0xe8, 0x64, 0xc0, 0xec, 0x9b, 0xbb, 0xab, 0x7b, 0xb7, 0xf6, 0x3f, 0x5a, 0xd0,
        0xca, 0x63, 0x03, 0xf0, 0x2a, 0x93, 0xe2, 0x27, 0x69, 0x14, 0x7f, 0x89, 0x36, 0x14, 0x5e, 0x44,
        0x62, 0x12, 0x02, 0x17, 0x76, 0x49, 0x81, 0x35, 0x0a, 0x80, 0x1d, 0xeb, 0x12, 0x6f, 0x9d, 0xa7,
        0x86, 0xc0, 0x4f, 0x51, 0x25, 0x61, 0x03, 0xea, 0x8f, 0x3b, 0x42, 0x12, 0x39, 0x14, 0x20, 0xec,
        0x35, 0x05, 0xf9, 0x60, 0xd1, 0x5e, 0xab, 0xaa, 0x13, 0x55, 0xe4, 0xbd, 0x97, 0x64, 0x2c, 0x10,
        0x78, 0x84, 0xb6, 0x0d, 0xaa, 0x21, 0xda, 0xf1, 0x49, 0x42, 0xba, 0x74, 0x40, 0x25, 0x05, 0x61,
        0xbf, 0xa3, 0x3a, 0x1c, 0x14, 0xea, 0x60, 0x98, 0xb6, 0xa7, 0xf5, 0x63, 0x6f, 0x2b, 0x99, 0x1b,
        0xa0, 0x20, 0xaa, 0x0e, 0xaa, 0xe4, 0xce, 0x03, 0x6f, 0xa3, 0x72, 0x0c, 0xcf, 0x3a, 0x23, 0x32,
        0x18, 0x82, 0xde, 0x16, 0xef, 0xdd, 0x18, 0x9e, 0x9d, 0x4e, 0xec, 0x85, 0xcb, 0x9a, 0x3b, 0x6c,
        0xb3, 0xac, 0x39, 0x6f, 0xfa, 0x28, 0xde, 0x40, 0xef, 0xcf, 0xc2, 0x87, 0xbe, 0x64, 0x7c, 0x32,
        0x77, 0xf1, 0xf6, 0xdb, 0x7a, 0x8a, 0xb0, 0x3a, 0x75, 0x32, 0xc1, 0x14, 0x1d, 0xc9, 0x3a, 0x24,
        0x08, 0xec, 0x55, 0x35, 0xc5, 0xfb, 0x05, 0x8e, 0x5e, 0x71, 0x11, 0x7a, 0x9b, 0xf4, 0xef, 0xa7,
        0xec, 0x30, 0x08, 0xf0, 0xb7, 0xe8, 0x83, 0x1c, 0x2e, 0x87, 0x11, 0xeb, 0x83, 0xd9, 0xaa, 0x25,
        0xa0, 0x71, 0x16, 0xda, 0x53, 0x20, 0x2d, 0x37, 0x37, 0xdc, 0x9d, 0xb9, 0xc3, 0x4d, 0xe7, 0x54,
        0xbf, 0x87, 0xb6, 0xe7, 0xb8, 0x67, 0xe3, 0x7d, 0xae, 0x2e, 0xf1, 0xf6, 0x80, 0xd0, 0xe8, 0x94,
        0x0d, 0xfd, 0x1e, 0xf0, 0xb7, 0x9e, 0x6c, 0xeb, 0x41, 0x8e, 0x63, 0xfe, 0x16, 0xce, 0x76, 0x33,
        0xb7, 0x70, 0xd6, 0x35, 0xe5, 0xb6, 0xff, 0x53, 0x09, 0xad, 0x1e, 0x8b, 0x10, 0x8f, 0xd0, 0xfa,
        0x95, 0xb7, 0x8c, 0x53, 0xf4, 0x42, 0xd1, 0xf9, 0xd5, 0x83, 0xe5, 0xf2, 0xa7, 0xfd, 0xf1, 0x73,
        0x54, 0xc9, 0xbf, 0x01, 0x9a, 0x8b, 0xa1, 0x72, 0x25, 0xd5, 0xcf, 0x96, 0x2e, 0xc9, 0x12, 0xc8,
        0x5f, 0xd2, 0xcd, 0xa5, 0x2f, 0xd3, 0x22, 0x04, 0xfe, 0xe3, 0xe1, 0xc3, 0x2f, 0x2c, 0x74, 0xfb,
        0xda, 0x93, 0xb7, 0x5f, 0x14, 0x2f, 0xad, 0xa9, 0xb6, 0x96, 0xaf, 0x99, 0x91, 0x18, 0xa1, 0xf5,
        0x2b, 0xfb, 0x59, 0xe0, 0xf8, 0xb3, 0xf9, 0x45, 0x8e, 0x7f, 0xde, 0xfa, 0x55, 0x4b, 0x3f, 0x5e,
        0x9e, 0x35, 0xac, 0xa3, 0xfe, 0xcb, 0xf3, 0x9a, 0xf5, 0xea, 0xbc, 0x66, 0xfd, 0x7d, 0x5e, 0xb3,
        0x7e, 0xbd, 0xa8, 0xad, 0xbc, 0xba, 0xa8, 0xad, 0xfc, 0x75, 0x51, 0x5b, 0xf9, 0xe6, 0xab, 0x90,
        0xca, 0xde, 0xb0, 0xeb, 0xf8, 0x2c, 0x72, 0xbf, 0x98, 0xb6, 0x78, 0x44, 0xba, 0x22, 0xfd, 0xbc,
        0x7a, 0xe8, 0x33, 0x0e, 0x59, 0xb3, 0x47, 0x68, 0xec, 0x46, 0x2c, 0x18, 0x0e, 0x40, 0x5c, 0xf9,
        0xf6, 0x92, 0xe3, 0x04, 0x44, 0x77, 0x4d, 0x7d, 0x5b, 0x7d, 0xfa, 0x6f, 0x00, 0x00, 0x00, 0xff,
        0xff, 0x89, 0x70, 0x57, 0xeb, 0x9e, 0x0a, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
        UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
        CreateNamespace(ctx context.Context, in *MsgCreateNamespace, opts ...grpc.CallOption) (*MsgCreateNamespaceResponse, error)
        UpdateNamespace(ctx context.Context, in *MsgUpdateNamespace, opts ...grpc.CallOption) (*MsgUpdateNamespaceResponse, error)
        UpdateActorRoles(ctx context.Context, in *MsgUpdateActorRoles, opts ...grpc.CallOption) (*MsgUpdateActorRolesResponse, error)
        ClaimVoucher(ctx context.Context, in *MsgClaimVoucher, opts ...grpc.CallOption) (*MsgClaimVoucherResponse, error)
}

type msgClient struct {
        cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
        return &msgClient{cc}
}

func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
        out := new(MsgUpdateParamsResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Msg/UpdateParams", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *msgClient) CreateNamespace(ctx context.Context, in *MsgCreateNamespace, opts ...grpc.CallOption) (*MsgCreateNamespaceResponse, error) {
        out := new(MsgCreateNamespaceResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Msg/CreateNamespace", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *msgClient) UpdateNamespace(ctx context.Context, in *MsgUpdateNamespace, opts ...grpc.CallOption) (*MsgUpdateNamespaceResponse, error) {
        out := new(MsgUpdateNamespaceResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Msg/UpdateNamespace", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *msgClient) UpdateActorRoles(ctx context.Context, in *MsgUpdateActorRoles, opts ...grpc.CallOption) (*MsgUpdateActorRolesResponse, error) {
        out := new(MsgUpdateActorRolesResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Msg/UpdateActorRoles", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *msgClient) ClaimVoucher(ctx context.Context, in *MsgClaimVoucher, opts ...grpc.CallOption) (*MsgClaimVoucherResponse, error) {
        out := new(MsgClaimVoucherResponse)
        err := c.cc.Invoke(ctx, "/injective.permissions.v1beta1.Msg/ClaimVoucher", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
        UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
        CreateNamespace(context.Context, *MsgCreateNamespace) (*MsgCreateNamespaceResponse, error)
        UpdateNamespace(context.Context, *MsgUpdateNamespace) (*MsgUpdateNamespaceResponse, error)
        UpdateActorRoles(context.Context, *MsgUpdateActorRoles) (*MsgUpdateActorRolesResponse, error)
        ClaimVoucher(context.Context, *MsgClaimVoucher) (*MsgClaimVoucherResponse, error)
}

// UnimplementedMsgServer can be embedded to have forward compatible implementations.
type UnimplementedMsgServer struct {
}

func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
}
func (*UnimplementedMsgServer) CreateNamespace(ctx context.Context, req *MsgCreateNamespace) (*MsgCreateNamespaceResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method CreateNamespace not implemented")
}
func (*UnimplementedMsgServer) UpdateNamespace(ctx context.Context, req *MsgUpdateNamespace) (*MsgUpdateNamespaceResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method UpdateNamespace not implemented")
}
func (*UnimplementedMsgServer) UpdateActorRoles(ctx context.Context, req *MsgUpdateActorRoles) (*MsgUpdateActorRolesResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method UpdateActorRoles not implemented")
}
func (*UnimplementedMsgServer) ClaimVoucher(ctx context.Context, req *MsgClaimVoucher) (*MsgClaimVoucherResponse, error) {
        return nil, status.Errorf(codes.Unimplemented, "method ClaimVoucher not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
        s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(MsgUpdateParams)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(MsgServer).UpdateParams(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Msg/UpdateParams",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
        }
        return interceptor(ctx, in, info, handler)
}

func _Msg_CreateNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(MsgCreateNamespace)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(MsgServer).CreateNamespace(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Msg/CreateNamespace",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(MsgServer).CreateNamespace(ctx, req.(*MsgCreateNamespace))
        }
        return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(MsgUpdateNamespace)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(MsgServer).UpdateNamespace(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Msg/UpdateNamespace",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(MsgServer).UpdateNamespace(ctx, req.(*MsgUpdateNamespace))
        }
        return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateActorRoles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(MsgUpdateActorRoles)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(MsgServer).UpdateActorRoles(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Msg/UpdateActorRoles",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(MsgServer).UpdateActorRoles(ctx, req.(*MsgUpdateActorRoles))
        }
        return interceptor(ctx, in, info, handler)
}

func _Msg_ClaimVoucher_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(MsgClaimVoucher)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(MsgServer).ClaimVoucher(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/injective.permissions.v1beta1.Msg/ClaimVoucher",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(MsgServer).ClaimVoucher(ctx, req.(*MsgClaimVoucher))
        }
        return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
        ServiceName: "injective.permissions.v1beta1.Msg",
        HandlerType: (*MsgServer)(nil),
        Methods: []grpc.MethodDesc{
                {
                        MethodName: "UpdateParams",
                        Handler:    _Msg_UpdateParams_Handler,
                },
                {
                        MethodName: "CreateNamespace",
                        Handler:    _Msg_CreateNamespace_Handler,
                },
                {
                        MethodName: "UpdateNamespace",
                        Handler:    _Msg_UpdateNamespace_Handler,
                },
                {
                        MethodName: "UpdateActorRoles",
                        Handler:    _Msg_UpdateActorRoles_Handler,
                },
                {
                        MethodName: "ClaimVoucher",
                        Handler:    _Msg_ClaimVoucher_Handler,
                },
        },
        Streams:  []grpc.StreamDesc{},
        Metadata: "injective/permissions/v1beta1/tx.proto",
}

func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) {
        size := m.Size()
        dAtA = make([]byte, size)
        n, err := m.MarshalToSizedBuffer(dAtA[:size])
        if err != nil {
                return nil, err
        }
        return dAtA[:n], nil
}

func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        {
                size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
                if err != nil {
                        return 0, err
                }
                i -= size
                i = encodeVarintTx(dAtA, i, uint64(size))
        }
        i--
        dAtA[i] = 0x12
        if len(m.Authority) > 0 {
                i -= len(m.Authority)
                copy(dAtA[i:], m.Authority)
                i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) {
        size := m.Size()
        dAtA = make([]byte, size)
        n, err := m.MarshalToSizedBuffer(dAtA[:size])
        if err != nil {
                return nil, err
        }
        return dAtA[:n], nil
}

func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func (m *MsgCreateNamespace) 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 *MsgCreateNamespace) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateNamespace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        {
                size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i])
                if err != nil {
                        return 0, err
                }
                i -= size
                i = encodeVarintTx(dAtA, i, uint64(size))
        }
        i--
        dAtA[i] = 0x12
        if len(m.Sender) > 0 {
                i -= len(m.Sender)
                copy(dAtA[i:], m.Sender)
                i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *MsgCreateNamespaceResponse) 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 *MsgCreateNamespaceResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func (m *MsgUpdateNamespace) 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 *MsgUpdateNamespace) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateNamespace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.PolicyManagerCapabilities) > 0 {
                for iNdEx := len(m.PolicyManagerCapabilities) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.PolicyManagerCapabilities[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintTx(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x3a
                }
        }
        if len(m.PolicyStatuses) > 0 {
                for iNdEx := len(m.PolicyStatuses) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.PolicyStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintTx(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x32
                }
        }
        if len(m.RoleManagers) > 0 {
                for iNdEx := len(m.RoleManagers) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.RoleManagers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintTx(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x2a
                }
        }
        if len(m.RolePermissions) > 0 {
                for iNdEx := len(m.RolePermissions) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.RolePermissions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintTx(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x22
                }
        }
        if m.ContractHook != nil {
                {
                        size, err := m.ContractHook.MarshalToSizedBuffer(dAtA[:i])
                        if err != nil {
                                return 0, err
                        }
                        i -= size
                        i = encodeVarintTx(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0x1a
        }
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintTx(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0x12
        }
        if len(m.Sender) > 0 {
                i -= len(m.Sender)
                copy(dAtA[i:], m.Sender)
                i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *MsgUpdateNamespace_SetContractHook) 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 *MsgUpdateNamespace_SetContractHook) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateNamespace_SetContractHook) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.NewValue) > 0 {
                i -= len(m.NewValue)
                copy(dAtA[i:], m.NewValue)
                i = encodeVarintTx(dAtA, i, uint64(len(m.NewValue)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *MsgUpdateNamespaceResponse) 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 *MsgUpdateNamespaceResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func (m *MsgUpdateActorRoles) 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 *MsgUpdateActorRoles) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateActorRoles) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.RoleActorsToRevoke) > 0 {
                for iNdEx := len(m.RoleActorsToRevoke) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.RoleActorsToRevoke[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintTx(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x2a
                }
        }
        if len(m.RoleActorsToAdd) > 0 {
                for iNdEx := len(m.RoleActorsToAdd) - 1; iNdEx >= 0; iNdEx-- {
                        {
                                size, err := m.RoleActorsToAdd[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                                if err != nil {
                                        return 0, err
                                }
                                i -= size
                                i = encodeVarintTx(dAtA, i, uint64(size))
                        }
                        i--
                        dAtA[i] = 0x1a
                }
        }
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintTx(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0x12
        }
        if len(m.Sender) > 0 {
                i -= len(m.Sender)
                copy(dAtA[i:], m.Sender)
                i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *MsgUpdateActorRolesResponse) 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 *MsgUpdateActorRolesResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateActorRolesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func (m *MsgClaimVoucher) 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 *MsgClaimVoucher) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgClaimVoucher) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        if len(m.Denom) > 0 {
                i -= len(m.Denom)
                copy(dAtA[i:], m.Denom)
                i = encodeVarintTx(dAtA, i, uint64(len(m.Denom)))
                i--
                dAtA[i] = 0x12
        }
        if len(m.Sender) > 0 {
                i -= len(m.Sender)
                copy(dAtA[i:], m.Sender)
                i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
                i--
                dAtA[i] = 0xa
        }
        return len(dAtA) - i, nil
}

func (m *MsgClaimVoucherResponse) 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 *MsgClaimVoucherResponse) MarshalTo(dAtA []byte) (int, error) {
        size := m.Size()
        return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgClaimVoucherResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
        i := len(dAtA)
        _ = i
        var l int
        _ = l
        return len(dAtA) - i, nil
}

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
        offset -= sovTx(v)
        base := offset
        for v >= 1<<7 {
                dAtA[offset] = uint8(v&0x7f | 0x80)
                v >>= 7
                offset++
        }
        dAtA[offset] = uint8(v)
        return base
}
func (m *MsgUpdateParams) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Authority)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        l = m.Params.Size()
        n += 1 + l + sovTx(uint64(l))
        return n
}

func (m *MsgUpdateParamsResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func (m *MsgCreateNamespace) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Sender)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        l = m.Namespace.Size()
        n += 1 + l + sovTx(uint64(l))
        return n
}

func (m *MsgCreateNamespaceResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func (m *MsgUpdateNamespace) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Sender)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        if m.ContractHook != nil {
                l = m.ContractHook.Size()
                n += 1 + l + sovTx(uint64(l))
        }
        if len(m.RolePermissions) > 0 {
                for _, e := range m.RolePermissions {
                        l = e.Size()
                        n += 1 + l + sovTx(uint64(l))
                }
        }
        if len(m.RoleManagers) > 0 {
                for _, e := range m.RoleManagers {
                        l = e.Size()
                        n += 1 + l + sovTx(uint64(l))
                }
        }
        if len(m.PolicyStatuses) > 0 {
                for _, e := range m.PolicyStatuses {
                        l = e.Size()
                        n += 1 + l + sovTx(uint64(l))
                }
        }
        if len(m.PolicyManagerCapabilities) > 0 {
                for _, e := range m.PolicyManagerCapabilities {
                        l = e.Size()
                        n += 1 + l + sovTx(uint64(l))
                }
        }
        return n
}

func (m *MsgUpdateNamespace_SetContractHook) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.NewValue)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        return n
}

func (m *MsgUpdateNamespaceResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func (m *MsgUpdateActorRoles) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Sender)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        if len(m.RoleActorsToAdd) > 0 {
                for _, e := range m.RoleActorsToAdd {
                        l = e.Size()
                        n += 1 + l + sovTx(uint64(l))
                }
        }
        if len(m.RoleActorsToRevoke) > 0 {
                for _, e := range m.RoleActorsToRevoke {
                        l = e.Size()
                        n += 1 + l + sovTx(uint64(l))
                }
        }
        return n
}

func (m *MsgUpdateActorRolesResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func (m *MsgClaimVoucher) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        l = len(m.Sender)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        l = len(m.Denom)
        if l > 0 {
                n += 1 + l + sovTx(uint64(l))
        }
        return n
}

func (m *MsgClaimVoucherResponse) Size() (n int) {
        if m == nil {
                return 0
        }
        var l int
        _ = l
        return n
}

func sovTx(x uint64) (n int) {
        return (math_bits.Len64(x|1) + 6) / 7
}
func sozTx(x uint64) (n int) {
        return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Authority = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgCreateNamespace) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgCreateNamespace: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgCreateNamespace: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Sender = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgCreateNamespaceResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgCreateNamespaceResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgCreateNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgUpdateNamespace) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgUpdateNamespace: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgUpdateNamespace: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Sender = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 3:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field ContractHook", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        if m.ContractHook == nil {
                                m.ContractHook = &MsgUpdateNamespace_SetContractHook{}
                        }
                        if err := m.ContractHook.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 4:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RolePermissions", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.RolePermissions = append(m.RolePermissions, &Role{})
                        if err := m.RolePermissions[len(m.RolePermissions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 5:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RoleManagers", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.RoleManagers = append(m.RoleManagers, &RoleManager{})
                        if err := m.RoleManagers[len(m.RoleManagers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 6:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field PolicyStatuses", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.PolicyStatuses = append(m.PolicyStatuses, &PolicyStatus{})
                        if err := m.PolicyStatuses[len(m.PolicyStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 7:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field PolicyManagerCapabilities", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.PolicyManagerCapabilities = append(m.PolicyManagerCapabilities, &PolicyManagerCapability{})
                        if err := m.PolicyManagerCapabilities[len(m.PolicyManagerCapabilities)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgUpdateNamespace_SetContractHook) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: SetContractHook: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: SetContractHook: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field NewValue", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.NewValue = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgUpdateNamespaceResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgUpdateNamespaceResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgUpdateNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgUpdateActorRoles) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgUpdateActorRoles: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgUpdateActorRoles: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Sender = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 3:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RoleActorsToAdd", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.RoleActorsToAdd = append(m.RoleActorsToAdd, &RoleActors{})
                        if err := m.RoleActorsToAdd[len(m.RoleActorsToAdd)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                case 5:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field RoleActorsToRevoke", wireType)
                        }
                        var msglen int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                msglen |= int(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if msglen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + msglen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.RoleActorsToRevoke = append(m.RoleActorsToRevoke, &RoleActors{})
                        if err := m.RoleActorsToRevoke[len(m.RoleActorsToRevoke)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                                return err
                        }
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgUpdateActorRolesResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgUpdateActorRolesResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgUpdateActorRolesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgClaimVoucher) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgClaimVoucher: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgClaimVoucher: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                case 1:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Sender = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                case 2:
                        if wireType != 2 {
                                return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
                        }
                        var stringLen uint64
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                stringLen |= uint64(b&0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        intStringLen := int(stringLen)
                        if intStringLen < 0 {
                                return ErrInvalidLengthTx
                        }
                        postIndex := iNdEx + intStringLen
                        if postIndex < 0 {
                                return ErrInvalidLengthTx
                        }
                        if postIndex > l {
                                return io.ErrUnexpectedEOF
                        }
                        m.Denom = string(dAtA[iNdEx:postIndex])
                        iNdEx = postIndex
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func (m *MsgClaimVoucherResponse) Unmarshal(dAtA []byte) error {
        l := len(dAtA)
        iNdEx := 0
        for iNdEx < l {
                preIndex := iNdEx
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= uint64(b&0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                fieldNum := int32(wire >> 3)
                wireType := int(wire & 0x7)
                if wireType == 4 {
                        return fmt.Errorf("proto: MsgClaimVoucherResponse: wiretype end group for non-group")
                }
                if fieldNum <= 0 {
                        return fmt.Errorf("proto: MsgClaimVoucherResponse: illegal tag %d (wire type %d)", fieldNum, wire)
                }
                switch fieldNum {
                default:
                        iNdEx = preIndex
                        skippy, err := skipTx(dAtA[iNdEx:])
                        if err != nil {
                                return err
                        }
                        if (skippy < 0) || (iNdEx+skippy) < 0 {
                                return ErrInvalidLengthTx
                        }
                        if (iNdEx + skippy) > l {
                                return io.ErrUnexpectedEOF
                        }
                        iNdEx += skippy
                }
        }

        if iNdEx > l {
                return io.ErrUnexpectedEOF
        }
        return nil
}
func skipTx(dAtA []byte) (n int, err error) {
        l := len(dAtA)
        iNdEx := 0
        depth := 0
        for iNdEx < l {
                var wire uint64
                for shift := uint(0); ; shift += 7 {
                        if shift >= 64 {
                                return 0, ErrIntOverflowTx
                        }
                        if iNdEx >= l {
                                return 0, io.ErrUnexpectedEOF
                        }
                        b := dAtA[iNdEx]
                        iNdEx++
                        wire |= (uint64(b) & 0x7F) << shift
                        if b < 0x80 {
                                break
                        }
                }
                wireType := int(wire & 0x7)
                switch wireType {
                case 0:
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return 0, ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return 0, io.ErrUnexpectedEOF
                                }
                                iNdEx++
                                if dAtA[iNdEx-1] < 0x80 {
                                        break
                                }
                        }
                case 1:
                        iNdEx += 8
                case 2:
                        var length int
                        for shift := uint(0); ; shift += 7 {
                                if shift >= 64 {
                                        return 0, ErrIntOverflowTx
                                }
                                if iNdEx >= l {
                                        return 0, io.ErrUnexpectedEOF
                                }
                                b := dAtA[iNdEx]
                                iNdEx++
                                length |= (int(b) & 0x7F) << shift
                                if b < 0x80 {
                                        break
                                }
                        }
                        if length < 0 {
                                return 0, ErrInvalidLengthTx
                        }
                        iNdEx += length
                case 3:
                        depth++
                case 4:
                        if depth == 0 {
                                return 0, ErrUnexpectedEndOfGroupTx
                        }
                        depth--
                case 5:
                        iNdEx += 4
                default:
                        return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
                }
                if iNdEx < 0 {
                        return 0, ErrInvalidLengthTx
                }
                if depth == 0 {
                        return iNdEx, nil
                }
        }
        return 0, io.ErrUnexpectedEOF
}

var (
        ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
        ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
        ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)

package types

import (
        "sort"

        sdk "github.com/cosmos/cosmos-sdk/types"
)

const (
        EVERYONE = "EVERYONE"
        MaxPerm  = uint32(Action_MINT) | uint32(Action_RECEIVE) | uint32(Action_BURN) | uint32(Action_SEND) | uint32(Action_SUPER_BURN)
        // ValidActionsBitmask calculates the valid bitmask for all actions.
        ValidActionsBitmask uint32 = uint32(Action_MINT | Action_RECEIVE | Action_BURN | Action_SEND | Action_SUPER_BURN | Action_MODIFY_POLICY_MANAGERS | Action_MODIFY_CONTRACT_HOOK | Action_MODIFY_ROLE_PERMISSIONS | Action_MODIFY_ROLE_MANAGERS)
        // DisallowedEveryoneActions calculates the disallowed actions for the everyone role.
        DisallowedEveryoneActions = uint32(Action_MINT | Action_SUPER_BURN | Action_MODIFY_POLICY_MANAGERS | Action_MODIFY_CONTRACT_HOOK | Action_MODIFY_ROLE_PERMISSIONS | Action_MODIFY_ROLE_MANAGERS)
        MaxRoleNameLength         = 20
)

var Actions = []Action{
        Action_MINT, Action_RECEIVE, Action_BURN, Action_SEND, Action_SUPER_BURN,
        Action_MODIFY_POLICY_MANAGERS, Action_MODIFY_CONTRACT_HOOK, Action_MODIFY_ROLE_PERMISSIONS, Action_MODIFY_ROLE_MANAGERS,
}

// IsValidPermission checks if the given permissions is a valid combination of actions.
func IsValidPermission(perm uint32) bool {
        return perm&ValidActionsBitmask == perm
}

func IsValidPolicyActionPermission(perm uint32) bool {
        isPowerOfTwo := perm > 0 && (perm&(perm-1)) == 0
        if !isPowerOfTwo {
                return false
        }
        return IsValidPermission(perm)
}

func (a Action) DeriveActor(fromAddr, toAddr sdk.AccAddress) sdk.AccAddress {
        switch a {
        case Action_MINT, Action_RECEIVE:
                return toAddr
        case Action_BURN:
                return fromAddr
        }
        return fromAddr
}

func NewEmptyVoucher(denom string) sdk.Coin {
        return sdk.NewInt64Coin(denom, 0)
}

func NewRoleManager(manager sdk.AccAddress, roles []string) *RoleManager {
        return &RoleManager{
                Manager: manager.String(),
                Roles:   roles,
        }
}

func NewPolicyStatus(action Action, isDisabled, isSealed bool) *PolicyStatus {
        return &PolicyStatus{
                Action:     action,
                IsDisabled: isDisabled,
                IsSealed:   isSealed,
        }
}

func NewPolicyManagerCapability(manager sdk.AccAddress, action Action, canDisable, canSeal bool) *PolicyManagerCapability {
        return &PolicyManagerCapability{
                Manager:    manager.String(),
                Action:     action,
                CanDisable: canDisable,
                CanSeal:    canSeal,
        }
}

// RoleActorsToActorRoles converts a slice of RoleActors to a slice of ActorRoles
func RoleActorsToActorRoles(roleActors []*RoleActors) []*ActorRoles {
        // actor => roles
        actorRolesMap := make(map[string][]string)
        for _, roleActor := range roleActors {
                role := roleActor.Role
                for _, actor := range roleActor.Actors {
                        if _, ok := actorRolesMap[actor]; !ok {
                                actorRolesMap[actor] = []string{role}
                        } else {
                                actorRolesMap[actor] = append(actorRolesMap[actor], role)
                        }
                }
        }

        actors := make([]string, 0, len(actorRolesMap))
        for k := range actorRolesMap {
                actors = append(actors, k)
        }

        // sort actors for deterministic ordering
        sort.Strings(actors)

        actorRoles := make([]*ActorRoles, 0, len(actors))

        for _, actor := range actors {
                actorRoles = append(actorRoles, &ActorRoles{
                        Actor: actor,
                        Roles: actorRolesMap[actor],
                })
        }

        return actorRoles
}

func NewRole(name string, roleID uint32, permissions ...Action) *Role {
        perm := uint32(0)

        for _, p := range permissions {
                perm |= uint32(p)
        }
        return &Role{
                Name:        name,
                RoleId:      roleID,
                Permissions: perm,
        }
}

func NewActorRoles(actor sdk.AccAddress, roles ...string) *ActorRoles {
        return &ActorRoles{
                Actor: actor.String(),
                Roles: roles,
        }
}

func NewRoleActors(role string, actors ...sdk.AccAddress) *RoleActors {
        actorStrings := make([]string, len(actors))
        for i, actor := range actors {
                actorStrings[i] = actor.String()
        }
        return &RoleActors{
                Role:   role,
                Actors: actorStrings,
        }
}

package types

import (
        "encoding/json"

        sdk "github.com/cosmos/cosmos-sdk/types"
)

type WasmHookMsg struct {
        From    sdk.AccAddress `json:"from_address"`
        To      sdk.AccAddress `json:"to_address"`
        Action  string         `json:"action"`
        Amounts sdk.Coins      `json:"amounts"`
}

func NewWasmHookMsg(fromAddr, toAddr sdk.AccAddress, action Action, amount sdk.Coin) WasmHookMsg {
        return WasmHookMsg{
                From:    fromAddr,
                To:      toAddr,
                Action:  action.String(),
                Amounts: sdk.NewCoins(amount),
        }
}

func GetWasmHookMsgBytes(fromAddr, toAddr sdk.AccAddress, action Action, amount sdk.Coin) ([]byte, error) {
        wasmHookMsg := struct {
                SendRestriction WasmHookMsg `json:"send_restriction"`
        }{NewWasmHookMsg(fromAddr, toAddr, action, amount)}

        bz, err := json.Marshal(wasmHookMsg)
        if err != nil {
                return nil, err
        }

        return bz, nil
}