Symbiotic Cosmos Relay SDK

https://github.com/symbioticfi/cosmos-relay-sdk
Admin
Symbiotic Cosmos Relay SDK is an example implementation demonstrating how to build relay...
Tokens:522,432
Snippets:3,601
Trust Score:7.1
License:Apache-2.0
Update:9 months ago
Show doc for...
Tokens:
Raw
### Simulation Operations Setup Example (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/build/building-modules/16-testing.md

Demonstrates how to set up simulation operations for a module, specifically the x/gov module, using a minimal application. This example highlights the use of `depinject` and `AppConfig` for configuring the simulation environment.

```Go
package slashing_test

import (
	"testing"

	"github.com/cosmos/cosmos-sdk/simapp"
	"github.com/cosmos/cosmos-sdk/simapp/config"
	"github.com/cosmos/cosmos-sdk/types/module/simulation"
)

func TestSlashingSimulation(t *testing.T) {
	// Create a new simulation app configuration
	cfg := config.NewConfig(true)

	// Use AppConfig configurator for inline configuration
	cfg.SetAppConfig(simapp.NewAppConfig(
		simapp.SetChainID("sim-1"),
		simapp.SetPruning("default"),
		simapp.SetMinGasPrices("0stake"),
		simapp.SetInterChainModules(),
		simapp.SetTxIndex(true),
		// ... other configurations ...
	))

	// Run the simulation
	ssimulation.Simulate(t,
		slashingsimulation.AppModuleBasic{},
		simapp.NewSimApp(cfg),
		cfg.GetAppConfig(),
		simulation.DefaultParams(),
		// ... other simulation parameters ...
	)
}

```

--------------------------------

### Write a Basic System Test in Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

An example of a basic Go system test file. It includes the necessary build tag, package declaration, import statements, and a test function that initializes the chain, queries the bank module's total supply, and logs the raw response.

```go
//go:build system_test

package systemtests

import (
	"testing"
)

func TestQueryTotalSupply(t *testing.T) {
	sut.ResetChain(t)
	sut.StartChain(t)

	cli := NewCLIWrapper(t, sut, verbose)
	raw := cli.CustomQuery("q", "bank", "total-supply")
	t.Log("### got: " + raw)
}

```

--------------------------------

### Integration Test Setup Helper (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/build/building-modules/16-testing.md

Provides helper functions for setting up integration tests within the Cosmos SDK. These helpers simplify the process of creating test environments where modules interact without mocked dependencies.

```Go
package integration_test

import (
	"testing"

	"github.com/cosmos/cosmos-sdk/testutil/integration"
	"github.com/cosmos/cosmos-sdk/testutil/network"
)

func TestIntegrationExample(t *testing.T) {
	// Create a new network configuration for integration tests
	cfg := network.DefaultConfig()
	// ... configure the network as needed ...

	// Build the test network
	net := integration.NewTestNetwork(t, cfg)
	defer net.Cleanup()

	// Perform integration tests using the test network
	// ... interact with modules, assert results ...
}

```

--------------------------------

### Example Integration Test Case (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/build/building-modules/16-testing.md

A practical example of an integration test in the Cosmos SDK. This snippet demonstrates how to use the `testutil/integration` helpers to set up a test environment and interact with module services.

```Go
package integration_test

import (
	"testing"

	"github.com/cosmos/cosmos-sdk/testutil/integration"
	"github.com/cosmos/cosmos-sdk/testutil/network"
	"github.com/cosmos/cosmos-sdk/x/bank/types"
	"github.com/stretchr/testify/require"
)

func TestSendCoinsIntegration(t *testing.T) {
	cfg := network.DefaultConfig()
	net := integration.NewTestNetwork(t, cfg)
	defer net.Cleanup()

	// Get client context
	clientCtx := net.Validators[0].ClientCtx

	// Create a MsgSend transaction
	fromAddr := net.Validators[0].Address
	toAddr := net.Validators[1].Address
	coins := "100stake"
	msg := types.NewMsgSend(fromAddr, toAddr, sdk.NewCoins(sdk.MustParseCoinsNormalized(coins)))

	// Broadcast the transaction and assert success
	_, err := integration.BroadcastTx(clientCtx, net.TxConfig, msg)
	require.NoError(t, err)

	// Verify the state changes
	// ... query balances and assert ...
}

```

--------------------------------

### Golang Pseudocode Algorithm Example

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/spec/SPEC_STANDARD.md

An example of how to represent an algorithm using Golang functions for pseudocode. This demonstrates a simple get function for a cache, including conditional logic.

```go
func get(
  store CacheKVStore,
  key Key) Value {

  value = store.cache.get(Key)
  if (value !== null) {
    return value
  } else {
    value = store.parent.get(key)
    store.cache.set(key, value)
    return value
  }
}
```

--------------------------------

### Set up App Simulator Manager (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/build/building-modules/14-simulator.md

This section details the setup of the SimulationManager at the application level, which is crucial for simulation test files. The SimulationManager is constructed using modules from ModuleManager and its RegisterStoreDecoders method is called.

```Go
type CoolApp struct {
  // ... other fields
  sm *module.SimulationManager
}

// NewCoolApp constructor example
func NewCoolApp(logger log.Logger, db dbm.DB, traceStore sim.TraceStore) *CoolApp {
  // ... other app initialization ...

  // Initialize the SimulationManager
  app.sm = module.NewSimulationManager(app.ModuleManager.Modules)

  // Register store decoders
  app.sm.RegisterStoreDecoders()

  // ... rest of the constructor ...
  return app
}

// SimulationManager implements the SimulationApp interface
func (app *SimApp) SimulationManager() *module.SimulationManager {
  return app.sm
}
```

--------------------------------

### Simulation Operations Example (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/build/building-modules/16-testing.md

This Go code snippet shows an example of simulation operations for the x/gov module. Simulations use a minimal application built with depinject to test module behaviors under randomized conditions.

```Go
package simulation_test

import (
	"math/rand"

	"github.com/cosmos/cosmos-sdk/codec"
	"github.com/cosmos/cosmos-sdk/types/module/simulation"
	"github.com/cosmos/cosmos-sdk/x/gov/simulation"
	"github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
)

func ExampleGovSimulateMsgSubmitProposal(r *rand.Rand, cdc *codec.ProtoCodec, app simulation.App) {
	// Setup simulation parameters and context
	appParams := simulation.AppParams{}
	ctx := simulation.NewSimulatedContext(r, cdc, app, appParams)

	// Get operation
	op := simulation.OperationWeightList{
		{Wgt: simulation.DefaultWeightMsgSubmitProposal, Content: simulation.NewWeightedOperation(
			simulation.DefaultWeightMsgSubmitProposal,
			simulation.MsgJSONEncoderFunc(cdc.MarshalJSON),
			simulation.MsgJSONDecoderFunc(cdc.UnmarshalJSON),
		),
	}
	// ... other operations ...

	// Run the simulation operation
	operation := simulation.Operations{}.NewOperation(ctx, appParams, r, cdc, app)

	// Perform assertions on the simulation results
	// ... 
}

```

--------------------------------

### Example Module Registration (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-057-app-wiring.md

An example demonstrating how to register a bank module using the `appmodule.Register` API. It shows how to provide protobuf types and dependency providers, including the module's configuration object and the necessary input/output structures for the provider function.

```go
package main

import (
	"github.com/cosmos/cosmos-sdk/core/appmodule"
	"github.com/cosmos/cosmos-sdk/orm/model/ormdb"
	"github.com/cosmos/cosmos-sdk/x/auth"
	bankmodulev1 "github.com/cosmos/cosmos-sdk/x/bank/types"
	types "path/to/your/generated/types"
)

// Assuming appmodule and auth are imported elsewhere

func init() {
	appmodule.Register("cosmos.bank.module.v1.Module",
		appmodule.Types(
			types.Types_tx_proto,
			types.Types_query_proto,
			types.Types_types_proto,
		),
		appmodule.Provide(
			provideBankModule,
		)
	)
}

type Inputs struct {
	container.In
	
	AuthKeeper auth.Keeper
	DB ormdb.ModuleDB
}

type Outputs struct {
	Keeper bank.Keeper
	AppModule appmodule.AppModule
}

func ProvideBankModule(config *bankmodulev1.Module, inputs Inputs) (Outputs, error) { 
    // Implementation details...
    return Outputs{}, nil 
}
```

--------------------------------

### Install and Initialize tmkms (Bash)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/user/run-node/06-run-production.md

This snippet demonstrates how to install the tmkms binary from source or using cargo, initialize its configuration, and generate a new softsign key. It requires git and Rust/Cargo to be installed. The output includes the initialization of the configuration and the generation of a secret key.

```bash
cd $HOME
git clone https://github.com/iqlusioninc/tmkms.git
cd $HOME/tmkms
cargo install tmkms --features=softsign
tmkms init config
tmkms softsign keygen ./config/secrets/secret_connection_key
```

```bash
cargo install tmkms --features=softsign
tmkms init config
tmkms softsign keygen ./config/secrets/secret_connection_key
```

--------------------------------

### Root Command Setup in Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/learn/advanced/07-cli.md

This Go code snippet demonstrates the setup of the root command for an application using the Cobra CLI framework. It includes adding persistent flags, a PreRun function, and essential subcommands for basic application functionality. It also shows how to initialize the application's configuration.

```go
package main

import (
	"fmt"
	"os"

	"github.com/cosmos/cosmos-sdk/server"
	pruningtypes "github.com/cosmos/cosmos-sdk/server/pruning/types"
	cmm "github.com/cometbft/cometbft/cmd/cometbft/commands"
	cmdcfg "github.com/cometbft/cometbft/config"
	// ... other imports
)

var ( 
	rootCmd *cobra.Command
)

func init() {
	rootCmd = &cobra.Command{
		Use:   "simd",
		Short: "The CometBFT SDK application",
	
		// If we are expecting a subcommand, then we don't need to run the pre run function.
		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
			// Set client context
			// ...
			
			// Enable or disable metric flushing
			if err := server.InterceptFn(); err != nil {
				return err
			}
		
			server.SetCmd(cmd)
		
			// ... other initializations
			return nil
		},
	}

	// ... add subcommands like status, keys, server, tx, query ...
}

func main() {
	if err := rootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

func initAppConfig() (appOpts server.AppCreateFn) {
	return func(app *runtime.App, baseappOptions ...func(*baseapp.BaseApp)) {
		// ... config initialization ...
	}
}

```

--------------------------------

### Start Local Documentation Server

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/README.md

Command to start a local development server for the documentation. This command also executes pre-build scripts to fetch necessary documentation files and post-build scripts for cleanup.

```shell
npm start
```

--------------------------------

### Example Query Applied Upgrade (CLI)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/x/upgrade/README.md

An example of how to use the `simd query upgrade applied` command to retrieve information about a specific upgrade named 'test-upgrade'.

```bash
simd query upgrade applied "test-upgrade"
```

--------------------------------

### KVStore Iterator Example

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/learn/advanced/04-store.md

An example from the bank module's keeper demonstrating how to use the Iterator method of a KVStore to iterate over a range of keys, specifically for listing all account balances.

```go
func (k Keeper) IterateAccounts(ctx Context) (accs []types.AccountI) {
	store := ctx.KVStore(k.storeKey)
	iterator := store.Iterator(nil, nil)

	defer iterator.Close()

	for ; iterator.Valid(); iterator.Next() {
		// ... process account ...
	}

	return accs
}
```

--------------------------------

### Unit Test Example for x/gov Keeper (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/build/building-modules/16-testing.md

A Go code snippet illustrating unit tests for the x/gov module's Keeper. It focuses on testing the Keeper's functionality in isolation by using mocked dependencies.

```Go
package gov_test

import (
	"testing"

	"github.com/cosmos/cosmos-sdk/testutil/testdata"
	"github.com/cosmos/cosmos-sdk/x/gov/keeper"
	"github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
	"github.com/stretchr/testify/require"
)

func TestProposalMsgs(t *testing.T) {
	// Setup mocks and keeper instance
	k, ctx, _, _ := keeper.Setup(t)

	// Define test parameters
	t params := k.GetParams(ctx)
	proposer := testdata.AccAddress("proposer")
	// ... other test setup ...

	// Test proposal creation and processing
	// ... assertions ...
}

```

--------------------------------

### Install Confix Standalone

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/tools/confix/README.md

Instructions for installing the Confix tool as a standalone binary using 'go install'. Alternatively, it can be built from source using 'make confix'.

```bash
go install cosmossdk.io/tools/confix/cmd/confix@latest
```

```bash
make confix
```

--------------------------------

### Example Query Implementation with sdk.Context Retrieval (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-021-protobuf-query-encoding.md

This Go code snippet demonstrates an example implementation of the `QueryBalance` method for the bank module. It shows how to retrieve the `sdk.Context` from the incoming `context.Context` using `sdk.UnwrapSDKContext` and then use it to interact with the module's keeper.

```go
type Querier struct {
	Keeper
}

func (q Querier) QueryBalance(ctx context.Context, params *types.QueryBalanceParams) (*sdk.Coin, error) {
	balance := q.GetBalance(sdk.UnwrapSDKContext(ctx), params.Address, params.Denom)
	return &balance, nil
}
```

--------------------------------

### Go: Iterator Example from Auth Module

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/build/building-modules/06-keeper.md

An example showcasing the use of the `Iterator()` method from a module's KVStore to iterate over a domain of keys. This specific example is from the `auth` module for iterating accounts.

```Go
// This is a conceptual example based on the description and likely structure
// The actual code would be more specific to account iteration.
func (k Keeper) IterateAccounts(ctx context.Context) (accounts []Account) {
	store := prefix.NewStore(ctx.KVStore(k.storeKey), auth.AccountStorePrefix)
	iterator := store.Iterator(nil, nil)
defer iterator.Close()

	for ; iterator.Valid(); iterator.Next() {
		account := k.decodeAccount(iterator.Value())
		accounts = append(accounts, account)
	}

	return accounts
}
```

--------------------------------

### Install Dependencies for Local Docs Build

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/README.md

Commands to install project dependencies required for building the documentation locally. This involves navigating to the docs directory and running npm install.

```shell
cd docs
npm install
```

--------------------------------

### Start In-Process Testnet - Bash

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/user/run-node/05-run-testnet.md

Initializes and starts a simulated test network directly within the current process. This is the quickest method for setting up a local test environment. The command outputs a mnemonic for the first validator node, which is for testing purposes only.

```bash
simd testnet start
```

--------------------------------

### Epoch Hooks Example (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/x/epochs/README.md

An example demonstrating how a module can implement and utilize epoch hooks. It shows how to retrieve module parameters to filter for a specific `epochIdentifier` before executing custom logic within the `AfterEpochEnd` hook.

```go
func (k MyModuleKeeper) AfterEpochEnd(ctx sdk.Context, epochIdentifier string, epochNumber int64) {
    params := k.GetParams(ctx)
    if epochIdentifier == params.DistrEpochIdentifier {
    // my logic
  }
}
```

--------------------------------

### Custom Minter DI Example: Double Foo Coin Supply (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/x/mint/README.md

Provides a practical example of creating a custom mint function that doubles the supply of a specific coin ('foo'). It utilizes dependency injection by accepting a `bankkeeper.BaseKeeper` and returns a `mintkeeper.MintFn`. This function is then passed into the `depinject.Supply` function.

```go
import (
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/x/bank/keeper" as bankkeeper
	mintkeeper "github.com/symbioticfi/cosmos-relay-sdk/x/mint/keeper"
)

// MyCustomMintFunction is a custom mint function that doubles the supply of `foo` coin.
func MyCustomMintFunction(bank bankkeeper.BaseKeeper) mintkeeper.MintFn {
	return func(ctx sdk.Context, k *mintkeeper.Keeper) error {
		supply := bank.GetSupply(ctx, "foo")
		err := k.MintCoins(ctx, sdk.NewCoins(supply.Add(supply)))
		if err != nil {
			return err
		}
		return nil
	}
}
```

--------------------------------

### Confix CLI Usage Examples

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/tools/confix/README.md

Examples of how to use the Confix CLI for various configuration management tasks. These commands can be run standalone or integrated within an application's CLI (e.g., 'simd config').

```shell
# General help
confix --help
simd config --help

# Get configuration value
simd config get app pruning
simd config get client chain-id
confix get ~/.simapp/config/app.toml pruning
confix get ~/.simapp/config/client.toml chain-id

# Set configuration value
simd config set app pruning "enabled"
simd config set client chain-id "foo-1"
confix set ~/.simapp/config/app.toml pruning "enabled"
confix set ~/.simapp/config/client.toml chain-id "foo-1"

# Migrate configuration file
simd config migrate v0.50
simd config migrate v0.50 --client
confix migrate v0.50 ~/.simapp/config/app.toml
confix migrate v0.50 ~/.simapp/config/client.toml --client

# Diff configuration file
simd config diff v0.47
simd config diff v0.47 --client
confix diff v0.47 ~/.simapp/config/app.toml
confix diff v0.47 ~/.simapp/config/client.toml --client

# View configuration file
simd config view client
confix view ~/.simapp/config/client.toml
```

--------------------------------

### Cosmos SDK Application CLI Setup (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/learn/beginner/00-app-anatomy.md

Illustrates the setup of a Cosmos SDK application's command-line interface (CLI) within its main.go file. This includes defining the main function, adding generic commands, and integrating query and transaction commands from various modules. It's crucial for enabling user interaction with the full-node client.

```go
package main

import (
	"fmt"
	"os"

	"github.com/cosmos/cosmos-sdk/client/config"
	"github.com/cosmos/cosmos-sdk/client/debug"
	"github.com/cosmos/cosmos-sdk/client/flags"
	"github.com/cosmos/cosmos-sdk/client/keys"
	"github.com/cosmos/cosmos-sdk/client/pruning"
	"github.com/cosmos/cosmos-sdk/server"
	"github.com/cosmos/cosmos-sdk/version"
	"github.com/cosmos/gaia/v7/app"
	"github.com/spf13/cobra"
)

func main() {
	encodingConfig := app.MakeEncodingConfig()

	rootCmd := &cobra.Command{
		Use:   "gaiad",
		Short: "All-in-one daemon for Gaia Hub",
	
		PersistentPreRunE: server.PersistentPreRunEFn(encodingConfig),
	}

	rootCmd.AddCommand(version.Cmd)
	rootCmd.AddCommand(debug.Cmd())
	rootCmd.AddCommand(pruning.Cmd(store.NewStoreLoader(app.NewGaiaApp(app.GetWasmEnabled()))))

	// Add --home' flag
	rootCmd.PersistentFlags().StringVar(
		&clientHome,
		"home",
		os.ExpandEnv("$HOME"),
		"directory for config and data",
	)

	// Set config
	clientConfig.Cmd.Root = rootCmd

	// Build genesis file
	genesisCmd.Root = rootCmd

	// Build keys command
	keys.Cmd = keys.KeysCmd()

	// Add --home' flag to keys command
	keys.Cmd.PersistentFlags().StringVar(
		&clientHome,
		"home",
		os.ExpandEnv("$HOME"),
		"directory for config and data",
	)

	rootCmd.AddCommand(keys.Cmd)

	// Build query command
	queryCmd := client.QueryCmd()
	queryCmd.AddCommand(cli.GetCommands(app.GetSubCmds()...)...)
	rootCmd.AddCommand(queryCmd)

	// Build tx command
	xCmd := tx.TxCmd()
	xCmd.AddCommand(cli.GetCommands(app.GetTxCommands()...)...)
	rootCmd.AddCommand(xCmd)

	// Build rest server command
	serverCmd := server.StartCmd(app.NewGaiaApp(app.GetWasmEnabled()), encodingConfig)
	serverCmd.AddCommand(
		config.Cmd(),
		flags.LineBreakLFlag(),
		flags.FlagBase64FilterFlag(),
	)

	// Build grant-app-role command
	grantAppRoleCmd := cli.GrantAppRoleCmd()
	rootCmd.AddCommand(grantAppRoleCmd)

	if err := rootCmd.Execute(); err != nil {
		fmt.Fprintf(os.Stderr, "%+v\n", err)
		os.Exit(1)
	}
}

```

--------------------------------

### Parse JSON Responses with gjson in Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

Example of using the gjson library in Go to parse and assert values from a JSON response. It demonstrates how to extract array elements and specific values based on conditions, comparing them against expected values.

```go
	raw := cli.CustomQuery("q", "bank", "total-supply")

	exp := map[string]int64{
        "stake":     int64(500000000 * sut.nodesCount),
        "testtoken": int64(1000000000 * sut.nodesCount),
	}
	require.Len(t, gjson.Get(raw, "supply").Array(), len(exp), raw)

	for k, v := range exp {
		got := gjson.Get(raw, fmt.Sprintf("supply.#(denom==%q).amount", k)).Int()
		assert.Equal(t, v, got, raw)
	}

```

--------------------------------

### Initialize BaseApp and Store Keys in Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/spec/store/README.md

Illustrates the initialization of a `BaseApp` instance and the creation of various store keys (KV, Transient, Memory) within a Cosmos SDK application. It shows how to mount these stores to the application, enabling modules to access their respective KVStores.

```go
func NewApp(...) Application {
  // ...
  
  bApp := baseapp.NewBaseApp(appName, logger, db, txConfig.TxDecoder(), baseAppOptions...)
  bApp.SetCommitMultiStoreTracer(traceStore)
  bApp.SetVersion(version.Version)
  bApp.SetInterfaceRegistry(interfaceRegistry)

	// ...

  keys := sdk.NewKVStoreKeys(...)
	transientKeys := sdk.NewTransientStoreKeys(...)
	memKeys := sdk.NewMemoryStoreKeys(...)

	// ...

	// initialize stores
	app.MountKVStores(keys)
	app.MountTransientStores(transientKeys)
	app.MountMemoryStores(memKeys)

	// ...
}
```

--------------------------------

### Cosmos SDK Application Setup (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-057-app-wiring.md

Illustrates a simplified `app.go` file for a Cosmos SDK application using the new module system. It highlights the use of blank imports for module registration side-effects and the `app.Run` function to load the application configuration from YAML.

```go
package main

import (
	// Each go package which registers a module must be imported just for side-effects
	// so that module implementations are registered.
	_ "github.com/cosmos/cosmos-sdk/x/auth/module"
	_ "github.com/cosmos/cosmos-sdk/x/bank/module"
	_ "github.com/cosmos/cosmos-sdk/x/staking/module"

	"github.com/cosmos/cosmos-sdk/core/app"
)

// go:embed app.yaml
var appConfigYAML []byte

func main() {
	app.Run(app.LoadYAML(appConfigYAML))
}
```

--------------------------------

### Start a Single Cosmos SDK Node

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/user/run-node/01-run-node.md

This command starts a single node of the Cosmos SDK application. It's useful for initial setup and interaction with a node. Ensure the 'simd' binary is in your PATH.

```bash
simd start
```

--------------------------------

### Example: Smart Contract Address Construction (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-028-public-key-addresses.md

Shows how to construct a smart contract address using multiple derivation components, including the module name, a namespace, and a specific key. It also provides an equivalent representation using a derived function.

```go
smartContractAddr = Module("mySmartContractVM", smartContractsNamespace, smartContractKey})

// which equals to:
smartContractAddr = Derived(
    Module("mySmartContractVM", smartContractsNamespace),
    []{smartContractKey})
```

--------------------------------

### Setup Hypothetical 'foo' v2 Module in Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-063-core-module-api.md

Demonstrates setting up a hypothetical 'foo' v2 module using ORM for state management and genesis. It defines a Keeper struct and registers services for message and query servers. The `ProvideApp` function initializes the Keeper and returns it as an `AppModule`.

```go
type Keeper struct {
	db orm.ModuleDB
	evtSrv event.Service
}

func (k Keeper) RegisterServices(r grpc.ServiceRegistrar) {
  foov1.RegisterMsgServer(r, k)
  foov1.RegisterQueryServer(r, k)
}

func (k Keeper) BeginBlock(context.Context) error {
	return nil
}

func ProvideApp(config *foomodulev2.Module, evtSvc event.EventService, db orm.ModuleDB) (Keeper, appmodule.AppModule){
    k := &Keeper{db: db, evtSvc: evtSvc}
    return k, k
}
```

--------------------------------

### Test Scenario Comment Block

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

A structured comment block used to describe the intention and flow of a test scenario, outlining the given, when, and then steps.

```go
// scenario:
	// given a chain with a custom token on genesis
	// when an amount is burned
	// then this is reflected in the total supply
```

--------------------------------

### Build and Copy System Test Binary (Shell)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

Commands to build the system test binary from the current branch and copy it to the designated binaries folder. This ensures the latest code is used for testing.

```shell
make test-system

```

```shell
make build
mkdir -p ./tests/systemtests/binaries
cp ./build/simd ./tests/systemtests/binaries/

```

--------------------------------

### Start Streaming Plugin Server (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-038-state-listening.md

Launches a streaming plugin process using `plugin.NewClient`. It configures the client with handshake information, plugin map, command to execute, logger, and allowed protocols (NetRPC and GRPC). It then connects via RPC and dispenses the requested plugin.

```go
func NewStreamingPlugin(name string, logLevel string) (interface{}, error) {
    logger := hclog.New(&hclog.LoggerOptions{
       Output: hclog.DefaultOutput,
       Level:  toHclogLevel(logLevel),
       Name:   fmt.Sprintf("plugin.%s", name),
    })

    // We're a host. Start by launching the streaming process.
    env := os.Getenv(GetPluginEnvKey(name))
    client := plugin.NewClient(&plugin.ClientConfig{
       HandshakeConfig: HandshakeMap[name],
       Plugins:         PluginMap,
       Cmd:             exec.Command("sh", "-c", env),
       Logger:          logger,
       AllowedProtocols: []plugin.Protocol{
           plugin.ProtocolNetRPC, plugin.ProtocolGRPC},
    })

    // Connect via RPC
    rpcClient, err := client.Client()
    if err != nil {
       return nil, err
    }

    // Request streaming plugin
    return rpcClient.Dispense(name)
}
```

--------------------------------

### SimApp Chain Setup and Configuration

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/tools/cosmovisor/README.md

This section demonstrates setting up a SimApp chain by checking out a specific version, building the binary, resetting the chain data, and configuring basic app settings like chain ID and keyring backend. It also includes initializing the node and modifying the genesis file.

```shell
git checkout v0.47.4
make build
./build/simd tendermint unsafe-reset-all
./build/simd config chain-id test
./build/simd config keyring-backend test
./build/simd config broadcast-mode sync
./build/simd init test --chain-id test --overwrite
cat <<< $(jq '.app_state.gov.params.voting_period = "20s"' $HOME/.simapp/config/genesis.json) > $HOME/.simapp/config/genesis.json
```

--------------------------------

### Set Epochs Keeper Hooks in Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/UPGRADE_GUIDE.md

Configures hooks for the epochs keeper, allowing other modules to react to epoch-related events. The example shows how to set up a multi-hook receiver, which can be extended to include hooks from other modules.

```go
app.EpochsKeeper.SetHooks(
    epochstypes.NewMultiEpochHooks(
        // insert epoch hooks receivers here
        app.SomeOtherModule
    ),
)
```

--------------------------------

### Example: Concatenated Derivation Keys (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-028-public-key-addresses.md

Illustrates how to create a module account address that depends on multiple derivation keys by concatenating them. This is useful for scenarios requiring combined key information.

```go
btcAtomAMM := address.Module("amm", btc.Address() + atom.Address()})
```

--------------------------------

### Burn Tokens via Bank TX with Go SDK

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

Submits a bank burn transaction using the CLI wrapper to reduce the supply of a specific token. It requires a successful transaction hash for verification.

```go
// and when
	txHash := cli.Run("tx", "bank", "burn", "node0", "400000mytoken")
	RequireTxSuccess(t, txHash)
```

--------------------------------

### Example: Lending BTC Pool Address (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-028-public-key-addresses.md

Demonstrates the creation of a specific module account address for a lending BTC pool. It utilizes the `address.Module` function with a module name and a specific BTC address derivation.

```go
btcPool := address.Module("lending", btc.Address()})
```

--------------------------------

### Define Expected Token Balances with Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

Defines a map to hold expected token balances, scaling certain token amounts based on the number of nodes in the chain. This is useful for setting up test assertions.

```go
exp := map[string]int64{
		"stake":     int64(500000000 * sut.nodesCount),
		"testtoken": int64(1000000000 * sut.nodesCount),
		"mytoken":   1000000,
	}
```

--------------------------------

### Deterministic Regression Test Example (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/build/building-modules/16-testing.md

Illustrates how deterministic regression tests are written for Cosmos SDK queries annotated with `module_query_safe`. These tests ensure that query responses and gas consumption remain consistent across SDK versions.

```Go
package bank_test

import (
	"testing"

	"github.com/cosmos/cosmos-sdk/testutil/testdata"
	"github.com/cosmos/cosmos-sdk/x/bank/keeper"
	"github.com/stretchr/testify/require"
)

func TestDeterministicBalanceQuery(t *testing.T) {
	// Setup keeper and context
	k, ctx, _ := keeper.Setup(t)

	// Create accounts and fund them
	accs := testdata.CreateSimpleAccounts(2)
	addr1 := accs[0].Address
	addr2 := accs[1].Address
	// ... fund accounts ...

	// Define expected response and gas for 1000 queries
	expResponse := "..."
	expGas := uint64(10000)

	// Run regression test for Balance query
	k.Keeper.SetParams(ctx, banktypes.DefaultParams())
	bankkeeper.TestBalance(t, k.Keeper, ctx, addr1, expResponse, expGas)

	// ... other query tests ...
}

```

--------------------------------

### Verify Token Supply and Balance Changes with Go SDK

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

Queries the total token supply and an account's balance after a transaction to verify state changes. It uses `gjson` for parsing query results and `assert` for comparisons.

```go
exp["mytoken"] = 600_000 // update expected state
	raw = cli.CustomQuery("q", "bank", "total-supply")
	for k, v := range exp {
		got := gjson.Get(raw, fmt.Sprintf("supply.#(denom==%q).amount", k)).Int()
		assert.Equal(t, v, got, raw)
	}
	assert.Equal(t, int64(600_000), cli.QueryBalance(cli.GetKeyAddr("node0"), "mytoken"))
```

--------------------------------

### Run System Tests with Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

Command to execute system tests using Go. It specifies read-only module mode, includes the `system_test` tag, enables verbose output, and allows specifying the number of nodes for the test.

```shell
go test -mod=readonly -tags='system_test' -v ./...  --run TestQueryTotalSupply --verbose --nodes-count=1 
```

--------------------------------

### gRPC Gateway Registration Example (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-063-core-module-api.md

Illustrates how modules can provide gRPC gateway handler registration information. The `GrpcGatewayInfo` struct and `GrpcGatewayHandler` function type facilitate this, allowing modules to register their query services with the runtime module.

```go
type GrpcGatewayInfo struct {
    Handlers []GrpcGatewayHandler
}

type GrpcGatewayHandler func(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error

func ProvideGrpcGateway() GrpcGatewayInfo {
    return GrpcGatewayinfo {
        Handlers: []Handler {types.RegisterQueryHandlerClient}
    }
}
```

--------------------------------

### Run System Tests with Go Test

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

Command to execute system tests using the Go test runner. It specifies the read-only module mode, applies the 'system_test' build tag, enables verbose output, and targets a specific test function.

```shell
go test -mod=readonly -tags='system_test' -v ./...  --run TestQueryTotalSupply --verbose 

```

--------------------------------

### Pack sdk.Msg as Any using anyutil

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/learn/advanced/05-encoding.md

Demonstrates how to pack an sdk.Msg into an anypb.Any using the 'cosmos-proto/anyutil' package. This method ensures compatibility with the Cosmos SDK's TypeURL conventions by omitting the 'type.googleapis.com' prefix, unlike the default 'anypb.New' function. It highlights the import change and the direct replacement of the function call.

```go
import (
	"fmt"
	"github.com/cosmos/cosmos-proto/anyutil"
)

// Assuming internalMsg is an object that satisfies sdk.Msg interface
// and has a Message() method returning a protobuf.Message
// Example usage:
// anyMsg, err := anyutil.New(internalMsg.Message().Interface())
// if err != nil {
// 	// Handle error
// }
// fmt.Println(anyMsg.TypeURL) // Expected output: /cosmos.bank.v1beta1.MsgSend

```

--------------------------------

### Cosmovisor Software Upgrade CLI Command with Auto-Download Info

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/tools/cosmovisor/README.md

Example command to submit a software upgrade proposal using `gaiad`. It includes the `upgrade-info` flag, demonstrating how to embed the JSON structure for binary download configurations directly in the command. This allows cosmovisor to automatically fetch and install the specified binaries upon upgrade.

```shell
> gaiad tx upgrade software-upgrade Vega \
    --title Vega \
    --deposit 100uatom \
    --upgrade-height 7368420 \
    --upgrade-info '{"binaries":{"linux/amd64":"https://github.com/cosmos/gaia/releases/download/v6.0.0-rc1/gaiad-v6.0.0-rc1-linux-amd64","linux/arm64":"https://github.com/cosmos/gaia/releases/download/v6.0.0-rc1/gaiad-v6.0.0-rc1-linux-arm64","darwin/amd64":"https://github.com/cosmos/gaia/releases/download/v6.0.0-rc1/gaiad-v6.0.0-rc1-darwin-amd64"}}' \
    --summary "upgrade to Vega" \
    --gas 400000 \
    --from user \
    --chain-id test \
    --home test/val2 \
    --node tcp://localhost:36657 \
    --yes
```

--------------------------------

### Initialize Cobra Root Command with Server Context

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/server/README.md

Demonstrates how to set up the root Cobra command for an application, including essential pre-run handlers for initializing the client and server contexts. This ensures that all sub-commands have access to necessary configurations and utilities.

```go
var (
	initClientCtx  = client.Context{...}

	rootCmd = &cobra.Command{
		Use:   "simd",
		Short: "simulation app",
		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
			if err := client.SetCmdClientContextHandler(initClientCtx, cmd); err != nil {
				return err
			}

			return server.InterceptConfigsPreRunHandler(cmd)
		},
	}
    // add root sub-commands ...
)
```

--------------------------------

### Install Cosmovisor with Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/tools/cosmovisor/RELEASE_NOTES.md

Installs the latest version of Cosmovisor using the Go installation command. This command fetches and installs the binary to your Go bin path, making it accessible from your terminal.

```go
go install cosmossdk.io/tools/cosmovisor/cmd/cosmovisor@latest
```

--------------------------------

### Install Specific Cosmovisor Version

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/tools/cosmovisor/README.md

Installs a specific version of Cosmovisor by specifying the version tag in the go install command. This is useful for testing or compatibility with older chain versions.

```shell
go install cosmossdk.io/tools/cosmovisor/cmd/cosmovisor@v1.5.0
```

--------------------------------

### Modify Genesis State with Go SDK

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/systemtests/GETTING_STARTED.md

Demonstrates disabling inflation, adding a new token to the supply, and updating account balances within the genesis file using Go. It leverages `sjson` for setting raw bytes, `gjson` for querying, and standard Go JSON operations. Dependencies include the SDK's `ModifyGenesisJSON` helper and CLI wrapper.

```go
sut.ResetChain(t)
    cli := NewCLIWrapper(t, sut, verbose)

	sut.ModifyGenesisJSON(t, func(genesis []byte) []byte {
		// disable inflation
		genesis, err := sjson.SetRawBytes(genesis, "app_state.mint.minter.inflation", []byte(`"0.000000000000000000"`))
		require.NoError(t, err)

		// add new token to supply
		var supply []json.RawMessage
		rawSupply := gjson.Get(string(genesis), "app_state.bank.supply").String()
		require.NoError(t, json.Unmarshal([]byte(rawSupply), &supply))
		supply = append(supply, json.RawMessage(`{"denom": "mytoken","amount": "1000000"}`))
		newSupply, err := json.Marshal(supply)
		require.NoError(t, err)
		genesis, err = sjson.SetRawBytes(genesis, "app_state.bank.supply", newSupply)
		require.NoError(t, err)

		// add amount to any balance
		anyAddr := cli.GetKeyAddr("node0")
		newBalances := GetGenesisBalance(genesis, anyAddr).Add(sdk.NewInt64Coin("mytoken", 1000000))
		newBalancesBz, err := newBalances.MarshalJSON()
		require.NoError(t, err)
		newState, err := sjson.SetRawBytes(genesis, fmt.Sprintf("app_state.bank.balances.#[address==%q]#.coins", anyAddr), newBalancesBz)
		require.NoError(t, err)
		return newState
	})
    sut.StartChain(t)
```

--------------------------------

### Prepare for Cosmovisor Upgrade

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/tools/cosmovisor/README.md

The `prepare-upgrade` command retrieves upgrade information, downloads the new binary, verifies its checksum, and places it in the correct directory for Cosmovisor. It provides detailed logging throughout the process.

```shell
cosmovisor prepare-upgrade
```

--------------------------------

### Keyring Account Creation in Go

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/learn/beginner/03-accounts.md

Demonstrates the `NewAccount` method of the Keyring interface in Go. This function generates a new account using a mnemonic, passphrase, and BIP44 derivation path, encrypting the private key before storage.

```go
// NewAccount creates a new account based on the bip44 path and persists it on disk.
// The PrivKey is never stored unencrypted, instead it is encrypted with a passphrase
// before being persisted.
func (k DefaultKeyring) NewAccount(uid, mnemonic, bip39Passphrase, hdPath string, algo SignatureAlgo) (*Record, error) {
	// ... implementation details ...
}
```

--------------------------------

### YAML Example of App Configuration

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-057-app-wiring.md

Illustrates a declarative app configuration using YAML, specifying modules like 'baseapp', 'auth', 'bank', and 'staking'. Each module is defined with a unique name and a configuration object referencing its protobuf type URL.

```yaml
modules:
  - name: baseapp
    config:
      "@type": cosmos.baseapp.module.v1.Module
      begin_blockers: [staking, auth, bank]
      end_blockers: [bank, auth, staking]
      init_genesis: [bank, auth, staking]
  - name: auth
    config:
      "@type": cosmos.auth.module.v1.Module
      bech32_prefix: "foo"
  - name: bank
    config:
      "@type": cosmos.bank.module.v1.Module
  - name: staking
    config:
      "@type": cosmos.staking.module.v1.Module
```

--------------------------------

### Install TMKMS Dependencies on Ubuntu

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/user/run-node/06-run-production.md

This script installs the necessary dependencies for running the TMKMS (Tendermint Key Management System) remote signer. It updates the package list, installs essential build tools and utilities, and sets up the Rust programming language environment.

```sh
sudo apt update -y && sudo apt install build-essential curl jq -y
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
sudo apt install libusb-1.0-0-dev
```

--------------------------------

### Example Usage of Unit Test Runner for Dependency Version Testing (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-054-semver-compatible-modules.md

Demonstrates how to use the `UnitTestConfig.Run` method to test a module's interaction with a dependency, specifically handling conditional service revisions. This example mocks a `MsgServer` and uses `EXPECT` with conditional arguments based on service revision.

```go
func TestBar(t *testing.T) {
    UnitTestConfig{ModuleConfig: &foomodulev1.Module{}}.
		Run(t, func (t *testing.T, f moduletesting.UnitTestFixture) {
        ctrl := gomock.NewController(t)
        mockFooMsgServer := footestutil.NewMockMsgServer()
        foov1.RegisterMsgServer(f, mockFooMsgServer)
        barMsgClient := barv1.NewMsgClient(f)
			if f.ServiceRevision(foov1.Msg_ServiceDesc.ServiceName) >= 1 {
            mockFooMsgServer.EXPECT().DoSomething(gomock.Any(), &foov1.MsgDoSomething{
				...,
				Condition: ..., // condition is expected in revision >= 1
            }).Return(&foov1.MsgDoSomethingResponse{}, nil)
        } else {
            mockFooMsgServer.EXPECT().DoSomething(gomock.Any(), &foov1.MsgDoSomething{...}).Return(&foov1.MsgDoSomethingResponse{}, nil)
        }
        res, err := barMsgClient.CallFoo(f, &MsgCallFoo{}) // Assuming MsgCallFoo is defined elsewhere
        ...
    })
}
```

--------------------------------

### Golang Pseudocode Struct Example

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/spec/SPEC_STANDARD.md

An example of how to represent a struct using Golang syntax for pseudocode. This follows the convention of using interfaces to define the structure and its fields.

```go
type CacheKVStore interface {
  cache: map[Key]Value
  parent: KVStore
  deleted: Key
}
```

--------------------------------

### Install Go Tools for Pre-commit Hook

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/contrib/githooks/README.md

These commands install the necessary Go tools for the pre-commit hook: goimports for code formatting and misspell for checking spelling in Go code. These tools must be installed and available in your system's PATH for the hook to function correctly.

```shell
go install golang.org/x/tools/cmd/goimports
go install github.com/golangci/misspell/cmd/misspell@master
```

--------------------------------

### Query Staking Module Help via CLI

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/x/staking/README.md

This command displays the help information for the staking module in the Cosmos CLI. It serves as an entry point to understand the available staking-related commands and their usage.

```bash
simd query staking --help
```

--------------------------------

### Example Integration Test with Dependency Combinations (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/architecture/adr-054-semver-compatible-modules.md

Provides an example of an integration test function `TestBarIntegration` using `IntegrationTestConfig`. This test configures dependencies for 'runtime' with two versions and 'foo' with three versions. The `Run` method is called with a test function that utilizes the `IntegrationTestFixture` to interact with module clients.

```go
func TestBarIntegration(t *testing.T) {
    IntegrationTestConfig{
        ModuleConfig: &barmodulev1.Module{},
        DependencyMatrix: map[string][]proto.Message{
            "runtime": []proto.Message{ // test against two versions of runtime
                &runtimev1.Module{},
                &runtimev2.Module{},
            },
            "foo": []proto.Message{ // test against three versions of foo
                &foomodulev1.Module{},
                &foomodulev2.Module{},
                &foomodulev3.Module{},
            }
        }   
    }.Run(t, func (t *testing.T, f moduletesting.IntegrationTestFixture) {
        barMsgClient := barv1.NewMsgClient(f)
        res, err := barMsgClient.CallFoo(f, &MsgCallFoo{}) 
        ...
    })
}
```

--------------------------------

### Disabling Message Processing (Trip) CLI Examples

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/x/circuit/README.md

These examples demonstrate how to use the CLI to disable specific message types from being processed. This action, known as 'tripping' the circuit breaker, requires the user to be authorized. Examples include tripping single, multiple, or all message types.

```bash
# Disable a single message type
<appd> tx circuit trip --type-urls="/cosmos.bank.v1beta1.MsgSend" --from=<authorized_key> --gas=auto --gas-adjustment=1.5

# Disable multiple message types
<appd> tx circuit trip --type-urls="/cosmos.bank.v1beta1.MsgSend,/cosmos.staking.v1beta1.MsgDelegate" --from=<authorized_key> --gas=auto --gas-adjustment=1.5

# Disable all message types (emergency measure)
<appd> tx circuit trip --from=<authorized_key> --gas=auto --gas-adjustment=1.5
```

--------------------------------

### Start tmkms and Simd Processes (Bash)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/docs/docs/user/run-node/06-run-production.md

These commands initiate the tmkms relay process and the CometBFT node (simd). The first command starts tmkms using the specified configuration file, while the second command starts the blockchain node. Both processes need to be running for the relay to function correctly.

```bash
tmkms start -c $HOME/tmkms/config/tmkms.toml
```

```bash
simd start
```

--------------------------------

### Query Distribution Module Help - Shell

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/x/distribution/README.md

Displays the help information for the distribution module's query commands. This is the entry point for exploring available query functionalities.

```shell
simd query distribution --help
```

--------------------------------

### Initializing Distribution Keeper with External Community Pool (Go)

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/x/distribution/README.md

Demonstrates how to initialize the distribution keeper using an external community pool keeper. This involves passing an implementation of the `ExternalCommunityPoolKeeper` interface during the keeper's creation, enabling an external module like `x/protocolpool` to manage community funds.

```go
app.DistrKeeper = distrkeeper.NewKeeper(
    appCodec,
    runtime.NewKVStoreService(keys[distrtypes.StoreKey]),
    app.AccountKeeper,
    app.BankKeeper,
    app.StakingKeeper,
    authtypes.FeeCollectorName,
    authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    distrkeeper.WithExternalCommunityPool(app.ProtocolPoolKeeper), // New option.
)
```

--------------------------------

### Query Auth Module Help

Source: https://github.com/symbioticfi/cosmos-relay-sdk/blob/main/x/auth/README.md

Displays help information for the auth module's query commands, outlining available subcommands and their usage.

```bash
simd query auth --help
```
Tokens:
Raw