cosmos-sdk: github.com/cosmos/cosmos-sdk/x/params Index | Files | Directories

package params

import "github.com/cosmos/cosmos-sdk/x/params"

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.

Index

Package Files

doc.go module.go proposal_handler.go

func NewParamChangeProposalHandler Uses

func NewParamChangeProposalHandler(k keeper.Keeper) govtypes.Handler

NewParamChangeProposalHandler creates a new governance Handler for a ParamChangeProposal

type AppModule Uses

type AppModule struct {
    AppModuleBasic
    // contains filtered or unexported fields
}

AppModule implements an application module for the distribution module.

func NewAppModule Uses

func NewAppModule(k keeper.Keeper) AppModule

NewAppModule creates a new AppModule object

func (AppModule) BeginBlock Uses

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

BeginBlock performs a no-op.

func (AppModule) EndBlock Uses

func (AppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate

EndBlock performs a no-op.

func (AppModule) ExportGenesis Uses

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

ExportGenesis performs a no-op.

func (AppModule) GenerateGenesisState Uses

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

GenerateGenesisState performs a no-op.

func (AppModule) InitGenesis Uses

func (am AppModule) InitGenesis(_ sdk.Context, _ codec.JSONMarshaler, _ json.RawMessage) []abci.ValidatorUpdate

InitGenesis performs a no-op.

func (AppModule) LegacyQuerierHandler Uses

func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc codec.JSONMarshaler) sdk.Querier

LegacyQuerierHandler returns the x/params querier handler.

func (AppModule) ProposalContents Uses

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

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

func (AppModule) QuerierRoute Uses

func (AppModule) QuerierRoute() string

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

func (AppModule) RandomizedParams Uses

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

RandomizedParams creates randomized distribution param changes for the simulator.

func (AppModule) RegisterInvariants Uses

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

func (AppModule) RegisterQueryService Uses

func (am AppModule) RegisterQueryService(server grpc.Server)

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

func (AppModule) RegisterStoreDecoder Uses

func (AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry)

RegisterStoreDecoder doesn't register any type.

func (AppModule) Route Uses

func (AppModule) Route() sdk.Route

func (AppModule) WeightedOperations Uses

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

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

type AppModuleBasic Uses

type AppModuleBasic struct{}

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

func (AppModuleBasic) DefaultGenesis Uses

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

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

func (AppModuleBasic) GetQueryCmd Uses

func (AppModuleBasic) GetQueryCmd() *cobra.Command

GetQueryCmd returns no root query command for the params module.

func (AppModuleBasic) GetTxCmd Uses

func (AppModuleBasic) GetTxCmd() *cobra.Command

GetTxCmd returns no root tx command for the params module.

func (AppModuleBasic) Name Uses

func (AppModuleBasic) Name() string

Name returns the params module's name.

func (AppModuleBasic) RegisterCodec Uses

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

RegisterCodec registers the params module's types for the given codec.

func (AppModuleBasic) RegisterInterfaces Uses

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

func (AppModuleBasic) RegisterRESTRoutes Uses

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

RegisterRESTRoutes registers the REST routes for the params module.

func (AppModuleBasic) ValidateGenesis Uses

func (AppModuleBasic) ValidateGenesis(_ codec.JSONMarshaler, config client.TxEncodingConfig, _ json.RawMessage) error

ValidateGenesis performs genesis state validation for the params module.

Directories

PathSynopsis
client
client/cli
client/rest
client/utils
keeper
simulation
typesTo prevent namespace collision between consumer modules, we define a type Subspace.
types/proposal

Package params imports 20 packages (graph) and is imported by 91 packages. Updated 2020-08-13. Refresh now. Tools for package owners.