feature: debug_traceCall RPC support

app/app.go

@@ -923,7 +923,7 @@ func (app *EthermintApp) RegisterNodeService(clientCtx client.Context) {
 }
 
 // RegisterSwaggerAPI registers swagger route with API Server
-func RegisterSwaggerAPI(ctx client.Context, rtr *mux.Router) {
+func RegisterSwaggerAPI(_ client.Context, rtr *mux.Router) {
 	root, err := fs.Sub(docs.SwaggerUI, "swagger-ui")
 	if err != nil {
 		panic(err)

proto/ethermint/evm/v1/query.proto

@@ -71,6 +71,11 @@ service Query {
     option (google.api.http).get = "/ethermint/evm/v1/trace_block";
   }
 
+  // TraceCall implements the `debug_traceCall` rpc api
+  rpc TraceCall(QueryTraceCallRequest) returns (QueryTraceCallResponse) {
+    option (google.api.http).get = "/ethermint/evm/v1/trace_call";
+  }
+
   // BaseFee queries the base fee of the parent block of the current block,
   // it's similar to feemarket module's method, but also checks london hardfork status.
   rpc BaseFee(QueryBaseFeeRequest) returns (QueryBaseFeeResponse) {
@@ -272,6 +277,32 @@ message QueryTraceTxResponse {
   bytes data = 1;
 }
 
+// QueryTraceCallRequest defines TraceCall request
+message QueryTraceCallRequest {
+  // args uses the same json format as the json rpc api.
+  bytes args = 1;
+  // gas_cap defines the default gas cap to be used
+  uint64 gas_cap = 2;
+  // proposer_address of the requested block in hex format
+  bytes proposer_address = 3 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ConsAddress"];
+  // trace_config holds extra parameters to trace functions.
+  TraceConfig trace_config = 4;
+  // block_number of requested transaction
+  int64 block_number = 5;
+  // block_hash of requested transaction
+  string block_hash = 6;
+  // block_time of requested transaction
+  google.protobuf.Timestamp block_time = 7 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+  // chain_id is the the eip155 chain id parsed from the requested block header
+  int64 chain_id = 8;
+}
+
+// QueryTraceCallResponse defines TraceCallResponse
+message QueryTraceCallResponse {
+  // data is the response serialized in bytes
+  bytes data = 1;
+}
+
 // QueryTraceBlockRequest defines TraceTx request
 message QueryTraceBlockRequest {
   // txs is an array of messages in the block

proto/ethermint/evm/v1/trace_config_v0.proto

@@ -6,6 +6,17 @@ import "ethermint/evm/v1/chain_config_v0.proto";
 
 option go_package = "github.com/evmos/ethermint/x/evm/types";
 
+
+// OverrideAccount indicates the overriding fields of account during the execution of
+// a message call.
+message V0OverrideAccount {
+  uint64 nonce  = 1;
+  string code = 2;
+  string balance = 3;
+  map<string, string> state = 4;
+  map<string, string> state_diff = 5 [(gogoproto.jsontag) = "stateDiff"];
+}
+
 // V0TraceConfig holds extra parameters to trace functions.
 message V0TraceConfig {
   // DEPRECATED: DisableMemory and DisableReturnData have been renamed to
@@ -36,4 +47,6 @@ message V0TraceConfig {
   bool enable_return_data = 12 [(gogoproto.jsontag) = "enableReturnData"];
   // tracer_json_config configures the tracer using a JSON string
   string tracer_json_config = 13 [(gogoproto.jsontag) = "tracerConfig"];
+  // temporary state modifications to Geth in order to simulate the effects of eth_call
+  map<string, V0OverrideAccount> state_overrides = 14 [(gogoproto.jsontag) = "stateOverrides"];
 }

rpc/backend/backend.go

@@ -139,6 +139,7 @@ type EVMBackend interface {
 	// Tracing
 	TraceTransaction(hash common.Hash, config *rpctypes.TraceConfig) (interface{}, error)
 	TraceBlock(height rpctypes.BlockNumber, config *rpctypes.TraceConfig, block *tmrpctypes.ResultBlock) ([]*evmtypes.TxTraceResult, error)
+	TraceCall(args evmtypes.TransactionArgs, blockNr rpctypes.BlockNumberOrHash, config *rpctypes.TraceConfig) (interface{}, error)
 }
 
 var _ BackendI = (*Backend)(nil)

rpc/backend/evm_query_client_test.go

@@ -273,3 +273,15 @@ func RegisterBalanceError(queryClient *mocks.EVMQueryClient, addr common.Address
 	queryClient.On("Balance", rpc.ContextWithHeight(height), &evmtypes.QueryBalanceRequest{Address: addr.String()}).
 		Return(nil, errortypes.ErrInvalidRequest)
 }
+
+// TraceCall
+func RegisterTraceCall(queryClient *mocks.EVMQueryClient, request *evmtypes.QueryTraceCallRequest, response *evmtypes.QueryTraceCallResponse) {
+	queryClient.On("TraceCall", rpc.ContextWithHeight(request.BlockNumber), request).
+		Return(response, nil)
+}
+
+func RegisterTraceCallError(queryClient *mocks.EVMQueryClient, request *evmtypes.QueryTraceCallRequest) {
+	ctx, _ := context.WithCancel(rpc.ContextWithHeight(1))
+	queryClient.On("TraceCall", ctx, request).
+		Return(nil, errortypes.ErrInvalidRequest)
+}

rpc/backend/tracing.go

@@ -211,3 +211,58 @@ func (b *Backend) TraceBlock(height rpctypes.BlockNumber,
 
 	return decodedResults, nil
 }
+
+// TraceCall returns the structured logs created during the execution of EVM call
+// and returns them as a JSON object.
+func (b *Backend) TraceCall(
+	args evmtypes.TransactionArgs, blockNrOrHash rpctypes.BlockNumberOrHash, config *rpctypes.TraceConfig,
+) (interface{}, error) {
+	bz, err := json.Marshal(&args)
+	if err != nil {
+		return nil, err
+	}
+	blockNr, err := b.BlockNumberFromTendermint(blockNrOrHash)
+	if err != nil {
+		return nil, err
+	}
+	blk, err := b.TendermintBlockByNumber(blockNr)
+	if err != nil {
+		// the error message imitates geth behavior
+		return nil, errors.New("header not found")
+	}
+
+	traceCallRequest := evmtypes.QueryTraceCallRequest{
+		Args:            bz,
+		GasCap:          b.RPCGasCap(),
+		ProposerAddress: sdk.ConsAddress(blk.Block.ProposerAddress),
+		BlockNumber:     blk.Block.Height,
+		BlockHash:       common.Bytes2Hex(blk.BlockID.Hash),
+		BlockTime:       blk.Block.Time,
+		ChainId:         b.chainID.Int64(),
+	}
+
+	if config != nil {
+		traceCallRequest.TraceConfig = b.convertConfig(config)
+	}
+
+	// minus one to get the context of block beginning
+	contextHeight := blk.Block.Height - 1
+	if contextHeight < 1 {
+		// 0 is a special value in `ContextWithHeight`
+		contextHeight = 1
+	}
+	traceResult, err := b.queryClient.TraceCall(rpctypes.ContextWithHeight(contextHeight), &traceCallRequest)
+	if err != nil {
+		return nil, err
+	}
+
+	// Response format is unknown due to custom tracer config param
+	// More information can be found here https://geth.ethereum.org/docs/dapp/tracing-filtered
+	var decodedResult interface{}
+	err = json.Unmarshal(traceResult.Data, &decodedResult)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodedResult, nil
+}

rpc/backend/tracing_test.go

@@ -1,7 +1,9 @@
 package backend
 
 import (
+	"encoding/json"
 	"fmt"
+	"math/big"
 
 	dbm "github.com/cometbft/cometbft-db"
 	abci "github.com/cometbft/cometbft/abci/types"
@@ -11,11 +13,13 @@ import (
 	tmtypes "github.com/cometbft/cometbft/types"
 	"github.com/cosmos/cosmos-sdk/crypto"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/evmos/ethermint/crypto/ethsecp256k1"
 	"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"
 )
 
@@ -251,3 +255,72 @@ func (suite *BackendTestSuite) TestTraceBlock() {
 		})
 	}
 }
+
+func (suite *BackendTestSuite) TestDebugTraceCall() {
+	_, bz := suite.buildEthereumTx()
+	gasPrice := (*hexutil.Big)(big.NewInt(1))
+	toAddr := tests.GenerateAddress()
+	chainID := (*hexutil.Big)(suite.backend.chainID)
+	callArgs := evmtypes.TransactionArgs{
+		From:                 nil,
+		To:                   &toAddr,
+		Gas:                  nil,
+		GasPrice:             nil,
+		MaxFeePerGas:         gasPrice,
+		MaxPriorityFeePerGas: gasPrice,
+		Value:                gasPrice,
+		Input:                nil,
+		Data:                 nil,
+		AccessList:           nil,
+		ChainID:              chainID,
+	}
+	argsBz, err := json.Marshal(callArgs)
+	suite.Require().NoError(err)
+
+	blockNum := rpctypes.NewBlockNumber(big.NewInt(1))
+
+	testCases := []struct {
+		name         string
+		registerMock func()
+		blockNum     rpctypes.BlockNumberOrHash
+		callArgs     evmtypes.TransactionArgs
+		expEthTx     interface{}
+		expPass      bool
+	}{
+		{
+			"pass",
+			func() {
+				client := suite.backend.clientCtx.Client.(*mocks.Client)
+				queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient)
+				RegisterBlock(client, 1, bz)
+				RegisterTraceCall(
+					queryClient,
+					&evmtypes.QueryTraceCallRequest{Args: argsBz, ChainId: suite.backend.chainID.Int64(), BlockNumber: 1},
+					&evmtypes.QueryTraceCallResponse{Data: []byte("{}")},
+				)
+			},
+			rpctypes.BlockNumberOrHash{
+				BlockNumber: &blockNum,
+			},
+			callArgs,
+			map[string]interface{}{},
+			true,
+		},
+	}
+
+	for _, tc := range testCases {
+		suite.Run(fmt.Sprintf("case %s", tc.name), func() {
+			suite.SetupTest()
+			tc.registerMock()
+
+			result, err := suite.backend.TraceCall(tc.callArgs, tc.blockNum, nil)
+
+			if tc.expPass {
+				suite.Require().Equal(tc.expEthTx, result)
+				suite.Require().NoError(err)
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}

rpc/namespaces/ethereum/debug/api.go

@@ -117,6 +117,17 @@ func (a *API) TraceBlockByHash(hash common.Hash, config *rpctypes.TraceConfig) (
 	return a.backend.TraceBlock(rpctypes.BlockNumber(resBlock.Block.Height), config, resBlock)
 }
 
+// TraceCall returns the structured logs created during the execution of EVM call
+// and returns them as a JSON object.
+func (a *API) TraceCall(
+	args evmtypes.TransactionArgs,
+	blockNrOrHash rpctypes.BlockNumberOrHash,
+	config *rpctypes.TraceConfig,
+) (interface{}, error) {
+	a.logger.Debug("debug_traceCall", "args", args.String(), "block number or hash", blockNrOrHash)
+	return a.backend.TraceCall(args, blockNrOrHash, config)
+}
+
 // BlockProfile turns on goroutine profiling for nsec seconds and writes profile data to
 // file. It uses a profile rate of 1 for most accurate information. If a different rate is
 // desired, set the rate and write the profile manually.

tests/integration_tests/network.py

@@ -129,7 +129,11 @@ def setup_custom_ethermint(
     if chain_binary is not None:
         cmd = cmd[:1] + ["--cmd", chain_binary] + cmd[1:]
     print(*cmd)
-    subprocess.run(cmd, check=True)
+    try:
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        print("Error {}: {}".format(e.returncode, e.output))
+        raise e
     if post_init is not None:
         post_init(path, base_port, config)
     proc = subprocess.Popen(

tests/integration_tests/test_debug_trace.py → tests/integration_tests/test_debug_traceblock.py

@@ -9,7 +9,7 @@
 )
 
 
-def test_trace_blk(ethermint):
+def test_traceblock(ethermint):
     w3 = ethermint.w3
     cli = ethermint.cosmos_cli()
     acc = derive_new_account(3)