From dec073d1b109d216bc68d410d85a4b75bc779257 Mon Sep 17 00:00:00 2001 From: Daniel Burckhardt Date: Tue, 11 Oct 2022 20:43:32 +0200 Subject: [PATCH] tests(rpc): Add account info unit tests (#1339) * tests(rpc): add GetCode pass test * tests(rpc): add GetCode failing tests * tests(rpc): wip StorageAt tests * tests(rpc): add StorageAt tests * wip * wip balance tests * add balance tests * add TestGetTransactionCount * fix TestGetProof * WIP GetTransactionCount * WIP GetTransactionCount with RegisterABCIQueryWithOptions * remove TODO * go mod tidy --- rpc/backend/account_info_test.go | 375 ++++++++++++++++++ rpc/backend/backend_suite_test.go | 16 +- rpc/backend/blocks_test.go | 52 +-- rpc/backend/chain_info_test.go | 14 +- rpc/backend/client_test.go | 18 +- ...lient_test.go => evm_query_client_test.go} | 87 +++- .../{query_client.go => evm_query_client.go} | 36 +- 7 files changed, 526 insertions(+), 72 deletions(-) create mode 100644 rpc/backend/account_info_test.go rename rpc/backend/{query_client_test.go => evm_query_client_test.go} (58%) rename rpc/backend/mocks/{query_client.go => evm_query_client.go} (80%) diff --git a/rpc/backend/account_info_test.go b/rpc/backend/account_info_test.go new file mode 100644 index 00000000..e0c95c66 --- /dev/null +++ b/rpc/backend/account_info_test.go @@ -0,0 +1,375 @@ +package backend + +import ( + "fmt" + "math/big" + + sdk "github.com/cosmos/cosmos-sdk/types" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + tmrpcclient "github.com/tendermint/tendermint/rpc/client" + + "github.com/evmos/ethermint/rpc/backend/mocks" + rpctypes "github.com/evmos/ethermint/rpc/types" + "github.com/evmos/ethermint/tests" + evmtypes "github.com/evmos/ethermint/x/evm/types" +) + +func (suite *BackendTestSuite) TestGetCode() { + blockNr := rpctypes.NewBlockNumber(big.NewInt(1)) + contractCode := []byte("0xef616c92f3cfc9e92dc270d6acff9cea213cecc7020a76ee4395af09bdceb4837a1ebdb5735e11e7d3adb6104e0c3ac55180b4ddf5e54d022cc5e8837f6a4f971b") + + testCases := []struct { + name string + addr common.Address + blockNrOrHash rpctypes.BlockNumberOrHash + registerMock func(common.Address) + expPass bool + expCode hexutil.Bytes + }{ + { + "fail - BlockHash and BlockNumber are both nil ", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{}, + func(addr common.Address) {}, + false, + nil, + }, + { + "fail - query client errors on getting Code", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(addr common.Address) { + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterCodeError(queryClient, addr) + }, + false, + nil, + }, + { + "pass", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(addr common.Address) { + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterCode(queryClient, addr, contractCode) + }, + true, + contractCode, + }, + } + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.name), func() { + suite.SetupTest() // reset + tc.registerMock(tc.addr) + + code, err := suite.backend.GetCode(tc.addr, tc.blockNrOrHash) + if tc.expPass { + suite.Require().NoError(err) + suite.Require().Equal(tc.expCode, code) + } else { + suite.Require().Error(err) + } + }) + } +} + +func (suite *BackendTestSuite) TestGetProof() { + blockNrInvalid := rpctypes.NewBlockNumber(big.NewInt(1)) + blockNr := rpctypes.NewBlockNumber(big.NewInt(4)) + address1 := tests.GenerateAddress() + + testCases := []struct { + name string + addr common.Address + storageKeys []string + blockNrOrHash rpctypes.BlockNumberOrHash + registerMock func(rpctypes.BlockNumber, common.Address) + expPass bool + expAccRes *rpctypes.AccountResult + }{ + { + "fail - BlockNumeber = 1 (invalidBlockNumber)", + address1, + []string{}, + rpctypes.BlockNumberOrHash{BlockNumber: &blockNrInvalid}, + func(bn rpctypes.BlockNumber, addr common.Address) { + client := suite.backend.clientCtx.Client.(*mocks.Client) + RegisterBlock(client, bn.Int64(), nil) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterAccount(queryClient, addr, blockNrInvalid.Int64()) + }, + false, + &rpctypes.AccountResult{}, + }, + { + "pass", + address1, + []string{"0x0"}, + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(bn rpctypes.BlockNumber, addr common.Address) { + suite.backend.ctx = rpctypes.ContextWithHeight(bn.Int64()) + + client := suite.backend.clientCtx.Client.(*mocks.Client) + RegisterBlock(client, bn.Int64(), nil) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterAccount(queryClient, addr, bn.Int64()) + + // Use the IAVL height if a valid tendermint height is passed in. + ivalHeight := bn.Int64() - 1 + RegisterABCIQueryWithOptions( + client, + bn.Int64(), + "store/evm/key", + evmtypes.StateKey(address1, common.HexToHash("0x0").Bytes()), + tmrpcclient.ABCIQueryOptions{Height: ivalHeight, Prove: true}, + ) + RegisterABCIQueryWithOptions( + client, + bn.Int64(), + "store/acc/key", + authtypes.AddressStoreKey(sdk.AccAddress(address1.Bytes())), + tmrpcclient.ABCIQueryOptions{Height: ivalHeight, Prove: true}, + ) + }, + true, + &rpctypes.AccountResult{ + Address: address1, + AccountProof: []string{""}, + Balance: (*hexutil.Big)(big.NewInt(0)), + CodeHash: common.HexToHash(""), + Nonce: 0x0, + StorageHash: common.Hash{}, + StorageProof: []rpctypes.StorageResult{ + { + Key: "0x0", + Value: (*hexutil.Big)(big.NewInt(2)), + Proof: []string{""}, + }, + }, + }, + }, + } + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.name), func() { + suite.SetupTest() + tc.registerMock(*tc.blockNrOrHash.BlockNumber, tc.addr) + + accRes, err := suite.backend.GetProof(tc.addr, tc.storageKeys, tc.blockNrOrHash) + + if tc.expPass { + suite.Require().NoError(err) + suite.Require().Equal(tc.expAccRes, accRes) + } else { + suite.Require().Error(err) + } + }) + } +} + +func (suite *BackendTestSuite) TestGetStorageAt() { + blockNr := rpctypes.NewBlockNumber(big.NewInt(1)) + + testCases := []struct { + name string + addr common.Address + key string + blockNrOrHash rpctypes.BlockNumberOrHash + registerMock func(common.Address, string, string) + expPass bool + expStorage hexutil.Bytes + }{ + { + "fail - BlockHash and BlockNumber are both nil", + tests.GenerateAddress(), + "0x0", + rpctypes.BlockNumberOrHash{}, + func(addr common.Address, key string, storage string) {}, + false, + nil, + }, + { + "fail - query client errors on getting Storage", + tests.GenerateAddress(), + "0x0", + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(addr common.Address, key string, storage string) { + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterStorageAtError(queryClient, addr, key) + }, + false, + nil, + }, + { + "pass", + tests.GenerateAddress(), + "0x0", + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(addr common.Address, key string, storage string) { + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterStorageAt(queryClient, addr, key, storage) + }, + true, + hexutil.Bytes{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, + }, + } + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.name), func() { + suite.SetupTest() + tc.registerMock(tc.addr, tc.key, tc.expStorage.String()) + + storage, err := suite.backend.GetStorageAt(tc.addr, tc.key, tc.blockNrOrHash) + if tc.expPass { + suite.Require().NoError(err) + suite.Require().Equal(tc.expStorage, storage) + } else { + suite.Require().Error(err) + } + }) + } +} + +func (suite *BackendTestSuite) TestGetBalance() { + blockNr := rpctypes.NewBlockNumber(big.NewInt(1)) + + testCases := []struct { + name string + addr common.Address + blockNrOrHash rpctypes.BlockNumberOrHash + registerMock func(rpctypes.BlockNumber, common.Address) + expPass bool + expBalance *hexutil.Big + }{ + { + "fail - BlockHash and BlockNumber are both nil", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{}, + func(bn rpctypes.BlockNumber, addr common.Address) { + }, + false, + nil, + }, + { + "fail - tendermint client failed to get block", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(bn rpctypes.BlockNumber, addr common.Address) { + client := suite.backend.clientCtx.Client.(*mocks.Client) + RegisterBlockError(client, bn.Int64()) + }, + false, + nil, + }, + { + "fail - query client failed to get balance", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(bn rpctypes.BlockNumber, addr common.Address) { + client := suite.backend.clientCtx.Client.(*mocks.Client) + RegisterBlock(client, bn.Int64(), nil) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterBalanceError(queryClient, addr, bn.Int64()) + }, + false, + nil, + }, + { + "fail - invalid balance", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(bn rpctypes.BlockNumber, addr common.Address) { + client := suite.backend.clientCtx.Client.(*mocks.Client) + RegisterBlock(client, bn.Int64(), nil) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterBalanceInvalid(queryClient, addr, bn.Int64()) + }, + false, + nil, + }, + { + "fail - pruned node state", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(bn rpctypes.BlockNumber, addr common.Address) { + client := suite.backend.clientCtx.Client.(*mocks.Client) + RegisterBlock(client, bn.Int64(), nil) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterBalanceNegative(queryClient, addr, bn.Int64()) + }, + false, + nil, + }, + { + "pass", + tests.GenerateAddress(), + rpctypes.BlockNumberOrHash{BlockNumber: &blockNr}, + func(bn rpctypes.BlockNumber, addr common.Address) { + client := suite.backend.clientCtx.Client.(*mocks.Client) + RegisterBlock(client, bn.Int64(), nil) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) + RegisterBalance(queryClient, addr, bn.Int64()) + }, + true, + (*hexutil.Big)(big.NewInt(1)), + }, + } + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.name), func() { + suite.SetupTest() + + // avoid nil pointer reference + if tc.blockNrOrHash.BlockNumber != nil { + tc.registerMock(*tc.blockNrOrHash.BlockNumber, tc.addr) + } + + balance, err := suite.backend.GetBalance(tc.addr, tc.blockNrOrHash) + if tc.expPass { + suite.Require().NoError(err) + suite.Require().Equal(tc.expBalance, balance) + } else { + suite.Require().Error(err) + } + }) + } +} + +func (suite *BackendTestSuite) TestGetTransactionCount() { + testCases := []struct { + name string + accExists bool + blockNum rpctypes.BlockNumber + registerMock func(common.Address, rpctypes.BlockNumber) + expPass bool + expTxCount hexutil.Uint64 + }{ + { + "pass - account doesn't exist", + false, + rpctypes.NewBlockNumber(big.NewInt(1)), + func(addr common.Address, bn rpctypes.BlockNumber) {}, + true, + hexutil.Uint64(0), + }, + } + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.name), func() { + suite.SetupTest() + + addr := tests.GenerateAddress() + if tc.accExists { + addr = common.BytesToAddress(suite.acc.Bytes()) + } + + tc.registerMock(addr, tc.blockNum) + + txCount, err := suite.backend.GetTransactionCount(addr, tc.blockNum) + if tc.expPass { + suite.Require().NoError(err) + suite.Require().Equal(tc.expTxCount, *txCount) + } else { + suite.Require().Error(err) + } + }) + } +} diff --git a/rpc/backend/backend_suite_test.go b/rpc/backend/backend_suite_test.go index 016f525a..7bc798b9 100644 --- a/rpc/backend/backend_suite_test.go +++ b/rpc/backend/backend_suite_test.go @@ -25,12 +25,14 @@ import ( "github.com/evmos/ethermint/indexer" "github.com/evmos/ethermint/rpc/backend/mocks" rpctypes "github.com/evmos/ethermint/rpc/types" + "github.com/evmos/ethermint/tests" evmtypes "github.com/evmos/ethermint/x/evm/types" ) type BackendTestSuite struct { suite.Suite backend *Backend + acc sdk.AccAddress } func TestBackendTestSuite(t *testing.T) { @@ -50,19 +52,29 @@ func (suite *BackendTestSuite) SetupTest() { panic(err) } + // Create Account with set sequence + suite.acc = sdk.AccAddress(tests.GenerateAddress().Bytes()) + accounts := map[string]client.TestAccount{} + accounts[suite.acc.String()] = client.TestAccount{ + Address: suite.acc, + Num: uint64(1), + Seq: uint64(1), + } + encodingConfig := encoding.MakeConfig(app.ModuleBasics) clientCtx := client.Context{}.WithChainID("ethermint_9000-1"). WithHeight(1). WithTxConfig(encodingConfig.TxConfig). WithKeyringDir(clientDir). - WithKeyring(keyRing) + WithKeyring(keyRing). + WithAccountRetriever(client.TestAccountRetriever{Accounts: accounts}) allowUnprotectedTxs := false idxer := indexer.NewKVIndexer(dbm.NewMemDB(), ctx.Logger, clientCtx) suite.backend = NewBackend(ctx, ctx.Logger, clientCtx, allowUnprotectedTxs, idxer) - suite.backend.queryClient.QueryClient = mocks.NewQueryClient(suite.T()) + suite.backend.queryClient.QueryClient = mocks.NewEVMQueryClient(suite.T()) suite.backend.clientCtx.Client = mocks.NewClient(suite.T()) suite.backend.ctx = rpctypes.ContextWithHeight(1) } diff --git a/rpc/backend/blocks_test.go b/rpc/backend/blocks_test.go index e4eff35e..7ac7aeca 100644 --- a/rpc/backend/blocks_test.go +++ b/rpc/backend/blocks_test.go @@ -32,7 +32,7 @@ func (suite *BackendTestSuite) TestBlockNumber() { func() { height := int64(1) var header metadata.MD - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterParamsInvalidHeight(queryClient, &header, int64(height)) }, 0x0, @@ -43,7 +43,7 @@ func (suite *BackendTestSuite) TestBlockNumber() { func() { height := int64(1) var header metadata.MD - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterParamsInvalidHeader(queryClient, &header, int64(height)) }, 0x0, @@ -54,7 +54,7 @@ func (suite *BackendTestSuite) TestBlockNumber() { func() { height := int64(1) var header metadata.MD - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterParams(queryClient, &header, int64(height)) }, 0x1, @@ -161,7 +161,7 @@ func (suite *BackendTestSuite) TestGetBlockByNumber() { blockRes, _ = RegisterBlockResults(client, blockNum.Int64()) RegisterConsensusParams(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) }, @@ -183,7 +183,7 @@ func (suite *BackendTestSuite) TestGetBlockByNumber() { blockRes, _ = RegisterBlockResults(client, blockNum.Int64()) RegisterConsensusParams(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) }, @@ -306,7 +306,7 @@ func (suite *BackendTestSuite) TestGetBlockByHash() { blockRes, _ = RegisterBlockResults(client, height) RegisterConsensusParams(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) }, @@ -329,7 +329,7 @@ func (suite *BackendTestSuite) TestGetBlockByHash() { blockRes, _ = RegisterBlockResults(client, height) RegisterConsensusParams(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) }, @@ -554,7 +554,7 @@ func (suite *BackendTestSuite) TestTendermintBlockByNumber() { func(_ ethrpc.BlockNumber) { appHeight := int64(1) var header metadata.MD - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterParamsError(queryClient, &header, appHeight) }, false, @@ -566,7 +566,7 @@ func (suite *BackendTestSuite) TestTendermintBlockByNumber() { func(blockNum ethrpc.BlockNumber) { appHeight := int64(1) var header metadata.MD - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterParams(queryClient, &header, appHeight) tmHeight := appHeight @@ -901,7 +901,7 @@ func (suite *BackendTestSuite) TestGetEthBlockFromTendermint() { }, false, func(baseFee sdk.Int, validator sdk.AccAddress, height int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) @@ -925,7 +925,7 @@ func (suite *BackendTestSuite) TestGetEthBlockFromTendermint() { }, true, func(baseFee sdk.Int, validator sdk.AccAddress, height int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeError(queryClient) RegisterValidatorAccount(queryClient, validator) @@ -949,7 +949,7 @@ func (suite *BackendTestSuite) TestGetEthBlockFromTendermint() { }, true, func(baseFee sdk.Int, validator sdk.AccAddress, height int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccountError(queryClient) @@ -973,7 +973,7 @@ func (suite *BackendTestSuite) TestGetEthBlockFromTendermint() { }, true, func(baseFee sdk.Int, validator sdk.AccAddress, height int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) @@ -1003,7 +1003,7 @@ func (suite *BackendTestSuite) TestGetEthBlockFromTendermint() { }, true, func(baseFee sdk.Int, validator sdk.AccAddress, height int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) @@ -1027,7 +1027,7 @@ func (suite *BackendTestSuite) TestGetEthBlockFromTendermint() { }, false, func(baseFee sdk.Int, validator sdk.AccAddress, height int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) @@ -1051,7 +1051,7 @@ func (suite *BackendTestSuite) TestGetEthBlockFromTendermint() { }, true, func(baseFee sdk.Int, validator sdk.AccAddress, height int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) RegisterValidatorAccount(queryClient, validator) @@ -1237,7 +1237,7 @@ func (suite *BackendTestSuite) TestHeaderByNumber() { expResultBlock, _ = RegisterBlock(client, height, nil) RegisterBlockResults(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeError(queryClient) }, true, @@ -1252,7 +1252,7 @@ func (suite *BackendTestSuite) TestHeaderByNumber() { expResultBlock, _ = RegisterBlock(client, height, nil) RegisterBlockResults(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) }, true, @@ -1267,7 +1267,7 @@ func (suite *BackendTestSuite) TestHeaderByNumber() { expResultBlock, _ = RegisterBlock(client, height, bz) RegisterBlockResults(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) }, true, @@ -1347,7 +1347,7 @@ func (suite *BackendTestSuite) TestHeaderByHash() { expResultBlock, _ = RegisterBlockByHash(client, hash, bz) RegisterBlockResults(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeError(queryClient) }, true, @@ -1362,7 +1362,7 @@ func (suite *BackendTestSuite) TestHeaderByHash() { expResultBlock, _ = RegisterBlockByHash(client, hash, nil) RegisterBlockResults(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) }, true, @@ -1377,7 +1377,7 @@ func (suite *BackendTestSuite) TestHeaderByHash() { expResultBlock, _ = RegisterBlockByHash(client, hash, bz) RegisterBlockResults(client, height) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) }, true, @@ -1444,7 +1444,7 @@ func (suite *BackendTestSuite) TestEthBlockByNumber() { RegisterBlock(client, height, nil) RegisterBlockResults(client, blockNum.Int64()) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) baseFee := sdk.NewInt(1) RegisterBaseFee(queryClient, baseFee) }, @@ -1470,7 +1470,7 @@ func (suite *BackendTestSuite) TestEthBlockByNumber() { RegisterBlock(client, height, bz) RegisterBlockResults(client, blockNum.Int64()) - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) baseFee := sdk.NewInt(1) RegisterBaseFee(queryClient, baseFee) }, @@ -1535,7 +1535,7 @@ func (suite *BackendTestSuite) TestEthBlockFromTendermintBlock() { TxsResults: []*types.ResponseDeliverTx{{Code: 0, GasUsed: 0}}, }, func(baseFee sdk.Int, blockNum int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) }, ethtypes.NewBlock( @@ -1570,7 +1570,7 @@ func (suite *BackendTestSuite) TestEthBlockFromTendermintBlock() { }, }, func(baseFee sdk.Int, blockNum int64) { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) }, ethtypes.NewBlock( diff --git a/rpc/backend/chain_info_test.go b/rpc/backend/chain_info_test.go index 4b47902c..d30159cb 100644 --- a/rpc/backend/chain_info_test.go +++ b/rpc/backend/chain_info_test.go @@ -27,7 +27,7 @@ func (suite *BackendTestSuite) TestBaseFee() { "fail - grpc BaseFee error", &tmrpctypes.ResultBlockResults{Height: 1}, func() { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeError(queryClient) }, nil, @@ -44,7 +44,7 @@ func (suite *BackendTestSuite) TestBaseFee() { }, }, func() { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeError(queryClient) }, nil, @@ -61,7 +61,7 @@ func (suite *BackendTestSuite) TestBaseFee() { }, }, func() { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeError(queryClient) }, nil, @@ -81,7 +81,7 @@ func (suite *BackendTestSuite) TestBaseFee() { }, }, func() { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeError(queryClient) }, nil, @@ -101,7 +101,7 @@ func (suite *BackendTestSuite) TestBaseFee() { }, }, func() { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeError(queryClient) }, baseFee.BigInt(), @@ -111,7 +111,7 @@ func (suite *BackendTestSuite) TestBaseFee() { "fail - base fee or london fork not enabled", &tmrpctypes.ResultBlockResults{Height: 1}, func() { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFeeDisabled(queryClient) }, nil, @@ -121,7 +121,7 @@ func (suite *BackendTestSuite) TestBaseFee() { "pass", &tmrpctypes.ResultBlockResults{Height: 1}, func() { - queryClient := suite.backend.queryClient.QueryClient.(*mocks.QueryClient) + queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) RegisterBaseFee(queryClient, baseFee) }, baseFee.BigInt(), diff --git a/rpc/backend/client_test.go b/rpc/backend/client_test.go index 6fbe8b05..6dc8949e 100644 --- a/rpc/backend/client_test.go +++ b/rpc/backend/client_test.go @@ -1,6 +1,7 @@ package backend import ( + "context" "testing" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -10,6 +11,7 @@ import ( mock "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" abci "github.com/tendermint/tendermint/abci/types" + "github.com/tendermint/tendermint/libs/bytes" tmrpcclient "github.com/tendermint/tendermint/rpc/client" tmrpctypes "github.com/tendermint/tendermint/rpc/core/types" "github.com/tendermint/tendermint/types" @@ -39,10 +41,10 @@ func RegisterBlock( // with tx block := types.MakeBlock(height, []types.Tx{tx}, nil, nil) - res := &tmrpctypes.ResultBlock{Block: block} + resBlock := &tmrpctypes.ResultBlock{Block: block} client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")). - Return(res, nil) - return res, nil + Return(resBlock, nil) + return resBlock, nil } // Block returns error @@ -155,3 +157,13 @@ func RegisterBlockByHashNotFound(client *mocks.Client, hash common.Hash, tx []by client.On("BlockByHash", rpc.ContextWithHeight(1), []byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}). Return(nil, nil) } + +func RegisterABCIQueryWithOptions(client *mocks.Client, height int64, path string, data bytes.HexBytes, opts tmrpcclient.ABCIQueryOptions) { + client.On("ABCIQueryWithOptions", context.Background(), path, data, opts). + Return(&tmrpctypes.ResultABCIQuery{ + Response: abci.ResponseQuery{ + Value: []byte{2}, // TODO replace with data.Bytes(), + Height: height, + }, + }, nil) +} diff --git a/rpc/backend/query_client_test.go b/rpc/backend/evm_query_client_test.go similarity index 58% rename from rpc/backend/query_client_test.go rename to rpc/backend/evm_query_client_test.go index f7e97dc4..5aef0d05 100644 --- a/rpc/backend/query_client_test.go +++ b/rpc/backend/evm_query_client_test.go @@ -8,6 +8,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" grpctypes "github.com/cosmos/cosmos-sdk/types/grpc" + "github.com/ethereum/go-ethereum/common" "github.com/evmos/ethermint/rpc/backend/mocks" rpc "github.com/evmos/ethermint/rpc/types" "github.com/evmos/ethermint/tests" @@ -25,10 +26,10 @@ import ( // to run a ethermint GRPC server. // // To use a mock method it has to be registered in a given test. -var _ evmtypes.QueryClient = &mocks.QueryClient{} +var _ evmtypes.QueryClient = &mocks.EVMQueryClient{} // Params -func RegisterParams(queryClient *mocks.QueryClient, header *metadata.MD, height int64) { +func RegisterParams(queryClient *mocks.EVMQueryClient, header *metadata.MD, height int64) { queryClient.On("Params", rpc.ContextWithHeight(height), &evmtypes.QueryParamsRequest{}, grpc.Header(header)). Return(&evmtypes.QueryParamsResponse{}, nil). Run(func(args mock.Arguments) { @@ -40,7 +41,7 @@ func RegisterParams(queryClient *mocks.QueryClient, header *metadata.MD, height }) } -func RegisterParamsInvalidHeader(queryClient *mocks.QueryClient, header *metadata.MD, height int64) { +func RegisterParamsInvalidHeader(queryClient *mocks.EVMQueryClient, header *metadata.MD, height int64) { queryClient.On("Params", rpc.ContextWithHeight(height), &evmtypes.QueryParamsRequest{}, grpc.Header(header)). Return(&evmtypes.QueryParamsResponse{}, nil). Run(func(args mock.Arguments) { @@ -51,7 +52,7 @@ func RegisterParamsInvalidHeader(queryClient *mocks.QueryClient, header *metadat }) } -func RegisterParamsInvalidHeight(queryClient *mocks.QueryClient, header *metadata.MD, height int64) { +func RegisterParamsInvalidHeight(queryClient *mocks.EVMQueryClient, header *metadata.MD, height int64) { queryClient.On("Params", rpc.ContextWithHeight(height), &evmtypes.QueryParamsRequest{}, grpc.Header(header)). Return(&evmtypes.QueryParamsResponse{}, nil). Run(func(args mock.Arguments) { @@ -64,13 +65,13 @@ func RegisterParamsInvalidHeight(queryClient *mocks.QueryClient, header *metadat } // Params returns error -func RegisterParamsError(queryClient *mocks.QueryClient, header *metadata.MD, height int64) { +func RegisterParamsError(queryClient *mocks.EVMQueryClient, header *metadata.MD, height int64) { queryClient.On("Params", rpc.ContextWithHeight(height), &evmtypes.QueryParamsRequest{}, grpc.Header(header)). Return(nil, sdkerrors.ErrInvalidRequest) } func TestRegisterParams(t *testing.T) { - queryClient := mocks.NewQueryClient(t) + queryClient := mocks.NewEVMQueryClient(t) var header metadata.MD height := int64(1) RegisterParams(queryClient, &header, height) @@ -84,33 +85,33 @@ func TestRegisterParams(t *testing.T) { } func TestRegisterParamsError(t *testing.T) { - queryClient := mocks.NewQueryClient(t) + queryClient := mocks.NewEVMQueryClient(t) RegisterBaseFeeError(queryClient) _, err := queryClient.BaseFee(rpc.ContextWithHeight(1), &evmtypes.QueryBaseFeeRequest{}) require.Error(t, err) } // BaseFee -func RegisterBaseFee(queryClient *mocks.QueryClient, baseFee sdk.Int) { +func RegisterBaseFee(queryClient *mocks.EVMQueryClient, baseFee sdk.Int) { queryClient.On("BaseFee", rpc.ContextWithHeight(1), &evmtypes.QueryBaseFeeRequest{}). Return(&evmtypes.QueryBaseFeeResponse{BaseFee: &baseFee}, nil) } // Base fee returns error -func RegisterBaseFeeError(queryClient *mocks.QueryClient) { +func RegisterBaseFeeError(queryClient *mocks.EVMQueryClient) { queryClient.On("BaseFee", rpc.ContextWithHeight(1), &evmtypes.QueryBaseFeeRequest{}). Return(&evmtypes.QueryBaseFeeResponse{}, evmtypes.ErrInvalidBaseFee) } // Base fee not enabled -func RegisterBaseFeeDisabled(queryClient *mocks.QueryClient) { +func RegisterBaseFeeDisabled(queryClient *mocks.EVMQueryClient) { queryClient.On("BaseFee", rpc.ContextWithHeight(1), &evmtypes.QueryBaseFeeRequest{}). Return(&evmtypes.QueryBaseFeeResponse{}, nil) } func TestRegisterBaseFee(t *testing.T) { baseFee := sdk.NewInt(1) - queryClient := mocks.NewQueryClient(t) + queryClient := mocks.NewEVMQueryClient(t) RegisterBaseFee(queryClient, baseFee) res, err := queryClient.BaseFee(rpc.ContextWithHeight(1), &evmtypes.QueryBaseFeeRequest{}) require.Equal(t, &evmtypes.QueryBaseFeeResponse{BaseFee: &baseFee}, res) @@ -118,7 +119,7 @@ func TestRegisterBaseFee(t *testing.T) { } func TestRegisterBaseFeeError(t *testing.T) { - queryClient := mocks.NewQueryClient(t) + queryClient := mocks.NewEVMQueryClient(t) RegisterBaseFeeError(queryClient) res, err := queryClient.BaseFee(rpc.ContextWithHeight(1), &evmtypes.QueryBaseFeeRequest{}) require.Equal(t, &evmtypes.QueryBaseFeeResponse{}, res) @@ -126,7 +127,7 @@ func TestRegisterBaseFeeError(t *testing.T) { } func TestRegisterBaseFeeDisabled(t *testing.T) { - queryClient := mocks.NewQueryClient(t) + queryClient := mocks.NewEVMQueryClient(t) RegisterBaseFeeDisabled(queryClient) res, err := queryClient.BaseFee(rpc.ContextWithHeight(1), &evmtypes.QueryBaseFeeRequest{}) require.Equal(t, &evmtypes.QueryBaseFeeResponse{}, res) @@ -134,7 +135,7 @@ func TestRegisterBaseFeeDisabled(t *testing.T) { } // ValidatorAccount -func RegisterValidatorAccount(queryClient *mocks.QueryClient, validator sdk.AccAddress) { +func RegisterValidatorAccount(queryClient *mocks.EVMQueryClient, validator sdk.AccAddress) { queryClient.On("ValidatorAccount", rpc.ContextWithHeight(1), &evmtypes.QueryValidatorAccountRequest{}). Return( &evmtypes.QueryValidatorAccountResponse{ @@ -144,13 +145,13 @@ func RegisterValidatorAccount(queryClient *mocks.QueryClient, validator sdk.AccA ) } -func RegisterValidatorAccountError(queryClient *mocks.QueryClient) { +func RegisterValidatorAccountError(queryClient *mocks.EVMQueryClient) { queryClient.On("ValidatorAccount", rpc.ContextWithHeight(1), &evmtypes.QueryValidatorAccountRequest{}). Return(nil, status.Error(codes.InvalidArgument, "empty request")) } func TestRegisterValidatorAccount(t *testing.T) { - queryClient := mocks.NewQueryClient(t) + queryClient := mocks.NewEVMQueryClient(t) validator := sdk.AccAddress(tests.GenerateAddress().Bytes()) RegisterValidatorAccount(queryClient, validator) @@ -158,3 +159,57 @@ func TestRegisterValidatorAccount(t *testing.T) { require.Equal(t, &evmtypes.QueryValidatorAccountResponse{AccountAddress: validator.String()}, res) require.NoError(t, err) } + +// Code +func RegisterCode(queryClient *mocks.EVMQueryClient, addr common.Address, code []byte) { + queryClient.On("Code", rpc.ContextWithHeight(1), &evmtypes.QueryCodeRequest{Address: addr.String()}). + Return(&evmtypes.QueryCodeResponse{Code: code}, nil) +} + +func RegisterCodeError(queryClient *mocks.EVMQueryClient, addr common.Address) { + queryClient.On("Code", rpc.ContextWithHeight(1), &evmtypes.QueryCodeRequest{Address: addr.String()}). + Return(nil, sdkerrors.ErrInvalidRequest) +} + +// Storage +func RegisterStorageAt(queryClient *mocks.EVMQueryClient, addr common.Address, key string, storage string) { + queryClient.On("Storage", rpc.ContextWithHeight(1), &evmtypes.QueryStorageRequest{Address: addr.String(), Key: key}). + Return(&evmtypes.QueryStorageResponse{Value: storage}, nil) +} + +func RegisterStorageAtError(queryClient *mocks.EVMQueryClient, addr common.Address, key string) { + queryClient.On("Storage", rpc.ContextWithHeight(1), &evmtypes.QueryStorageRequest{Address: addr.String(), Key: key}). + Return(nil, sdkerrors.ErrInvalidRequest) +} + +func RegisterAccount(queryClient *mocks.EVMQueryClient, addr common.Address, height int64) { + queryClient.On("Account", rpc.ContextWithHeight(height), &evmtypes.QueryAccountRequest{Address: addr.String()}). + Return(&evmtypes.QueryAccountResponse{ + Balance: "0", + CodeHash: "", + Nonce: 0, + }, + nil, + ) +} + +// Balance +func RegisterBalance(queryClient *mocks.EVMQueryClient, addr common.Address, height int64) { + queryClient.On("Balance", rpc.ContextWithHeight(height), &evmtypes.QueryBalanceRequest{Address: addr.String()}). + Return(&evmtypes.QueryBalanceResponse{Balance: "1"}, nil) +} + +func RegisterBalanceInvalid(queryClient *mocks.EVMQueryClient, addr common.Address, height int64) { + queryClient.On("Balance", rpc.ContextWithHeight(height), &evmtypes.QueryBalanceRequest{Address: addr.String()}). + Return(&evmtypes.QueryBalanceResponse{Balance: "invalid"}, nil) +} + +func RegisterBalanceNegative(queryClient *mocks.EVMQueryClient, addr common.Address, height int64) { + queryClient.On("Balance", rpc.ContextWithHeight(height), &evmtypes.QueryBalanceRequest{Address: addr.String()}). + Return(&evmtypes.QueryBalanceResponse{Balance: "-1"}, nil) +} + +func RegisterBalanceError(queryClient *mocks.EVMQueryClient, addr common.Address, height int64) { + queryClient.On("Balance", rpc.ContextWithHeight(height), &evmtypes.QueryBalanceRequest{Address: addr.String()}). + Return(nil, sdkerrors.ErrInvalidRequest) +} diff --git a/rpc/backend/mocks/query_client.go b/rpc/backend/mocks/evm_query_client.go similarity index 80% rename from rpc/backend/mocks/query_client.go rename to rpc/backend/mocks/evm_query_client.go index c2d41844..231759d1 100644 --- a/rpc/backend/mocks/query_client.go +++ b/rpc/backend/mocks/evm_query_client.go @@ -12,13 +12,13 @@ import ( types "github.com/evmos/ethermint/x/evm/types" ) -// QueryClient is an autogenerated mock type for the QueryClient type -type QueryClient struct { +// EVMQueryClient is an autogenerated mock type for the EVMQueryClient type +type EVMQueryClient struct { mock.Mock } // Account provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) Account(ctx context.Context, in *types.QueryAccountRequest, opts ...grpc.CallOption) (*types.QueryAccountResponse, error) { +func (_m *EVMQueryClient) Account(ctx context.Context, in *types.QueryAccountRequest, opts ...grpc.CallOption) (*types.QueryAccountResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -48,7 +48,7 @@ func (_m *QueryClient) Account(ctx context.Context, in *types.QueryAccountReques } // Balance provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) Balance(ctx context.Context, in *types.QueryBalanceRequest, opts ...grpc.CallOption) (*types.QueryBalanceResponse, error) { +func (_m *EVMQueryClient) Balance(ctx context.Context, in *types.QueryBalanceRequest, opts ...grpc.CallOption) (*types.QueryBalanceResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -78,7 +78,7 @@ func (_m *QueryClient) Balance(ctx context.Context, in *types.QueryBalanceReques } // BaseFee provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) BaseFee(ctx context.Context, in *types.QueryBaseFeeRequest, opts ...grpc.CallOption) (*types.QueryBaseFeeResponse, error) { +func (_m *EVMQueryClient) BaseFee(ctx context.Context, in *types.QueryBaseFeeRequest, opts ...grpc.CallOption) (*types.QueryBaseFeeResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -108,7 +108,7 @@ func (_m *QueryClient) BaseFee(ctx context.Context, in *types.QueryBaseFeeReques } // Code provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) Code(ctx context.Context, in *types.QueryCodeRequest, opts ...grpc.CallOption) (*types.QueryCodeResponse, error) { +func (_m *EVMQueryClient) Code(ctx context.Context, in *types.QueryCodeRequest, opts ...grpc.CallOption) (*types.QueryCodeResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -138,7 +138,7 @@ func (_m *QueryClient) Code(ctx context.Context, in *types.QueryCodeRequest, opt } // CosmosAccount provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) CosmosAccount(ctx context.Context, in *types.QueryCosmosAccountRequest, opts ...grpc.CallOption) (*types.QueryCosmosAccountResponse, error) { +func (_m *EVMQueryClient) CosmosAccount(ctx context.Context, in *types.QueryCosmosAccountRequest, opts ...grpc.CallOption) (*types.QueryCosmosAccountResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -168,7 +168,7 @@ func (_m *QueryClient) CosmosAccount(ctx context.Context, in *types.QueryCosmosA } // EstimateGas provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) EstimateGas(ctx context.Context, in *types.EthCallRequest, opts ...grpc.CallOption) (*types.EstimateGasResponse, error) { +func (_m *EVMQueryClient) EstimateGas(ctx context.Context, in *types.EthCallRequest, opts ...grpc.CallOption) (*types.EstimateGasResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -198,7 +198,7 @@ func (_m *QueryClient) EstimateGas(ctx context.Context, in *types.EthCallRequest } // EthCall provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) EthCall(ctx context.Context, in *types.EthCallRequest, opts ...grpc.CallOption) (*types.MsgEthereumTxResponse, error) { +func (_m *EVMQueryClient) EthCall(ctx context.Context, in *types.EthCallRequest, opts ...grpc.CallOption) (*types.MsgEthereumTxResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -228,7 +228,7 @@ func (_m *QueryClient) EthCall(ctx context.Context, in *types.EthCallRequest, op } // Params provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) Params(ctx context.Context, in *types.QueryParamsRequest, opts ...grpc.CallOption) (*types.QueryParamsResponse, error) { +func (_m *EVMQueryClient) Params(ctx context.Context, in *types.QueryParamsRequest, opts ...grpc.CallOption) (*types.QueryParamsResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -258,7 +258,7 @@ func (_m *QueryClient) Params(ctx context.Context, in *types.QueryParamsRequest, } // Storage provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) Storage(ctx context.Context, in *types.QueryStorageRequest, opts ...grpc.CallOption) (*types.QueryStorageResponse, error) { +func (_m *EVMQueryClient) Storage(ctx context.Context, in *types.QueryStorageRequest, opts ...grpc.CallOption) (*types.QueryStorageResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -288,7 +288,7 @@ func (_m *QueryClient) Storage(ctx context.Context, in *types.QueryStorageReques } // TraceBlock provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) TraceBlock(ctx context.Context, in *types.QueryTraceBlockRequest, opts ...grpc.CallOption) (*types.QueryTraceBlockResponse, error) { +func (_m *EVMQueryClient) TraceBlock(ctx context.Context, in *types.QueryTraceBlockRequest, opts ...grpc.CallOption) (*types.QueryTraceBlockResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -318,7 +318,7 @@ func (_m *QueryClient) TraceBlock(ctx context.Context, in *types.QueryTraceBlock } // TraceTx provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) TraceTx(ctx context.Context, in *types.QueryTraceTxRequest, opts ...grpc.CallOption) (*types.QueryTraceTxResponse, error) { +func (_m *EVMQueryClient) TraceTx(ctx context.Context, in *types.QueryTraceTxRequest, opts ...grpc.CallOption) (*types.QueryTraceTxResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -348,7 +348,7 @@ func (_m *QueryClient) TraceTx(ctx context.Context, in *types.QueryTraceTxReques } // ValidatorAccount provides a mock function with given fields: ctx, in, opts -func (_m *QueryClient) ValidatorAccount(ctx context.Context, in *types.QueryValidatorAccountRequest, opts ...grpc.CallOption) (*types.QueryValidatorAccountResponse, error) { +func (_m *EVMQueryClient) ValidatorAccount(ctx context.Context, in *types.QueryValidatorAccountRequest, opts ...grpc.CallOption) (*types.QueryValidatorAccountResponse, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -377,14 +377,14 @@ func (_m *QueryClient) ValidatorAccount(ctx context.Context, in *types.QueryVali return r0, r1 } -type mockConstructorTestingTNewQueryClient interface { +type mockConstructorTestingTNewEVMQueryClient interface { mock.TestingT Cleanup(func()) } -// NewQueryClient creates a new instance of QueryClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewQueryClient(t mockConstructorTestingTNewQueryClient) *QueryClient { - mock := &QueryClient{} +// NewEVMQueryClient creates a new instance of EVMQueryClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +func NewEVMQueryClient(t mockConstructorTestingTNewEVMQueryClient) *EVMQueryClient { + mock := &EVMQueryClient{} mock.Mock.Test(t) t.Cleanup(func() { mock.AssertExpectations(t) })