params

package
v0.1.3 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 25, 2021 License: Apache-2.0 Imports: 16 Imported by: 5

Documentation

Overview

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

Constants

View Source
const (
	StoreKey           = subspace.StoreKey
	TStoreKey          = subspace.TStoreKey
	ModuleName         = types.ModuleName
	RouterKey          = types.RouterKey
	ProposalTypeChange = types.ProposalTypeChange
)

Variables

View Source
var (
	// functions aliases
	NewParamSetPair            = subspace.NewParamSetPair
	NewSubspace                = subspace.NewSubspace
	NewKeyTable                = subspace.NewKeyTable
	RegisterCodec              = types.RegisterCodec
	ErrUnknownSubspace         = types.ErrUnknownSubspace
	ErrSettingParameter        = types.ErrSettingParameter
	ErrEmptyChanges            = types.ErrEmptyChanges
	ErrEmptySubspace           = types.ErrEmptySubspace
	ErrEmptyKey                = types.ErrEmptyKey
	ErrEmptyValue              = types.ErrEmptyValue
	NewParameterChangeProposal = types.NewParameterChangeProposal
	NewParamChange             = types.NewParamChange
	ValidateChanges            = types.ValidateChanges

	// variable aliases
	ModuleCdc = types.ModuleCdc
)

Functions

func NewParamChangeProposalHandler

func NewParamChangeProposalHandler(k Keeper) govtypes.Handler

NewParamChangeProposalHandler creates a new governance Handler for a ParamChangeProposal

Types

type AppModule

type AppModule struct {
	AppModuleBasic
}

AppModule implements an application module for the distribution module.

func NewAppModule

func NewAppModule() AppModule

NewAppModule creates a new AppModule object

func (AppModule) GenerateGenesisState

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

GenerateGenesisState performs a no-op.

func (AppModule) ProposalContents

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

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

func (AppModule) RandomizedParams

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

RandomizedParams creates randomized distribution param changes for the simulator.

func (AppModule) RegisterStoreDecoder

func (AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry)

RegisterStoreDecoder doesn't register any type.

func (AppModule) WeightedOperations

func (am AppModule) WeightedOperations(_ module.SimulationState) []sim.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() json.RawMessage

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

func (AppModuleBasic) GetQueryCmd

func (AppModuleBasic) GetQueryCmd(_ *codec.Codec) *cobra.Command

GetQueryCmd returns no root query command for the params module.

func (AppModuleBasic) GetTxCmd

func (AppModuleBasic) GetTxCmd(_ *codec.Codec) *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) RegisterCodec

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

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

func (AppModuleBasic) RegisterRESTRoutes

func (AppModuleBasic) RegisterRESTRoutes(_ context.CLIContext, _ *mux.Router)

RegisterRESTRoutes registers the REST routes for the params module.

func (AppModuleBasic) ValidateGenesis

func (AppModuleBasic) ValidateGenesis(_ json.RawMessage) error

ValidateGenesis performs genesis state validation for the params module.

type Keeper

type Keeper struct {
	// contains filtered or unexported fields
}

Keeper of the global paramstore

func NewKeeper

func NewKeeper(cdc *codec.Codec, key, tkey sdk.StoreKey) Keeper

NewKeeper constructs a params keeper

func (Keeper) GetSubspace added in v0.1.3

func (k Keeper) GetSubspace(s string) (Subspace, bool)

Get existing substore from keeper

func (Keeper) Logger added in v0.1.3

func (k Keeper) Logger(ctx sdk.Context) log.Logger

Logger returns a module-specific logger.

func (Keeper) Subspace added in v0.1.3

func (k Keeper) Subspace(s string) Subspace

Allocate subspace used for keepers

type KeyTable

type KeyTable = subspace.KeyTable

type ParamChange added in v0.1.3

type ParamChange = types.ParamChange

type ParamSet

type ParamSet = subspace.ParamSet

type ParamSetPair

type ParamSetPair = subspace.ParamSetPair

type ParamSetPairs

type ParamSetPairs = subspace.ParamSetPairs

type ParameterChangeProposal added in v0.1.3

type ParameterChangeProposal = types.ParameterChangeProposal

type ReadOnlySubspace

type ReadOnlySubspace = subspace.ReadOnlySubspace

type Subspace

type Subspace = subspace.Subspace

Directories

Path Synopsis
cli
To prevent namespace collision between consumer modules, we define a type Subspace.
To prevent namespace collision between consumer modules, we define a type Subspace.
To prevent namespace collision between consumer modules, we define a type Subspace.
To prevent namespace collision between consumer modules, we define a type Subspace.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL