Package params provides a namespaced module parameter store.

    There are two core components, Keeper and Subspace. Subspace is an isolated namespace for a parameter store, where keys are prefixed by pre-configured subspace names which modules provide. The Keeper has a permission to access all existing subspaces.

    Subspace can be used by the individual keepers, who needs a private parameter store that the other keeper cannot modify. Keeper can be used by the Governance keeper, who need to modify any parameter in case of the proposal passes.

    Basic Usage:

    1. Declare constant module parameter keys and the globally unique Subspace name:

    const (
    	ModuleSubspace = "mymodule"
    const (
    	KeyParameter1 = "myparameter1"
    	KeyParameter2 = "myparameter2"

    2. Create a concrete parameter struct and define the validation functions:

    type MyParams struct {
    	MyParam1 int64 `json:"my_param1" yaml:"my_param1"`
    	MyParam2 bool `json:"my_param2" yaml:"my_param2"`
    func validateMyParam1(i interface{}) error {
    	_, ok := i.(int64)
    	if !ok {
    		return fmt.Errorf("invalid parameter type: %T", i)
    	// validate (if necessary)...
    	return nil
    func validateMyParam2(i interface{}) error {
    	_, ok := i.(bool)
    	if !ok {
    		return fmt.Errorf("invalid parameter type: %T", i)
    	// validate (if necessary)...
    	return nil

    3. Implement the params.ParamSet interface:

    func (p *MyParams) ParamSetPairs() params.ParamSetPairs {
    	return params.ParamSetPairs{
    		{KeyParameter1, &p.MyParam1, validateMyParam1},
    		{KeyParameter2, &p.MyParam2, validateMyParam2},
    func paramKeyTable() params.KeyTable {
    	return params.NewKeyTable().RegisterParamSet(&MyParams{})

    4. Have the module accept a Subspace in the constructor and set the KeyTable (if necessary):

    func NewKeeper(..., paramSpace params.Subspace, ...) Keeper {
    	// set KeyTable if it has not already been set
    	if !paramSpace.HasKeyTable() {
    		paramSpace = paramSpace.WithKeyTable(paramKeyTable())
    	return Keeper {
    		// ...
    		paramSpace: paramSpace,

    Now we have access to the module's parameters that are namespaced using the keys defined:

    func InitGenesis(ctx sdk.Context, k Keeper, gs GenesisState) {
    	// ...
    	k.SetParams(ctx, gs.Params)
    func (k Keeper) SetParams(ctx sdk.Context, params Params) {
    	k.paramSpace.SetParamSet(ctx, &params)
    func (k Keeper) GetParams(ctx sdk.Context) (params Params) {
    	k.paramSpace.GetParamSet(ctx, &params)
    	return params
    func (k Keeper) MyParam1(ctx sdk.Context) (res int64) {
    	k.paramSpace.Get(ctx, KeyParameter1, &res)
    	return res
    func (k Keeper) MyParam2(ctx sdk.Context) (res bool) {
    	k.paramSpace.Get(ctx, KeyParameter2, &res)
    	return res

    NOTE: Any call to SetParamSet will panic or any call to Update will error if any given parameter value is invalid based on the registered value validation function.



    This section is empty.


    This section is empty.


    func NewParamChangeProposalHandler

    func NewParamChangeProposalHandler(k keeper.Keeper) govtypes.Handler

      NewParamChangeProposalHandler creates a new governance Handler for a ParamChangeProposal


      type AppModule

      type AppModule struct {
      	// contains filtered or unexported fields

        AppModule implements an application module for the distribution module.

        func NewAppModule

        func NewAppModule(k keeper.Keeper) AppModule

          NewAppModule creates a new AppModule object

          func (AppModule) BeginBlock

          func (AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock)

            BeginBlock performs a no-op.

            func (AppModule) EndBlock

              EndBlock performs a no-op.

              func (AppModule) ExportGenesis

              func (am AppModule) ExportGenesis(_ sdk.Context, _ codec.JSONMarshaler) json.RawMessage

                ExportGenesis performs a no-op.

                func (AppModule) GenerateGenesisState

                func (AppModule) GenerateGenesisState(simState *module.SimulationState)

                  GenerateGenesisState performs a no-op.

                  func (AppModule) InitGenesis

                    InitGenesis performs a no-op.

                    func (AppModule) LegacyQuerierHandler

                    func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sdk.Querier

                      LegacyQuerierHandler returns the x/params querier handler.

                      func (AppModule) ProposalContents

                      func (am AppModule) ProposalContents(simState module.SimulationState) []simtypes.WeightedProposalContent

                        ProposalContents returns all the params content functions used to simulate governance proposals.

                        func (AppModule) QuerierRoute

                        func (AppModule) QuerierRoute() string

                          QuerierRoute returns the x/param module's querier route name.

                          func (AppModule) RandomizedParams

                          func (AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange

                            RandomizedParams creates randomized distribution param changes for the simulator.

                            func (AppModule) RegisterInvariants

                            func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry)

                            func (AppModule) RegisterServices

                            func (am AppModule) RegisterServices(cfg module.Configurator)

                              RegisterServices registers a gRPC query service to respond to the module-specific gRPC queries.

                              func (AppModule) RegisterStoreDecoder

                              func (AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry)

                                RegisterStoreDecoder doesn't register any type.

                                func (AppModule) Route

                                func (AppModule) Route() sdk.Route

                                func (AppModule) WeightedOperations

                                func (am AppModule) WeightedOperations(_ module.SimulationState) []simtypes.WeightedOperation

                                  WeightedOperations returns the all the gov module operations with their respective weights.

                                  type AppModuleBasic

                                  type AppModuleBasic struct{}

                                    AppModuleBasic defines the basic application module used by the params module.

                                    func (AppModuleBasic) DefaultGenesis

                                    func (AppModuleBasic) DefaultGenesis(_ codec.JSONMarshaler) json.RawMessage

                                      DefaultGenesis returns default genesis state as raw bytes for the params module.

                                      func (AppModuleBasic) GetQueryCmd

                                      func (AppModuleBasic) GetQueryCmd() *cobra.Command

                                        GetQueryCmd returns no root query command for the params module.

                                        func (AppModuleBasic) GetTxCmd

                                        func (AppModuleBasic) GetTxCmd() *cobra.Command

                                          GetTxCmd returns no root tx command for the params module.

                                          func (AppModuleBasic) Name

                                          func (AppModuleBasic) Name() string

                                            Name returns the params module's name.

                                            func (AppModuleBasic) RegisterGRPCGatewayRoutes

                                            func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux)

                                              RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the params module.

                                              func (AppModuleBasic) RegisterInterfaces

                                              func (am AppModuleBasic) RegisterInterfaces(registry codectypes.InterfaceRegistry)

                                              func (AppModuleBasic) RegisterLegacyAminoCodec

                                              func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino)

                                                RegisterLegacyAminoCodec registers the params module's types on the given LegacyAmino codec.

                                                func (AppModuleBasic) RegisterRESTRoutes

                                                func (AppModuleBasic) RegisterRESTRoutes(_ client.Context, _ *mux.Router)

                                                  RegisterRESTRoutes registers the REST routes for the params module.

                                                  func (AppModuleBasic) ValidateGenesis

                                                    ValidateGenesis performs genesis state validation for the params module.


                                                    Path Synopsis
                                                    To prevent namespace collision between consumer modules, we define a type Subspace.
                                                    To prevent namespace collision between consumer modules, we define a type Subspace.
                                                    Package proposal is a reverse proxy.
                                                    Package proposal is a reverse proxy.