Synopsis
This document describes the core parts of a Cosmos SDK application, represented throughout the document as a placeholder application namedapp.
Node Client
The Daemon, or Full-Node Client, is the core process of a Cosmos SDK-based blockchain. Participants in the network run this process to initialize their state-machine, connect with other full-nodes, and update their state-machine as new blocks come in.-d for “daemon” (e.g. appd for app or gaiad for gaia). This binary is built by running a simple main.go function placed in ./cmd/appd/. This operation usually happens through the Makefile.
Once the main binary is built, the node can be started by running the start command. This command function primarily does three things:
- Create an instance of the state-machine defined in
app.go. - Initialize the state-machine with the latest known state, extracted from the
dbstored in the~/.app/datafolder. At this point, the state-machine is at heightappBlockHeight. - Create and start a new CometBFT instance. Among other things, the node performs a handshake with its peers. It gets the latest
blockHeightfrom them and replays blocks to sync to this height if it is greater than the localappBlockHeight. The node starts from genesis and CometBFT sends anInitChainmessage via the ABCI to theapp, which triggers theInitChainer.
When starting a CometBFT instance, the genesis file is the
0 height and the
state within the genesis file is committed at block height 1. When querying
the state of the node, querying block height 0 will return an error.Core Application File
In general, the core of the state-machine is defined in a file calledapp.go. This file mainly contains the type definition of the application and functions to create and initialize it.
Type Definition of the Application
The first thing defined inapp.go is the type of the application. It is generally comprised of the following parts:
- Embeding runtime.App The runtime package manages the application’s core components and modules through dependency injection. It provides declarative configuration for module management, state storage, and ABCI handling.
RuntimewrapsBaseApp, meaning when a transaction is relayed by CometBFT to the application,appusesruntime’s methods to route them to the appropriate module.BaseAppimplements all the ABCI methods and the routing logic.- It automatically configures the module manager based on the app wiring configuration. The module manager facilitates operations related to these modules, like registering their
Msgservice and gRPCQueryservice, or setting the order of execution between modules for various functions likeInitChainer,PreBlockerandBeginBlockerandEndBlocker.
- An App Wiring configuration file The app wiring configuration file contains the list of application’s modules that
runtimemust instantiate. The instantiation of the modules are done usingdepinject. It also contains the order in which all module’sInitGenesisandPre/Begin/EndBlockermethods should be executed. - A reference to an
appCodec. The application’sappCodecis used to serialize and deserialize data structures in order to store them, as stores can only persist[]bytes. The default codec is Protocol Buffers. - A reference to a
legacyAminocodec. Some parts of the Cosmos SDK have not been migrated to use theappCodecabove, and are still hardcoded to use Amino. Other parts explicitly use Amino for backwards compatibility. For these reasons, the application still holds a reference to the legacy Amino codec. Please note that the Amino codec will be removed from the SDK in the upcoming releases.
simapp, the Cosmos SDK’s own app used for demo and testing purposes:
Constructor Function
Also defined inapp.go is the constructor function, which constructs a new application of the type defined in the preceding section. The function must fulfill the AppCreator signature in order to be used in the start command of the application’s daemon command.
- Instantiate a new
codecand initialize thecodecof each of the application’s modules using the basic manager. - Instantiate a new application with a reference to a
baseappinstance, a codec, and all the appropriate store keys. - Instantiate all the
keeperobjects defined in the application’stypeusing theNewKeeperfunction of each of the application’s modules. Note that keepers must be instantiated in the correct order, as theNewKeeperof one module might require a reference to another module’skeeper. - Instantiate the application’s module manager with the
AppModuleobject of each of the application’s modules. - With the module manager, initialize the application’s
Msgservices, gRPCQueryservices, legacyMsgroutes, and legacy query routes. When a transaction is relayed to the application by CometBFT via the ABCI, it is routed to the appropriate module’sMsgservice using the routes defined here. Likewise, when a gRPC query request is received by the application, it is routed to the appropriate module’sgRPC query serviceusing the gRPC routes defined here. The Cosmos SDK still supports legacyMsgs and legacy CometBFT queries, which are routed using the legacyMsgroutes and the legacy query routes, respectively. - With the module manager, register the application’s modules’ invariants. Invariants are variables (e.g. total supply of a token) that are evaluated at the end of each block. The process of checking invariants is done via a special module called the
InvariantsRegistry. The value of the invariant should be equal to a predicted value defined in the module. Should the value be different than the predicted one, special logic defined in the invariant registry is triggered (usually the chain is halted). This is useful to make sure that no critical bug goes unnoticed, producing long-lasting effects that are hard to fix. - With the module manager, set the order of execution between the
InitGenesis,PreBlocker,BeginBlocker, andEndBlockerfunctions of each of the application’s modules. Note that not all modules implement these functions. - Set the remaining application parameters:
InitChainer: used to initialize the application when it is first started.PreBlocker: called before BeginBlock.BeginBlocker,EndBlocker: called at the beginning and at the end of every block.anteHandler: used to handle fees and signature verification.
- Mount the stores.
- Return the application.
~/.app/data folder if the node is restarted, or generated from the genesis file if the node is started for the first time.
See an example of application constructor from simapp:
InitChainer
TheInitChainer is a function that initializes the state of the application from a genesis file (i.e. token balances of genesis accounts). It is called when the application receives the InitChain message from the CometBFT engine, which happens when the node is started at appBlockHeight == 0 (i.e. on genesis). The application must set the InitChainer in its constructor via the SetInitChainer method.
In general, the InitChainer is mostly composed of the InitGenesis function of each of the application’s modules. This is done by calling the InitGenesis function of the module manager, which in turn calls the InitGenesis function of each of the modules it contains. Note that the order in which the modules’ InitGenesis functions must be called has to be set in the module manager using the module manager’s SetOrderInitGenesis method. This is done in the application’s constructor, and the SetOrderInitGenesis has to be called before the SetInitChainer.
See an example of an InitChainer from simapp:
PreBlocker
There are two semantics around the new lifecycle method:- It runs before the
BeginBlockerof all modules - It can modify consensus parameters in storage, and signal the caller through the return value.
ConsensusParamsChanged=true, the caller must refresh the consensus parameter in the finalize context:
BeginBlocker and EndBlocker
The Cosmos SDK offers developers the possibility to implement automatic execution of code as part of their application. This is implemented through two functions calledBeginBlocker and EndBlocker. They are called when the application receives the FinalizeBlock messages from the CometBFT consensus engine, which happens respectively at the beginning and at the end of each block. The application must set the BeginBlocker and EndBlocker in its constructor via the SetBeginBlocker and SetEndBlocker methods.
In general, the BeginBlocker and EndBlocker functions are mostly composed of the BeginBlock and EndBlock functions of each of the application’s modules. This is done by calling the BeginBlock and EndBlock functions of the module manager, which in turn calls the BeginBlock and EndBlock functions of each of the modules it contains. Note that the order in which the modules’ BeginBlock and EndBlock functions must be called has to be set in the module manager using the SetOrderBeginBlockers and SetOrderEndBlockers methods, respectively. This is done via the module manager in the application’s constructor, and the SetOrderBeginBlockers and SetOrderEndBlockers methods have to be called before the SetBeginBlocker and SetEndBlocker functions.
As a sidenote, it is important to remember that application-specific blockchains are deterministic. Developers must be careful not to introduce non-determinism in BeginBlocker or EndBlocker, and must also be careful not to make them too computationally expensive, as gas does not constrain the cost of BeginBlocker and EndBlocker execution.
See an example of BeginBlocker and EndBlocker functions from simapp
Register Codec
TheEncodingConfig structure is the last important part of the app.go file. The goal of this structure is to define the codecs that will be used throughout the app.
InterfaceRegistry: TheInterfaceRegistryis used by the Protobuf codec to handle interfaces that are encoded and decoded (we also say “unpacked”) usinggoogle.protobuf.Any.Anycould be thought as a struct that contains atype_url(name of a concrete type implementing the interface) and avalue(its encoded bytes).InterfaceRegistryprovides a mechanism for registering interfaces and implementations that can be safely unpacked fromAny. Each application module implements theRegisterInterfacesmethod that can be used to register the module’s own interfaces and implementations.- You can read more about
Anyin ADR-019. - To go more into details, the Cosmos SDK uses an implementation of the Protobuf specification called
gogoprotobuf. By default, the gogo protobuf implementation ofAnyuses global type registration to decode values packed inAnyinto concrete Go types. This introduces a vulnerability where any malicious module in the dependency tree could register a type with the global protobuf registry and cause it to be loaded and unmarshaled by a transaction that referenced it in thetype_urlfield. For more information, please refer to ADR-019.
- You can read more about
Codec: The default codec used throughout the Cosmos SDK. It is composed of aBinaryCodecused to encode and decode state, and aJSONCodecused to output data to the users (for example, in the CLI). By default, the SDK uses Protobuf asCodec.TxConfig:TxConfigdefines an interface a client can utilize to generate an application-defined concrete transaction type. Currently, the SDK handles two transaction types:SIGN_MODE_DIRECT(which uses Protobuf binary as over-the-wire encoding) andSIGN_MODE_LEGACY_AMINO_JSON(which depends on Amino). Read more about transactions here.Amino: Some legacy parts of the Cosmos SDK still use Amino for backwards-compatibility. Each module exposes aRegisterLegacyAminomethod to register the module’s specific types within Amino. ThisAminocodec should not be used by app developers anymore, and will be removed in future releases.
simappparams.EncodingConfig from simapp:
Modules
Modules are the heart and soul of Cosmos SDK applications. They can be considered as state-machines nested within the state-machine. When a transaction is relayed from the underlying CometBFT engine via the ABCI to the application, it is routed bybaseapp to the appropriate module in order to be processed. This paradigm enables developers to easily build complex state-machines, as most of the modules they need often already exist. For developers, most of the work involved in building a Cosmos SDK application revolves around building custom modules required by their application that do not exist yet, and integrating them with modules that do already exist into one coherent application. In the application directory, the standard practice is to store modules in the x/ folder (not to be confused with the Cosmos SDK’s x/ folder, which contains already-built modules).
Application Module Interface
Modules must implement interfaces defined in the Cosmos SDK,AppModuleBasic and AppModule. The former implements basic non-dependent elements of the module, such as the codec, while the latter handles the bulk of the module methods (including methods that require references to other modules’ keepers). Both the AppModule and AppModuleBasic types are, by convention, defined in a file called module.go.
AppModule exposes a collection of useful methods on the module that facilitates the composition of modules into a coherent application. These methods are called from the module manager, which manages the application’s collection of modules.
Msg Services
Each application module defines two Protobuf services: one Msg service to handle messages, and one gRPC Query service to handle queries. If we consider the module as a state-machine, then a Msg service is a set of state transition RPC methods.
Each Protobuf Msg service method is 1:1 related to a Protobuf request type, which must implement sdk.Msg interface.
Note that sdk.Msgs are bundled in transactions, and each transaction contains one or multiple messages.
When a valid block of transactions is received by the full-node, CometBFT relays each one to the application via DeliverTx. Then, the application handles the transaction:
- Upon receiving the transaction, the application first unmarshalls it from
[]byte. - Then, it verifies a few things about the transaction like fee payment and signatures before extracting the
Msg(s) contained in the transaction. sdk.Msgs are encoded using ProtobufAnys. By analyzing eachAny’stype_url, baseapp’smsgServiceRouterroutes thesdk.Msgto the corresponding module’sMsgservice.- If the message is successfully processed, the state is updated.
Msg services when they build their own module. The general practice is to define the Msg Protobuf service in a tx.proto file. For example, the x/bank module defines a service with two methods to transfer tokens:
keeper in order to update the module state.
Each module should also implement the RegisterServices method as part of the AppModule interface. This method should call the RegisterMsgServer function provided by the generated Protobuf code.
gRPC Query Services
gRPC Query services allow users to query the state using gRPC. They are enabled by default, and can be configured under the grpc.enable and grpc.address fields inside app.toml.
gRPC Query services are defined in the module’s Protobuf definition files, specifically inside query.proto. The query.proto definition file exposes a single Query Protobuf service. Each gRPC query endpoint corresponds to a service method, starting with the rpc keyword, inside the Query service.
Protobuf generates a QueryServer interface for each module, containing all the service methods. A module’s keeper then needs to implement this QueryServer interface, by providing the concrete implementation of each service method. This concrete implementation is the handler of the corresponding gRPC query endpoint.
Finally, each module should also implement the RegisterServices method as part of the AppModule interface. This method should call the RegisterQueryServer function provided by the generated Protobuf code.
Keeper
Keepers are the gatekeepers of their module’s store(s). To read or write in a module’s store, it is mandatory to go through one of its keeper’s methods. This is ensured by the object-capabilities model of the Cosmos SDK. Only objects that hold the key to a store can access it, and only the module’s keeper should hold the key(s) to the module’s store(s).
Keepers are generally defined in a file called keeper.go. It contains the keeper’s type definition and methods.
The keeper type definition generally consists of the following:
- Key(s) to the module’s store(s) in the multistore.
- Reference to other module’s
keepers. Only needed if thekeeperneeds to access other module’s store(s) (either to read or write from them). - A reference to the application’s codec. The
keeperneeds it to marshal structs before storing them, or to unmarshal them when it retrieves them, because stores only accept[]bytesas value.
keeper.go file is the keeper’s constructor function, NewKeeper. This function instantiates a new keeper of the type defined above with a codec, stores keys and potentially references other modules’ keepers as parameters. The NewKeeper function is called from the application’s constructor. The rest of the file defines the keeper’s methods, which are primarily getters and setters.
Command-Line, gRPC Services and REST Interfaces
Each module defines command-line commands, gRPC services, and REST routes to be exposed to the end-user via the application’s interfaces. This enables end-users to create messages of the types defined in the module, or to query the subset of the state managed by the module.CLI
Generally, the commands related to a module are defined in a folder calledclient/cli in the module’s folder. The CLI divides commands into two categories, transactions and queries, defined in client/cli/tx.go and client/cli/query.go, respectively. Both commands are built on top of the Cobra Library:
- Transactions commands let users generate new transactions so that they can be included in a block and eventually update the state. One command should be created for each message type defined in the module. The command calls the constructor of the message with the parameters provided by the end-user, and wraps it into a transaction. The Cosmos SDK handles signing and the addition of other transaction metadata.
- Queries let users query the subset of the state defined by the module. Query commands forward queries to the application’s query router, which routes them to the appropriate querier the
queryRouteparameter supplied.
gRPC
gRPC is a modern open-source high performance RPC framework that has support in multiple languages. It is the recommended way for external clients (such as wallets, browsers and other backend services) to interact with a node. Each module can expose gRPC endpoints called service methods, which are defined in the module’s Protobufquery.proto file. A service method is defined by its name, input arguments, and output response. The module then needs to perform the following actions:
- Define a
RegisterGRPCGatewayRoutesmethod onAppModuleBasicto wire the client gRPC requests to the correct handler inside the module. - For each service method, define a corresponding handler. The handler implements the core logic necessary to serve the gRPC request, and is located in the
keeper/grpc_query.gofile.
gRPC-gateway REST Endpoints
Some external clients may not wish to use gRPC. In this case, the Cosmos SDK provides a gRPC gateway service, which exposes each gRPC service as a corresponding REST endpoint. Please refer to the grpc-gateway documentation to learn more. The REST endpoints are defined in the Protobuf files, along with the gRPC services, using Protobuf annotations. Modules that want to expose REST queries should addgoogle.api.http annotations to their rpc methods. By default, all REST endpoints defined in the SDK have a URL starting with the /cosmos/ prefix.
The Cosmos SDK also provides a development endpoint to generate Swagger definition files for these REST endpoints. This endpoint can be enabled inside the app.toml config file, under the api.swagger key.
Application Interface
Interfaces let end-users interact with full-node clients. This means querying data from the full-node or creating and sending new transactions to be relayed by the full-node and eventually included in a block. The main interface is the Command-Line Interface. The CLI of a Cosmos SDK application is built by aggregating CLI commands defined in each of the modules used by the application. The CLI of an application is the same as the daemon (e.g.appd), and is defined in a file called appd/main.go. The file contains the following:
- A
main()function, which is executed to build theappdinterface client. This function prepares each command and adds them to therootCmdbefore building them. At the root ofappd, the function adds generic commands likestatus,keys, andconfig, query commands, tx commands, andrest-server. - Query commands, which are added by calling the
queryCmdfunction. This function returns a Cobra command that contains the query commands defined in each of the application’s modules (passed as an array ofsdk.ModuleClientsfrom themain()function), as well as some other lower level query commands such as block or validator queries. Query command are called by using the commandappd query [query]of the CLI. - Transaction commands, which are added by calling the
txCmdfunction. Similar toqueryCmd, the function returns a Cobra command that contains the tx commands defined in each of the application’s modules, as well as lower level tx commands like transaction signing or broadcasting. Tx commands are called by using the commandappd tx [tx]of the CLI.
Dependencies and Makefile
This section is optional, as developers are free to choose their dependency manager and project building method. That said, the current most used framework for versioning control isgo.mod. It ensures each of the libraries used throughout the application are imported with the correct version.
The following is the go.mod of the Cosmos Hub, provided as an example.
go.mod is run before building the two entrypoints to the application, Node Client and Application Interface.
Here is an example of the Cosmos Hub Makefile.