From d689de47e341550700603cd468d18da95d5113f2 Mon Sep 17 00:00:00 2001
From: Jeremy Wei <jeremy.t.wei@gmail.com>
Date: Fri, 6 Sep 2024 01:01:42 -0400
Subject: [PATCH] more wrap EVMTestApp in a func

---
 app/ante_test.go                              |  18 +--
 app/receipt_test.go                           | 114 +++++++++---------
 evmrpc/block_test.go                          |  12 +-
 evmrpc/info_test.go                           |   1 -
 precompiles/bank/bank_test.go                 |   8 +-
 precompiles/common/precompiles_test.go        |  12 +-
 precompiles/pointerview/pointerview_test.go   |   4 +-
 testutil/keeper/evm.go                        |   6 +-
 x/evm/ante/basic_test.go                      |   4 +-
 x/evm/ante/fee_test.go                        |   8 +-
 x/evm/ante/gas_test.go                        |   4 +-
 x/evm/ante/preprocess_test.go                 |  34 +++---
 x/evm/ante/sig_test.go                        |   8 +-
 x/evm/client/wasm/query_test.go               |  72 +++++------
 x/evm/genesis_test.go                         |   4 +-
 x/evm/gov_test.go                             |   4 +-
 x/evm/integration_test.go                     |  76 ++++++------
 x/evm/keeper/params_test.go                   |  28 +----
 .../add_new_param_migration_test.go           |   4 +-
 x/evm/migrations/fix_total_supply_test.go     |   4 +-
 x/evm/migrations/migrate_all_pointers_test.go |  20 +--
 .../migrate_cast_address_balances_test.go     |   4 +-
 .../migrate_deliver_tx_gas_limit_test.go      |   4 +-
 x/evm/state/accesslist_test.go                |  16 +--
 x/evm/state/balance_test.go                   |  16 +--
 x/evm/state/check_test.go                     |   8 +-
 x/evm/state/code_test.go                      |   4 +-
 x/evm/state/log_test.go                       |   8 +-
 x/evm/state/nonce_test.go                     |   4 +-
 x/evm/state/refund_test.go                    |   4 +-
 x/evm/state/state_test.go                     |  16 +--
 x/evm/state/transfer_test.go                  |   4 +-
 x/evm/types/message_evm_transaction_test.go   |   4 +-
 33 files changed, 255 insertions(+), 282 deletions(-)

diff --git a/app/ante_test.go b/app/ante_test.go
index dfbf7a533..b175b424b 100644
--- a/app/ante_test.go
+++ b/app/ante_test.go
@@ -222,7 +222,7 @@ func (suite *AnteTestSuite) TestValidateDepedencies() {
 }
 
 func TestEvmAnteErrorHandler(t *testing.T) {
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{})
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{})
 	privKey := testkeeper.MockPrivateKey()
 	testPrivHex := hex.EncodeToString(privKey.Bytes())
 	key, _ := crypto.HexToECDSA(testPrivHex)
@@ -234,7 +234,7 @@ func TestEvmAnteErrorHandler(t *testing.T) {
 		Data:     []byte{},
 		Nonce:    1, // will cause ante error
 	}
-	chainID := testkeeper.EVMTestApp.EvmKeeper.ChainID(ctx)
+	chainID := testkeeper.EVMTestApp().EvmKeeper.ChainID(ctx)
 	chainCfg := evmtypes.DefaultChainConfig()
 	ethCfg := chainCfg.EthereumConfig(chainID)
 	blockNum := big.NewInt(ctx.BlockHeight())
@@ -245,22 +245,22 @@ func TestEvmAnteErrorHandler(t *testing.T) {
 	require.Nil(t, err)
 	req, err := types.NewMsgEVMTransaction(txwrapper)
 	require.Nil(t, err)
-	builder := testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	builder := testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	builder.SetMsgs(req)
 	txToSend := builder.GetTx()
-	encodedTx, err := testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(txToSend)
+	encodedTx, err := testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(txToSend)
 	require.Nil(t, err)
 
 	addr, _ := testkeeper.PrivateKeyToAddresses(privKey)
-	testkeeper.EVMTestApp.BankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(100000000000))), true)
-	res := testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: encodedTx}, txToSend, sha256.Sum256(encodedTx))
+	testkeeper.EVMTestApp().BankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(100000000000))), true)
+	res := testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: encodedTx}, txToSend, sha256.Sum256(encodedTx))
 	require.NotEqual(t, 0, res.Code)
-	testkeeper.EVMTestApp.EvmKeeper.SetTxResults([]*abci.ExecTxResult{{
+	testkeeper.EVMTestApp().EvmKeeper.SetTxResults([]*abci.ExecTxResult{{
 		Code: res.Code,
 		Log:  "nonce too high",
 	}})
-	testkeeper.EVMTestApp.EvmKeeper.SetMsgs([]*evmtypes.MsgEVMTransaction{req})
-	deferredInfo := testkeeper.EVMTestApp.EvmKeeper.GetAllEVMTxDeferredInfo(ctx)
+	testkeeper.EVMTestApp().EvmKeeper.SetMsgs([]*evmtypes.MsgEVMTransaction{req})
+	deferredInfo := testkeeper.EVMTestApp().EvmKeeper.GetAllEVMTxDeferredInfo(ctx)
 	require.Equal(t, 1, len(deferredInfo))
 	require.Contains(t, deferredInfo[0].Error, "nonce too high")
 }
diff --git a/app/receipt_test.go b/app/receipt_test.go
index bfdff291b..15ea3590a 100644
--- a/app/receipt_test.go
+++ b/app/receipt_test.go
@@ -34,9 +34,9 @@ import (
 var f embed.FS
 
 func TestEvmEventsForCw20(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
+	k := testkeeper.EVMTestApp().EvmKeeper
 	wasmKeeper := k.WasmKeeper()
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now()).WithChainID("sei-test").WithBlockHeight(1)
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now()).WithChainID("sei-test").WithBlockHeight(1)
 	code, err := os.ReadFile("../contracts/wasm/cw20_base.wasm")
 	require.Nil(t, err)
 	privKey := testkeeper.MockPrivateKey()
@@ -60,22 +60,22 @@ func TestEvmEventsForCw20(t *testing.T) {
 		Contract: contractAddr.String(),
 		Msg:      payload,
 	}
-	txBuilder := testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder := testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000))))
 	txBuilder.SetGasLimit(300000)
 	tx := signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, creator))
-	txbz, err := testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err := testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum := sha256.Sum256(txbz)
-	res := testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res := testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err := testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
+	receipt, err := testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found := testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found := testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 
 	// calling from wasmd precompile
@@ -105,20 +105,20 @@ func TestEvmEventsForCw20(t *testing.T) {
 	require.Nil(t, err)
 	emsg, err := evmtypes.NewMsgEVMTransaction(typedTx)
 	require.Nil(t, err)
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(emsg)
 	tx = txBuilder.GetTx()
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum = sha256.Sum256(txbz)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()).WithTxIndex(1), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res = testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()).WithTxIndex(1), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err = testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, signedTx.Hash())
+	receipt, err = testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, signedTx.Hash())
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found = testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found = testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 
 	// test approval message
@@ -128,30 +128,30 @@ func TestEvmEventsForCw20(t *testing.T) {
 		Contract: contractAddr.String(),
 		Msg:      payload,
 	}
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000))))
 	txBuilder.SetGasLimit(300000)
 	tx = signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, creator))
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum = sha256.Sum256(txbz)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res = testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err = testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
+	receipt, err = testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found = testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found = testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 	require.Equal(t, common.HexToHash("0x64").Bytes(), receipt.Logs[0].Data)
 }
 
 func TestEvmEventsForCw721(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
+	k := testkeeper.EVMTestApp().EvmKeeper
 	wasmKeeper := k.WasmKeeper()
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now()).WithChainID("sei-test").WithBlockHeight(1)
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now()).WithChainID("sei-test").WithBlockHeight(1)
 	code, err := os.ReadFile("../contracts/wasm/cw721_base.wasm")
 	require.Nil(t, err)
 	privKey := testkeeper.MockPrivateKey()
@@ -175,22 +175,22 @@ func TestEvmEventsForCw721(t *testing.T) {
 		Contract: contractAddr.String(),
 		Msg:      payload,
 	}
-	txBuilder := testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder := testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000))))
 	txBuilder.SetGasLimit(300000)
 	tx := signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, creator))
-	txbz, err := testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err := testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum := sha256.Sum256(txbz)
-	res := testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res := testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err := testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
+	receipt, err := testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found := testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found := testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 
 	// calling from wasmd precompile
@@ -221,20 +221,20 @@ func TestEvmEventsForCw721(t *testing.T) {
 	require.Nil(t, err)
 	emsg, err := evmtypes.NewMsgEVMTransaction(typedTx)
 	require.Nil(t, err)
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(emsg)
 	tx = txBuilder.GetTx()
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum = sha256.Sum256(txbz)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()).WithTxIndex(1), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res = testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()).WithTxIndex(1), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err = testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, signedTx.Hash())
+	receipt, err = testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, signedTx.Hash())
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found = testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found = testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 
 	// test approval message
@@ -244,17 +244,17 @@ func TestEvmEventsForCw721(t *testing.T) {
 		Contract: contractAddr.String(),
 		Msg:      payload,
 	}
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000))))
 	txBuilder.SetGasLimit(300000)
 	tx = signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, creator))
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum = sha256.Sum256(txbz)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res = testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err = testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
+	receipt, err = testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
@@ -262,7 +262,7 @@ func TestEvmEventsForCw721(t *testing.T) {
 	require.Equal(t, uint32(0), receipt.Logs[0].Index)
 	tokenIdHash := receipt.Logs[0].Topics[3]
 	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000002", tokenIdHash)
-	_, found = testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found = testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 	require.Equal(t, common.HexToHash("0x0").Bytes(), receipt.Logs[0].Data)
 
@@ -273,22 +273,22 @@ func TestEvmEventsForCw721(t *testing.T) {
 		Contract: contractAddr.String(),
 		Msg:      payload,
 	}
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000))))
 	txBuilder.SetGasLimit(300000)
 	tx = signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, creator))
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum = sha256.Sum256(txbz)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res = testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err = testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
+	receipt, err = testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found = testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found = testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 	tokenIdHash = receipt.Logs[0].Topics[3]
 	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000002", tokenIdHash)
@@ -301,22 +301,22 @@ func TestEvmEventsForCw721(t *testing.T) {
 		Contract: contractAddr.String(),
 		Msg:      payload,
 	}
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000))))
 	txBuilder.SetGasLimit(300000)
 	tx = signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, creator))
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum = sha256.Sum256(txbz)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res = testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err = testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
+	receipt, err = testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found = testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found = testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 	require.Equal(t, common.HexToHash("0x1").Bytes(), receipt.Logs[0].Data)
 
@@ -327,22 +327,22 @@ func TestEvmEventsForCw721(t *testing.T) {
 		Contract: contractAddr.String(),
 		Msg:      payload,
 	}
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000))))
 	txBuilder.SetGasLimit(300000)
 	tx = signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, creator))
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum = sha256.Sum256(txbz)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res = testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err = testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
+	receipt, err = testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found = testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found = testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 	require.Equal(t, common.HexToHash("0x0").Bytes(), receipt.Logs[0].Data)
 
@@ -353,22 +353,22 @@ func TestEvmEventsForCw721(t *testing.T) {
 		Contract: contractAddr.String(),
 		Msg:      payload,
 	}
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000))))
 	txBuilder.SetGasLimit(300000)
 	tx = signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, creator))
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(tx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(tx)
 	require.Nil(t, err)
 	sum = sha256.Sum256(txbz)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
+	res = testkeeper.EVMTestApp().DeliverTx(ctx.WithEventManager(sdk.NewEventManager()), abci.RequestDeliverTx{Tx: txbz}, tx, sum)
 	require.Equal(t, uint32(0), res.Code)
-	receipt, err = testkeeper.EVMTestApp.EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
+	receipt, err = testkeeper.EVMTestApp().EvmKeeper.GetTransientReceipt(ctx, common.BytesToHash(sum[:]))
 	require.Nil(t, err)
 	require.Equal(t, 1, len(receipt.Logs))
 	require.NotEmpty(t, receipt.LogsBloom)
 	require.Equal(t, mockPointerAddr.Hex(), receipt.Logs[0].Address)
-	_, found = testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
+	_, found = testkeeper.EVMTestApp().EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.True(t, found)
 	tokenIdHash = receipt.Logs[0].Topics[3]
 	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000002", tokenIdHash)
@@ -380,7 +380,7 @@ func signTx(txBuilder client.TxBuilder, privKey cryptotypes.PrivKey, acc authtyp
 	sigV2 := signing.SignatureV2{
 		PubKey: privKey.PubKey(),
 		Data: &signing.SingleSignatureData{
-			SignMode:  testkeeper.EVMTestApp.GetTxConfig().SignModeHandler().DefaultMode(),
+			SignMode:  testkeeper.EVMTestApp().GetTxConfig().SignModeHandler().DefaultMode(),
 			Signature: nil,
 		},
 		Sequence: acc.GetSequence(),
@@ -394,11 +394,11 @@ func signTx(txBuilder client.TxBuilder, privKey cryptotypes.PrivKey, acc authtyp
 		Sequence:      acc.GetSequence(),
 	}
 	sigV2, _ = clienttx.SignWithPrivKey(
-		testkeeper.EVMTestApp.GetTxConfig().SignModeHandler().DefaultMode(),
+		testkeeper.EVMTestApp().GetTxConfig().SignModeHandler().DefaultMode(),
 		signerData,
 		txBuilder,
 		privKey,
-		testkeeper.EVMTestApp.GetTxConfig(),
+		testkeeper.EVMTestApp().GetTxConfig(),
 		acc.GetSequence(),
 	)
 	sigsV2 = append(sigsV2, sigV2)
diff --git a/evmrpc/block_test.go b/evmrpc/block_test.go
index 73b464599..e3ff68a3a 100644
--- a/evmrpc/block_test.go
+++ b/evmrpc/block_test.go
@@ -151,8 +151,8 @@ func verifyBlockResult(t *testing.T, resObj map[string]interface{}) {
 }
 
 func TestEncodeTmBlock_EmptyTransactions(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	block := &coretypes.ResultBlock{
 		BlockID: MockBlockID,
 		Block: &tmtypes.Block{
@@ -182,8 +182,8 @@ func TestEncodeTmBlock_EmptyTransactions(t *testing.T) {
 }
 
 func TestEncodeBankMsg(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	fromSeiAddr, _ := testkeeper.MockAddressPair()
 	toSeiAddr, _ := testkeeper.MockAddressPair()
 	b := TxConfig.NewTxBuilder()
@@ -227,8 +227,8 @@ func TestEncodeBankMsg(t *testing.T) {
 }
 
 func TestEncodeWasmExecuteMsg(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	fromSeiAddr, fromEvmAddr := testkeeper.MockAddressPair()
 	toSeiAddr, _ := testkeeper.MockAddressPair()
 	b := TxConfig.NewTxBuilder()
diff --git a/evmrpc/info_test.go b/evmrpc/info_test.go
index 52462b74e..e92769717 100644
--- a/evmrpc/info_test.go
+++ b/evmrpc/info_test.go
@@ -2,7 +2,6 @@ package evmrpc_test
 
 import (
 	"errors"
-	"fmt"
 	"math/big"
 	"testing"
 
diff --git a/precompiles/bank/bank_test.go b/precompiles/bank/bank_test.go
index 06fcabc4f..6459f0b4d 100644
--- a/precompiles/bank/bank_test.go
+++ b/precompiles/bank/bank_test.go
@@ -340,8 +340,8 @@ func TestSendForUnlinkedReceiver(t *testing.T) {
 }
 
 func TestMetadata(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	k.BankKeeper().SetDenomMetaData(ctx, banktypes.Metadata{Name: "SEI", Symbol: "usei", Base: "usei"})
 	p, err := bank.NewPrecompile(k.BankKeeper(), k, k.AccountKeeper())
 	require.Nil(t, err)
@@ -381,7 +381,7 @@ func TestMetadata(t *testing.T) {
 }
 
 func TestRequiredGas(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
+	k := &testkeeper.EVMTestApp().EvmKeeper
 	p, err := bank.NewPrecompile(k.BankKeeper(), k, k.AccountKeeper())
 	require.Nil(t, err)
 	balanceRequiredGas := p.RequiredGas(p.GetExecutor().(*bank.PrecompileExecutor).BalanceID)
@@ -391,7 +391,7 @@ func TestRequiredGas(t *testing.T) {
 }
 
 func TestAddress(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
+	k := &testkeeper.EVMTestApp().EvmKeeper
 	p, err := bank.NewPrecompile(k.BankKeeper(), k, k.AccountKeeper())
 	require.Nil(t, err)
 	require.Equal(t, common.HexToAddress(bank.BankAddress), p.Address())
diff --git a/precompiles/common/precompiles_test.go b/precompiles/common/precompiles_test.go
index eae5ad7ab..f36705cb4 100644
--- a/precompiles/common/precompiles_test.go
+++ b/precompiles/common/precompiles_test.go
@@ -39,8 +39,8 @@ func TestValidteNonPayable(t *testing.T) {
 
 func TestHandlePrecompileError(t *testing.T) {
 	_, evmAddr := testkeeper.MockAddressPair()
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	stateDB := state.NewDBImpl(ctx, k, false)
 	evm := &vm.EVM{StateDB: stateDB}
 
@@ -67,8 +67,8 @@ func (e *MockPrecompileExecutor) Execute(ctx sdk.Context, method *abi.Method, ca
 }
 
 func TestPrecompileRun(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	abiBz, err := os.ReadFile("erc20_abi.json")
 	require.Nil(t, err)
 	newAbi, err := abi.JSON(bytes.NewReader(abiBz))
@@ -108,8 +108,8 @@ func (e *MockDynamicGasPrecompileExecutor) EVMKeeper() common.EVMKeeper {
 }
 
 func TestDynamicGasPrecompileRun(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	abiBz, err := os.ReadFile("erc20_abi.json")
 	require.Nil(t, err)
 	newAbi, err := abi.JSON(bytes.NewReader(abiBz))
diff --git a/precompiles/pointerview/pointerview_test.go b/precompiles/pointerview/pointerview_test.go
index e338a9c43..1f6e1875a 100644
--- a/precompiles/pointerview/pointerview_test.go
+++ b/precompiles/pointerview/pointerview_test.go
@@ -14,8 +14,8 @@ import (
 )
 
 func TestPointerView(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	p, err := pointerview.NewPrecompile(k)
 	require.Nil(t, err)
 	_, pointer := testkeeper.MockAddressPair()
diff --git a/testutil/keeper/evm.go b/testutil/keeper/evm.go
index d658c833d..43a7eea8f 100644
--- a/testutil/keeper/evm.go
+++ b/testutil/keeper/evm.go
@@ -58,8 +58,8 @@ func MockEVMKeeperWithPrecompiles() (*evmkeeper.Keeper, sdk.Context) {
 	return &k, ctx
 }
 
-func MockEVMKeeper() (*evmkeeper.Keeper, sdk.Context) {
-	testApp := app.Setup(false, false)
+func MockEVMKeeper() (*evmkeeper.Keeper, sdk.Context, *app.App) {
+	testApp := app.Setup(false, true)
 	ctx := testApp.GetContextForDeliverTx([]byte{}).WithBlockHeight(8).WithBlockTime(time.Now())
 	k := testApp.EvmKeeper
 	k.InitGenesis(ctx, *evmtypes.DefaultGenesis())
@@ -77,7 +77,7 @@ func MockEVMKeeper() (*evmkeeper.Keeper, sdk.Context) {
 	if err != nil {
 		panic(err)
 	}
-	return &k, ctx
+	return &k, ctx, testApp
 }
 
 func MockAddressPair() (sdk.AccAddress, common.Address) {
diff --git a/x/evm/ante/basic_test.go b/x/evm/ante/basic_test.go
index 6f6ceb5cd..3d5921ea2 100644
--- a/x/evm/ante/basic_test.go
+++ b/x/evm/ante/basic_test.go
@@ -15,8 +15,8 @@ import (
 )
 
 func TestBasicDecorator(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	a := ante.NewBasicDecorator(k)
 	msg, _ := types.NewMsgEVMTransaction(&ethtx.LegacyTx{})
 	ctx, err := a.AnteHandle(ctx, &mockTx{msgs: []sdk.Msg{msg}}, false, func(ctx sdk.Context, _ sdk.Tx, _ bool) (sdk.Context, error) {
diff --git a/x/evm/ante/fee_test.go b/x/evm/ante/fee_test.go
index 138d22dbd..02bbc7928 100644
--- a/x/evm/ante/fee_test.go
+++ b/x/evm/ante/fee_test.go
@@ -21,8 +21,8 @@ import (
 )
 
 func TestEVMFeeCheckDecorator(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	handler := ante.NewEVMFeeCheckDecorator(k)
 	privKey := testkeeper.MockPrivateKey()
 	testPrivHex := hex.EncodeToString(privKey.Bytes())
@@ -115,8 +115,8 @@ func TestEVMFeeCheckDecorator(t *testing.T) {
 }
 
 func TestCalculatePriorityScenarios(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	decorator := ante.NewEVMFeeCheckDecorator(k)
 
 	_1gwei := big.NewInt(100000000000)
diff --git a/x/evm/ante/gas_test.go b/x/evm/ante/gas_test.go
index d1cac2b93..357679a3c 100644
--- a/x/evm/ante/gas_test.go
+++ b/x/evm/ante/gas_test.go
@@ -13,8 +13,8 @@ import (
 )
 
 func TestGasLimitDecorator(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	a := ante.NewGasLimitDecorator(k)
 	limitMsg, _ := types.NewMsgEVMTransaction(&ethtx.LegacyTx{GasLimit: 100})
 	ctx, err := a.AnteHandle(ctx, &mockTx{msgs: []sdk.Msg{limitMsg}}, false, func(ctx sdk.Context, _ sdk.Tx, _ bool) (sdk.Context, error) {
diff --git a/x/evm/ante/preprocess_test.go b/x/evm/ante/preprocess_test.go
index b503f07f5..ff66158b4 100644
--- a/x/evm/ante/preprocess_test.go
+++ b/x/evm/ante/preprocess_test.go
@@ -29,8 +29,8 @@ import (
 )
 
 func TestPreprocessAnteHandler(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	handler := ante.NewEVMPreprocessDecorator(k, k.AccountKeeper())
 	privKey := testkeeper.MockPrivateKey()
 	seiAddr, evmAddr := testkeeper.PrivateKeyToAddresses(privKey)
@@ -71,8 +71,8 @@ func TestPreprocessAnteHandler(t *testing.T) {
 }
 
 func TestPreprocessAnteHandlerUnprotected(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	handler := ante.NewEVMPreprocessDecorator(k, k.AccountKeeper())
 	gasPrice := sdk.NewInt(73141930316)
 	amt := sdk.NewInt(270000000000000000)
@@ -100,8 +100,8 @@ func TestPreprocessAnteHandlerUnprotected(t *testing.T) {
 }
 
 func TestPreprocessAssociateTx(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	handler := ante.NewEVMPreprocessDecorator(k, k.AccountKeeper())
 	privKey := testkeeper.MockPrivateKey()
 	testPrivHex := hex.EncodeToString(privKey.Bytes())
@@ -144,8 +144,8 @@ func TestPreprocessAssociateTx(t *testing.T) {
 }
 
 func TestPreprocessAssociateTxWithWeiBalance(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	handler := ante.NewEVMPreprocessDecorator(k, k.AccountKeeper())
 	privKey := testkeeper.MockPrivateKey()
 	testPrivHex := hex.EncodeToString(privKey.Bytes())
@@ -192,7 +192,7 @@ func TestGetVersion(t *testing.T) {
 }
 
 func TestAnteDeps(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
+	k := &testkeeper.EVMTestApp().EvmKeeper
 	handler := ante.NewEVMPreprocessDecorator(k, k.AccountKeeper())
 	msg, _ := types.NewMsgEVMTransaction(&ethtx.LegacyTx{GasLimit: 100})
 	msg.Derived = &derived.Derived{
@@ -208,8 +208,8 @@ func TestAnteDeps(t *testing.T) {
 }
 
 func TestEVMAddressDecorator(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	sender, evmAddr := testkeeper.PrivateKeyToAddresses(privKey)
 	recipient, _ := testkeeper.MockAddressPair()
@@ -226,8 +226,8 @@ func TestEVMAddressDecorator(t *testing.T) {
 }
 
 func TestIsAccountBalancePositive(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	s1, e1 := testkeeper.MockAddressPair()
 	s2, e2 := testkeeper.MockAddressPair()
 	s3, e3 := testkeeper.MockAddressPair()
@@ -259,8 +259,8 @@ func (m MockTxIncompatible) ValidateBasic() error {
 }
 
 func TestEVMAddressDecoratorContinueDespiteErrors(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	handler := ante.NewEVMAddressDecorator(k, k.AccountKeeper())
 
 	_, err := handler.AnteHandle(ctx, MockTxIncompatible{}, false, func(ctx sdk.Context, _ sdk.Tx, _ bool) (sdk.Context, error) {
@@ -301,8 +301,8 @@ func TestEVMAddressDecoratorContinueDespiteErrors(t *testing.T) {
 }
 
 func TestMigrateBalance(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	admin, _ := testkeeper.MockAddressPair()
 	seiAddr, evmAddr := testkeeper.MockAddressPair()
 	k.BankKeeper().AddCoins(ctx, sdk.AccAddress(evmAddr[:]), sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(2))), false)
diff --git a/x/evm/ante/sig_test.go b/x/evm/ante/sig_test.go
index a4ccd8895..efd24b50e 100644
--- a/x/evm/ante/sig_test.go
+++ b/x/evm/ante/sig_test.go
@@ -19,8 +19,8 @@ import (
 )
 
 func TestEVMSigVerifyDecorator(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	handler := ante.NewEVMSigVerifyDecorator(k, func() sdk.Context { return ctx })
 	privKey := testkeeper.MockPrivateKey()
 	testPrivHex := hex.EncodeToString(privKey.Bytes())
@@ -101,8 +101,8 @@ func TestEVMSigVerifyDecorator(t *testing.T) {
 }
 
 func TestSigVerifyPendingTransaction(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	ctx = ctx.WithIsCheckTx(true)
 	handler := ante.NewEVMSigVerifyDecorator(k, func() sdk.Context { return ctx })
 	privKey := testkeeper.MockPrivateKey()
diff --git a/x/evm/client/wasm/query_test.go b/x/evm/client/wasm/query_test.go
index e9b68d8dd..3b56cbbe9 100644
--- a/x/evm/client/wasm/query_test.go
+++ b/x/evm/client/wasm/query_test.go
@@ -29,8 +29,8 @@ import (
 )
 
 func TestERC721TransferPayload(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	addr1, e1 := testkeeper.MockAddressPair()
 	addr2, e2 := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, addr1, e1)
@@ -42,8 +42,8 @@ func TestERC721TransferPayload(t *testing.T) {
 }
 
 func TestERC721ApprovePayload(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	addr1, e1 := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, addr1, e1)
 	h := wasm.NewEVMQueryHandler(k)
@@ -53,8 +53,8 @@ func TestERC721ApprovePayload(t *testing.T) {
 }
 
 func TestERC721ApproveAllPayload(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	addr1, e1 := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, addr1, e1)
 	h := wasm.NewEVMQueryHandler(k)
@@ -64,8 +64,8 @@ func TestERC721ApproveAllPayload(t *testing.T) {
 }
 
 func TestERC20TransferPayload(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	addr1, e1 := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, addr1, e1)
 	h := wasm.NewEVMQueryHandler(k)
@@ -76,8 +76,8 @@ func TestERC20TransferPayload(t *testing.T) {
 }
 
 func TestHandleERC20TokenInfo(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc20/ERC20.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -92,8 +92,8 @@ func TestHandleERC20TokenInfo(t *testing.T) {
 }
 
 func TestERC20TransferFromPayload(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	addr1, e1 := testkeeper.MockAddressPair()
 	addr2, e2 := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, addr1, e1)
@@ -106,8 +106,8 @@ func TestERC20TransferFromPayload(t *testing.T) {
 }
 
 func TestERC20ApprovePayload(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	addr1, e1 := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, addr1, e1)
 	h := wasm.NewEVMQueryHandler(k)
@@ -118,8 +118,8 @@ func TestERC20ApprovePayload(t *testing.T) {
 }
 
 func TestHandleERC20Balance(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc20/ERC20.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -135,8 +135,8 @@ func TestHandleERC20Balance(t *testing.T) {
 }
 
 func TestHandleERC721Owner(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc721/DummyERC721.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -151,8 +151,8 @@ func TestHandleERC721Owner(t *testing.T) {
 }
 
 func TestHandleERC20Allowance(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc20/ERC20.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -170,8 +170,8 @@ func TestHandleERC20Allowance(t *testing.T) {
 }
 
 func TestHandleERC721Approved(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc721/DummyERC721.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -188,8 +188,8 @@ func TestHandleERC721Approved(t *testing.T) {
 }
 
 func TestHandleERC721IsApprovedForAll(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc721/DummyERC721.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -206,8 +206,8 @@ func TestHandleERC721IsApprovedForAll(t *testing.T) {
 }
 
 func TestHandleERC721TotalSupply(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc721/DummyERC721.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -223,8 +223,8 @@ func TestHandleERC721TotalSupply(t *testing.T) {
 }
 
 func TestHandleERC721NameSymbol(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc721/DummyERC721.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -240,8 +240,8 @@ func TestHandleERC721NameSymbol(t *testing.T) {
 }
 
 func TestHandleERC721TokenURI(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc721/DummyERC721.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -256,8 +256,8 @@ func TestHandleERC721TokenURI(t *testing.T) {
 }
 
 func TestHandleERC721RoyaltyInfo(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	res, _ := deployContract(t, ctx, k, "../../../../example/contracts/erc721/DummyERC721.bin", privKey)
 	addr1, e1 := testkeeper.MockAddressPair()
@@ -275,8 +275,8 @@ func TestHandleERC721RoyaltyInfo(t *testing.T) {
 }
 
 func TestGetAddress(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	seiAddr1, evmAddr1 := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, seiAddr1, evmAddr1)
 	seiAddr2, evmAddr2 := testkeeper.MockAddressPair()
@@ -379,8 +379,8 @@ func createSigner(k *keeper.Keeper, ctx sdk.Context) ethtypes.Signer {
 }
 
 func TestHandleStaticCall(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	privKey := testkeeper.MockPrivateKey()
 	_, evmAddr := testkeeper.PrivateKeyToAddresses(privKey)
 	testPrivHex := hex.EncodeToString(privKey.Bytes())
diff --git a/x/evm/genesis_test.go b/x/evm/genesis_test.go
index 2ad13e0f4..799c00db1 100644
--- a/x/evm/genesis_test.go
+++ b/x/evm/genesis_test.go
@@ -13,8 +13,8 @@ import (
 )
 
 func TestExportImportGenesis(t *testing.T) {
-	keeper := &testkeeper.EVMTestApp.EvmKeeper
-	origctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	keeper := &testkeeper.EVMTestApp().EvmKeeper
+	origctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	ctx := origctx.WithMultiStore(origctx.MultiStore().CacheMultiStore())
 	seiAddr, evmAddr := testkeeper.MockAddressPair()
 	keeper.SetAddressMapping(ctx, seiAddr, evmAddr)
diff --git a/x/evm/gov_test.go b/x/evm/gov_test.go
index 402bf4f5c..6b25fc062 100644
--- a/x/evm/gov_test.go
+++ b/x/evm/gov_test.go
@@ -11,8 +11,8 @@ import (
 )
 
 func TestAddERCNativePointerProposalsV2(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	require.Nil(t, evm.HandleAddERCNativePointerProposalV2(ctx, k, &types.AddERCNativePointerProposalV2{
 		Token:    "test",
 		Name:     "NAME",
diff --git a/x/evm/integration_test.go b/x/evm/integration_test.go
index 6c312f5a8..1b2a6f6a2 100644
--- a/x/evm/integration_test.go
+++ b/x/evm/integration_test.go
@@ -39,8 +39,8 @@ import (
 var f embed.FS
 
 func TestERC2981PointerToCW2981(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	adminSeiAddr, adminEvmAddr := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, adminSeiAddr, adminEvmAddr)
 	// deploy cw2981
@@ -98,12 +98,12 @@ func TestERC2981PointerToCW2981(t *testing.T) {
 	require.Nil(t, err)
 	msg, err := types.NewMsgEVMTransaction(typedTx)
 	require.Nil(t, err)
-	txBuilder := testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder := testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	cosmosTx := txBuilder.GetTx()
-	txbz, err := testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(cosmosTx)
+	txbz, err := testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(cosmosTx)
 	require.Nil(t, err)
-	res := testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
+	res := testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(0), res.Code)
 	pointerAddr, _, exists := k.GetERC721CW721Pointer(ctx, cw2981Addr.String())
 	require.True(t, exists)
@@ -126,12 +126,12 @@ func TestERC2981PointerToCW2981(t *testing.T) {
 	require.Nil(t, err)
 	msg, err = types.NewMsgEVMTransaction(typedTx)
 	require.Nil(t, err)
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	cosmosTx = txBuilder.GetTx()
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(cosmosTx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(cosmosTx)
 	require.Nil(t, err)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
+	res = testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(0), res.Code)
 	typedTxData := sdk.TxMsgData{}
 	require.Nil(t, typedTxData.Unmarshal(res.Data))
@@ -144,8 +144,8 @@ func TestERC2981PointerToCW2981(t *testing.T) {
 }
 
 func TestCW2981PointerToERC2981(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	// deploy erc2981
 	privKey := testkeeper.MockPrivateKey()
 	seiAddr, evmAddr := testkeeper.PrivateKeyToAddresses(privKey)
@@ -181,12 +181,12 @@ func TestCW2981PointerToERC2981(t *testing.T) {
 	require.Nil(t, err)
 	msg, err := types.NewMsgEVMTransaction(typedTx)
 	require.Nil(t, err)
-	txBuilder := testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder := testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	cosmosTx := txBuilder.GetTx()
-	txbz, err := testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(cosmosTx)
+	txbz, err := testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(cosmosTx)
 	require.Nil(t, err)
-	res := testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
+	res := testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(0), res.Code)
 	err = k.FlushTransientReceipts(ctx)
 	require.NoError(t, err)
@@ -211,12 +211,12 @@ func TestCW2981PointerToERC2981(t *testing.T) {
 	require.Nil(t, err)
 	msg, err = types.NewMsgEVMTransaction(typedTx)
 	require.Nil(t, err)
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	cosmosTx = txBuilder.GetTx()
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(cosmosTx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(cosmosTx)
 	require.Nil(t, err)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
+	res = testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(0), res.Code)
 	// deploy CW->ERC pointer
 	res2, err := keeper.NewMsgServerImpl(&k).RegisterPointer(sdk.WrapSDKContext(ctx), &types.MsgRegisterPointer{
@@ -235,7 +235,7 @@ func TestCW2981PointerToERC2981(t *testing.T) {
 		},
 	})
 	require.Nil(t, err)
-	ret, err := testkeeper.EVMTestApp.WasmKeeper.QuerySmart(ctx, sdk.MustAccAddressFromBech32(res2.PointerAddress), query)
+	ret, err := testkeeper.EVMTestApp().WasmKeeper.QuerySmart(ctx, sdk.MustAccAddressFromBech32(res2.PointerAddress), query)
 	require.Nil(t, err)
 	require.Equal(t, "{\"royalty_payments\":true}", string(ret))
 	query, err = json.Marshal(map[string]interface{}{
@@ -249,14 +249,14 @@ func TestCW2981PointerToERC2981(t *testing.T) {
 		},
 	})
 	require.Nil(t, err)
-	ret, err = testkeeper.EVMTestApp.WasmKeeper.QuerySmart(ctx, sdk.MustAccAddressFromBech32(res2.PointerAddress), query)
+	ret, err = testkeeper.EVMTestApp().WasmKeeper.QuerySmart(ctx, sdk.MustAccAddressFromBech32(res2.PointerAddress), query)
 	require.Nil(t, err)
 	require.Equal(t, fmt.Sprintf("{\"address\":\"%s\",\"royalty_amount\":\"1000\"}", seiAddr.String()), string(ret))
 }
 
 func TestNonceIncrementsForInsufficientFunds(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	privKey := testkeeper.MockPrivateKey()
 	seiAddr, evmAddr := testkeeper.PrivateKeyToAddresses(privKey)
 	k.SetAddressMapping(ctx, seiAddr, evmAddr)
@@ -280,25 +280,25 @@ func TestNonceIncrementsForInsufficientFunds(t *testing.T) {
 	require.Nil(t, err)
 	msg, err := types.NewMsgEVMTransaction(typedTx)
 	require.Nil(t, err)
-	txBuilder := testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder := testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	cosmosTx := txBuilder.GetTx()
-	txbz, err := testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(cosmosTx)
+	txbz, err := testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(cosmosTx)
 	require.Nil(t, err)
-	res := testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
+	res := testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(5), res.Code)                 // insufficient funds has error code 5
 	require.Equal(t, uint64(1), k.GetNonce(ctx, evmAddr)) // make sure nonce is incremented regardless
 
 	// ensure that old txs cannot be used by malicious party to bump nonces
-	res = testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
+	res = testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(32), res.Code)                // wrong nonce has error code 32
 	require.Equal(t, uint64(1), k.GetNonce(ctx, evmAddr)) // nonce should not be incremented this time because the tx is an old one
 }
 
 func TestInvalidAssociateMsg(t *testing.T) {
 	// EVM associate tx
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now()).WithChainID("sei-test").WithBlockHeight(1)
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now()).WithChainID("sei-test").WithBlockHeight(1)
 	privKey := testkeeper.MockPrivateKey()
 	seiAddr, _ := testkeeper.PrivateKeyToAddresses(privKey)
 	amt := sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(1000000)))
@@ -319,40 +319,40 @@ func TestInvalidAssociateMsg(t *testing.T) {
 	}
 	msg, err := types.NewMsgEVMTransaction(typedTx)
 	require.Nil(t, err)
-	txBuilder := testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder := testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(msg)
 	cosmosTx := txBuilder.GetTx()
-	txbz, err := testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(cosmosTx)
+	txbz, err := testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(cosmosTx)
 	require.Nil(t, err)
-	res := testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
+	res := testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, cosmosTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(21), res.Code) // tx too large
 
 	// cosmos associate tx
 	amsg := &types.MsgAssociate{
 		Sender: seiAddr.String(), CustomMessage: customMsg,
 	}
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	txBuilder.SetMsgs(amsg)
 	signedTx := signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, seiAddr))
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(signedTx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(signedTx)
 	require.Nil(t, err)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, signedTx, sha256.Sum256(txbz))
+	res = testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, signedTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(21), res.Code)
 
 	// multiple associate msgs should charge gas (and run out of gas in this test case)
 	amsg = &types.MsgAssociate{
 		Sender: seiAddr.String(), CustomMessage: "",
 	}
-	txBuilder = testkeeper.EVMTestApp.GetTxConfig().NewTxBuilder()
+	txBuilder = testkeeper.EVMTestApp().GetTxConfig().NewTxBuilder()
 	msgs := []sdk.Msg{}
 	for i := 1; i <= 1000; i++ {
 		msgs = append(msgs, amsg)
 	}
 	txBuilder.SetMsgs(msgs...)
 	signedTx = signTx(txBuilder, privKey, k.AccountKeeper().GetAccount(ctx, seiAddr))
-	txbz, err = testkeeper.EVMTestApp.GetTxConfig().TxEncoder()(signedTx)
+	txbz, err = testkeeper.EVMTestApp().GetTxConfig().TxEncoder()(signedTx)
 	require.Nil(t, err)
-	res = testkeeper.EVMTestApp.DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, signedTx, sha256.Sum256(txbz))
+	res = testkeeper.EVMTestApp().DeliverTx(ctx, abci.RequestDeliverTx{Tx: txbz}, signedTx, sha256.Sum256(txbz))
 	require.Equal(t, uint32(11), res.Code) // out of gas
 }
 
@@ -361,7 +361,7 @@ func signTx(txBuilder client.TxBuilder, privKey cryptotypes.PrivKey, acc authtyp
 	sigV2 := signing.SignatureV2{
 		PubKey: privKey.PubKey(),
 		Data: &signing.SingleSignatureData{
-			SignMode:  testkeeper.EVMTestApp.GetTxConfig().SignModeHandler().DefaultMode(),
+			SignMode:  testkeeper.EVMTestApp().GetTxConfig().SignModeHandler().DefaultMode(),
 			Signature: nil,
 		},
 		Sequence: acc.GetSequence(),
@@ -375,11 +375,11 @@ func signTx(txBuilder client.TxBuilder, privKey cryptotypes.PrivKey, acc authtyp
 		Sequence:      acc.GetSequence(),
 	}
 	sigV2, _ = clienttx.SignWithPrivKey(
-		testkeeper.EVMTestApp.GetTxConfig().SignModeHandler().DefaultMode(),
+		testkeeper.EVMTestApp().GetTxConfig().SignModeHandler().DefaultMode(),
 		signerData,
 		txBuilder,
 		privKey,
-		testkeeper.EVMTestApp.GetTxConfig(),
+		testkeeper.EVMTestApp().GetTxConfig(),
 		acc.GetSequence(),
 	)
 	sigsV2 = append(sigsV2, sigV2)
diff --git a/x/evm/keeper/params_test.go b/x/evm/keeper/params_test.go
index 3e5091a9f..c38bbfd05 100644
--- a/x/evm/keeper/params_test.go
+++ b/x/evm/keeper/params_test.go
@@ -5,40 +5,14 @@ import (
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/sei-protocol/sei-chain/app"
 	testkeeper "github.com/sei-protocol/sei-chain/testutil/keeper"
-	evmkeeper "github.com/sei-protocol/sei-chain/x/evm/keeper"
 	"github.com/sei-protocol/sei-chain/x/evm/types"
-	evmtypes "github.com/sei-protocol/sei-chain/x/evm/types"
 	"github.com/stretchr/testify/require"
 )
 
-func MockEVMKeeper() (*evmkeeper.Keeper, sdk.Context, *app.App) {
-	testApp := app.Setup(false, true)
-	ctx := testApp.GetContextForDeliverTx([]byte{}).WithBlockHeight(8).WithBlockTime(time.Now())
-	k := testApp.EvmKeeper
-	k.InitGenesis(ctx, *evmtypes.DefaultGenesis())
-
-	// mint some coins to a sei address
-	seiAddr, err := sdk.AccAddressFromHex(common.Bytes2Hex([]byte("seiAddr")))
-	if err != nil {
-		panic(err)
-	}
-	err = testApp.BankKeeper.MintCoins(ctx, "evm", sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(10))))
-	if err != nil {
-		panic(err)
-	}
-	err = testApp.BankKeeper.SendCoinsFromModuleToAccount(ctx, "evm", seiAddr, sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(10))))
-	if err != nil {
-		panic(err)
-	}
-	return &k, ctx, testApp
-}
-
 func TestParams(t *testing.T) {
 	// k := &testkeeper.EVMTestApp().EvmKeeper
-	k, _, testApp := MockEVMKeeper()
+	k, _, testApp := testkeeper.MockEVMKeeper()
 	ctx := testApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	// ctx, _ = ctx.CacheContext()
 	require.Equal(t, "usei", k.GetBaseDenom(ctx))
diff --git a/x/evm/migrations/add_new_param_migration_test.go b/x/evm/migrations/add_new_param_migration_test.go
index 981ab5d1e..8966b6959 100644
--- a/x/evm/migrations/add_new_param_migration_test.go
+++ b/x/evm/migrations/add_new_param_migration_test.go
@@ -10,8 +10,8 @@ import (
 )
 
 func TestAddNewParamsAndSetAllToDefaults(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.NewContext(false, tmtypes.Header{})
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().NewContext(false, tmtypes.Header{})
 	migrations.AddNewParamsAndSetAllToDefaults(ctx, &k)
 	require.NotPanics(t, func() { k.GetParams(ctx) })
 }
diff --git a/x/evm/migrations/fix_total_supply_test.go b/x/evm/migrations/fix_total_supply_test.go
index da0bb5bbe..8af2c4a1f 100644
--- a/x/evm/migrations/fix_total_supply_test.go
+++ b/x/evm/migrations/fix_total_supply_test.go
@@ -11,8 +11,8 @@ import (
 )
 
 func TestFixTotalSupply(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	addr, _ := testkeeper.MockAddressPair()
 	balance := sdk.NewCoins(sdk.NewCoin(sdk.MustGetBaseDenom(), sdk.OneInt()))
 	k.BankKeeper().MintCoins(ctx, "evm", balance)
diff --git a/x/evm/migrations/migrate_all_pointers_test.go b/x/evm/migrations/migrate_all_pointers_test.go
index fee2e4732..27516ca83 100644
--- a/x/evm/migrations/migrate_all_pointers_test.go
+++ b/x/evm/migrations/migrate_all_pointers_test.go
@@ -16,8 +16,8 @@ import (
 )
 
 func TestMigrateERCNativePointers(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	var pointerAddr common.Address
 	require.Nil(t, k.RunWithOneOffEVMInstance(ctx, func(e *vm.EVM) error {
 		a, err := k.UpsertERCNativePointer(ctx, e, "test", utils.ERCMetadata{Name: "name", Symbol: "symbol", Decimals: 6})
@@ -31,8 +31,8 @@ func TestMigrateERCNativePointers(t *testing.T) {
 }
 
 func TestMigrateERCCW20Pointers(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	var pointerAddr common.Address
 	require.Nil(t, k.RunWithOneOffEVMInstance(ctx, func(e *vm.EVM) error {
 		a, err := k.UpsertERCCW20Pointer(ctx, e, "test", utils.ERCMetadata{Name: "name", Symbol: "symbol"})
@@ -46,8 +46,8 @@ func TestMigrateERCCW20Pointers(t *testing.T) {
 }
 
 func TestMigrateERCCW721Pointers(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	var pointerAddr common.Address
 	require.Nil(t, k.RunWithOneOffEVMInstance(ctx, func(e *vm.EVM) error {
 		a, err := k.UpsertERCCW721Pointer(ctx, e, "test", utils.ERCMetadata{Name: "name", Symbol: "symbol"})
@@ -61,8 +61,8 @@ func TestMigrateERCCW721Pointers(t *testing.T) {
 }
 
 func TestMigrateCWERC20Pointers(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	require.Nil(t, migrations.StoreCWPointerCode(ctx, &k, true, false))
 	msgServer := keeper.NewMsgServerImpl(&k)
 	res, err := msgServer.RegisterPointer(sdk.WrapSDKContext(ctx), &types.MsgRegisterPointer{
@@ -77,8 +77,8 @@ func TestMigrateCWERC20Pointers(t *testing.T) {
 }
 
 func TestMigrateCWERC721Pointers(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	require.Nil(t, migrations.StoreCWPointerCode(ctx, &k, false, true))
 	msgServer := keeper.NewMsgServerImpl(&k)
 	res, err := msgServer.RegisterPointer(sdk.WrapSDKContext(ctx), &types.MsgRegisterPointer{
diff --git a/x/evm/migrations/migrate_cast_address_balances_test.go b/x/evm/migrations/migrate_cast_address_balances_test.go
index e770637fa..1c143e935 100644
--- a/x/evm/migrations/migrate_cast_address_balances_test.go
+++ b/x/evm/migrations/migrate_cast_address_balances_test.go
@@ -12,8 +12,8 @@ import (
 )
 
 func TestMigrateCastAddressBalances(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	require.Nil(t, k.BankKeeper().MintCoins(ctx, types.ModuleName, testkeeper.UseiCoins(100)))
 	// unassociated account with funds
 	seiAddr1, evmAddr1 := testkeeper.MockAddressPair()
diff --git a/x/evm/migrations/migrate_deliver_tx_gas_limit_test.go b/x/evm/migrations/migrate_deliver_tx_gas_limit_test.go
index 5d88fb200..40ddde686 100644
--- a/x/evm/migrations/migrate_deliver_tx_gas_limit_test.go
+++ b/x/evm/migrations/migrate_deliver_tx_gas_limit_test.go
@@ -11,8 +11,8 @@ import (
 )
 
 func TestMigrateDeliverTxHookWasmGasLimitParam(t *testing.T) {
-	k := testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.NewContext(false, tmtypes.Header{})
+	k := testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().NewContext(false, tmtypes.Header{})
 
 	currParams := k.GetParams(ctx)
 
diff --git a/x/evm/state/accesslist_test.go b/x/evm/state/accesslist_test.go
index 7ccdd8b86..b04b553a5 100644
--- a/x/evm/state/accesslist_test.go
+++ b/x/evm/state/accesslist_test.go
@@ -13,8 +13,8 @@ import (
 )
 
 func TestAddAddressToAccessList(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	statedb := state.NewDBImpl(ctx, k, false)
 
 	_, addr := testkeeper.MockAddressPair()
@@ -30,8 +30,8 @@ func TestAddAddressToAccessList(t *testing.T) {
 }
 
 func TestAddSlotToAccessList(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	statedb := state.NewDBImpl(ctx, k, false)
 
 	_, addr := testkeeper.MockAddressPair()
@@ -48,8 +48,8 @@ func TestAddSlotToAccessList(t *testing.T) {
 }
 
 func TestAddSlotToAccessListWithNonExistentAddress(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	statedb := state.NewDBImpl(ctx, k, false)
 
 	_, addr := testkeeper.MockAddressPair()
@@ -59,8 +59,8 @@ func TestAddSlotToAccessListWithNonExistentAddress(t *testing.T) {
 }
 
 func TestPrepare(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	statedb := state.NewDBImpl(ctx, k, false)
 
 	_, sender := testkeeper.MockAddressPair()
diff --git a/x/evm/state/balance_test.go b/x/evm/state/balance_test.go
index c676af2ef..0a5bf4f9b 100644
--- a/x/evm/state/balance_test.go
+++ b/x/evm/state/balance_test.go
@@ -14,8 +14,8 @@ import (
 )
 
 func TestAddBalance(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	db := state.NewDBImpl(ctx, k, false)
 	seiAddr, evmAddr := testkeeper.MockAddressPair()
 	require.Equal(t, big.NewInt(0), db.GetBalance(evmAddr))
@@ -42,8 +42,8 @@ func TestAddBalance(t *testing.T) {
 }
 
 func TestSubBalance(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	db := state.NewDBImpl(ctx, k, false)
 	seiAddr, evmAddr := testkeeper.MockAddressPair()
 	require.Equal(t, big.NewInt(0), db.GetBalance(evmAddr))
@@ -81,8 +81,8 @@ func TestSubBalance(t *testing.T) {
 }
 
 func TestSetBalance(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	db := state.NewDBImpl(ctx, k, true)
 	_, evmAddr := testkeeper.MockAddressPair()
 	db.SetBalance(evmAddr, big.NewInt(10000000000000), tracing.BalanceChangeUnspecified)
@@ -95,8 +95,8 @@ func TestSetBalance(t *testing.T) {
 }
 
 func TestSurplus(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	_, evmAddr := testkeeper.MockAddressPair()
 
 	// test negative usei surplus negative wei surplus
diff --git a/x/evm/state/check_test.go b/x/evm/state/check_test.go
index 2707b9547..876df99f4 100644
--- a/x/evm/state/check_test.go
+++ b/x/evm/state/check_test.go
@@ -13,8 +13,8 @@ import (
 
 func TestExist(t *testing.T) {
 	// not exist
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	_, addr := testkeeper.MockAddressPair()
 	statedb := state.NewDBImpl(ctx, k, false)
 	require.False(t, statedb.Exist(addr))
@@ -37,8 +37,8 @@ func TestExist(t *testing.T) {
 
 func TestEmpty(t *testing.T) {
 	// empty
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	_, addr := testkeeper.MockAddressPair()
 	statedb := state.NewDBImpl(ctx, k, false)
 	require.True(t, statedb.Empty(addr))
diff --git a/x/evm/state/code_test.go b/x/evm/state/code_test.go
index fedb6dd9e..1e390fbfc 100644
--- a/x/evm/state/code_test.go
+++ b/x/evm/state/code_test.go
@@ -12,8 +12,8 @@ import (
 )
 
 func TestCode(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	_, addr := testkeeper.MockAddressPair()
 	statedb := state.NewDBImpl(ctx, k, false)
 
diff --git a/x/evm/state/log_test.go b/x/evm/state/log_test.go
index 87d3f1186..9f2dd5b53 100644
--- a/x/evm/state/log_test.go
+++ b/x/evm/state/log_test.go
@@ -12,8 +12,8 @@ import (
 )
 
 func TestAddLog(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	statedb := state.NewDBImpl(ctx, k, false)
 
 	logs := statedb.GetAllLogs()
@@ -39,8 +39,8 @@ func TestAddLog(t *testing.T) {
 }
 
 func TestLogIndex(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	statedb := state.NewDBImpl(ctx, k, false)
 	statedb.AddLog(&ethtypes.Log{})
 	statedb.Snapshot()
diff --git a/x/evm/state/nonce_test.go b/x/evm/state/nonce_test.go
index 298231119..577c42c84 100644
--- a/x/evm/state/nonce_test.go
+++ b/x/evm/state/nonce_test.go
@@ -11,8 +11,8 @@ import (
 )
 
 func TestNonce(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	stateDB := state.NewDBImpl(ctx, k, false)
 	_, addr := testkeeper.MockAddressPair()
 	stateDB.SetNonce(addr, 1)
diff --git a/x/evm/state/refund_test.go b/x/evm/state/refund_test.go
index 89c59cd19..d4f6ea8bb 100644
--- a/x/evm/state/refund_test.go
+++ b/x/evm/state/refund_test.go
@@ -10,8 +10,8 @@ import (
 )
 
 func TestGasRefund(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	statedb := state.NewDBImpl(ctx, k, false)
 
 	require.Equal(t, uint64(0), statedb.GetRefund())
diff --git a/x/evm/state/state_test.go b/x/evm/state/state_test.go
index ff2a8671a..40dc80f6f 100644
--- a/x/evm/state/state_test.go
+++ b/x/evm/state/state_test.go
@@ -15,8 +15,8 @@ import (
 )
 
 func TestState(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	_, evmAddr := testkeeper.MockAddressPair()
 	statedb := state.NewDBImpl(ctx, k, false)
 	statedb.CreateAccount(evmAddr)
@@ -55,8 +55,8 @@ func TestState(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	_, evmAddr := testkeeper.MockAddressPair()
 	statedb := state.NewDBImpl(ctx, k, false)
 	statedb.CreateAccount(evmAddr)
@@ -89,8 +89,8 @@ func TestCreate(t *testing.T) {
 }
 
 func TestSelfDestructAssociated(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	seiAddr, evmAddr := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, seiAddr, evmAddr)
 	statedb := state.NewDBImpl(ctx, k, false)
@@ -134,8 +134,8 @@ func TestSelfDestructAssociated(t *testing.T) {
 }
 
 func TestSnapshot(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	seiAddr, evmAddr := testkeeper.MockAddressPair()
 	k.SetAddressMapping(ctx, seiAddr, evmAddr)
 	eventCount := len(ctx.EventManager().Events())
diff --git a/x/evm/state/transfer_test.go b/x/evm/state/transfer_test.go
index e45a38396..1218b9f41 100644
--- a/x/evm/state/transfer_test.go
+++ b/x/evm/state/transfer_test.go
@@ -11,8 +11,8 @@ import (
 )
 
 func TestEventlessTransfer(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	db := state.NewDBImpl(ctx, k, false)
 	_, fromAddr := testkeeper.MockAddressPair()
 	_, toAddr := testkeeper.MockAddressPair()
diff --git a/x/evm/types/message_evm_transaction_test.go b/x/evm/types/message_evm_transaction_test.go
index 77a834ffb..0dcf5a9c1 100644
--- a/x/evm/types/message_evm_transaction_test.go
+++ b/x/evm/types/message_evm_transaction_test.go
@@ -35,8 +35,8 @@ func TestIsNotAssociate(t *testing.T) {
 }
 
 func TestAsTransaction(t *testing.T) {
-	k := &testkeeper.EVMTestApp.EvmKeeper
-	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx(nil)
+	k := &testkeeper.EVMTestApp().EvmKeeper
+	ctx := testkeeper.EVMTestApp().GetContextForDeliverTx(nil)
 	chainID := k.ChainID(ctx)
 	chainCfg := types.DefaultChainConfig()
 	ethCfg := chainCfg.EthereumConfig(chainID)