support create_access_list

Author: thomas-nguy

rpc/backend/backend.go

@@ -125,6 +125,7 @@ type EVMBackend interface {
 	GetTransactionReceipt(hash common.Hash, resBlock *tmrpctypes.ResultBlock) (map[string]interface{}, error)
 	GetTransactionByBlockHashAndIndex(hash common.Hash, idx hexutil.Uint) (*rpctypes.RPCTransaction, error)
 	GetTransactionByBlockNumberAndIndex(blockNum rpctypes.BlockNumber, idx hexutil.Uint) (*rpctypes.RPCTransaction, error)
+	CreateAccessList(args evmtypes.TransactionArgs, blockNrOrHash rpctypes.BlockNumberOrHash, overrides *json.RawMessage) (*rpctypes.AccessListResult, error)
 
 	// Send Transaction
 	Resend(args evmtypes.TransactionArgs, gasPrice *hexutil.Big, gasLimit *hexutil.Uint64) (common.Hash, error)

rpc/backend/backend_suite_test.go

@@ -2,6 +2,7 @@ package backend
 
 import (
 	"bufio"
+	sdkmath "cosmossdk.io/math"
 	"math/big"
 	"os"
 	"path/filepath"
@@ -194,3 +195,20 @@ func (suite *BackendTestSuite) signAndEncodeEthTx(msgEthereumTx *evmtypes.MsgEth
 
 	return txBz
 }
+
+func (suite *BackendTestSuite) SetupMockCLient() {
+	c := suite.backend.clientCtx.Client.(*mocks.Client)
+	_, err := RegisterBlockResults(c, 1)
+	suite.Require().NoError(err)
+	height := rpctypes.NewBlockNumber(big.NewInt(1)).Int64()
+	_, err = RegisterHeader(c, &height, nil)
+	suite.Require().NoError(err)
+	RegisterHeaderByHashAny(c)
+	RegisterABCIQueryAny(c, 1)
+
+	queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient)
+	RegisterParamsAny(queryClient)
+	RegisterBaseFee(queryClient, sdkmath.NewInt(1))
+	validator := sdk.AccAddress(tests.GenerateAddress().Bytes())
+	RegisterValidatorAccount(queryClient, validator)
+}

rpc/backend/call_tx.go

@@ -245,6 +245,9 @@ func (b *Backend) SetTxDefaults(args evmtypes.TransactionArgs) (evmtypes.Transac
 		args.Value = new(hexutil.Big)
 	}
 	if args.Nonce == nil {
+		if args.From == nil {
+			return args, errors.New("missing from in argument")
+		}
 		// get the nonce from the account retriever
 		// ignore error in case tge account doesn't exist yet
 		nonce, _ := b.getAccountNonce(*args.From, true, 0, b.logger)

rpc/backend/client_test.go

@@ -35,57 +35,67 @@ var _ tmrpcclient.Client = &mocks.Client{}
 func RegisterTxSearch(client *mocks.Client, query string, txBz []byte) {
 	resulTxs := []*tmrpctypes.ResultTx{{Tx: txBz}}
 	client.On("TxSearch", rpc.ContextWithHeight(1), query, false, (*int)(nil), (*int)(nil), "").
-		Return(&tmrpctypes.ResultTxSearch{Txs: resulTxs, TotalCount: 1}, nil)
+		Return(&tmrpctypes.ResultTxSearch{Txs: resulTxs, TotalCount: 1}, nil).
+		Maybe()
 }
 
 func RegisterTxSearchEmpty(client *mocks.Client, query string) {
 	client.On("TxSearch", rpc.ContextWithHeight(1), query, false, (*int)(nil), (*int)(nil), "").
-		Return(&tmrpctypes.ResultTxSearch{}, nil)
+		Return(&tmrpctypes.ResultTxSearch{}, nil).
+		Maybe()
 }
 
 func RegisterTxSearchError(client *mocks.Client, query string) {
 	client.On("TxSearch", rpc.ContextWithHeight(1), query, false, (*int)(nil), (*int)(nil), "").
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 // Broadcast Tx
 func RegisterBroadcastTx(client *mocks.Client, tx types.Tx) {
 	client.On("BroadcastTxSync", context.Background(), tx).
-		Return(&tmrpctypes.ResultBroadcastTx{}, nil)
+		Return(&tmrpctypes.ResultBroadcastTx{}, nil).
+		Maybe()
 }
 
 func RegisterBroadcastTxError(client *mocks.Client, tx types.Tx) {
 	client.On("BroadcastTxSync", context.Background(), tx).
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 // Unconfirmed Transactions
 func RegisterUnconfirmedTxs(client *mocks.Client, limit *int, txs []types.Tx) {
 	client.On("UnconfirmedTxs", rpc.ContextWithHeight(1), limit).
-		Return(&tmrpctypes.ResultUnconfirmedTxs{Txs: txs}, nil)
+		Return(&tmrpctypes.ResultUnconfirmedTxs{Txs: txs}, nil).
+		Maybe()
 }
 
 func RegisterUnconfirmedTxsEmpty(client *mocks.Client, limit *int) {
 	client.On("UnconfirmedTxs", rpc.ContextWithHeight(1), limit).
 		Return(&tmrpctypes.ResultUnconfirmedTxs{
 			Txs: make([]types.Tx, 2),
-		}, nil)
+		}, nil).
+		Maybe()
 }
 
 func RegisterUnconfirmedTxsError(client *mocks.Client, limit *int) {
 	client.On("UnconfirmedTxs", rpc.ContextWithHeight(1), limit).
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 // Status
 func RegisterStatus(client *mocks.Client) {
 	client.On("Status", rpc.ContextWithHeight(1)).
-		Return(&tmrpctypes.ResultStatus{}, nil)
+		Return(&tmrpctypes.ResultStatus{}, nil).
+		Maybe()
 }
 
 func RegisterStatusError(client *mocks.Client) {
 	client.On("Status", rpc.ContextWithHeight(1)).
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 // Block
@@ -97,7 +107,8 @@ func RegisterBlockMultipleTxs(
 	block := types.MakeBlock(height, txs, nil, nil)
 	block.ChainID = ChainID
 	resBlock := &tmrpctypes.ResultBlock{Block: block}
-	client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).Return(resBlock, nil)
+	client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).Return(resBlock, nil).
+		Maybe()
 	return resBlock, nil
 }
 
@@ -111,22 +122,25 @@ func RegisterBlock(
 		emptyBlock := types.MakeBlock(height, []types.Tx{}, nil, nil)
 		emptyBlock.ChainID = ChainID
 		resBlock := &tmrpctypes.ResultBlock{Block: emptyBlock}
-		client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).Return(resBlock, nil)
+		client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).Return(resBlock, nil).
+			Maybe()
 		return resBlock, nil
 	}
 
 	// with tx
 	block := types.MakeBlock(height, []types.Tx{tx}, nil, nil)
 	block.ChainID = ChainID
 	resBlock := &tmrpctypes.ResultBlock{Block: block}
-	client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).Return(resBlock, nil)
+	client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).Return(resBlock, nil).
+		Maybe()
 	return resBlock, nil
 }
 
 // Block returns error
 func RegisterBlockError(client *mocks.Client, height int64) {
 	client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 // Block not found
@@ -135,7 +149,8 @@ func RegisterBlockNotFound(
 	height int64,
 ) (*tmrpctypes.ResultBlock, error) {
 	client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
-		Return(&tmrpctypes.ResultBlock{Block: nil}, nil)
+		Return(&tmrpctypes.ResultBlock{Block: nil}, nil).
+		Maybe()
 
 	return &tmrpctypes.ResultBlock{Block: nil}, nil
 }
@@ -145,7 +160,8 @@ func RegisterBlockPanic(client *mocks.Client, height int64) {
 	client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
 		Return(func(context.Context, *int64) *tmrpctypes.ResultBlock {
 			panic("Block call panic")
-		}, nil)
+		}, nil).
+		Maybe()
 }
 
 func TestRegisterBlock(t *testing.T) {
@@ -166,12 +182,14 @@ func TestRegisterBlock(t *testing.T) {
 func RegisterConsensusParams(client *mocks.Client, height int64) {
 	consensusParams := types.DefaultConsensusParams()
 	client.On("ConsensusParams", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
-		Return(&tmrpctypes.ResultConsensusParams{ConsensusParams: *consensusParams}, nil)
+		Return(&tmrpctypes.ResultConsensusParams{ConsensusParams: *consensusParams}, nil).
+		Maybe()
 }
 
 func RegisterConsensusParamsError(client *mocks.Client, height int64) {
 	client.On("ConsensusParams", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 func TestRegisterConsensusParams(t *testing.T) {
@@ -209,7 +227,8 @@ func RegisterBlockResultsWithEventLog(client *mocks.Client, height int64) (*tmrp
 	}
 
 	client.On("BlockResults", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
-		Return(res, nil)
+		Return(res, nil).
+		Maybe()
 	return res, nil
 }
 
@@ -223,13 +242,15 @@ func RegisterBlockResults(
 	}
 
 	client.On("BlockResults", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
-		Return(res, nil)
+		Return(res, nil).
+		Maybe()
 	return res, nil
 }
 
 func RegisterBlockResultsError(client *mocks.Client, height int64) {
 	client.On("BlockResults", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 func TestRegisterBlockResults(t *testing.T) {
@@ -256,18 +277,21 @@ func RegisterBlockByHash(
 	resBlock := &tmrpctypes.ResultBlock{Block: block}
 
 	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(resBlock, nil)
+		Return(resBlock, nil).
+		Maybe()
 	return resBlock, nil
 }
 
 func RegisterBlockByHashError(client *mocks.Client, hash common.Hash, tx []byte) {
 	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, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 func RegisterBlockByHashNotFound(client *mocks.Client, hash common.Hash, tx []byte) {
 	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)
+		Return(nil, nil).
+		Maybe()
 }
 
 // HeaderByHash
@@ -280,36 +304,47 @@ func RegisterHeaderByHash(
 	resHeader := &tmrpctypes.ResultHeader{Header: &block.Header}
 
 	client.On("HeaderByHash", rpc.ContextWithHeight(1), bytes.HexBytes(hash.Bytes())).
-		Return(resHeader, nil)
+		Return(resHeader, nil).
+		Maybe()
 	return resHeader, nil
 }
 
 func RegisterHeaderByHashError(client *mocks.Client, hash common.Hash, tx []byte) {
 	client.On("HeaderByHash", rpc.ContextWithHeight(1), bytes.HexBytes(hash.Bytes())).
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 func RegisterHeaderByHashNotFound(client *mocks.Client, hash common.Hash, tx []byte) {
 	client.On("HeaderByHash", rpc.ContextWithHeight(1), bytes.HexBytes(hash.Bytes())).
-		Return(&tmrpctypes.ResultHeader{Header: nil}, nil)
+		Return(&tmrpctypes.ResultHeader{Header: nil}, nil).
+		Maybe()
+}
+
+func RegisterHeaderByHashAny(client *mocks.Client) {
+	client.On("HeaderByHash", mock.Anything, mock.Anything).
+		Return(&tmrpctypes.ResultHeader{Header: &types.Header{Height: 1}}, nil).Maybe()
 }
 
 // Header
 func RegisterHeader(client *mocks.Client, height *int64, tx []byte) (*tmrpctypes.ResultHeader, error) {
 	block := types.MakeBlock(*height, []types.Tx{tx}, nil, nil)
 	resHeader := &tmrpctypes.ResultHeader{Header: &block.Header}
-	client.On("Header", rpc.ContextWithHeight(*height), height).Return(resHeader, nil)
+	client.On("Header", rpc.ContextWithHeight(*height), height).Return(resHeader, nil).
+		Maybe()
 	return resHeader, nil
 }
 
 func RegisterHeaderError(client *mocks.Client, height *int64) {
-	client.On("Header", rpc.ContextWithHeight(*height), height).Return(nil, errortypes.ErrInvalidRequest)
+	client.On("Header", rpc.ContextWithHeight(*height), height).Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
 }
 
 // Header not found
 func RegisterHeaderNotFound(client *mocks.Client, height int64) {
 	client.On("Header", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).
-		Return(&tmrpctypes.ResultHeader{Header: nil}, nil)
+		Return(&tmrpctypes.ResultHeader{Header: nil}, nil).
+		Maybe()
 }
 
 func RegisterABCIQueryWithOptions(client *mocks.Client, height int64, path string, data bytes.HexBytes, opts tmrpcclient.ABCIQueryOptions) {
@@ -319,12 +354,26 @@ func RegisterABCIQueryWithOptions(client *mocks.Client, height int64, path strin
 				Value:  []byte{2}, // TODO replace with data.Bytes(),
 				Height: height,
 			},
-		}, nil)
+		}, nil).
+		Maybe()
 }
 
 func RegisterABCIQueryWithOptionsError(clients *mocks.Client, path string, data bytes.HexBytes, opts tmrpcclient.ABCIQueryOptions) {
 	clients.On("ABCIQueryWithOptions", context.Background(), path, data, opts).
-		Return(nil, errortypes.ErrInvalidRequest)
+		Return(nil, errortypes.ErrInvalidRequest).
+		Maybe()
+}
+
+func RegisterABCIQueryAny(client *mocks.Client, height int64) {
+	client.On("ABCIQueryWithOptions", context.Background(), mock.Anything, mock.Anything, mock.Anything).
+		Return(&tmrpctypes.ResultABCIQuery{
+			Response: abci.ResponseQuery{
+				Value:  []byte{2}, // TODO replace with data.Bytes(),
+				Height: height,
+			},
+		}, nil).
+		Maybe()
+
 }
 
 func RegisterABCIQueryAccount(clients *mocks.Client, data bytes.HexBytes, opts tmrpcclient.ABCIQueryOptions, acc client.Account) {
@@ -338,5 +387,6 @@ func RegisterABCIQueryAccount(clients *mocks.Client, data bytes.HexBytes, opts t
 				Value:  respBz,
 				Height: 1,
 			},
-		}, nil)
+		}, nil).
+		Maybe()
 }