v0.27.1

Cosmos SDK v0.47.3 upgrade notes

Imports

To use the new cosmos SDK make sure you update go.mod dependencies:

go.mod

go 1.20

require (
    github.com/cosmos/cosmos-sdk v0.46.7
    github.com/tendermint/tendermint v0.34.24
    github.com/tendermint/tm-db v0.6.7
    github.com/cosmos/ibc-go/v7 v7.1.0
    github.com/gogo/protobuf v1.3.3
    github.com/regen-network/cosmos-proto v0.3.1
    cosmossdk.io/api v0.3.1
    github.com/cosmos/cosmos-sdk v0.47.3
    github.com/cometbft/cometbft v0.37.1
    github.com/cometbft/cometbft-db v0.7.0
    github.com/cosmos/ibc-go/v6 v6.1.0
    github.com/cosmos/gogoproto v1.4.7

    // ...
)

replace (
    github.com/confio/ics23/go => github.com/cosmos/cosmos-sdk/ics23/go v0.8.0
    github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1
    github.com/syndtr/goleveldb => github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
)

The Cosmos SDK has migrated to CometBFT as its default consensus engine which requires changes in your app imports:

1. Replace github.com/tendermint/tendermint by github.com/cometbft/cometbft
2. Replace github.com/tendermint/tm-db by github.com/cometbft/cometbft-db
3. Verify github.com/tendermint/tendermint is not an indirect or direct dependency

The SDK has also migrated from gogo/protobuf to cosmos/gogoproto. This means you must replace all github.com/gogo/protobuf imports with github.com/cosmos/gogoproto. This change might introduce breaking changes to your proto layout. Follow the official Cosmos migration guide to make sure you are using the correct layout.

You might need to replace the following imports:

1. Replace github.com/cosmos/cosmos-sdk/simapp by cosmossdk.io/simapp

App changes

Applications scaffolded with older version of Ignite CLI would require the following changes to some of the app files:

app/app.go

import (
    //...

    tmjson "github.com/tendermint/tendermint/libs/json"
    "encoding/json"

    autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
    reflectionv1 "cosmossdk.io/api/cosmos/reflection/v1"
    "github.com/cosmos/cosmos-sdk/runtime"
    runtimeservices "github.com/cosmos/cosmos-sdk/runtime/services"
    "github.com/cosmos/cosmos-sdk/x/consensus"
    consensusparamkeeper "github.com/cosmos/cosmos-sdk/x/consensus/keeper"
    consensusparamtypes "github.com/cosmos/cosmos-sdk/x/consensus/types"
)

func getGovProposalHandlers() []govclient.ProposalHandler {
    // ...
    govProposalHandlers = append(govProposalHandlers,
        paramsclient.ProposalHandler,
        distrclient.ProposalHandler,
        upgradeclient.LegacyProposalHandler,
        // ...
    )

    return govProposalHandlers
}

var (
    // ...

    ModuleBasics = module.NewBasicManager(
        auth.AppModuleBasic{},
        authzmodule.AppModuleBasic{},
        genutil.AppModuleBasic{},
        genutil.NewAppModuleBasic(genutiltypes.DefaultMessageValidator),
        bank.AppModuleBasic{},
        // ...
        vesting.AppModuleBasic{},
        consensus.AppModuleBasic{},
        //...
    )
)

var (
    _ runtime.AppI            = (*App)(nil)
    _ servertypes.Application = (*App)(nil)
    _ simapp.App              = (*App)(nil)
)

type App struct {
    *baseapp.BaseApp

    cdc               *codec.LegacyAmino
    appCodec          codec.Codec
    interfaceRegistry types.InterfaceRegistry
    txConfig          client.TxConfig

    invCheckPeriod uint

    // ...
    StakingKeeper         stakingkeeper.Keeper
    CrisisKeeper          crisiskeeper.Keeper
    UpgradeKeeper         upgradekeeper.Keeper
    StakingKeeper         *stakingkeeper.Keeper
    CrisisKeeper          *crisiskeeper.Keeper
    UpgradeKeeper         *upgradekeeper.Keeper
    // ...
    FeeGrantKeeper        feegrantkeeper.Keeper
    GroupKeeper           groupkeeper.Keeper
    ConsensusParamsKeeper consensusparamkeeper.Keeper

    // ...
}

func New(
    logger log.Logger,
    db dbm.DB,
    traceStore io.Writer,
    loadLatest bool,
    skipUpgradeHeights map[int64]bool,
    homePath string,
    invCheckPeriod uint,
    encodingConfig appparams.EncodingConfig,
    appOpts servertypes.AppOptions,
    baseAppOptions ...func(*baseapp.BaseApp),
) *App {
    appCodec := encodingConfig.Marshaler
    cdc := encodingConfig.Amino
    interfaceRegistry := encodingConfig.InterfaceRegistry
    txConfig := encodingConfig.TxConfig

    // ...

    bApp.SetCommitMultiStoreTracer(traceStore)
    bApp.SetVersion(version.Version)
    bApp.SetInterfaceRegistry(interfaceRegistry)
    bApp.SetTxEncoder(txConfig.TxEncoder())

    keys := sdk.NewKVStoreKeys(
        // ...
        banktypes.StoreKey,
        stakingtypes.StoreKey,
        crisistypes.StoreKey,
        // ...
        group.StoreKey,
        icacontrollertypes.StoreKey,
        consensusparamtypes.StoreKey,
        // ...
    )

    // ...

    app := &App{
        // ...
        interfaceRegistry: interfaceRegistry,
        txConfig:          txConfig,
        invCheckPeriod:    invCheckPeriod,
        // ...
    }

    // ...

    // set the BaseApp's parameter store
    bApp.SetParamStore(app.ParamsKeeper.Subspace(baseapp.Paramspace).WithKeyTable(paramstypes.ConsensusParamsKeyTable()))
    app.ConsensusParamsKeeper = consensusparamkeeper.NewKeeper(appCodec, keys[upgradetypes.StoreKey], authtypes.NewModuleAddress(govtypes.ModuleName).String())
    bApp.SetParamStore(&app.ConsensusParamsKeeper)

    // ...

    app.AccountKeeper = authkeeper.NewAccountKeeper(
        appCodec,
        keys[authtypes.StoreKey],
        app.GetSubspace(authtypes.ModuleName),
        authtypes.ProtoBaseAccount,
        maccPerms,
        sdk.Bech32PrefixAccAddr,
        authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    )

    app.BankKeeper = bankkeeper.NewBaseKeeper(
        appCodec,
        keys[banktypes.StoreKey],
        app.AccountKeeper,
        app.GetSubspace(banktypes.ModuleName),
        app.BlockedModuleAccountAddrs(),
        authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    )

    app.StakingKeeper = stakingkeeper.NewKeeper(
        appCodec,
        keys[stakingtypes.StoreKey],
        app.AccountKeeper,
        app.BankKeeper,
        app.GetSubspace(stakingtypes.ModuleName),
        authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    )

    app.MintKeeper = mintkeeper.NewKeeper(
        appCodec,
        keys[minttypes.StoreKey],
        app.GetSubspace(minttypes.ModuleName),
        &app.StakingKeeper,
        app.StakingKeeper,
        app.AccountKeeper,
        app.BankKeeper,
        authtypes.FeeCollectorName,
        authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    )

    app.DistrKeeper = distrkeeper.NewKeeper(
        appCodec,
        keys[distrtypes.StoreKey],
        app.GetSubspace(distrtypes.ModuleName),
        app.AccountKeeper,
        app.BankKeeper,
        &app.StakingKeeper,
        app.StakingKeeper,
        authtypes.FeeCollectorName,
        authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    )

    app.SlashingKeeper = slashingkeeper.NewKeeper(
        appCodec,
        cdc,
        keys[slashingtypes.StoreKey],
        &app.StakingKeeper,
        app.StakingKeeper,
        app.GetSubspace(slashingtypes.ModuleName),
        authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    )

    app.CrisisKeeper = crisiskeeper.NewKeeper(
        app.GetSubspace(crisistypes.ModuleName),
        appCodec,
        keys[crisistypes.StoreKey],
        invCheckPeriod,
        app.BankKeeper,
        authtypes.FeeCollectorName,
        authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    )

    // ...

    // Create evidence Keeper for to register the IBC light client misbehaviour evidence route
    evidenceKeeper := evidencekeeper.NewKeeper(
        appCodec,
        keys[evidencetypes.StoreKey],
        &app.StakingKeeper,
        app.StakingKeeper,
        app.SlashingKeeper,
    )
    // If evidence needs to be handled for the app, set routes in router here and seal
    app.EvidenceKeeper = *evidenceKeeper

    govConfig := govtypes.DefaultConfig()
    govKeeper := govkeeper.NewKeeper(
        appCodec,
        keys[govtypes.StoreKey],
        app.AccountKeeper,
        app.BankKeeper,
        app.StakingKeeper,
        app.MsgServiceRouter(),
        govConfig,
        authtypes.NewModuleAddress(govtypes.ModuleName).String(),
    )

    govRouter := govv1beta1.NewRouter()
    govRouter.
        AddRoute(govtypes.RouterKey, govv1beta1.ProposalHandler).
        AddRoute(paramproposal.RouterKey, params.NewParamChangeProposalHandler(app.ParamsKeeper)).
        AddRoute(distrtypes.RouterKey, distr.NewCommunityPoolSpendProposalHandler(app.DistrKeeper)).
        AddRoute(upgradetypes.RouterKey, upgrade.NewSoftwareUpgradeProposalHandler(app.UpgradeKeeper)).
        AddRoute(ibcclienttypes.RouterKey, ibcclient.NewClientProposalHandler(app.IBCKeeper.ClientKeeper))
    govKeeper.SetLegacyRouter(govRouter)

    govConfig := govtypes.DefaultConfig()
    app.GovKeeper = govkeeper.NewKeeper(
        appCodec,
        keys[govtypes.StoreKey],
        app.GetSubspace(govtypes.ModuleName),
        app.AccountKeeper,
        app.BankKeeper,
        &app.StakingKeeper,
        govRouter,
        app.MsgServiceRouter(),
        govConfig,
    )
    app.GovKeeper = *govKeeper.SetHooks(
        govtypes.NewMultiGovHooks(
            // register the governance hooks
        ),
    )

    // ...

    app.GovKeeper.SetHooks(
        govtypes.NewMultiGovHooks(
        // insert governance hooks receivers here
        ),
    )

    // ...

    app.mm = module.NewManager(
        genutil.NewAppModule(
            app.AccountKeeper,
            app.StakingKeeper,
            app.BaseApp.DeliverTx,
            encodingConfig.TxConfig,
        ),
        auth.NewAppModule(appCodec, app.AccountKeeper, nil),
        auth.NewAppModule(appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts, app.GetSubspace(authtypes.ModuleName)),
        authzmodule.NewAppModule(appCodec, app.AuthzKeeper, app.AccountKeeper, app.BankKeeper, app.interfaceRegistry),
        vesting.NewAppModule(app.AccountKeeper, app.BankKeeper),
        bank.NewAppModule(appCodec, app.BankKeeper, app.AccountKeeper),
        capability.NewAppModule(appCodec, *app.CapabilityKeeper),
        bank.NewAppModule(appCodec, app.BankKeeper, app.AccountKeeper, app.GetSubspace(banktypes.ModuleName)),
        capability.NewAppModule(appCodec, *app.CapabilityKeeper, false),
        feegrantmodule.NewAppModule(appCodec, app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, app.interfaceRegistry),
        groupmodule.NewAppModule(appCodec, app.GroupKeeper, app.AccountKeeper, app.BankKeeper, app.interfaceRegistry),
        crisis.NewAppModule(&app.CrisisKeeper, skipGenesisInvariants),
        gov.NewAppModule(appCodec, app.GovKeeper, app.AccountKeeper, app.BankKeeper),
        mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, minttypes.DefaultInflationCalculationFn),
        slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper),
        distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper),
        staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper),
        crisis.NewAppModule(app.CrisisKeeper, skipGenesisInvariants, app.GetSubspace(crisistypes.ModuleName)),
        gov.NewAppModule(appCodec, &app.GovKeeper, app.AccountKeeper, app.BankKeeper, app.GetSubspace(govtypes.ModuleName)),
        mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, nil, app.GetSubspace(minttypes.ModuleName)),
        slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.GetSubspace(slashingtypes.ModuleName)),
        distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.GetSubspace(distrtypes.ModuleName)),
        staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper, app.GetSubspace(stakingtypes.ModuleName)),
        upgrade.NewAppModule(app.UpgradeKeeper),
        evidence.NewAppModule(app.EvidenceKeeper),
        consensus.NewAppModule(appCodec, app.ConsensusParamsKeeper),
        ibc.NewAppModule(app.IBCKeeper),
        params.NewAppModule(app.ParamsKeeper),
        transferModule,
        icaModule,
        // this line is used by starport scaffolding # stargate/app/appModule

    )

    app.mm.SetOrderBeginBlockers(
        // ...
        paramstypes.ModuleName,
        vestingtypes.ModuleName,
        consensusparamtypes.ModuleName,
        // ...
    )

    app.mm.SetOrderEndBlockers(
        // ...
        paramstypes.ModuleName,
        upgradetypes.ModuleName,
        vestingtypes.ModuleName,
        consensusparamtypes.ModuleName,
        // ...
    )

    app.mm.SetOrderInitGenesis(
    genesisModuleOrder := []string{
        // ...
        paramstypes.ModuleName,
        upgradetypes.ModuleName,
        vestingtypes.ModuleName,
        consensusparamtypes.ModuleName,
        // ...
    )
    }
    app.mm.SetOrderInitGenesis(genesisModuleOrder...)
    app.mm.SetOrderExportGenesis(genesisModuleOrder...)

    app.mm.RegisterInvariants(&app.CrisisKeeper)
    app.mm.RegisterRoutes(app.Router(), app.QueryRouter(), encodingConfig.Amino)
    app.mm.RegisterInvariants(app.CrisisKeeper)

    app.configurator = module.NewConfigurator(app.appCodec, app.MsgServiceRouter(), app.GRPCQueryRouter())
    app.mm.RegisterServices(app.configurator)

    autocliv1.RegisterQueryServer(app.GRPCQueryRouter(), runtimeservices.NewAutoCLIQueryService(app.mm.Modules))
    reflectionSvc, err := runtimeservices.NewReflectionService()
    if err != nil {
        panic(err)
    }
    reflectionv1.RegisterReflectionServiceServer(app.GRPCQueryRouter(), reflectionSvc)

    // create the simulation manager and define the order of the modules for deterministic simulations
    app.sm = module.NewSimulationManager(
        // ...
    )
    overrideModules := map[string]module.AppModuleSimulation{
        authtypes.ModuleName: auth.NewAppModule(app.appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts, app.GetSubspace(authtypes.ModuleName)),
    }
    app.sm = module.NewSimulationManagerFromAppModules(app.mm.Modules, overrideModules)
    app.sm.RegisterStoreDecoders()

    // ...

    app.SetInitChainer(app.InitChainer)
    app.SetBeginBlocker(app.BeginBlocker)

    // ...
}

func (app *App) InitChainer(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
    var genesisState GenesisState
    if err := tmjson.Unmarshal(req.AppStateBytes, &genesisState); err != nil {
    if err := json.Unmarshal(req.AppStateBytes, &genesisState); err != nil {
        panic(err)
    }
    // ...
}

// GetMaccPerms returns a copy of the module account permissions
func GetMaccPerms() map[string][]string {
    dupMaccPerms := make(map[string][]string)
    for k, v := range maccPerms {
        dupMaccPerms[k] = v
    }
    return dupMaccPerms
}

// TxConfig returns App's TxConfig.
func (app *App) TxConfig() client.TxConfig {
    return app.txConfig
}

// Configurator get app configurator
func (app *App) Configurator() module.Configurator {
    return app.configurator
}

// ModuleManager returns the app ModuleManager
func (app *App) ModuleManager() *module.Manager {
    return app.mm
}

app/simulation_test.go

import (
    // ...
    "cosmossdk.io/simapp"
    tmtypes "github.com/tendermint/tendermint/types"
    "encoding/json"
    "fmt"
    "math/rand"
    "runtime/debug"
    "strings"

    dbm "github.com/cometbft/cometbft-db"
    "github.com/cometbft/cometbft/libs/log"
    "github.com/cosmos/cosmos-sdk/baseapp"
    "github.com/cosmos/cosmos-sdk/client/flags"
    "github.com/cosmos/cosmos-sdk/server"
    storetypes "github.com/cosmos/cosmos-sdk/store/types"
    simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
    sdk "github.com/cosmos/cosmos-sdk/types"
    authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
    authzkeeper "github.com/cosmos/cosmos-sdk/x/authz/keeper"
    banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
    capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
    distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
    evidencetypes "github.com/cosmos/cosmos-sdk/x/evidence/types"
    govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
    minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
    paramstypes "github.com/cosmos/cosmos-sdk/x/params/types"
    simcli "github.com/cosmos/cosmos-sdk/x/simulation/client/cli"
    slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types"
    stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)

type storeKeysPrefixes struct {
    A        storetypes.StoreKey
    B        storetypes.StoreKey
    Prefixes [][]byte
}

// Get flags every time the simulator is run
func init() {
    simapp.GetSimulatorFlags()
    simcli.GetSimulatorFlags()
}

var defaultConsensusParams = &abci.ConsensusParams{
    Block: &abci.BlockParams{
        MaxBytes: 200000,
        MaxGas:   2000000,
    },
    Evidence: &tmproto.EvidenceParams{
        MaxAgeNumBlocks: 302400,
        MaxAgeDuration:  504 * time.Hour, // 3 weeks is the max duration
        MaxBytes:        10000,
    },
    Validator: &tmproto.ValidatorParams{
        PubKeyTypes: []string{
            tmtypes.ABCIPubKeyTypeEd25519,
        },
    },
}
func fauxMerkleModeOpt(bapp *baseapp.BaseApp) {
    bapp.SetFauxMerkleMode()
}

func BenchmarkSimulation(b *testing.B) {
    simapp.FlagEnabledValue = true
    simapp.FlagCommitValue = true

    config, db, dir, logger, _, err := simapp.SetupSimulation("goleveldb-app-sim", "Simulation")
    simcli.FlagSeedValue = time.Now().Unix()
    simcli.FlagVerboseValue = true
    simcli.FlagCommitValue = true
    simcli.FlagEnabledValue = true

    config := simcli.NewConfigFromFlags()
    config.ChainID = "mars-simapp"
    db, dir, logger, _, err := simtestutil.SetupSimulation(
        config,
        "leveldb-bApp-sim",
        "Simulation",
        simcli.FlagVerboseValue,
        simcli.FlagEnabledValue,
    )

    require.NoError(b, err, "simulation setup failed")

    b.Cleanup(func() {
        db.Close()
        err = os.RemoveAll(dir)
        require.NoError(b, err)
        require.NoError(b, db.Close())
        require.NoError(b, os.RemoveAll(dir))
    })


    encoding := app.MakeEncodingConfig()
    appOptions := make(simtestutil.AppOptionsMap, 0)
    appOptions[flags.FlagHome] = app.DefaultNodeHome
    appOptions[server.FlagInvCheckPeriod] = simcli.FlagPeriodValue

    app := app.New(
    bApp := app.New(
        logger,
        db,
        nil,
        true,
        map[int64]bool{},
        app.DefaultNodeHome,
        0,
        encoding,
        simapp.EmptyAppOptions{},
        app.MakeEncodingConfig(),
        appOptions,
        baseapp.SetChainID(config.ChainID),
    )
    require.Equal(b, app.Name, bApp.Name())

    _, simParams, simErr := simulation.SimulateFromSeed(
        b,
        os.Stdout,
        app.BaseApp,
        simapp.AppStateFn(app.AppCodec(), app.SimulationManager()),
        simulationtypes.RandomAccounts,
        simapp.SimulationOperations(app, app.AppCodec(), config),
        app.ModuleAccountAddrs(),
        config,
        app.AppCodec(),
        bApp.BaseApp,
        simtestutil.AppStateFn(
            bApp.AppCodec(),
            bApp.SimulationManager(),
            app.NewDefaultGenesisState(bApp.AppCodec()),
        ),
        simulationtypes.RandomAccounts,
        simtestutil.SimulationOperations(bApp, bApp.AppCodec(), config),
        bApp.ModuleAccountAddrs(),
        config,
        bApp.AppCodec(),
    )

    err = simapp.CheckExportSimulation(app, config, simParams)
    err = simtestutil.CheckExportSimulation(bApp, config, simParams)
    require.NoError(b, err)
    require.NoError(b, simErr)

    if config.Commit {
        simapp.PrintStats(db)
        simtestutil.PrintStats(db)
    }
}

x/{{moduleName}}/module_simulation.go

import (
    // ...
    simappparams "cosmossdk.io/simapp/params"
)

var (
    // ...
    _ = simappparams.StakePerAccount
    _ = rand.Rand{}
)

func (am AppModule) RandomizedParams(_ *rand.Rand) []simtypes.ParamChange {
    // ...
}
// ProposalMsgs returns msgs used for governance proposals for simulations.
func (am AppModule) ProposalMsgs(simState module.SimulationState) []simtypes.WeightedProposalMsg {
    return []simtypes.WeightedProposalMsg{
        // this line is used by starport scaffolding # simapp/module/OpMsg
    }
}

Deprecations

The app module might contains some legacy methods that are deprecated and can be removed:

x/{{moduleName}}/module.go

// Deprecated: use RegisterServices
func (am AppModule) Route() sdk.Route { return sdk.Route{} }

// Deprecated: use RegisterServices
func (AppModule) QuerierRoute() string { return types.RouterKey }

// Deprecated: use RegisterServices
func (am AppModule) LegacyQuerierHandler(_ *codec.LegacyAmino) sdk.Querier {
    return nil
}

Other required changes

Changes required to the network test util:

testutil/network/network.go

import (
    // ...

    "github.com/cosmos/cosmos-sdk/simapp"
    pruningtypes "github.com/cosmos/cosmos-sdk/pruning/types"
    pruningtypes "github.com/cosmos/cosmos-sdk/store/pruning/types"
    simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
)

func New(t *testing.T, configs ...Config) *Network {
    // ...

    net, err := network.New(t, t.TempDir(), cfg)
    require.NoError(t, err)
    _, err = net.WaitForHeight(1)
    require.NoError(t, err)

    // ...
}

func DefaultConfig() network.Config {
    encoding := app.MakeEncodingConfig()
    var (
        encoding = app.MakeEncodingConfig()
        chainID  = "chain-" + tmrand.NewRand().Str(6)
    )

    return network.Config{
        // ...
        AppConstructor: func(val network.Validator) servertypes.Application {
        AppConstructor: func(val network.ValidatorI) servertypes.Application {
            return app.New(
                val.Ctx.Logger,
                val.GetCtx().Logger,
                tmdb.NewMemDB(),
                nil,
                true,
                map[int64]bool{},
                val.Ctx.Config.RootDir,
                val.GetCtx().Config.RootDir,
                0,
                encoding,
                simapp.EmptyAppOptions{},
                baseapp.SetPruning(pruningtypes.NewPruningOptionsFromString(val.AppConfig.Pruning)),
                baseapp.SetMinGasPrices(val.AppConfig.MinGasPrices),
                simtestutil.EmptyAppOptions{},
                baseapp.SetPruning(pruningtypes.NewPruningOptionsFromString(val.GetAppConfig().Pruning)),
                baseapp.SetMinGasPrices(val.GetAppConfig().MinGasPrices),
                baseapp.SetChainID(chainID),
            )
        },
        // ...
        ChainID:         "chain-" + tmrand.NewRand().Str(6),
        ChainID:         chainID,
        // ...
    }
}

Update the collect genesis transactions command and add the new message validator argument:

cmd/{{binaryNamePrefix}}d/cmd/root.go

import (
    // ...

    tmtypes "github.com/cometbft/cometbft/types"
    "github.com/cosmos/cosmos-sdk/x/genutil"
    genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
)

func initRootCmd(rootCmd *cobra.Command, encodingConfig params.EncodingConfig) {
    // ...

    gentxModule := app.ModuleBasics[genutiltypes.ModuleName].(genutil.AppModuleBasic)
    rootCmd.AddCommand(
        // ...
        genutilcli.CollectGenTxsCmd(banktypes.GenesisBalancesIterator{}, app.DefaultHome),
        genutilcli.CollectGenTxsCmd(banktypes.GenesisBalancesIterator{}, app.DefaultNodeHome, gentxModule.GenTxValidator),
        // ...
    )

    // ...
}

func (a appCreator) newApp(
    logger log.Logger,
    db dbm.DB,
    traceStore io.Writer,
    appOpts servertypes.AppOptions,
) servertypes.Application {
    // ...

    pruningOpts, err := server.GetPruningOptionsFromFlags(appOpts)
    if err != nil {
        panic(err)
    }

    homeDir := cast.ToString(appOpts.Get(flags.FlagHome))
    chainID := cast.ToString(appOpts.Get(flags.FlagChainID))
    if chainID == "" {
        // fallback to genesis chain-id
        appGenesis, err := tmtypes.GenesisDocFromFile(filepath.Join(homeDir, "config", "genesis.json"))
        if err != nil {
            panic(err)
        }

        chainID = appGenesis.ChainID
    }

    // ...

    return app.New(
        // ...
        baseapp.SetPruning(pruningOpts),
        baseapp.SetMinGasPrices(cast.ToString(appOpts.Get(server.FlagMinGasPrices))),
        baseapp.SetMinRetainBlocks(cast.ToUint64(appOpts.Get(server.FlagMinRetainBlocks))),
        baseapp.SetHaltHeight(cast.ToUint64(appOpts.Get(server.FlagHaltHeight))),
        baseapp.SetHaltTime(cast.ToUint64(appOpts.Get(server.FlagHaltTime))),
        baseapp.SetMinRetainBlocks(cast.ToUint64(appOpts.Get(server.FlagMinRetainBlocks))),
        // ...
        baseapp.SetIAVLDisableFastNode(cast.ToBool(appOpts.Get(server.FlagDisableIAVLFastNode))),
        baseapp.SetChainID(chainID),
    )
)

func (a appCreator) appExport(
    logger log.Logger,
    db dbm.DB,
    traceStore io.Writer,
    height int64,
    forZeroHeight bool,
    jailAllowedAddrs []string,
    appOpts servertypes.AppOptions,
    modulesToExport []string,
) (servertypes.ExportedApp, error) {
    // ...

    return app.ExportAppStateAndValidators(forZeroHeight, jailAllowedAddrs)
    return app.ExportAppStateAndValidators(forZeroHeight, jailAllowedAddrs, modulesToExport)
}

Add the new extra argument to ExportAppStateAndValidators:

app/export.go

func (app *App) ExportAppStateAndValidators(
    forZeroHeight bool,
    jailAllowedAddrs []string,
    modulesToExport []string,
) (servertypes.ExportedApp, error) {
    // ...

    genState := app.mm.ExportGenesis(ctx, app.appCodec)
    genState := app.mm.ExportGenesisForModules(ctx, app.appCodec, modulesToExport)
    appState, err := json.MarshalIndent(genState, "", "  ")
    if err != nil {
        return servertypes.ExportedApp{}, err
    }

    // ...
}

Migration

You can also follow other Cosmos SDK migration steps in their upgrade guide. Specially the parameter migration which is required if you want to run the updated version keeping you current app state.

Query commands

Query commands context initialization should be changed to:

x/{moduleName}/client/cli/query_{typeName}.go

RunE: func(cmd *cobra.Command, args []string) (err error) {
    clientCtx := client.GetClientContextFromCmd(cmd)
    clientCtx, err := client.GetClientQueryContext(cmd)
    if err != nil {
        return err
    }

    // ...
}

ibc-go v7

Chains that are newly scaffolded with Ignite CLI v0.27.1 now use ibc-go/v7 for IBC functionality. It is required to upgrade to the newest version of ibc-go.

Applications scaffolded with older version of Ignite CLI require the following changes to the app file:

app/app.go

import (
    // ...
    ica "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts"
    icacontrollerkeeper "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/controller/keeper"
    icacontrollertypes "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/controller/types"
    icahost "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/host"
    icahostkeeper "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/host/keeper"
    icahosttypes "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/host/types"
    icatypes "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/types"
    "github.com/cosmos/ibc-go/v6/modules/apps/transfer"
    ibctransferkeeper "github.com/cosmos/ibc-go/v6/modules/apps/transfer/keeper"
    ibctransfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
    ibc "github.com/cosmos/ibc-go/v6/modules/core"
    ibcclient "github.com/cosmos/ibc-go/v6/modules/core/02-client"
    ibcclientclient "github.com/cosmos/ibc-go/v6/modules/core/02-client/client"
    ibcclienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
    ibcporttypes "github.com/cosmos/ibc-go/v6/modules/core/05-port/types"
    ibchost "github.com/cosmos/ibc-go/v6/modules/core/24-host"
    ibckeeper "github.com/cosmos/ibc-go/v6/modules/core/keeper"
    ica "github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts"
    icacontrollerkeeper "github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts/controller/keeper"
    icacontrollertypes "github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts/controller/types"
    icahost "github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts/host"
    icahostkeeper "github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts/host/keeper"
    icahosttypes "github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts/host/types"
    icatypes "github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts/types"
    "github.com/cosmos/ibc-go/v7/modules/apps/transfer"
    ibctransferkeeper "github.com/cosmos/ibc-go/v7/modules/apps/transfer/keeper"
    ibctransfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
    ibc "github.com/cosmos/ibc-go/v7/modules/core"
    ibcclient "github.com/cosmos/ibc-go/v7/modules/core/02-client"
    ibcclientclient "github.com/cosmos/ibc-go/v7/modules/core/02-client/client"
    ibcclienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
    ibcporttypes "github.com/cosmos/ibc-go/v7/modules/core/05-port/types"
    ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported"
    ibckeeper "github.com/cosmos/ibc-go/v7/modules/core/keeper"
    solomachine "github.com/cosmos/ibc-go/v7/modules/light-clients/06-solomachine"
    ibctm "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint"
)

var (
    // ...

    ModuleBasics = module.NewBasicManager(
        // ...
        groupmodule.AppModuleBasic{},
        ibc.AppModuleBasic{},
        ibctm.AppModuleBasic{},
        solomachine.AppModuleBasic{},
        upgrade.AppModuleBasic{},
        // ...
    )
)

func New(
    logger log.Logger,
    db dbm.DB,
    traceStore io.Writer,
    loadLatest bool,
    skipUpgradeHeights map[int64]bool,
    homePath string,
    invCheckPeriod uint,
    encodingConfig appparams.EncodingConfig,
    appOpts servertypes.AppOptions,
    baseAppOptions ...func(*baseapp.BaseApp),
) *App {
    // ...

    keys := sdk.NewKVStoreKeys(
        // ...
        govtypes.StoreKey,
        paramstypes.StoreKey,
        ibchost.StoreKey,
        ibcexported.StoreKey,
        // ...
    )

    // ...
    // grant capabilities for the ibc and ibc-transfer modules
    scopedIBCKeeper := app.CapabilityKeeper.ScopeToModule(ibchost.ModuleName)
    scopedIBCKeeper := app.CapabilityKeeper.ScopeToModule(ibcexported.ModuleName)
    scopedICAControllerKeeper := app.CapabilityKeeper.ScopeToModule(icacontrollertypes.SubModuleName)

    // ...

    app.IBCKeeper = ibckeeper.NewKeeper(
        appCodec,
        keys[ibchost.StoreKey],
        app.GetSubspace(ibchost.ModuleName),
        keys[ibcexported.StoreKey],
        app.GetSubspace(ibcexported.ModuleName),
        app.StakingKeeper,
        app.UpgradeKeeper,
        scopedIBCKeeper,
    )

    // ...

    app.mm.SetOrderBeginBlockers(
        // ...
        crisistypes.ModuleName,
        ibctransfertypes.ModuleName,
        ibchost.ModuleName,
        ibcexported.ModuleName,
        // ...
    )

    app.mm.SetOrderEndBlockers(
        // ...
        stakingtypes.ModuleName,
        ibctransfertypes.ModuleName,
        ibchost.ModuleName,
        ibcexported.ModuleName,
        // ...
    )

    genesisModuleOrder := []string{
        // ...
        genutiltypes.ModuleName,
        ibctransfertypes.ModuleName,
        ibchost.ModuleName,
        ibcexported.ModuleName,
        // ...
    }

    // ...
)

func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino, key, tkey storetypes.StoreKey) paramskeeper.Keeper {
    // ...
    paramsKeeper.Subspace(crisistypes.ModuleName)
    paramsKeeper.Subspace(ibctransfertypes.ModuleName)
    paramsKeeper.Subspace(ibchost.ModuleName)
    paramsKeeper.Subspace(ibcexported.ModuleName)
    // ...
}

You can follow other IBC migration steps in their migration guide v6 to v7.

Doctor command

As the final steps it's recommended to run ignite doctor and go mod tidy.