feat: refactor app struct

.github/workflows/build-linux-arm64.yml

@@ -63,7 +63,7 @@ jobs:
           ls -l
           file miniwasm_${VERSION}_Linux_${ARCH_NAME}.tar.gz
 
-          # remove builder
+          # Remove builder
           docker buildx rm arm64-builder
 
       - name: List files

.github/workflows/lint.yml

@@ -40,7 +40,7 @@ jobs:
             go.mod
             go.sum
       # install golangci-lint
-      - run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@${GOLANGCI_LINT_VERSION}
+      - run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@${{ env.GOLANGCI_LINT_VERSION }}
       - name: run go linters (long)
         if: env.GIT_DIFF
         id: lint_long

app/app_test.go

@@ -41,7 +41,7 @@ func TestSimAppExportAndBlockedAddrs(t *testing.T) {
 	app := SetupWithGenesisAccounts(t.TempDir(), nil, nil)
 
 	// BlockedAddresses returns a map of addresses in app v1 and a map of modules name in app v2.
-	for acc := range app.ModuleAccountAddrs() {
+	for acc := range app.BlockedModuleAccountAddrs(app.ModuleAccountAddrs()) {
 		var addr sdk.AccAddress
 		if modAddr, err := sdk.AccAddressFromBech32(acc); err == nil {
 			addr = modAddr

app/blocksdk.go

@@ -0,0 +1,154 @@
+package app
+
+import (
+	"cosmossdk.io/math"
+	storetypes "cosmossdk.io/store/types"
+
+	"github.com/cosmos/cosmos-sdk/runtime"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/mempool"
+	cosmosante "github.com/cosmos/cosmos-sdk/x/auth/ante"
+
+	opchildlanes "github.com/initia-labs/OPinit/x/opchild/lanes"
+	initialanes "github.com/initia-labs/initia/app/lanes"
+
+	blockabci "github.com/skip-mev/block-sdk/v2/abci"
+	blockchecktx "github.com/skip-mev/block-sdk/v2/abci/checktx"
+	signer_extraction "github.com/skip-mev/block-sdk/v2/adapters/signer_extraction_adapter"
+	"github.com/skip-mev/block-sdk/v2/block"
+	blockbase "github.com/skip-mev/block-sdk/v2/block/base"
+	mevlane "github.com/skip-mev/block-sdk/v2/lanes/mev"
+
+	appante "github.com/initia-labs/miniwasm/app/ante"
+
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+)
+
+func setupBlockSDK(
+	app *MinitiaApp,
+	mempoolMaxTxs int,
+	wasmConfig wasmtypes.WasmConfig,
+	txCounterStoreKey *storetypes.KVStoreKey,
+) (
+	mempool.Mempool,
+	sdk.AnteHandler,
+	blockchecktx.CheckTx,
+	sdk.PrepareProposalHandler,
+	sdk.ProcessProposalHandler,
+	error,
+) {
+
+	// initialize and set the InitiaApp mempool. The current mempool will be the
+	// x/auction module's mempool which will extract the top bid from the current block's auction
+	// and insert the txs at the top of the block spots.
+	signerExtractor := signer_extraction.NewDefaultAdapter()
+
+	systemLane := initialanes.NewSystemLane(blockbase.LaneConfig{
+		Logger:          app.Logger(),
+		TxEncoder:       app.txConfig.TxEncoder(),
+		TxDecoder:       app.txConfig.TxDecoder(),
+		MaxBlockSpace:   math.LegacyMustNewDecFromStr("0.01"),
+		MaxTxs:          1,
+		SignerExtractor: signerExtractor,
+	}, opchildlanes.SystemLaneMatchHandler())
+
+	factory := mevlane.NewDefaultAuctionFactory(app.txConfig.TxDecoder(), signerExtractor)
+	mevLane := mevlane.NewMEVLane(blockbase.LaneConfig{
+		Logger:          app.Logger(),
+		TxEncoder:       app.txConfig.TxEncoder(),
+		TxDecoder:       app.txConfig.TxDecoder(),
+		MaxBlockSpace:   math.LegacyMustNewDecFromStr("0.09"),
+		MaxTxs:          100,
+		SignerExtractor: signerExtractor,
+	}, factory, factory.MatchHandler())
+
+	freeLane := initialanes.NewFreeLane(blockbase.LaneConfig{
+		Logger:          app.Logger(),
+		TxEncoder:       app.txConfig.TxEncoder(),
+		TxDecoder:       app.txConfig.TxDecoder(),
+		MaxBlockSpace:   math.LegacyMustNewDecFromStr("0.1"),
+		MaxTxs:          100,
+		SignerExtractor: signerExtractor,
+	}, opchildlanes.NewFreeLaneMatchHandler(app.ac, app.OPChildKeeper).MatchHandler())
+
+	defaultLane := initialanes.NewDefaultLane(blockbase.LaneConfig{
+		Logger:          app.Logger(),
+		TxEncoder:       app.txConfig.TxEncoder(),
+		TxDecoder:       app.txConfig.TxDecoder(),
+		MaxBlockSpace:   math.LegacyMustNewDecFromStr("0.8"),
+		MaxTxs:          mempoolMaxTxs,
+		SignerExtractor: signerExtractor,
+	})
+
+	lanes := []block.Lane{systemLane, mevLane, freeLane, defaultLane}
+	mempool, err := block.NewLanedMempool(app.Logger(), lanes)
+	if err != nil {
+		return nil, nil, nil, nil, nil, err
+	}
+
+	anteHandler, err := appante.NewAnteHandler(
+		appante.HandlerOptions{
+			HandlerOptions: cosmosante.HandlerOptions{
+				AccountKeeper:   app.AccountKeeper,
+				BankKeeper:      app.BankKeeper,
+				FeegrantKeeper:  app.FeeGrantKeeper,
+				SignModeHandler: app.txConfig.SignModeHandler(),
+			},
+			IBCkeeper:             app.IBCKeeper,
+			Codec:                 app.appCodec,
+			OPChildKeeper:         app.OPChildKeeper,
+			TxEncoder:             app.txConfig.TxEncoder(),
+			AuctionKeeper:         *app.AuctionKeeper,
+			MevLane:               mevLane,
+			FreeLane:              freeLane,
+			WasmKeeper:            app.WasmKeeper,
+			WasmConfig:            &wasmConfig,
+			TXCounterStoreService: runtime.NewKVStoreService(txCounterStoreKey),
+		},
+	)
+	if err != nil {
+		return nil, nil, nil, nil, nil, err
+	}
+
+	// set ante handler to lanes
+	opt := []blockbase.LaneOption{
+		blockbase.WithAnteHandler(anteHandler),
+	}
+	systemLane.(*blockbase.BaseLane).WithOptions(
+		opt...,
+	)
+	mevLane.WithOptions(
+		opt...,
+	)
+	freeLane.(*blockbase.BaseLane).WithOptions(
+		opt...,
+	)
+	defaultLane.(*blockbase.BaseLane).WithOptions(
+		opt...,
+	)
+
+	mevCheckTx := blockchecktx.NewMEVCheckTxHandler(
+		app.BaseApp,
+		app.txConfig.TxDecoder(),
+		mevLane,
+		anteHandler,
+		app.BaseApp.CheckTx,
+	)
+	checkTxHandler := blockchecktx.NewMempoolParityCheckTx(
+		app.Logger(), mempool,
+		app.txConfig.TxDecoder(), mevCheckTx.CheckTx(),
+	)
+	checkTx := checkTxHandler.CheckTx()
+
+	proposalHandler := blockabci.NewProposalHandler(
+		app.Logger(),
+		app.txConfig.TxDecoder(),
+		app.txConfig.TxEncoder(),
+		mempool,
+	)
+
+	prepareProposalHandler := proposalHandler.PrepareProposalHandler()
+	processProposalHandler := proposalHandler.ProcessProposalHandler()
+
+	return mempool, anteHandler, checkTx, prepareProposalHandler, processProposalHandler, nil
+}

app/indexer.go

@@ -0,0 +1,92 @@
+package app
+
+import (
+	storetypes "cosmossdk.io/store/types"
+
+	dbm "github.com/cosmos/cosmos-db"
+	servertypes "github.com/cosmos/cosmos-sdk/server/types"
+
+	// kvindexer
+	kvindexer "github.com/initia-labs/kvindexer"
+	kvindexerconfig "github.com/initia-labs/kvindexer/config"
+	blocksubmodule "github.com/initia-labs/kvindexer/submodules/block"
+	tx "github.com/initia-labs/kvindexer/submodules/tx"
+	nft "github.com/initia-labs/kvindexer/submodules/wasm-nft"
+	pair "github.com/initia-labs/kvindexer/submodules/wasm-pair"
+	kvindexermodule "github.com/initia-labs/kvindexer/x/kvindexer"
+	kvindexerkeeper "github.com/initia-labs/kvindexer/x/kvindexer/keeper"
+)
+
+func setupIndexer(
+	app *MinitiaApp,
+	appOpts servertypes.AppOptions,
+	kvindexerDB dbm.DB,
+) (*kvindexerkeeper.Keeper, *kvindexermodule.AppModuleBasic, *storetypes.StreamingManager, error) {
+	// initialize the indexer keeper
+	kvindexerConfig, err := kvindexerconfig.NewConfig(appOpts)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	kvIndexerKeeper := kvindexerkeeper.NewKeeper(
+		app.appCodec,
+		"wasm",
+		kvindexerDB,
+		kvindexerConfig,
+		app.ac,
+		app.vc,
+	)
+
+	smBlock, err := blocksubmodule.NewBlockSubmodule(app.appCodec, kvIndexerKeeper, app.OPChildKeeper)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	smTx, err := tx.NewTxSubmodule(app.appCodec, kvIndexerKeeper)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	smPair, err := pair.NewPairSubmodule(app.appCodec, kvIndexerKeeper, app.IBCKeeper.ChannelKeeper, app.TransferKeeper)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	smNft, err := nft.NewWasmNFTSubmodule(app.ac, app.appCodec, kvIndexerKeeper, app.WasmKeeper, smPair)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	err = kvIndexerKeeper.RegisterSubmodules(smBlock, smTx, smPair, smNft)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	// Add your implementation here
+
+	kvIndexer, err := kvindexer.NewIndexer(app.GetBaseApp().Logger(), kvIndexerKeeper)
+	if err != nil {
+		return nil, nil, nil, err
+	} else if kvIndexer == nil {
+		return nil, nil, nil, nil
+	}
+
+	if err = kvIndexer.Validate(); err != nil {
+		return nil, nil, nil, err
+	}
+
+	if err = kvIndexer.Prepare(nil); err != nil {
+		return nil, nil, nil, err
+	}
+
+	if err = kvIndexerKeeper.Seal(); err != nil {
+		return nil, nil, nil, err
+	}
+
+	if err = kvIndexer.Start(nil); err != nil {
+		return nil, nil, nil, err
+	}
+
+	kvIndexerModule := kvindexermodule.NewAppModuleBasic(kvIndexerKeeper)
+	streamingManager := storetypes.StreamingManager{
+		ABCIListeners: []storetypes.ABCIListener{kvIndexer},
+		StopNodeOnErr: true,
+	}
+
+	return kvIndexerKeeper, &kvIndexerModule, &streamingManager, nil
+}