cosmos-sdk: Index | Files

package module

import ""

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


Package Files

configurator.go module.go simulation.go

type AppModule Uses

type AppModule interface {

    // registers

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

    // ABCI
    BeginBlock(sdk.Context, abci.RequestBeginBlock)
    EndBlock(sdk.Context, abci.RequestEndBlock) []abci.ValidatorUpdate

AppModule is the standard form for an application module

func NewGenesisOnlyAppModule Uses

func NewGenesisOnlyAppModule(amg AppModuleGenesis) AppModule

NewGenesisOnlyAppModule creates a new GenesisOnlyAppModule object

type AppModuleBasic Uses

type AppModuleBasic interface {
    Name() string

    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 Uses

type AppModuleGenesis interface {

    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 Uses

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

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

type BasicManager map[string]AppModuleBasic

BasicManager is a collection of AppModuleBasic

func NewBasicManager Uses

func NewBasicManager(modules ...AppModuleBasic) BasicManager

NewBasicManager creates a new BasicManager object

func (BasicManager) AddQueryCommands Uses

func (bm BasicManager) AddQueryCommands(rootQueryCmd *cobra.Command)

AddQueryCommands adds all query commands to the rootQueryCmd.

TODO: Remove clientCtx argument. REF:

func (BasicManager) AddTxCommands Uses

func (bm BasicManager) AddTxCommands(rootTxCmd *cobra.Command)

AddTxCommands adds all tx commands to the rootTxCmd.

TODO: Remove clientCtx argument. REF:

func (BasicManager) DefaultGenesis Uses

func (bm BasicManager) DefaultGenesis(cdc codec.JSONMarshaler) map[string]json.RawMessage

DefaultGenesis provides default genesis information for all modules

func (BasicManager) RegisterGRPCGatewayRoutes Uses

func (bm BasicManager) RegisterGRPCGatewayRoutes(clientCtx client.Context, rtr *runtime.ServeMux)

RegisterGRPCGatewayRoutes registers all module rest routes

func (BasicManager) RegisterInterfaces Uses

func (bm BasicManager) RegisterInterfaces(registry codectypes.InterfaceRegistry)

RegisterInterfaces registers all module interface types

func (BasicManager) RegisterLegacyAminoCodec Uses

func (bm BasicManager) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino)

RegisterLegacyAminoCodec registers all module codecs

func (BasicManager) RegisterRESTRoutes Uses

func (bm BasicManager) RegisterRESTRoutes(clientCtx client.Context, rtr *mux.Router)

RegisterRESTRoutes registers all module rest routes

func (BasicManager) ValidateGenesis Uses

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 Uses

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

func NewConfigurator Uses

func NewConfigurator(msgServer grpc.Server, queryServer grpc.Server) Configurator

NewConfigurator returns a new Configurator instance

type GenesisOnlyAppModule Uses

type GenesisOnlyAppModule struct {

GenesisOnlyAppModule is an AppModule that only has import/export functionality

func (GenesisOnlyAppModule) BeginBlock Uses

func (gam GenesisOnlyAppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock)

BeginBlock returns an empty module begin-block

func (GenesisOnlyAppModule) EndBlock Uses

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

EndBlock returns an empty module end-block

func (GenesisOnlyAppModule) LegacyQuerierHandler Uses

func (gam GenesisOnlyAppModule) LegacyQuerierHandler(*codec.LegacyAmino) sdk.Querier

LegacyQuerierHandler returns an empty module querier

func (GenesisOnlyAppModule) QuerierRoute Uses

func (GenesisOnlyAppModule) QuerierRoute() string

QuerierRoute returns an empty module querier route

func (GenesisOnlyAppModule) RegisterInvariants Uses

func (GenesisOnlyAppModule) RegisterInvariants(_ sdk.InvariantRegistry)

RegisterInvariants is a placeholder function register no invariants

func (GenesisOnlyAppModule) RegisterServices Uses

func (gam GenesisOnlyAppModule) RegisterServices(Configurator)

RegisterServices registers all services.

func (GenesisOnlyAppModule) Route Uses

func (GenesisOnlyAppModule) Route() sdk.Route

Route empty module message route

type Manager Uses

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

func NewManager Uses

func NewManager(modules ...AppModule) *Manager

NewManager creates a new Manager object

func (*Manager) BeginBlock Uses

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 (*Manager) EndBlock Uses

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 (*Manager) ExportGenesis Uses

func (m *Manager) ExportGenesis(ctx sdk.Context, cdc codec.JSONMarshaler) map[string]json.RawMessage

ExportGenesis performs export genesis functionality for modules

func (*Manager) InitGenesis Uses

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 (*Manager) RegisterInvariants Uses

func (m *Manager) RegisterInvariants(ir sdk.InvariantRegistry)

RegisterInvariants registers all module routes and module querier routes

func (*Manager) RegisterRoutes Uses

func (m *Manager) RegisterRoutes(router sdk.Router, queryRouter sdk.QueryRouter, legacyQuerierCdc *codec.LegacyAmino)

RegisterRoutes registers all module routes and module querier routes

func (*Manager) RegisterServices Uses

func (m *Manager) RegisterServices(cfg Configurator)

RegisterServices registers all module services

func (*Manager) SetOrderBeginBlockers Uses

func (m *Manager) SetOrderBeginBlockers(moduleNames ...string)

SetOrderBeginBlockers sets the order of set begin-blocker calls

func (*Manager) SetOrderEndBlockers Uses

func (m *Manager) SetOrderEndBlockers(moduleNames ...string)

SetOrderEndBlockers sets the order of set end-blocker calls

func (*Manager) SetOrderExportGenesis Uses

func (m *Manager) SetOrderExportGenesis(moduleNames ...string)

SetOrderExportGenesis sets the order of export genesis calls

func (*Manager) SetOrderInitGenesis Uses

func (m *Manager) SetOrderInitGenesis(moduleNames ...string)

SetOrderInitGenesis sets the order of init genesis calls

type SimulationManager Uses

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 Uses

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 (*SimulationManager) GenerateGenesisStates Uses

func (sm *SimulationManager) GenerateGenesisStates(simState *SimulationState)

GenerateGenesisStates generates a randomized GenesisState for each of the registered modules

func (*SimulationManager) GenerateParamChanges Uses

func (sm *SimulationManager) GenerateParamChanges(seed int64) (paramChanges []simulation.ParamChange)

GenerateParamChanges generates randomized contents for creating params change proposal transactions

func (*SimulationManager) GetProposalContents Uses

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 (*SimulationManager) RegisterStoreDecoders Uses

func (sm *SimulationManager) RegisterStoreDecoders()

RegisterStoreDecoders registers each of the modules' store decoders into a map

func (*SimulationManager) WeightedOperations Uses

func (sm *SimulationManager) WeightedOperations(simState SimulationState) []simulation.WeightedOperation

WeightedOperations returns all the modules' weighted operations of an application

type SimulationState Uses

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.