import "github.com/cosmos/cosmos-sdk/types/module"
Package module contains application module patterns and associated "manager" functionality. The module pattern has been broken down by:
- independent module functionality (AppModuleBasic) - inter-dependent module genesis functionality (AppModuleGenesis) - inter-dependent module simulation functionality (AppModuleSimulation) - inter-dependent module full functionality (AppModule)
inter-dependent module functionality is module functionality which somehow depends on other modules, typically through the module keeper. Many of the module keepers are dependent on each other, thus in order to access the full set of module functionality we need to define all the keepers/params-store/keys etc. This full set of advanced functionality is defined by the AppModule interface.
Independent module functions are separated to allow for the construction of the basic application structures required early on in the application definition and used to enable the definition of full module functionality later in the process. This separation is necessary, however we still want to allow for a high level pattern for modules to follow - for instance, such that we don't have to manually register all of the codecs for all the modules. This basic procedure as well as other basic patterns are handled through the use of BasicManager.
Lastly the interface for genesis functionality (AppModuleGenesis) has been separated out from full module functionality (AppModule) so that modules which are only used for genesis can take advantage of the Module patterns without needlessly defining many placeholder functions
configurator.go module.go simulation.go
type AppModule interface {
AppModuleGenesis
// registers
RegisterInvariants(sdk.InvariantRegistry)
// Deprecated: use RegisterServices
Route() sdk.Route
// Deprecated: use RegisterServices
QuerierRoute() string
// Deprecated: use RegisterServices
LegacyQuerierHandler(*codec.LegacyAmino) sdk.Querier
// RegisterServices allows a module to register services
RegisterServices(Configurator)
// ABCI
BeginBlock(sdk.Context, abci.RequestBeginBlock)
EndBlock(sdk.Context, abci.RequestEndBlock) []abci.ValidatorUpdate
}AppModule is the standard form for an application module
func NewGenesisOnlyAppModule(amg AppModuleGenesis) AppModule
NewGenesisOnlyAppModule creates a new GenesisOnlyAppModule object
type AppModuleBasic interface {
Name() string
RegisterLegacyAminoCodec(*codec.LegacyAmino)
RegisterInterfaces(codectypes.InterfaceRegistry)
DefaultGenesis(codec.JSONMarshaler) json.RawMessage
ValidateGenesis(codec.JSONMarshaler, client.TxEncodingConfig, json.RawMessage) error
// client functionality
RegisterRESTRoutes(client.Context, *mux.Router)
RegisterGRPCGatewayRoutes(client.Context, *runtime.ServeMux)
GetTxCmd() *cobra.Command
GetQueryCmd() *cobra.Command
}AppModuleBasic is the standard form for basic non-dependant elements of an application module.
type AppModuleGenesis interface {
AppModuleBasic
InitGenesis(sdk.Context, codec.JSONMarshaler, json.RawMessage) []abci.ValidatorUpdate
ExportGenesis(sdk.Context, codec.JSONMarshaler) json.RawMessage
}AppModuleGenesis is the standard form for an application module genesis functions
type AppModuleSimulation interface {
// randomized genesis states
GenerateGenesisState(input *SimulationState)
// content functions used to simulate governance proposals
ProposalContents(simState SimulationState) []simulation.WeightedProposalContent
// randomized module parameters for param change proposals
RandomizedParams(r *rand.Rand) []simulation.ParamChange
// register a func to decode the each module's defined types from their corresponding store key
RegisterStoreDecoder(sdk.StoreDecoderRegistry)
// simulation operations (i.e msgs) with their respective weight
WeightedOperations(simState SimulationState) []simulation.WeightedOperation
}AppModuleSimulation defines the standard functions that every module should expose for the SDK blockchain simulator
type BasicManager map[string]AppModuleBasic
BasicManager is a collection of AppModuleBasic
func NewBasicManager(modules ...AppModuleBasic) BasicManager
NewBasicManager creates a new BasicManager object
func (bm BasicManager) AddQueryCommands(rootQueryCmd *cobra.Command)
AddQueryCommands adds all query commands to the rootQueryCmd.
TODO: Remove clientCtx argument. REF: https://github.com/cosmos/cosmos-sdk/issues/6571
func (bm BasicManager) AddTxCommands(rootTxCmd *cobra.Command)
AddTxCommands adds all tx commands to the rootTxCmd.
TODO: Remove clientCtx argument. REF: https://github.com/cosmos/cosmos-sdk/issues/6571
func (bm BasicManager) DefaultGenesis(cdc codec.JSONMarshaler) map[string]json.RawMessage
DefaultGenesis provides default genesis information for all modules
RegisterGRPCGatewayRoutes registers all module rest routes
func (bm BasicManager) RegisterInterfaces(registry codectypes.InterfaceRegistry)
RegisterInterfaces registers all module interface types
func (bm BasicManager) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino)
RegisterLegacyAminoCodec registers all module codecs
RegisterRESTRoutes registers all module rest routes
func (bm BasicManager) ValidateGenesis(cdc codec.JSONMarshaler, txEncCfg client.TxEncodingConfig, genesis map[string]json.RawMessage) error
ValidateGenesis performs genesis state validation for all modules
type Configurator interface {
// MsgServer returns a grpc.Server instance which allows registering services
// that will handle TxBody.messages in transactions. These Msg's WILL NOT
// be exposed as gRPC services.
MsgServer() grpc.Server
// QueryServer returns a grpc.Server instance which allows registering services
// that will be exposed as gRPC services as well as ABCI query handlers.
QueryServer() grpc.Server
}Configurator provides the hooks to allow modules to configure and register their services in the RegisterServices method. It is designed to eventually support module object capabilities isolation as described in https://github.com/cosmos/cosmos-sdk/issues/7093
NewConfigurator returns a new Configurator instance
type GenesisOnlyAppModule struct {
AppModuleGenesis
}GenesisOnlyAppModule is an AppModule that only has import/export functionality
func (gam GenesisOnlyAppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock)
BeginBlock returns an empty module begin-block
func (GenesisOnlyAppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate
EndBlock returns an empty module end-block
func (gam GenesisOnlyAppModule) LegacyQuerierHandler(*codec.LegacyAmino) sdk.Querier
LegacyQuerierHandler returns an empty module querier
func (GenesisOnlyAppModule) QuerierRoute() string
QuerierRoute returns an empty module querier route
func (GenesisOnlyAppModule) RegisterInvariants(_ sdk.InvariantRegistry)
RegisterInvariants is a placeholder function register no invariants
func (gam GenesisOnlyAppModule) RegisterServices(Configurator)
RegisterServices registers all services.
func (GenesisOnlyAppModule) Route() sdk.Route
Route empty module message route
type Manager struct {
Modules map[string]AppModule
OrderInitGenesis []string
OrderExportGenesis []string
OrderBeginBlockers []string
OrderEndBlockers []string
}Manager defines a module manager that provides the high level utility for managing and executing operations for a group of modules
NewManager creates a new Manager object
func (m *Manager) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) abci.ResponseBeginBlock
BeginBlock performs begin block functionality for all modules. It creates a child context with an event manager to aggregate events emitted from all modules.
func (m *Manager) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) abci.ResponseEndBlock
EndBlock performs end block functionality for all modules. It creates a child context with an event manager to aggregate events emitted from all modules.
func (m *Manager) ExportGenesis(ctx sdk.Context, cdc codec.JSONMarshaler) map[string]json.RawMessage
ExportGenesis performs export genesis functionality for modules
func (m *Manager) InitGenesis(ctx sdk.Context, cdc codec.JSONMarshaler, genesisData map[string]json.RawMessage) abci.ResponseInitChain
InitGenesis performs init genesis functionality for modules
func (m *Manager) RegisterInvariants(ir sdk.InvariantRegistry)
RegisterInvariants registers all module routes and module querier routes
func (m *Manager) RegisterRoutes(router sdk.Router, queryRouter sdk.QueryRouter, legacyQuerierCdc *codec.LegacyAmino)
RegisterRoutes registers all module routes and module querier routes
func (m *Manager) RegisterServices(cfg Configurator)
RegisterServices registers all module services
SetOrderBeginBlockers sets the order of set begin-blocker calls
SetOrderEndBlockers sets the order of set end-blocker calls
SetOrderExportGenesis sets the order of export genesis calls
SetOrderInitGenesis sets the order of init genesis calls
type SimulationManager struct {
Modules []AppModuleSimulation // array of app modules; we use an array for deterministic simulation tests
StoreDecoders sdk.StoreDecoderRegistry // functions to decode the key-value pairs from each module's store
}SimulationManager defines a simulation manager that provides the high level utility for managing and executing simulation functionalities for a group of modules
func NewSimulationManager(modules ...AppModuleSimulation) *SimulationManager
NewSimulationManager creates a new SimulationManager object
CONTRACT: All the modules provided must be also registered on the module Manager
func (sm *SimulationManager) GenerateGenesisStates(simState *SimulationState)
GenerateGenesisStates generates a randomized GenesisState for each of the registered modules
func (sm *SimulationManager) GenerateParamChanges(seed int64) (paramChanges []simulation.ParamChange)
GenerateParamChanges generates randomized contents for creating params change proposal transactions
func (sm *SimulationManager) GetProposalContents(simState SimulationState) []simulation.WeightedProposalContent
GetProposalContents returns each module's proposal content generator function with their default operation weight and key.
func (sm *SimulationManager) RegisterStoreDecoders()
RegisterStoreDecoders registers each of the modules' store decoders into a map
func (sm *SimulationManager) WeightedOperations(simState SimulationState) []simulation.WeightedOperation
WeightedOperations returns all the modules' weighted operations of an application
type SimulationState struct {
AppParams simulation.AppParams
Cdc codec.JSONMarshaler // application codec
Rand *rand.Rand // random number
GenState map[string]json.RawMessage // genesis state
Accounts []simulation.Account // simulation accounts
InitialStake int64 // initial coins per account
NumBonded int64 // number of initially bonded accounts
GenTimestamp time.Time // genesis timestamp
UnbondTime time.Duration // staking unbond time stored to use it as the slashing maximum evidence duration
ParamChanges []simulation.ParamChange // simulated parameter changes from modules
Contents []simulation.WeightedProposalContent // proposal content generator functions with their default weight and app sim key
}SimulationState is the input parameters used on each of the module's randomized GenesisState generator function
Package module imports 13 packages (graph) and is imported by 274 packages. Updated 2020-11-18. Refresh now. Tools for package owners.