feat: add indexer tests

app/app.go

@@ -602,6 +602,10 @@
 		return err
 	}
 
+	if app.evmIndexer != nil {
+		app.evmIndexer.Stop()
+	}
+
 	return nil
 }
 

app/indexer.go

@@ -25,7 +25,7 @@ func setupIndexer(
 	indexerDB, kvindexerDB dbm.DB,
 ) (evmindexer.EVMIndexer, *kvindexerkeeper.Keeper, *kvindexermodule.AppModuleBasic, *storetypes.StreamingManager, error) {
 	// setup evm indexer
-	evmIndexer, err := evmindexer.NewEVMIndexer(indexerDB, app.appCodec, app.Logger(), app.txConfig, app.EVMKeeper, app.OPChildKeeper)
+	evmIndexer, err := evmindexer.NewEVMIndexer(indexerDB, app.appCodec, app.Logger(), app.txConfig, app.EVMKeeper)
 	if err != nil {
 		return nil, nil, nil, nil, err
 	}

app/test_helpers.go

@@ -12,6 +12,7 @@ import (
 	tmtypes "github.com/cometbft/cometbft/types"
 	dbm "github.com/cosmos/cosmos-db"
 
+	"cosmossdk.io/math"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
@@ -22,7 +23,9 @@ import (
 
 	opchildtypes "github.com/initia-labs/OPinit/x/opchild/types"
 
+	"github.com/initia-labs/minievm/types"
 	evmconfig "github.com/initia-labs/minievm/x/evm/config"
+	evmtypes "github.com/initia-labs/minievm/x/evm/types"
 )
 
 // defaultConsensusParams defines the default Tendermint consensus params used in
@@ -65,7 +68,7 @@ func setup(db *dbm.DB, withGenesis bool) (*MinitiaApp, GenesisState) {
 	)
 
 	if withGenesis {
-		return app, NewDefaultGenesisState(encCdc.Codec, app.BasicModuleManager, sdk.DefaultBondDenom)
+		return app, NewDefaultGenesisState(encCdc.Codec, app.BasicModuleManager, types.BaseDenom)
 	}
 
 	return app, GenesisState{}
@@ -128,11 +131,18 @@ func SetupWithGenesisAccounts(
 	app.AppCodec().MustUnmarshalJSON(genesisState[opchildtypes.ModuleName], &opchildGenesis)
 	opchildGenesis.Params.Admin = sdk.AccAddress(valSet.Validators[0].Address.Bytes()).String()
 	opchildGenesis.Params.BridgeExecutors = []string{sdk.AccAddress(valSet.Validators[0].Address.Bytes()).String()}
+	opchildGenesis.Params.MinGasPrices = sdk.NewDecCoins(sdk.NewDecCoin(types.BaseDenom, math.NewInt(1_000_000_000)))
 
 	// set validators and delegations
 	opchildGenesis = *opchildtypes.NewGenesisState(opchildGenesis.Params, validators, nil)
 	genesisState[opchildtypes.ModuleName] = app.AppCodec().MustMarshalJSON(&opchildGenesis)
 
+	// set evm genesis params
+	var evmGenesis evmtypes.GenesisState
+	app.AppCodec().MustUnmarshalJSON(genesisState[evmtypes.ModuleName], &evmGenesis)
+	evmGenesis.Params.GasRefundRatio = math.LegacyZeroDec()
+	genesisState[evmtypes.ModuleName] = app.AppCodec().MustMarshalJSON(&evmGenesis)
+
 	// update total supply
 	bankGenesis := banktypes.NewGenesisState(banktypes.DefaultGenesisState().Params, balances, sdk.NewCoins(), []banktypes.Metadata{}, []banktypes.SendEnabled{})
 	genesisState[banktypes.ModuleName] = app.AppCodec().MustMarshalJSON(bankGenesis)

indexer/abci_test.go

@@ -0,0 +1,119 @@
+package indexer_test
+
+import (
+	"math/big"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	storetypes "cosmossdk.io/store/types"
+
+	evmtypes "github.com/initia-labs/minievm/x/evm/types"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+func Test_ListenFinalizeBlock(t *testing.T) {
+	app, indexer, addrs, privKeys := setupIndexer(t)
+	defer app.Close()
+
+	tx, evmTxHash := generateCreateERC20Tx(t, app, privKeys[0])
+	finalizeReq, finalizeRes := executeTxs(t, app, tx)
+	checkTxResult(t, finalizeRes.TxResults[0], true)
+
+	events := finalizeRes.TxResults[0].Events
+	createEvent := events[len(events)-3]
+	require.Equal(t, evmtypes.EventTypeContractCreated, createEvent.GetType())
+
+	contractAddr, err := hexutil.Decode(createEvent.Attributes[0].Value)
+	require.NoError(t, err)
+
+	// listen finalize block
+	ctx, err := app.CreateQueryContext(0, false)
+	require.NoError(t, err)
+
+	err = indexer.ListenFinalizeBlock(ctx.WithBlockGasMeter(storetypes.NewInfiniteGasMeter()), *finalizeReq, *finalizeRes)
+	require.NoError(t, err)
+
+	// check the tx is indexed
+	evmTx, err := indexer.TxByHash(ctx, evmTxHash)
+	require.NoError(t, err)
+	require.NotNil(t, evmTx)
+
+	// mint 1_000_000 tokens to the first address
+	tx, evmTxHash = generateMintERC20Tx(t, app, privKeys[0], common.BytesToAddress(contractAddr), addrs[0], new(big.Int).SetUint64(1_000_000_000_000))
+	finalizeReq, finalizeRes = executeTxs(t, app, tx)
+	checkTxResult(t, finalizeRes.TxResults[0], true)
+
+	// listen finalize block
+	ctx, err = app.CreateQueryContext(0, false)
+	require.NoError(t, err)
+
+	err = indexer.ListenFinalizeBlock(ctx.WithBlockGasMeter(storetypes.NewInfiniteGasMeter()), *finalizeReq, *finalizeRes)
+	require.NoError(t, err)
+
+	// check the tx is indexed
+	evmTx, err = indexer.TxByHash(ctx, evmTxHash)
+	require.NoError(t, err)
+	require.NotNil(t, evmTx)
+
+	// check the block header is indexed
+	header, err := indexer.BlockHeaderByNumber(ctx, uint64(finalizeReq.Height))
+	require.NoError(t, err)
+	require.NotNil(t, header)
+	require.Equal(t, finalizeReq.Height, header.Number.Int64())
+
+}
+
+func Test_ListenFinalizeBlock_Subscribe(t *testing.T) {
+	app, indexer, _, privKeys := setupIndexer(t)
+	defer app.Close()
+
+	blockChan, logsChan, pendChan := indexer.Subscribe()
+	close(pendChan)
+
+	tx, evmTxHash := generateCreateERC20Tx(t, app, privKeys[0])
+	finalizeReq, finalizeRes := executeTxs(t, app, tx)
+	checkTxResult(t, finalizeRes.TxResults[0], true)
+
+	events := finalizeRes.TxResults[0].Events
+	createEvent := events[len(events)-3]
+	require.Equal(t, evmtypes.EventTypeContractCreated, createEvent.GetType())
+
+	contractAddr, err := hexutil.Decode(createEvent.Attributes[0].Value)
+	require.NoError(t, err)
+
+	// listen finalize block
+	ctx, err := app.CreateQueryContext(0, false)
+	require.NoError(t, err)
+
+	wg := sync.WaitGroup{}
+	wg.Add(2)
+	go func() {
+		for {
+			select {
+			case block := <-blockChan:
+				require.NotNil(t, block)
+				require.Equal(t, finalizeReq.Height, block.Number.Int64())
+				wg.Done()
+			case logs := <-logsChan:
+				require.NotNil(t, logs)
+
+				for _, log := range logs {
+					if log.Address == common.BytesToAddress(contractAddr) {
+						require.Equal(t, evmTxHash, log.TxHash)
+						require.Equal(t, uint64(finalizeReq.Height), log.BlockNumber)
+						wg.Done()
+					}
+				}
+			}
+		}
+	}()
+
+	err = indexer.ListenFinalizeBlock(ctx.WithBlockGasMeter(storetypes.NewInfiniteGasMeter()), *finalizeReq, *finalizeRes)
+	require.NoError(t, err)
+
+	wg.Wait()
+}

indexer/indexer.go

@@ -19,8 +19,6 @@
 	"github.com/ethereum/go-ethereum/common"
 	coretypes "github.com/ethereum/go-ethereum/core/types"
 
-	opchildkeeper "github.com/initia-labs/OPinit/x/opchild/keeper"
-
 	rpctypes "github.com/initia-labs/minievm/jsonrpc/types"
 	evmconfig "github.com/initia-labs/minievm/x/evm/config"
 	evmkeeper "github.com/initia-labs/minievm/x/evm/keeper"
@@ -37,7 +35,7 @@
 
 	// tx receipt
 	TxReceiptByHash(ctx context.Context, hash common.Hash) (*coretypes.Receipt, error)
-	IterateBlockTxRecepts(ctx context.Context, blockHeight uint64, cb func(tx *coretypes.Receipt) (bool, error)) error
+	IterateBlockTxReceipts(ctx context.Context, blockHeight uint64, cb func(tx *coretypes.Receipt) (bool, error)) error
 
 	// block
 	BlockHashToNumber(ctx context.Context, hash common.Hash) (uint64, error)
@@ -53,6 +51,9 @@
 	// mempool
 	MempoolWrapper(mempool mempool.Mempool) mempool.Mempool
 	TxInMempool(hash common.Hash) *rpctypes.RPCTransaction
+
+	// Stop
+	Stop()
 }
 
 // EVMIndexerImpl implements EVMIndexer.
@@ -62,9 +63,8 @@
 	txConfig client.TxConfig
 	appCodec codec.Codec
 
-	store         *CacheStore
-	evmKeeper     *evmkeeper.Keeper
-	opChildKeeper *opchildkeeper.Keeper
+	store     *CacheStore
+	evmKeeper *evmkeeper.Keeper
 
 	schema                   collections.Schema
 	TxMap                    collections.Map[[]byte, rpctypes.RPCTransaction]
@@ -89,7 +89,6 @@
 	logger log.Logger,
 	txConfig client.TxConfig,
 	evmKeeper *evmkeeper.Keeper,
-	opChildKeeper *opchildkeeper.Keeper,
 ) (EVMIndexer, error) {
 	cfg := evmKeeper.Config()
 	if cfg.IndexerCacheSize == 0 {
@@ -110,8 +109,7 @@
 		txConfig: txConfig,
 		appCodec: appCodec,
 
-		evmKeeper:     evmKeeper,
-		opChildKeeper: opChildKeeper,
+		evmKeeper: evmKeeper,
 
 		TxMap:                    collections.NewMap(sb, prefixTx, "tx", collections.BytesKey, CollJsonVal[rpctypes.RPCTransaction]()),
 		TxReceiptMap:             collections.NewMap(sb, prefixTxReceipt, "tx_receipt", collections.BytesKey, CollJsonVal[coretypes.Receipt]()),
@@ -181,3 +179,8 @@
 
 	close(done)
 }
+
+// Stop stops the indexer.
+func (e *EVMIndexerImpl) Stop() {
+	e.txPendingMap.Stop()
+}

indexer/indexer_test.go

@@ -0,0 +1,70 @@
+package indexer_test
+
+import (
+	"crypto/ecdsa"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	minitiaapp "github.com/initia-labs/minievm/app"
+	minievmtypes "github.com/initia-labs/minievm/types"
+
+	"github.com/stretchr/testify/require"
+
+	"cosmossdk.io/math"
+	dbm "github.com/cosmos/cosmos-db"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+
+	"github.com/initia-labs/minievm/indexer"
+)
+
+// Bond denom should be set for staking test
+const baseDenom = minievmtypes.BaseDenom
+
+var (
+	genCoins = sdk.NewCoins(sdk.NewCoin(baseDenom, math.NewInt(1_000_000_000_000_000_000).MulRaw(1_000_000))).Sort()
+)
+
+func checkBalance(t *testing.T, app *minitiaapp.MinitiaApp, addr common.Address, balances sdk.Coins) {
+	ctxCheck := app.BaseApp.NewContext(true)
+	require.True(t, balances.Equal(app.BankKeeper.GetAllBalances(ctxCheck, addr.Bytes())))
+}
+
+func createApp(t *testing.T) (*minitiaapp.MinitiaApp, []common.Address, []*ecdsa.PrivateKey) {
+	addrs, privKeys := generateKeys(t, 2)
+	genAccs := authtypes.GenesisAccounts{}
+	for _, addr := range addrs {
+
+		genAccs = append(genAccs, &authtypes.BaseAccount{Address: sdk.AccAddress(addr.Bytes()).String()})
+	}
+
+	genBalances := []banktypes.Balance{}
+	for _, addr := range addrs {
+		genBalances = append(genBalances, banktypes.Balance{Address: sdk.AccAddress(addr.Bytes()).String(), Coins: genCoins})
+	}
+
+	app := minitiaapp.SetupWithGenesisAccounts(nil, genAccs, genBalances...)
+	for _, addr := range addrs {
+		checkBalance(t, app, addr, genCoins)
+	}
+
+	_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: app.LastBlockHeight() + 1})
+	require.NoError(t, err)
+
+	app.Commit()
+
+	return app, addrs, privKeys
+}
+
+func setupIndexer(t *testing.T) (*minitiaapp.MinitiaApp, indexer.EVMIndexer, []common.Address, []*ecdsa.PrivateKey) {
+	app, addrs, privKeys := createApp(t)
+
+	db := dbm.NewMemDB()
+	indexer, err := indexer.NewEVMIndexer(db, app.AppCodec(), app.Logger(), app.TxConfig(), app.EVMKeeper)
+	require.NoError(t, err)
+
+	return app, indexer, addrs, privKeys
+}

indexer/mempool_test.go

@@ -0,0 +1,44 @@
+package indexer_test
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/types/mempool"
+)
+
+func Test_Mempool_Subscribe(t *testing.T) {
+	app, indexer, _, privKeys := setupIndexer(t)
+	defer app.Close()
+
+	blockChan, logsChan, pendChan := indexer.Subscribe()
+	close(blockChan)
+	close(logsChan)
+
+	tx, evmTxHash := generateCreateERC20Tx(t, app, privKeys[0])
+
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	go func() {
+		pendingTx := <-pendChan
+		require.NotNil(t, pendingTx)
+		require.Equal(t, evmTxHash, pendingTx.Hash)
+		wg.Done()
+	}()
+
+	noopMempool := &mempool.NoOpMempool{}
+	mempool := indexer.MempoolWrapper(noopMempool)
+
+	// insert tx into mempool
+	ctx, err := app.CreateQueryContext(0, false)
+	require.NoError(t, err)
+	err = mempool.Insert(ctx, tx)
+	require.NoError(t, err)
+
+	rpcTx := indexer.TxInMempool(evmTxHash)
+	require.Equal(t, evmTxHash, rpcTx.Hash)
+
+	wg.Wait()
+}

indexer/reader.go

@@ -53,7 +53,7 @@ func (e *EVMIndexerImpl) IterateBlockTxs(ctx context.Context, blockHeight uint64
 }
 
 // IterateBlockTxs implements EVMIndexer.
-func (e *EVMIndexerImpl) IterateBlockTxRecepts(ctx context.Context, blockHeight uint64, cb func(tx *coretypes.Receipt) (bool, error)) error {
+func (e *EVMIndexerImpl) IterateBlockTxReceipts(ctx context.Context, blockHeight uint64, cb func(tx *coretypes.Receipt) (bool, error)) error {
 	return e.BlockAndIndexToTxHashMap.Walk(ctx, collections.NewPrefixedPairRange[uint64, uint64](blockHeight), func(key collections.Pair[uint64, uint64], txHashBz []byte) (bool, error) {
 		txHash := common.BytesToHash(txHashBz)
 		txRecept, err := e.TxReceiptByHash(ctx, txHash)