feat: support state overrides in eth_call

proto/cosmos/evm/vm/v1/query.proto

@@ -258,6 +258,8 @@ message EthCallRequest {
             "github.com/cosmos/cosmos-sdk/types.ConsAddress" ];
   // chain_id is the eip155 chain id parsed from the requested block header
   int64 chain_id = 4;
+  // state overrides encoded as json
+  bytes overrides = 5;
 }
 
 // EstimateGasResponse defines EstimateGas response

rpc/backend/backend.go

@@ -2,6 +2,7 @@ package backend
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"math/big"
 	"time"
@@ -112,7 +113,7 @@ type EVMBackend interface {
 	SendRawTransaction(data hexutil.Bytes) (common.Hash, error)
 	SetTxDefaults(args evmtypes.TransactionArgs) (evmtypes.TransactionArgs, error)
 	EstimateGas(args evmtypes.TransactionArgs, blockNrOptional *rpctypes.BlockNumber) (hexutil.Uint64, error)
-	DoCall(args evmtypes.TransactionArgs, blockNr rpctypes.BlockNumber) (*evmtypes.MsgEthereumTxResponse, error)
+	DoCall(args evmtypes.TransactionArgs, blockNr rpctypes.BlockNumber, overrides *json.RawMessage) (*evmtypes.MsgEthereumTxResponse, error)
 	GasPrice() (*hexutil.Big, error)
 
 	// Filter API

rpc/backend/call_tx.go

@@ -287,7 +287,10 @@ func (b *Backend) SetTxDefaults(args evmtypes.TransactionArgs) (evmtypes.Transac
 }
 
 // EstimateGas returns an estimate of gas usage for the given smart contract call.
-func (b *Backend) EstimateGas(args evmtypes.TransactionArgs, blockNrOptional *rpctypes.BlockNumber) (hexutil.Uint64, error) {
+func (b *Backend) EstimateGas(
+	args evmtypes.TransactionArgs,
+	blockNrOptional *rpctypes.BlockNumber,
+) (hexutil.Uint64, error) {
 	blockNr := rpctypes.EthPendingBlockNumber
 	if blockNrOptional != nil {
 		blockNr = *blockNrOptional
@@ -327,7 +330,7 @@ func (b *Backend) EstimateGas(args evmtypes.TransactionArgs, blockNrOptional *rp
 // DoCall performs a simulated call operation through the evmtypes. It returns the
 // estimated gas used on the operation or an error if fails.
 func (b *Backend) DoCall(
-	args evmtypes.TransactionArgs, blockNr rpctypes.BlockNumber,
+	args evmtypes.TransactionArgs, blockNr rpctypes.BlockNumber, overrides *json.RawMessage,
 ) (*evmtypes.MsgEthereumTxResponse, error) {
 	bz, err := json.Marshal(&args)
 	if err != nil {
@@ -339,11 +342,17 @@ func (b *Backend) DoCall(
 		return nil, errors.New("header not found")
 	}
 
+	var bzOverrides []byte
+	if overrides != nil {
+		bzOverrides = *overrides
+	}
+
 	req := evmtypes.EthCallRequest{
 		Args:            bz,
 		GasCap:          b.RPCGasCap(),
 		ProposerAddress: sdk.ConsAddress(header.Header.ProposerAddress),
 		ChainId:         b.EvmChainID.Int64(),
+		Overrides:       bzOverrides,
 	}
 
 	// From ContextWithHeight: if the provided height is 0,

rpc/namespaces/ethereum/eth/api.go

@@ -2,7 +2,7 @@ package eth
 
 import (
 	"context"
-	"fmt"
+	"encoding/json"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -68,7 +68,7 @@ type EthereumAPI interface {
 	//
 	// Allows developers to read data from the blockchain which includes executing
 	// smart contracts. However, no data is published to the Ethereum network.
-	Call(args evmtypes.TransactionArgs, blockNrOrHash rpctypes.BlockNumberOrHash, override *rpctypes.StateOverride) (hexutil.Bytes, error)
+	Call(args evmtypes.TransactionArgs, blockNrOrHash rpctypes.BlockNumberOrHash, overrides *json.RawMessage) (hexutil.Bytes, error)
 
 	// Chain Information
 	//
@@ -266,22 +266,18 @@ func (e *PublicAPI) GetProof(address common.Address,
 ///////////////////////////////////////////////////////////////////////////////
 
 // Call performs a raw contract call.
-func (e *PublicAPI) Call(args evmtypes.TransactionArgs,
+func (e *PublicAPI) Call(
+	args evmtypes.TransactionArgs,
 	blockNrOrHash rpctypes.BlockNumberOrHash,
-	override *rpctypes.StateOverride,
+	overrides *json.RawMessage,
 ) (hexutil.Bytes, error) {
 	e.logger.Debug("eth_call", "args", args.String(), "block number or hash", blockNrOrHash)
 
-	if override != nil {
-		e.logger.Debug("eth_call", "error", "overrides are unsupported in call queries")
-		return nil, fmt.Errorf("overrides are unsupported in call queries")
-	}
-
 	blockNum, err := e.backend.BlockNumberFromTendermint(blockNrOrHash)
 	if err != nil {
 		return nil, err
 	}
-	data, err := e.backend.DoCall(args, blockNum)
+	data, err := e.backend.DoCall(args, blockNum, overrides)
 	if err != nil {
 		return []byte{}, err
 	}

rpc/types/types.go

@@ -1,11 +1,16 @@
 package types
 
 import (
+	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/tracing"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/holiman/uint256"
+
+	"github.com/cosmos/evm/x/vm/statedb"
 )
 
 // Copied the Account and StorageResult types since they are registered under an
@@ -55,6 +60,42 @@ type RPCTransaction struct {
 // StateOverride is the collection of overridden accounts.
 type StateOverride map[common.Address]OverrideAccount
 
+// Apply overrides the fields of specified accounts into the given state.
+func (diff *StateOverride) Apply(db *statedb.StateDB) error {
+	if db == nil || diff == nil {
+		return nil
+	}
+	for addr, account := range *diff {
+		// Override account nonce.
+		if account.Nonce != nil {
+			db.SetNonce(addr, uint64(*account.Nonce), tracing.NonceChangeUnspecified)
+		}
+		// Override account(contract) code.
+		if account.Code != nil {
+			db.SetCode(addr, *account.Code)
+		}
+		// Override account balance.
+		if account.Balance != nil && *account.Balance != nil {
+			u256Balance, _ := uint256.FromBig((*big.Int)(*account.Balance))
+			db.SetBalance(addr, u256Balance)
+		}
+		if account.State != nil && account.StateDiff != nil {
+			return fmt.Errorf("account %s has both 'state' and 'stateDiff'", addr.Hex())
+		}
+		// Replace entire state if caller requires.
+		if account.State != nil {
+			db.SetStorage(addr, *account.State)
+		}
+		// Apply state diff into specified accounts.
+		if account.StateDiff != nil {
+			for key, value := range *account.StateDiff {
+				db.SetState(addr, key, value)
+			}
+		}
+	}
+	return nil
+}
+
 // OverrideAccount indicates the overriding fields of account during the execution of
 // a message call.
 // Note, state and stateDiff can't be specified at the same time. If state is

tests/integration/rpc/backend/test_call_tx.go

@@ -425,11 +425,24 @@ func (s *TestSuite) TestDoCall() {
 	argsBz, err := json.Marshal(callArgs)
 	s.Require().NoError(err)
 
+	overrides := json.RawMessage(`{
+        "` + toAddr.Hex() + `": {
+            "balance": "0x1000000000000000000",
+            "nonce": "0x1",
+            "code": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c8063c6888fa11461003b578063c8e7ca2e14610057575b600080fd5b610055600480360381019061005091906100a3565b610075565b005b61005f61007f565b60405161006c91906100e1565b60405180910390f35b8060008190555050565b60008054905090565b600080fd5b6000819050919050565b61009d8161008a565b81146100a857600080fd5b50565b6000813590506100ba81610094565b92915050565b6000602082840312156100d6576100d5610085565b5b60006100e4848285016100ab565b91505092915050565b6100f68161008a565b82525050565b600060208201905061011160008301846100ed565b9291505056fea2646970667358221220c7d2d7c0b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b264736f6c634300080a0033",
+            "storage": {
+                "0x0000000000000000000000000000000000000000000000000000000000000000": "0x123"
+            }
+        }
+    }`)
+	invalidOverrides := json.RawMessage(`{"invalid": json}`)
+	emptyOverrides := json.RawMessage(`{}`)
 	testCases := []struct {
 		name         string
 		registerMock func()
 		blockNum     rpctypes.BlockNumber
 		callArgs     evmtypes.TransactionArgs
+		overrides    *json.RawMessage
 		expEthTx     *evmtypes.MsgEthereumTxResponse
 		expPass      bool
 	}{
@@ -444,6 +457,7 @@ func (s *TestSuite) TestDoCall() {
 			},
 			rpctypes.BlockNumber(1),
 			callArgs,
+			nil,
 			&evmtypes.MsgEthereumTxResponse{},
 			false,
 		},
@@ -458,6 +472,67 @@ func (s *TestSuite) TestDoCall() {
 			},
 			rpctypes.BlockNumber(1),
 			callArgs,
+			nil,
+			&evmtypes.MsgEthereumTxResponse{},
+			true,
+		},
+		{
+			"pass - With state overrides",
+			func() {
+				client := s.backend.ClientCtx.Client.(*mocks.Client)
+				QueryClient := s.backend.QueryClient.QueryClient.(*mocks.EVMQueryClient)
+				_, err := RegisterBlock(client, 1, bz)
+				s.Require().NoError(err)
+				expected := &evmtypes.EthCallRequest{
+					Args:      argsBz,
+					ChainId:   s.backend.EvmChainID.Int64(),
+					Overrides: overrides,
+				}
+				RegisterEthCall(QueryClient, expected)
+			},
+			rpctypes.BlockNumber(1),
+			callArgs,
+			&overrides,
+			&evmtypes.MsgEthereumTxResponse{},
+			true,
+		},
+		{
+			"fail - Invalid state overrides JSON",
+			func() {
+				client := s.backend.ClientCtx.Client.(*mocks.Client)
+				QueryClient := s.backend.QueryClient.QueryClient.(*mocks.EVMQueryClient)
+				_, err := RegisterBlock(client, 1, bz)
+				s.Require().NoError(err)
+				expected := &evmtypes.EthCallRequest{
+					Args:      argsBz,
+					ChainId:   s.backend.EvmChainID.Int64(),
+					Overrides: invalidOverrides,
+				}
+				RegisterEthCallError(QueryClient, expected)
+			},
+			rpctypes.BlockNumber(1),
+			callArgs,
+			&invalidOverrides,
+			&evmtypes.MsgEthereumTxResponse{},
+			false,
+		},
+		{
+			"pass - Empty state overrides",
+			func() {
+				client := s.backend.ClientCtx.Client.(*mocks.Client)
+				QueryClient := s.backend.QueryClient.QueryClient.(*mocks.EVMQueryClient)
+				_, err := RegisterBlock(client, 1, bz)
+				s.Require().NoError(err)
+				expected := &evmtypes.EthCallRequest{
+					Args:      argsBz,
+					ChainId:   s.backend.EvmChainID.Int64(),
+					Overrides: emptyOverrides,
+				}
+				RegisterEthCall(QueryClient, expected)
+			},
+			rpctypes.BlockNumber(1),
+			callArgs,
+			&emptyOverrides,
 			&evmtypes.MsgEthereumTxResponse{},
 			true,
 		},
@@ -468,9 +543,10 @@ func (s *TestSuite) TestDoCall() {
 			s.SetupTest() // reset test and queries
 			tc.registerMock()
 
-			msgEthTx, err := s.backend.DoCall(tc.callArgs, tc.blockNum)
+			msgEthTx, err := s.backend.DoCall(tc.callArgs, tc.blockNum, tc.overrides)
 
 			if tc.expPass {
+				s.Require().NoError(err)
 				s.Require().Equal(tc.expEthTx, msgEthTx)
 			} else {
 				s.Require().Error(err)