0g-chain/app/app.go

package app

import (
	"fmt"
	"io"
	stdlog "log"
	"net/http"
	"os"
	"path/filepath"

	dbm "github.com/cometbft/cometbft-db"
	abci "github.com/cometbft/cometbft/abci/types"
	tmjson "github.com/cometbft/cometbft/libs/json"
	tmlog "github.com/cometbft/cometbft/libs/log"
	"github.com/cosmos/cosmos-sdk/baseapp"
	"github.com/cosmos/cosmos-sdk/client"
	nodeservice "github.com/cosmos/cosmos-sdk/client/grpc/node"
	"github.com/cosmos/cosmos-sdk/client/grpc/tmservice"
	"github.com/cosmos/cosmos-sdk/codec"
	"github.com/cosmos/cosmos-sdk/codec/types"
	"github.com/cosmos/cosmos-sdk/server/api"
	"github.com/cosmos/cosmos-sdk/server/config"
	servertypes "github.com/cosmos/cosmos-sdk/server/types"
	storetypes "github.com/cosmos/cosmos-sdk/store/types"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/types/module"
	"github.com/cosmos/cosmos-sdk/version"
	"github.com/cosmos/cosmos-sdk/x/auth"
	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
	authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation"
	authtx "github.com/cosmos/cosmos-sdk/x/auth/tx"
	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
	"github.com/cosmos/cosmos-sdk/x/auth/vesting"
	vestingtypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"
	"github.com/cosmos/cosmos-sdk/x/authz"
	authzkeeper "github.com/cosmos/cosmos-sdk/x/authz/keeper"
	authzmodule "github.com/cosmos/cosmos-sdk/x/authz/module"
	"github.com/cosmos/cosmos-sdk/x/bank"
	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
	"github.com/cosmos/cosmos-sdk/x/capability"
	capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper"
	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
	consensus "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"
	"github.com/cosmos/cosmos-sdk/x/crisis"
	crisiskeeper "github.com/cosmos/cosmos-sdk/x/crisis/keeper"
	crisistypes "github.com/cosmos/cosmos-sdk/x/crisis/types"
	distr "github.com/cosmos/cosmos-sdk/x/distribution"
	distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper"
	distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
	"github.com/cosmos/cosmos-sdk/x/evidence"
	evidencekeeper "github.com/cosmos/cosmos-sdk/x/evidence/keeper"
	evidencetypes "github.com/cosmos/cosmos-sdk/x/evidence/types"
	"github.com/cosmos/cosmos-sdk/x/genutil"
	genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
	"github.com/cosmos/cosmos-sdk/x/gov"
	govclient "github.com/cosmos/cosmos-sdk/x/gov/client"
	govkeeper "github.com/cosmos/cosmos-sdk/x/gov/keeper"
	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
	govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
	govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
	"github.com/cosmos/cosmos-sdk/x/mint"
	mintkeeper "github.com/cosmos/cosmos-sdk/x/mint/keeper"
	minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
	"github.com/cosmos/cosmos-sdk/x/params"
	paramsclient "github.com/cosmos/cosmos-sdk/x/params/client"
	paramskeeper "github.com/cosmos/cosmos-sdk/x/params/keeper"
	paramstypes "github.com/cosmos/cosmos-sdk/x/params/types"
	paramproposal "github.com/cosmos/cosmos-sdk/x/params/types/proposal"
	"github.com/cosmos/cosmos-sdk/x/slashing"
	slashingkeeper "github.com/cosmos/cosmos-sdk/x/slashing/keeper"
	slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types"
	"github.com/cosmos/cosmos-sdk/x/staking"
	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
	"github.com/cosmos/cosmos-sdk/x/upgrade"
	upgradeclient "github.com/cosmos/cosmos-sdk/x/upgrade/client"
	upgradekeeper "github.com/cosmos/cosmos-sdk/x/upgrade/keeper"
	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
	"github.com/cosmos/ibc-apps/middleware/packet-forward-middleware/v7/packetforward"
	packetforwardkeeper "github.com/cosmos/ibc-apps/middleware/packet-forward-middleware/v7/packetforward/keeper"
	packetforwardtypes "github.com/cosmos/ibc-apps/middleware/packet-forward-middleware/v7/packetforward/types"
	transfer "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"
	evmante "github.com/evmos/ethermint/app/ante"
	ethermintconfig "github.com/evmos/ethermint/server/config"
	"github.com/evmos/ethermint/x/evm"
	evmkeeper "github.com/evmos/ethermint/x/evm/keeper"
	evmtypes "github.com/evmos/ethermint/x/evm/types"
	"github.com/evmos/ethermint/x/evm/vm/geth"
	"github.com/evmos/ethermint/x/feemarket"
	feemarketkeeper "github.com/evmos/ethermint/x/feemarket/keeper"
	feemarkettypes "github.com/evmos/ethermint/x/feemarket/types"
	"github.com/gorilla/mux"

	"github.com/kava-labs/kava/app/ante"
	kavaparams "github.com/kava-labs/kava/app/params"

	// "github.com/kava-labs/kava/x/auction"
	// "github.com/kava-labs/kava/x/bep3"
	// bep3keeper "github.com/kava-labs/kava/x/bep3/keeper"
	// bep3types "github.com/kava-labs/kava/x/bep3/types"

	// "github.com/kava-labs/kava/x/cdp"
	// "github.com/kava-labs/kava/x/committee"
	// "github.com/kava-labs/kava/x/community"
	// "github.com/kava-labs/kava/x/earn"
	// "github.com/kava-labs/kava/x/hard"
	// "github.com/kava-labs/kava/x/incentive"
	// "github.com/kava-labs/kava/x/issuance"
	// "github.com/kava-labs/kava/x/kavadist"
	// "github.com/kava-labs/kava/x/liquid"
	// "github.com/kava-labs/kava/x/pricefeed"
	// "github.com/kava-labs/kava/x/router"
	// "github.com/kava-labs/kava/x/savings"
	// "github.com/kava-labs/kava/x/swap"

	"github.com/kava-labs/kava/x/bep3"
	evmutil "github.com/kava-labs/kava/x/evmutil"
	evmutilkeeper "github.com/kava-labs/kava/x/evmutil/keeper"
	evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"

	// metrics "github.com/kava-labs/kava/x/metrics"
	// metricstypes "github.com/kava-labs/kava/x/metrics/types"

	validatorvesting "github.com/kava-labs/kava/x/validator-vesting"
	validatorvestingrest "github.com/kava-labs/kava/x/validator-vesting/client/rest"
	validatorvestingtypes "github.com/kava-labs/kava/x/validator-vesting/types"
)

const (
	appName = "kava"
)

var (
	// DefaultNodeHome default home directories for the application daemon
	DefaultNodeHome string

	// ModuleBasics manages simple versions of full app modules.
	// It's used for things such as codec registration and genesis file verification.
	ModuleBasics = module.NewBasicManager(
		genutil.NewAppModuleBasic(genutiltypes.DefaultMessageValidator),
		auth.AppModuleBasic{},
		bank.AppModuleBasic{},
		capability.AppModuleBasic{},
		staking.AppModuleBasic{},
		distr.AppModuleBasic{},
		gov.NewAppModuleBasic([]govclient.ProposalHandler{
			paramsclient.ProposalHandler,
			upgradeclient.LegacyProposalHandler,
			upgradeclient.LegacyCancelProposalHandler,
			ibcclientclient.UpdateClientProposalHandler,
			ibcclientclient.UpgradeProposalHandler,
			// kavadistclient.ProposalHandler,
			// committeeclient.ProposalHandler,
			// earnclient.DepositProposalHandler,
			// earnclient.WithdrawProposalHandler,
			// communityclient.LendDepositProposalHandler,
			// communityclient.LendWithdrawProposalHandler,
		}),
		params.AppModuleBasic{},
		crisis.AppModuleBasic{},
		slashing.AppModuleBasic{},
		ibc.AppModuleBasic{},
		ibctm.AppModuleBasic{},
		solomachine.AppModuleBasic{},
		packetforward.AppModuleBasic{},
		upgrade.AppModuleBasic{},
		evidence.AppModuleBasic{},
		authzmodule.AppModuleBasic{},
		transfer.AppModuleBasic{},
		vesting.AppModuleBasic{},
		evm.AppModuleBasic{},
		feemarket.AppModuleBasic{},
		// kavadist.AppModuleBasic{},
		// auction.AppModuleBasic{},
		// issuance.AppModuleBasic{},
		bep3.AppModuleBasic{},
		// pricefeed.AppModuleBasic{},
		// swap.AppModuleBasic{},
		// cdp.AppModuleBasic{},
		// hard.AppModuleBasic{},
		// committee.AppModuleBasic{},
		// incentive.AppModuleBasic{},
		// savings.AppModuleBasic{},
		validatorvesting.AppModuleBasic{},
		evmutil.AppModuleBasic{},
		// liquid.AppModuleBasic{},
		// earn.AppModuleBasic{},
		// router.AppModuleBasic{},
		mint.AppModuleBasic{},
		// community.AppModuleBasic{},
		// metrics.AppModuleBasic{},
		consensus.AppModuleBasic{},
	)

	// module account permissions
	// If these are changed, the permissions stored in accounts
	// must also be migrated during a chain upgrade.
	mAccPerms = map[string][]string{
		authtypes.FeeCollectorName:     nil,
		distrtypes.ModuleName:          nil,
		stakingtypes.BondedPoolName:    {authtypes.Burner, authtypes.Staking},
		stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking},
		govtypes.ModuleName:            {authtypes.Burner},
		ibctransfertypes.ModuleName:    {authtypes.Minter, authtypes.Burner},
		evmtypes.ModuleName:            {authtypes.Minter, authtypes.Burner}, // used for secure addition and subtraction of balance using module account
		evmutiltypes.ModuleName:        {authtypes.Minter, authtypes.Burner},
		// kavadisttypes.KavaDistMacc:      {authtypes.Minter},
		// auctiontypes.ModuleName:         nil,
		// issuancetypes.ModuleAccountName: {authtypes.Minter, authtypes.Burner},
		// bep3types.ModuleName: {authtypes.Burner, authtypes.Minter},
		// swaptypes.ModuleName: nil,
		// cdptypes.ModuleName:             {authtypes.Minter, authtypes.Burner},
		// cdptypes.LiquidatorMacc:         {authtypes.Minter, authtypes.Burner},
		// hardtypes.ModuleAccountName:     {authtypes.Minter},
		// savingstypes.ModuleAccountName: nil,
		// liquidtypes.ModuleAccountName:   {authtypes.Minter, authtypes.Burner},
		// earntypes.ModuleAccountName:     nil,
		// kavadisttypes.FundModuleAccount: nil,
		minttypes.ModuleName: {authtypes.Minter},
		// communitytypes.ModuleName:       nil,
	}
)

// Verify app interface at compile time
var (
	_ servertypes.Application = (*App)(nil)
)

// Options bundles several configuration params for an App.
type Options struct {
	SkipLoadLatest        bool
	SkipUpgradeHeights    map[int64]bool
	SkipGenesisInvariants bool
	InvariantCheckPeriod  uint
	MempoolEnableAuth     bool
	MempoolAuthAddresses  []sdk.AccAddress
	EVMTrace              string
	EVMMaxGasWanted       uint64
	// TelemetryOptions      metricstypes.TelemetryOptions
}

// DefaultOptions is a sensible default Options value.
var DefaultOptions = Options{
	EVMTrace:        ethermintconfig.DefaultEVMTracer,
	EVMMaxGasWanted: ethermintconfig.DefaultMaxTxGasWanted,
}

// App is the Kava ABCI application.
type App struct {
	*baseapp.BaseApp

	// codec
	legacyAmino       *codec.LegacyAmino
	appCodec          codec.Codec
	interfaceRegistry types.InterfaceRegistry

	// keys to access the substores
	keys    map[string]*storetypes.KVStoreKey
	tkeys   map[string]*storetypes.TransientStoreKey
	memKeys map[string]*storetypes.MemoryStoreKey

	// keepers from all the modules
	accountKeeper       authkeeper.AccountKeeper
	bankKeeper          bankkeeper.Keeper
	capabilityKeeper    *capabilitykeeper.Keeper
	stakingKeeper       *stakingkeeper.Keeper
	distrKeeper         distrkeeper.Keeper
	govKeeper           govkeeper.Keeper
	paramsKeeper        paramskeeper.Keeper
	authzKeeper         authzkeeper.Keeper
	crisisKeeper        crisiskeeper.Keeper
	slashingKeeper      slashingkeeper.Keeper
	ibcKeeper           *ibckeeper.Keeper // IBC Keeper must be a pointer in the app, so we can SetRouter on it correctly
	packetForwardKeeper *packetforwardkeeper.Keeper
	evmKeeper           *evmkeeper.Keeper
	evmutilKeeper       evmutilkeeper.Keeper
	feeMarketKeeper     feemarketkeeper.Keeper
	upgradeKeeper       upgradekeeper.Keeper
	evidenceKeeper      evidencekeeper.Keeper
	transferKeeper      ibctransferkeeper.Keeper
	// kavadistKeeper        kavadistkeeper.Keeper
	// auctionKeeper         auctionkeeper.Keeper
	// issuanceKeeper        issuancekeeper.Keeper
	// bep3Keeper bep3keeper.Keeper
	// pricefeedKeeper pricefeedkeeper.Keeper
	// swapKeeper swapkeeper.Keeper
	// cdpKeeper             cdpkeeper.Keeper
	// hardKeeper            hardkeeper.Keeper
	// committeeKeeper       committeekeeper.Keeper
	// incentiveKeeper       incentivekeeper.Keeper
	// savingsKeeper savingskeeper.Keeper
	// liquidKeeper          liquidkeeper.Keeper
	// earnKeeper            earnkeeper.Keeper
	// routerKeeper routerkeeper.Keeper
	mintKeeper mintkeeper.Keeper
	// communityKeeper       communitykeeper.Keeper
	consensusParamsKeeper consensusparamkeeper.Keeper

	// make scoped keepers public for test purposes
	ScopedIBCKeeper      capabilitykeeper.ScopedKeeper
	ScopedTransferKeeper capabilitykeeper.ScopedKeeper

	// the module manager
	mm *module.Manager

	// simulation manager
	sm *module.SimulationManager

	// configurator
	configurator module.Configurator
}

func init() {
	userHomeDir, err := os.UserHomeDir()
	if err != nil {
		stdlog.Printf("Failed to get home dir %v", err)
	}

	DefaultNodeHome = filepath.Join(userHomeDir, ".kava")
}

// NewApp returns a reference to an initialized App.
func NewApp(
	logger tmlog.Logger,
	db dbm.DB,
	homePath string,
	traceStore io.Writer,
	encodingConfig kavaparams.EncodingConfig,
	options Options,
	baseAppOptions ...func(*baseapp.BaseApp),
) *App {
	appCodec := encodingConfig.Marshaler
	legacyAmino := encodingConfig.Amino
	interfaceRegistry := encodingConfig.InterfaceRegistry

	bApp := baseapp.NewBaseApp(appName, logger, db, encodingConfig.TxConfig.TxDecoder(), baseAppOptions...)
	bApp.SetCommitMultiStoreTracer(traceStore)
	bApp.SetVersion(version.Version)
	bApp.SetInterfaceRegistry(interfaceRegistry)

	keys := sdk.NewKVStoreKeys(
		authtypes.StoreKey,
		banktypes.StoreKey,
		stakingtypes.StoreKey,
		distrtypes.StoreKey,
		slashingtypes.StoreKey,
		packetforwardtypes.StoreKey,
		govtypes.StoreKey,
		paramstypes.StoreKey,
		ibcexported.StoreKey,
		upgradetypes.StoreKey,
		evidencetypes.StoreKey,
		ibctransfertypes.StoreKey,
		evmtypes.StoreKey,
		feemarkettypes.StoreKey,
		authzkeeper.StoreKey,
		capabilitytypes.StoreKey,
		// kavadisttypes.StoreKey,
		// auctiontypes.StoreKey,
		// issuancetypes.StoreKey,
		// bep3types.StoreKey,
		// pricefeedtypes.StoreKey,
		// swaptypes.StoreKey,
		// cdptypes.StoreKey,
		// hardtypes.StoreKey,
		// communitytypes.StoreKey,
		// committeetypes.StoreKey,
		// incentivetypes.StoreKey,
		evmutiltypes.StoreKey,
		// savingstypes.StoreKey,
		// earntypes.StoreKey,
		minttypes.StoreKey,
		consensusparamtypes.StoreKey,
		crisistypes.StoreKey,
	)
	tkeys := sdk.NewTransientStoreKeys(paramstypes.TStoreKey, evmtypes.TransientKey, feemarkettypes.TransientKey)
	memKeys := sdk.NewMemoryStoreKeys(capabilitytypes.MemStoreKey)

	// Authority for gov proposals, using the x/gov module account address
	govAuthAddr := authtypes.NewModuleAddress(govtypes.ModuleName)
	govAuthAddrStr := govAuthAddr.String()

	app := &App{
		BaseApp:           bApp,
		legacyAmino:       legacyAmino,
		appCodec:          appCodec,
		interfaceRegistry: interfaceRegistry,
		keys:              keys,
		tkeys:             tkeys,
		memKeys:           memKeys,
	}

	// init params keeper and subspaces
	app.paramsKeeper = paramskeeper.NewKeeper(
		appCodec,
		legacyAmino,
		keys[paramstypes.StoreKey],
		tkeys[paramstypes.TStoreKey],
	)
	authSubspace := app.paramsKeeper.Subspace(authtypes.ModuleName)
	bankSubspace := app.paramsKeeper.Subspace(banktypes.ModuleName)
	stakingSubspace := app.paramsKeeper.Subspace(stakingtypes.ModuleName)
	distrSubspace := app.paramsKeeper.Subspace(distrtypes.ModuleName)
	slashingSubspace := app.paramsKeeper.Subspace(slashingtypes.ModuleName)
	govSubspace := app.paramsKeeper.Subspace(govtypes.ModuleName).WithKeyTable(govv1.ParamKeyTable())
	crisisSubspace := app.paramsKeeper.Subspace(crisistypes.ModuleName)
	// kavadistSubspace := app.paramsKeeper.Subspace(kavadisttypes.ModuleName)
	// auctionSubspace := app.paramsKeeper.Subspace(auctiontypes.ModuleName)
	// issuanceSubspace := app.paramsKeeper.Subspace(issuancetypes.ModuleName)
	// bep3Subspace := app.paramsKeeper.Subspace(bep3types.ModuleName)
	// pricefeedSubspace := app.paramsKeeper.Subspace(pricefeedtypes.ModuleName)
	// swapSubspace := app.paramsKeeper.Subspace(swaptypes.ModuleName)
	// cdpSubspace := app.paramsKeeper.Subspace(cdptypes.ModuleName)
	// hardSubspace := app.paramsKeeper.Subspace(hardtypes.ModuleName)
	// incentiveSubspace := app.paramsKeeper.Subspace(incentivetypes.ModuleName)
	// savingsSubspace := app.paramsKeeper.Subspace(savingstypes.ModuleName)
	ibcSubspace := app.paramsKeeper.Subspace(ibcexported.ModuleName)
	ibctransferSubspace := app.paramsKeeper.Subspace(ibctransfertypes.ModuleName)
	packetforwardSubspace := app.paramsKeeper.Subspace(packetforwardtypes.ModuleName).WithKeyTable(packetforwardtypes.ParamKeyTable())
	feemarketSubspace := app.paramsKeeper.Subspace(feemarkettypes.ModuleName)
	evmSubspace := app.paramsKeeper.Subspace(evmtypes.ModuleName)
	evmutilSubspace := app.paramsKeeper.Subspace(evmutiltypes.ModuleName)
	// earnSubspace := app.paramsKeeper.Subspace(earntypes.ModuleName)
	mintSubspace := app.paramsKeeper.Subspace(minttypes.ModuleName)

	// set the BaseApp's parameter store
	app.consensusParamsKeeper = consensusparamkeeper.NewKeeper(appCodec, keys[consensusparamtypes.StoreKey], govAuthAddrStr)
	bApp.SetParamStore(&app.consensusParamsKeeper)

	app.capabilityKeeper = capabilitykeeper.NewKeeper(appCodec, keys[capabilitytypes.StoreKey], memKeys[capabilitytypes.MemStoreKey])
	scopedIBCKeeper := app.capabilityKeeper.ScopeToModule(ibcexported.ModuleName)
	scopedTransferKeeper := app.capabilityKeeper.ScopeToModule(ibctransfertypes.ModuleName)
	app.capabilityKeeper.Seal()

	// add keepers
	app.accountKeeper = authkeeper.NewAccountKeeper(
		appCodec,
		keys[authtypes.StoreKey],
		authtypes.ProtoBaseAccount,
		mAccPerms,
		sdk.GetConfig().GetBech32AccountAddrPrefix(),
		govAuthAddrStr,
	)
	app.bankKeeper = bankkeeper.NewBaseKeeper(
		appCodec,
		keys[banktypes.StoreKey],
		app.accountKeeper,
		app.loadBlockedMaccAddrs(),
		govAuthAddrStr,
	)
	app.stakingKeeper = stakingkeeper.NewKeeper(
		appCodec,
		keys[stakingtypes.StoreKey],
		app.accountKeeper,
		app.bankKeeper,
		govAuthAddrStr,
	)
	app.authzKeeper = authzkeeper.NewKeeper(
		keys[authzkeeper.StoreKey],
		appCodec,
		app.BaseApp.MsgServiceRouter(),
		app.accountKeeper,
	)
	app.distrKeeper = distrkeeper.NewKeeper(
		appCodec,
		keys[distrtypes.StoreKey],
		app.accountKeeper,
		app.bankKeeper,
		app.stakingKeeper,
		authtypes.FeeCollectorName,
		govAuthAddrStr,
	)
	app.slashingKeeper = slashingkeeper.NewKeeper(
		appCodec,
		app.legacyAmino,
		keys[slashingtypes.StoreKey],
		app.stakingKeeper,
		govAuthAddrStr,
	)
	app.crisisKeeper = *crisiskeeper.NewKeeper(
		appCodec,
		keys[crisistypes.StoreKey],
		options.InvariantCheckPeriod,
		app.bankKeeper,
		authtypes.FeeCollectorName,
		govAuthAddrStr,
	)
	app.upgradeKeeper = *upgradekeeper.NewKeeper(
		options.SkipUpgradeHeights,
		keys[upgradetypes.StoreKey],
		appCodec,
		homePath,
		app.BaseApp,
		govAuthAddrStr,
	)
	app.evidenceKeeper = *evidencekeeper.NewKeeper(
		appCodec,
		keys[evidencetypes.StoreKey],
		app.stakingKeeper,
		app.slashingKeeper,
	)

	app.ibcKeeper = ibckeeper.NewKeeper(
		appCodec,
		keys[ibcexported.StoreKey],
		ibcSubspace,
		app.stakingKeeper,
		app.upgradeKeeper,
		scopedIBCKeeper,
	)

	// Create Ethermint keepers
	app.feeMarketKeeper = feemarketkeeper.NewKeeper(
		appCodec,
		govAuthAddr,
		keys[feemarkettypes.StoreKey],
		tkeys[feemarkettypes.TransientKey],
		feemarketSubspace,
	)

	app.evmutilKeeper = evmutilkeeper.NewKeeper(
		app.appCodec,
		keys[evmutiltypes.StoreKey],
		evmutilSubspace,
		app.bankKeeper,
		app.accountKeeper,
	)

	evmBankKeeper := evmutilkeeper.NewEvmBankKeeper(app.evmutilKeeper, app.bankKeeper, app.accountKeeper)
	app.evmKeeper = evmkeeper.NewKeeper(
		appCodec, keys[evmtypes.StoreKey], tkeys[evmtypes.TransientKey],
		govAuthAddr,
		app.accountKeeper, evmBankKeeper, app.stakingKeeper, app.feeMarketKeeper,
		nil, // precompiled contracts
		geth.NewEVM,
		options.EVMTrace,
		evmSubspace,
	)

	app.evmutilKeeper.SetEvmKeeper(app.evmKeeper)

	// It's important to note that the PFM Keeper must be initialized before the Transfer Keeper
	app.packetForwardKeeper = packetforwardkeeper.NewKeeper(
		appCodec,
		keys[packetforwardtypes.StoreKey],
		nil, // will be zero-value here, reference is set later on with SetTransferKeeper.
		app.ibcKeeper.ChannelKeeper,
		app.distrKeeper,
		app.bankKeeper,
		app.ibcKeeper.ChannelKeeper,
		govAuthAddrStr,
	)

	app.transferKeeper = ibctransferkeeper.NewKeeper(
		appCodec,
		keys[ibctransfertypes.StoreKey],
		ibctransferSubspace,
		app.packetForwardKeeper,
		app.ibcKeeper.ChannelKeeper,
		&app.ibcKeeper.PortKeeper,
		app.accountKeeper,
		app.bankKeeper,
		scopedTransferKeeper,
	)
	app.packetForwardKeeper.SetTransferKeeper(app.transferKeeper)
	transferModule := transfer.NewAppModule(app.transferKeeper)

	// allow ibc packet forwarding for ibc transfers.
	// transfer stack contains (from top to bottom):
	// - Packet Forward Middleware
	// - Transfer
	var transferStack ibcporttypes.IBCModule
	transferStack = transfer.NewIBCModule(app.transferKeeper)
	transferStack = packetforward.NewIBCMiddleware(
		transferStack,
		app.packetForwardKeeper,
		0, // retries on timeout
		packetforwardkeeper.DefaultForwardTransferPacketTimeoutTimestamp,
		packetforwardkeeper.DefaultRefundTransferPacketTimeoutTimestamp,
	)

	// Create static IBC router, add transfer route, then set and seal it
	ibcRouter := ibcporttypes.NewRouter()
	ibcRouter.AddRoute(ibctransfertypes.ModuleName, transferStack)
	app.ibcKeeper.SetRouter(ibcRouter)

	// app.auctionKeeper = auctionkeeper.NewKeeper(
	// 	appCodec,
	// 	keys[auctiontypes.StoreKey],
	// 	auctionSubspace,
	// 	app.bankKeeper,
	// 	app.accountKeeper,
	// )
	// app.issuanceKeeper = issuancekeeper.NewKeeper(
	// 	appCodec,
	// 	keys[issuancetypes.StoreKey],
	// 	issuanceSubspace,
	// 	app.accountKeeper,
	// 	app.bankKeeper,
	// )
	// app.bep3Keeper = bep3keeper.NewKeeper(
	// 	appCodec,
	// 	keys[bep3types.StoreKey],
	// 	app.bankKeeper,
	// 	app.accountKeeper,
	// 	bep3Subspace,
	// 	app.ModuleAccountAddrs(),
	// )
	// app.pricefeedKeeper = pricefeedkeeper.NewKeeper(
	// 	appCodec,
	// 	keys[pricefeedtypes.StoreKey],
	// 	pricefeedSubspace,
	// )
	// swapKeeper := swapkeeper.NewKeeper(
	// 	appCodec,
	// 	keys[swaptypes.StoreKey],
	// 	swapSubspace,
	// 	app.accountKeeper,
	// 	app.bankKeeper,
	// )
	// cdpKeeper := cdpkeeper.NewKeeper(
	// 	appCodec,
	// 	keys[cdptypes.StoreKey],
	// 	cdpSubspace,
	// 	app.pricefeedKeeper,
	// 	app.auctionKeeper,
	// 	app.bankKeeper,
	// 	app.accountKeeper,
	// 	mAccPerms,
	// )
	// hardKeeper := hardkeeper.NewKeeper(
	// 	appCodec,
	// 	keys[hardtypes.StoreKey],
	// 	hardSubspace,
	// 	app.accountKeeper,
	// 	app.bankKeeper,
	// 	app.pricefeedKeeper,
	// 	app.auctionKeeper,
	// )
	// app.liquidKeeper = liquidkeeper.NewDefaultKeeper(
	// 	appCodec,
	// 	app.accountKeeper,
	// 	app.bankKeeper,
	// 	app.stakingKeeper,
	// 	&app.distrKeeper,
	// )
	// savingsKeeper := savingskeeper.NewKeeper(
	// 	appCodec,
	// 	keys[savingstypes.StoreKey],
	// 	savingsSubspace,
	// 	app.accountKeeper,
	// 	app.bankKeeper,
	// 	app.liquidKeeper,
	// )
	// earnKeeper := earnkeeper.NewKeeper(
	// 	appCodec,
	// 	keys[earntypes.StoreKey],
	// 	earnSubspace,
	// 	app.accountKeeper,
	// 	app.bankKeeper,
	// 	&app.liquidKeeper,
	// 	&hardKeeper,
	// 	&savingsKeeper,
	// 	&app.distrKeeper,
	// )

	// app.kavadistKeeper = kavadistkeeper.NewKeeper(
	// 	appCodec,
	// 	keys[kavadisttypes.StoreKey],
	// 	kavadistSubspace,
	// 	app.bankKeeper,
	// 	app.accountKeeper,
	// 	app.distrKeeper,
	// 	app.loadBlockedMaccAddrs(),
	// )

	app.mintKeeper = mintkeeper.NewKeeper(
		appCodec,
		keys[minttypes.StoreKey],
		app.stakingKeeper,
		app.accountKeeper,
		app.bankKeeper,
		authtypes.FeeCollectorName,
		govAuthAddrStr,
	)

	// x/community's deposit/withdraw to lend proposals depend on hard keeper.
	// app.communityKeeper = communitykeeper.NewKeeper(
	// 	appCodec,
	// 	keys[communitytypes.StoreKey],
	// 	app.accountKeeper,
	// 	app.bankKeeper,
	// 	&cdpKeeper,
	// 	app.distrKeeper,
	// 	&hardKeeper,
	// 	&app.mintKeeper,
	// 	&app.kavadistKeeper,
	// 	app.stakingKeeper,
	// 	govAuthAddr,
	// )

	// app.incentiveKeeper = incentivekeeper.NewKeeper(
	// 	appCodec,
	// 	keys[incentivetypes.StoreKey],
	// 	incentiveSubspace,
	// 	app.bankKeeper,
	// 	&cdpKeeper,
	// 	&hardKeeper,
	// 	app.accountKeeper,
	// 	app.stakingKeeper,
	// 	&swapKeeper,
	// 	&savingsKeeper,
	// 	&app.liquidKeeper,
	// 	&earnKeeper,
	// 	app.mintKeeper,
	// 	app.distrKeeper,
	// 	app.pricefeedKeeper,
	// )
	// app.routerKeeper = routerkeeper.NewKeeper(
	// 	&app.earnKeeper,
	// 	app.liquidKeeper,
	// 	app.stakingKeeper,
	// )

	// create committee keeper with router
	// committeeGovRouter := govv1beta1.NewRouter()
	// committeeGovRouter.
	// 	AddRoute(govtypes.RouterKey, govv1beta1.ProposalHandler).
	// 	AddRoute(communitytypes.RouterKey, community.NewCommunityPoolProposalHandler(app.communityKeeper)).
	// 	AddRoute(paramproposal.RouterKey, params.NewParamChangeProposalHandler(app.paramsKeeper)).
	// 	AddRoute(upgradetypes.RouterKey, upgrade.NewSoftwareUpgradeProposalHandler(&app.upgradeKeeper))
	// // Note: the committee proposal handler is not registered on the committee router. This means committees cannot create or update other committees.
	// // Adding the committee proposal handler to the router is possible but awkward as the handler depends on the keeper which depends on the handler.
	// app.committeeKeeper = committeekeeper.NewKeeper(
	// 	appCodec,
	// 	keys[committeetypes.StoreKey],
	// 	committeeGovRouter,
	// 	app.paramsKeeper,
	// 	app.accountKeeper,
	// 	app.bankKeeper,
	// )

	// register the staking hooks
	app.stakingKeeper.SetHooks(
		stakingtypes.NewMultiStakingHooks(
			app.distrKeeper.Hooks(),
			app.slashingKeeper.Hooks(),
			// app.incentiveKeeper.Hooks(),
		))

	// app.swapKeeper = *swapKeeper.SetHooks(app.incentiveKeeper.Hooks())
	// app.cdpKeeper = *cdpKeeper.SetHooks(cdptypes.NewMultiCDPHooks(app.incentiveKeeper.Hooks()))
	// app.hardKeeper = *hardKeeper.SetHooks(hardtypes.NewMultiHARDHooks(app.incentiveKeeper.Hooks()))
	// app.savingsKeeper = savingsKeeper // savings incentive hooks disabled
	// app.earnKeeper = *earnKeeper.SetHooks(app.incentiveKeeper.Hooks())

	// create gov keeper with router
	// NOTE this must be done after any keepers referenced in the gov router (ie committee) are defined
	govRouter := govv1beta1.NewRouter()
	govRouter.
		AddRoute(govtypes.RouterKey, govv1beta1.ProposalHandler).
		AddRoute(paramproposal.RouterKey, params.NewParamChangeProposalHandler(app.paramsKeeper)).
		AddRoute(upgradetypes.RouterKey, upgrade.NewSoftwareUpgradeProposalHandler(&app.upgradeKeeper)).
		AddRoute(ibcclienttypes.RouterKey, ibcclient.NewClientProposalHandler(app.ibcKeeper.ClientKeeper))
		// .
		// AddRoute(kavadisttypes.RouterKey, kavadist.NewCommunityPoolMultiSpendProposalHandler(app.kavadistKeeper)).
		// AddRoute(earntypes.RouterKey, earn.NewCommunityPoolProposalHandler(app.earnKeeper))
		// .
		// AddRoute(communitytypes.RouterKey, community.NewCommunityPoolProposalHandler(app.communityKeeper))
		// .AddRoute(committeetypes.RouterKey, committee.NewProposalHandler(app.committeeKeeper))

	govConfig := govtypes.DefaultConfig()
	govKeeper := govkeeper.NewKeeper(
		appCodec,
		keys[govtypes.StoreKey],
		app.accountKeeper,
		app.bankKeeper,
		app.stakingKeeper,
		app.MsgServiceRouter(),
		govConfig,
		govAuthAddrStr,
	)
	govKeeper.SetLegacyRouter(govRouter)
	app.govKeeper = *govKeeper

	// override x/gov tally handler with custom implementation
	// tallyHandler := NewTallyHandler(
	//	app.govKeeper, *app.stakingKeeper, app.savingsKeeper, app.earnKeeper,
	// 	app.liquidKeeper, app.bankKeeper,
	// )
	// app.govKeeper.SetTallyHandler(tallyHandler)

	// create the module manager (Note: Any module instantiated in the module manager that is later modified
	// must be passed by reference here.)
	app.mm = module.NewManager(
		genutil.NewAppModule(app.accountKeeper, app.stakingKeeper, app.BaseApp.DeliverTx, encodingConfig.TxConfig),
		auth.NewAppModule(appCodec, app.accountKeeper, authsims.RandomGenesisAccounts, authSubspace),
		bank.NewAppModule(appCodec, app.bankKeeper, app.accountKeeper, bankSubspace),
		capability.NewAppModule(appCodec, *app.capabilityKeeper, false), // todo: confirm if this is okay to not be sealed
		staking.NewAppModule(appCodec, app.stakingKeeper, app.accountKeeper, app.bankKeeper, stakingSubspace),
		distr.NewAppModule(appCodec, app.distrKeeper, app.accountKeeper, app.bankKeeper, app.stakingKeeper, distrSubspace),
		gov.NewAppModule(appCodec, &app.govKeeper, app.accountKeeper, app.bankKeeper, govSubspace),
		params.NewAppModule(app.paramsKeeper),
		crisis.NewAppModule(&app.crisisKeeper, options.SkipGenesisInvariants, crisisSubspace),
		slashing.NewAppModule(appCodec, app.slashingKeeper, app.accountKeeper, app.bankKeeper, app.stakingKeeper, slashingSubspace),
		consensus.NewAppModule(appCodec, app.consensusParamsKeeper),
		ibc.NewAppModule(app.ibcKeeper),
		packetforward.NewAppModule(app.packetForwardKeeper, packetforwardSubspace),
		evm.NewAppModule(app.evmKeeper, app.accountKeeper),
		feemarket.NewAppModule(app.feeMarketKeeper, feemarketSubspace),
		upgrade.NewAppModule(&app.upgradeKeeper),
		evidence.NewAppModule(app.evidenceKeeper),
		transferModule,
		vesting.NewAppModule(app.accountKeeper, app.bankKeeper),
		authzmodule.NewAppModule(appCodec, app.authzKeeper, app.accountKeeper, app.bankKeeper, app.interfaceRegistry),
		// kavadist.NewAppModule(app.kavadistKeeper, app.accountKeeper),
		// auction.NewAppModule(app.auctionKeeper, app.accountKeeper, app.bankKeeper),
		// issuance.NewAppModule(app.issuanceKeeper, app.accountKeeper, app.bankKeeper),
		// bep3.NewAppModule(app.bep3Keeper, app.accountKeeper, app.bankKeeper),
		// pricefeed.NewAppModule(app.pricefeedKeeper, app.accountKeeper),
		validatorvesting.NewAppModule(app.bankKeeper),
		// swap.NewAppModule(app.swapKeeper, app.accountKeeper),
		// cdp.NewAppModule(app.cdpKeeper, app.accountKeeper, app.pricefeedKeeper, app.bankKeeper),
		// hard.NewAppModule(app.hardKeeper, app.accountKeeper, app.bankKeeper, app.pricefeedKeeper),
		// committee.NewAppModule(app.committeeKeeper, app.accountKeeper),
		// incentive.NewAppModule(app.incentiveKeeper, app.accountKeeper, app.bankKeeper, app.cdpKeeper),
		evmutil.NewAppModule(app.evmutilKeeper, app.bankKeeper, app.accountKeeper),
		// savings.NewAppModule(app.savingsKeeper, app.accountKeeper, app.bankKeeper),
		// liquid.NewAppModule(app.liquidKeeper),
		// earn.NewAppModule(app.earnKeeper, app.accountKeeper, app.bankKeeper),
		// router.NewAppModule(app.routerKeeper),
		// nil InflationCalculationFn, use SDK's default inflation function
		mint.NewAppModule(appCodec, app.mintKeeper, app.accountKeeper, nil, mintSubspace),
		// community.NewAppModule(app.communityKeeper, app.accountKeeper),
		// metrics.NewAppModule(options.TelemetryOptions),
	)

	// Warning: Some begin blockers must run before others. Ensure the dependencies are understood before modifying this list.
	app.mm.SetOrderBeginBlockers(
		// metricstypes.ModuleName,
		// Upgrade begin blocker runs migrations on the first block after an upgrade. It should run before any other module.
		upgradetypes.ModuleName,
		// Capability begin blocker runs non state changing initialization.
		capabilitytypes.ModuleName,
		// Committee begin blocker changes module params by enacting proposals.
		// Run before to ensure params are updated together before state changes.
		// committeetypes.ModuleName,
		// Community begin blocker should run before x/mint and x/kavadist since
		// the disable inflation upgrade will update those modules' params.
		// communitytypes.ModuleName,
		minttypes.ModuleName,
		distrtypes.ModuleName,
		// During begin block slashing happens after distr.BeginBlocker so that
		// there is nothing left over in the validator fee pool, so as to keep the
		// CanWithdrawInvariant invariant.
		slashingtypes.ModuleName,
		evidencetypes.ModuleName,
		stakingtypes.ModuleName,
		feemarkettypes.ModuleName,
		evmtypes.ModuleName,
		// kavadisttypes.ModuleName,
		// Auction begin blocker will close out expired auctions and pay debt back to cdp.
		// It should be run before cdp begin blocker which cancels out debt with stable and starts more auctions.
		// auctiontypes.ModuleName,
		// cdptypes.ModuleName,
		// bep3types.ModuleName,
		// hardtypes.ModuleName,
		// issuancetypes.ModuleName,
		// incentivetypes.ModuleName,
		ibcexported.ModuleName,
		// Add all remaining modules with an empty begin blocker below since cosmos 0.45.0 requires it
		// swaptypes.ModuleName,
		vestingtypes.ModuleName,
		// pricefeedtypes.ModuleName,
		validatorvestingtypes.ModuleName,
		authtypes.ModuleName,
		banktypes.ModuleName,
		govtypes.ModuleName,
		crisistypes.ModuleName,
		genutiltypes.ModuleName,
		ibctransfertypes.ModuleName,
		paramstypes.ModuleName,
		authz.ModuleName,
		evmutiltypes.ModuleName,
		// savingstypes.ModuleName,
		// liquidtypes.ModuleName,
		// earntypes.ModuleName,
		// routertypes.ModuleName,
		consensusparamtypes.ModuleName,
		packetforwardtypes.ModuleName,
	)

	// Warning: Some end blockers must run before others. Ensure the dependencies are understood before modifying this list.
	app.mm.SetOrderEndBlockers(
		crisistypes.ModuleName,
		govtypes.ModuleName,
		stakingtypes.ModuleName,
		evmtypes.ModuleName,
		// fee market module must go after evm module in order to retrieve the block gas used.
		feemarkettypes.ModuleName,
		// pricefeedtypes.ModuleName,
		// Add all remaining modules with an empty end blocker below since cosmos 0.45.0 requires it
		capabilitytypes.ModuleName,
		// incentivetypes.ModuleName,
		// issuancetypes.ModuleName,
		slashingtypes.ModuleName,
		distrtypes.ModuleName,
		// auctiontypes.ModuleName,
		// bep3types.ModuleName,
		// cdptypes.ModuleName,
		// hardtypes.ModuleName,
		// committeetypes.ModuleName,
		upgradetypes.ModuleName,
		evidencetypes.ModuleName,
		// kavadisttypes.ModuleName,
		// swaptypes.ModuleName,
		vestingtypes.ModuleName,
		ibcexported.ModuleName,
		validatorvestingtypes.ModuleName,
		authtypes.ModuleName,
		banktypes.ModuleName,
		genutiltypes.ModuleName,
		ibctransfertypes.ModuleName,
		paramstypes.ModuleName,
		authz.ModuleName,
		evmutiltypes.ModuleName,
		// savingstypes.ModuleName,
		// liquidtypes.ModuleName,
		// earntypes.ModuleName,
		// routertypes.ModuleName,
		minttypes.ModuleName,
		// communitytypes.ModuleName,
		// metricstypes.ModuleName,
		consensusparamtypes.ModuleName,
		packetforwardtypes.ModuleName,
	)

	// Warning: Some init genesis methods must run before others. Ensure the dependencies are understood before modifying this list
	app.mm.SetOrderInitGenesis(
		capabilitytypes.ModuleName, // initialize capabilities, run before any module creating or claiming capabilities in InitGenesis
		authtypes.ModuleName,       // loads all accounts, run before any module with a module account
		banktypes.ModuleName,
		distrtypes.ModuleName,
		stakingtypes.ModuleName,
		slashingtypes.ModuleName, // iterates over validators, run after staking
		govtypes.ModuleName,
		minttypes.ModuleName,
		ibcexported.ModuleName,
		evidencetypes.ModuleName,
		authz.ModuleName,
		ibctransfertypes.ModuleName,
		evmtypes.ModuleName,
		feemarkettypes.ModuleName,
		// kavadisttypes.ModuleName,
		// auctiontypes.ModuleName,
		// issuancetypes.ModuleName,
		// savingstypes.ModuleName,
		// bep3types.ModuleName,
		// pricefeedtypes.ModuleName,
		// swaptypes.ModuleName,
		// cdptypes.ModuleName, // reads market prices, so must run after pricefeed genesis
		// hardtypes.ModuleName,
		// incentivetypes.ModuleName, // reads cdp params, so must run after cdp genesis
		// committeetypes.ModuleName,
		evmutiltypes.ModuleName,
		// earntypes.ModuleName,
		// communitytypes.ModuleName,
		genutiltypes.ModuleName, // runs arbitrary txs included in genisis state, so run after modules have been initialized
		// Add all remaining modules with an empty InitGenesis below since cosmos 0.45.0 requires it
		vestingtypes.ModuleName,
		paramstypes.ModuleName,
		upgradetypes.ModuleName,
		validatorvestingtypes.ModuleName,
		// liquidtypes.ModuleName,
		// routertypes.ModuleName,
		// metricstypes.ModuleName,
		consensusparamtypes.ModuleName,
		packetforwardtypes.ModuleName,
		crisistypes.ModuleName, // runs the invariants at genesis, should run after other modules
	)

	app.mm.RegisterInvariants(&app.crisisKeeper)

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

	// RegisterUpgradeHandlers is used for registering any on-chain upgrades.
	// It needs to be called after `app.mm` and `app.configurator` are set.
	app.RegisterUpgradeHandlers()

	// create the simulation manager and define the order of the modules for deterministic simulations
	//
	// NOTE: This is not required for apps that don't use the simulator for fuzz testing
	// transactions.
	// TODO
	// app.sm = module.NewSimulationManager(
	// 	auth.NewAppModule(app.accountKeeper),
	// 	bank.NewAppModule(app.bankKeeper, app.accountKeeper),
	// 	gov.NewAppModule(app.govKeeper, app.accountKeeper, app.accountKeeper, app.bankKeeper),
	// 	mint.NewAppModule(app.mintKeeper),
	// 	distr.NewAppModule(app.distrKeeper, app.accountKeeper, app.accountKeeper, app.bankKeeper, app.stakingKeeper),
	//  staking.NewAppModule(app.stakingKeeper, app.accountKeeper, app.accountKeeper, app.bankKeeper),
	//  evm.NewAppModule(app.evmKeeper, app.accountKeeper),
	// 	slashing.NewAppModule(app.slashingKeeper, app.accountKeeper, app.stakingKeeper),
	// )
	// app.sm.RegisterStoreDecoders()

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

	// initialize the app
	var fetchers []ante.AddressFetcher
	if options.MempoolEnableAuth {
		fetchers = append(fetchers,
			func(sdk.Context) []sdk.AccAddress { return options.MempoolAuthAddresses },
			// app.bep3Keeper.GetAuthorizedAddresses,
			// app.pricefeedKeeper.GetAuthorizedAddresses,
		)
	}

	anteOptions := ante.HandlerOptions{
		AccountKeeper:          app.accountKeeper,
		BankKeeper:             app.bankKeeper,
		EvmKeeper:              app.evmKeeper,
		IBCKeeper:              app.ibcKeeper,
		FeeMarketKeeper:        app.feeMarketKeeper,
		SignModeHandler:        encodingConfig.TxConfig.SignModeHandler(),
		SigGasConsumer:         evmante.DefaultSigVerificationGasConsumer,
		MaxTxGasWanted:         options.EVMMaxGasWanted,
		AddressFetchers:        fetchers,
		ExtensionOptionChecker: nil,
		TxFeeChecker:           nil,
	}

	antehandler, err := ante.NewAnteHandler(anteOptions)
	if err != nil {
		panic(fmt.Sprintf("failed to create antehandler: %s", err))
	}

	app.SetAnteHandler(antehandler)
	app.SetInitChainer(app.InitChainer)
	app.SetBeginBlocker(app.BeginBlocker)
	app.SetEndBlocker(app.EndBlocker)

	// load store
	if !options.SkipLoadLatest {
		if err := app.LoadLatestVersion(); err != nil {
			panic(fmt.Sprintf("failed to load latest version: %s", err))
		}
	}

	app.ScopedIBCKeeper = scopedIBCKeeper
	app.ScopedTransferKeeper = scopedTransferKeeper

	return app
}

func (app *App) RegisterServices(cfg module.Configurator) {
	app.mm.RegisterServices(cfg)
}

// BeginBlocker contains app specific logic for the BeginBlock abci call.
func (app *App) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) abci.ResponseBeginBlock {
	return app.mm.BeginBlock(ctx, req)
}

// EndBlocker contains app specific logic for the EndBlock abci call.
func (app *App) EndBlocker(ctx sdk.Context, req abci.RequestEndBlock) abci.ResponseEndBlock {
	return app.mm.EndBlock(ctx, req)
}

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

	// Store current module versions in kava-10 to setup future in-place upgrades.
	// During in-place migrations, the old module versions in the store will be referenced to determine which migrations to run.
	app.upgradeKeeper.SetModuleVersionMap(ctx, app.mm.GetVersionMap())

	return app.mm.InitGenesis(ctx, app.appCodec, genesisState)
}

// LoadHeight loads the app state for a particular height.
func (app *App) LoadHeight(height int64) error {
	return app.LoadVersion(height)
}

// ModuleAccountAddrs returns all the app's module account addresses.
func (app *App) ModuleAccountAddrs() map[string]bool {
	modAccAddrs := make(map[string]bool)
	for acc := range mAccPerms {
		modAccAddrs[authtypes.NewModuleAddress(acc).String()] = true
	}

	return modAccAddrs
}

// InterfaceRegistry returns the app's InterfaceRegistry.
func (app *App) InterfaceRegistry() types.InterfaceRegistry {
	return app.interfaceRegistry
}

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

// RegisterAPIRoutes registers all application module routes with the provided API server.
func (app *App) RegisterAPIRoutes(apiSvr *api.Server, apiConfig config.APIConfig) {
	clientCtx := apiSvr.ClientCtx

	// Register custom REST routes
	validatorvestingrest.RegisterRoutes(clientCtx, apiSvr.Router)

	// Register rewrite routes
	RegisterAPIRouteRewrites(apiSvr.Router)

	// Register GRPC Gateway routes
	tmservice.RegisterGRPCGatewayRoutes(clientCtx, apiSvr.GRPCGatewayRouter)
	authtx.RegisterGRPCGatewayRoutes(clientCtx, apiSvr.GRPCGatewayRouter)
	ModuleBasics.RegisterGRPCGatewayRoutes(clientCtx, apiSvr.GRPCGatewayRouter)
	nodeservice.RegisterGRPCGatewayRoutes(clientCtx, apiSvr.GRPCGatewayRouter)

	// Swagger API configuration is ignored
}

// RegisterAPIRouteRewrites registers overwritten API routes that are
// registered after this function is called. This must be called before any
// other route registrations on the router in order for rewrites to take effect.
// The first route that matches in the mux router wins, so any registrations
// here will be prioritized over the later registrations in modules.
func RegisterAPIRouteRewrites(router *mux.Router) {
	// Mapping of client path to backend path. Similar to nginx rewrite rules,
	// but does not return a 301 or 302 redirect.
	// Eg: querying /cosmos/distribution/v1beta1/community_pool will return
	// the same response as querying /kava/community/v1beta1/total_balance
	routeMap := map[string]string{
		"/cosmos/distribution/v1beta1/community_pool": "/kava/community/v1beta1/total_balance",
	}

	for clientPath, backendPath := range routeMap {
		router.HandleFunc(
			clientPath,
			func(w http.ResponseWriter, r *http.Request) {
				r.URL.Path = backendPath

				// Use handler of the new path
				router.ServeHTTP(w, r)
			},
		).Methods("GET")
	}
}

// RegisterTxService implements the Application.RegisterTxService method.
// It registers transaction related endpoints on the app's grpc server.
func (app *App) RegisterTxService(clientCtx client.Context) {
	authtx.RegisterTxService(app.BaseApp.GRPCQueryRouter(), clientCtx, app.BaseApp.Simulate, app.interfaceRegistry)
}

// RegisterTendermintService implements the Application.RegisterTendermintService method.
// It registers the standard tendermint grpc endpoints on the app's grpc server.
func (app *App) RegisterTendermintService(clientCtx client.Context) {
	tmservice.RegisterTendermintService(
		clientCtx,
		app.BaseApp.GRPCQueryRouter(),
		app.interfaceRegistry,
		app.Query,
	)
}

func (app *App) RegisterNodeService(clientCtx client.Context) {
	nodeservice.RegisterNodeService(clientCtx, app.BaseApp.GRPCQueryRouter())
}

// loadBlockedMaccAddrs returns a map indicating the blocked status of each module account address
func (app *App) loadBlockedMaccAddrs() map[string]bool {
	modAccAddrs := app.ModuleAccountAddrs()
	allowedMaccs := map[string]bool{
		// kavadist
		// app.accountKeeper.GetModuleAddress(kavadisttypes.ModuleName).String(): true,
		// earn
		// app.accountKeeper.GetModuleAddress(earntypes.ModuleName).String(): true,
		// liquid
		// app.accountKeeper.GetModuleAddress(liquidtypes.ModuleName).String(): true,
		// kavadist fund
		// app.accountKeeper.GetModuleAddress(kavadisttypes.FundModuleAccount).String(): true,
		// community
		// app.accountKeeper.GetModuleAddress(communitytypes.ModuleAccountName).String(): true,
		// NOTE: if adding evmutil, adjust the cosmos-coins-fully-backed-invariant accordingly.
	}

	for addr := range modAccAddrs {
		// Set allowed module accounts as unblocked
		if allowedMaccs[addr] {
			modAccAddrs[addr] = false
		}
	}
	return modAccAddrs
}

// GetMaccPerms returns a mapping of the application's module account permissions.
func GetMaccPerms() map[string][]string {
	perms := make(map[string][]string)
	for k, v := range mAccPerms {
		perms[k] = v
	}
	return perms
}