(Feat Anvil): add geth like debug_traceCall api (#3990)

* add geth like debug_traceCall api

* add debug trace call sanity check

Author: zsluedem

anvil/core/src/eth/mod.rs

@@ -263,6 +263,14 @@ pub enum EthRequest {
         #[cfg_attr(feature = "serde", serde(default))] GethDebugTracingOptions,
     ),
 
+    /// geth's `debug_traceCall`  endpoint
+    #[cfg_attr(feature = "serde", serde(rename = "debug_traceCall"))]
+    DebugTraceCall(
+        EthTransactionRequest,
+        #[cfg_attr(feature = "serde", serde(default))] Option<BlockId>,
+        #[cfg_attr(feature = "serde", serde(default))] GethDebugTracingOptions,
+    ),
+
     /// Trace transaction endpoint for parity's `trace_transaction`
     #[cfg_attr(feature = "serde", serde(rename = "trace_transaction", with = "sequence"))]
     TraceTransaction(H256),
@@ -1100,6 +1108,29 @@ mod tests {
         let _req = serde_json::from_value::<EthRequest>(value).unwrap();
     }
 
+    #[test]
+    fn test_serde_debug_trace_call() {
+        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}]}"#;
+        let value: serde_json::Value = serde_json::from_str(s).unwrap();
+        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
+
+        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "latest" }]}"#;
+        let value: serde_json::Value = serde_json::from_str(s).unwrap();
+        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
+
+        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }]}"#;
+        let value: serde_json::Value = serde_json::from_str(s).unwrap();
+        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
+
+        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockHash": "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" }]}"#;
+        let value: serde_json::Value = serde_json::from_str(s).unwrap();
+        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
+
+        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }, {"disableStorage": true}]}"#;
+        let value: serde_json::Value = serde_json::from_str(s).unwrap();
+        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
+    }
+
     #[test]
     fn test_serde_eth_storage() {
         let s = r#"{"method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"]}"#;

anvil/src/eth/api.rs

@@ -250,6 +250,10 @@ impl EthApi {
             EthRequest::DebugTraceTransaction(tx, opts) => {
                 self.debug_trace_transaction(tx, opts).await.to_rpc_result()
             }
+            // non eth-standard rpc calls
+            EthRequest::DebugTraceCall(tx, block, opts) => {
+                self.debug_trace_call(tx, block, opts).await.to_rpc_result()
+            }
             EthRequest::TraceTransaction(tx) => self.trace_transaction(tx).await.to_rpc_result(),
             EthRequest::TraceBlock(block) => self.trace_block(block).await.to_rpc_result(),
             EthRequest::ImpersonateAccount(addr) => {
@@ -1266,6 +1270,30 @@ impl EthApi {
         self.backend.debug_trace_transaction(tx_hash, opts).await
     }
 
+    /// Returns traces for the transaction for geth's tracing endpoint
+    ///
+    /// Handler for RPC call: `debug_traceCall`
+    pub async fn debug_trace_call(
+        &self,
+        request: EthTransactionRequest,
+        block_number: Option<BlockId>,
+        opts: GethDebugTracingOptions,
+    ) -> Result<GethTrace> {
+        node_info!("debug_traceCall");
+        if opts.tracer.is_some() {
+            return Err(RpcError::invalid_params("non-default tracer not supported yet").into())
+        }
+        let block_request = self.block_request(block_number).await?;
+        let fees = FeeDetails::new(
+            request.gas_price,
+            request.max_fee_per_gas,
+            request.max_priority_fee_per_gas,
+        )?
+        .or_zero_fees();
+
+        self.backend.call_with_tracing(request, fees, Some(block_request), opts).await
+    }
+
     /// Returns traces for the transaction hash via parity's tracing endpoint
     ///
     /// Handler for RPC call: `trace_transaction`

anvil/src/eth/backend/mem/mod.rs

@@ -895,6 +895,28 @@ impl Backend {
         Ok((exit_reason, out, gas_used, state))
     }
 
+    pub async fn call_with_tracing(
+        &self,
+        request: EthTransactionRequest,
+        fee_details: FeeDetails,
+        block_request: Option<BlockRequest>,
+        opts: GethDebugTracingOptions,
+    ) -> Result<GethTrace, BlockchainError> {
+        self.with_database_at(block_request, |state, block| {
+            let mut inspector = Inspector::default().with_steps_tracing();
+            let block_number = block.number;
+            let mut evm = revm::EVM::new();
+            evm.env = self.build_call_env(request, fee_details, block);
+            evm.database(state);
+            let (ExecutionResult { exit_reason, out, gas_used, .. }, _) =
+                evm.inspect_ref(&mut inspector);
+            let res = inspector.tracer.unwrap_or_default().traces.geth_trace(gas_used.into(), opts);
+            trace!(target: "backend", "trace call return {:?} out: {:?} gas {} on block {}", exit_reason, out, gas_used, block_number);
+            Ok(res)
+        })
+        .await?
+    }
+
     pub fn build_access_list_with_state<D>(
         &self,
         state: D,

anvil/tests/it/traces.rs

@@ -3,7 +3,7 @@ use anvil::{spawn, NodeConfig};
 use ethers::{
     contract::Contract,
     prelude::{Action, ContractFactory, Middleware, Signer, SignerMiddleware, TransactionRequest},
-    types::{ActionType, Address, Trace},
+    types::{ActionType, Address, GethDebugTracingCallOptions, Trace},
     utils::hex,
 };
 use ethers_solc::{project_util::TempProject, Artifact};
@@ -90,6 +90,55 @@ contract Contract {
     assert_eq!(traces[0].action_type, ActionType::Suicide);
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn test_transfer_debug_trace_call() {
+    let prj = TempProject::dapptools().unwrap();
+    prj.add_source(
+        "Contract",
+        r#"
+pragma solidity 0.8.13;
+contract Contract {
+    address payable private owner;
+    constructor() public {
+        owner = payable(msg.sender);
+    }
+    function goodbye() public {
+        selfdestruct(owner);
+    }
+}
+"#,
+    )
+    .unwrap();
+
+    let mut compiled = prj.compile().unwrap();
+    assert!(!compiled.has_compiler_errors());
+    let contract = compiled.remove_first("Contract").unwrap();
+    let (abi, bytecode, _) = contract.into_contract_bytecode().into_parts();
+
+    let (_api, handle) = spawn(NodeConfig::test()).await;
+    let provider = handle.ws_provider().await;
+    let wallets = handle.dev_wallets().collect::<Vec<_>>();
+    let client = Arc::new(SignerMiddleware::new(provider, wallets[0].clone()));
+
+    // deploy successfully
+    let factory = ContractFactory::new(abi.clone().unwrap(), bytecode.unwrap(), client);
+    let contract = factory.deploy(()).unwrap().send().await.unwrap();
+
+    let contract = Contract::new(
+        contract.address(),
+        abi.unwrap(),
+        SignerMiddleware::new(handle.http_provider(), wallets[1].clone()),
+    );
+    let call = contract.method::<_, ()>("goodbye", ()).unwrap();
+
+    let traces = handle
+        .http_provider()
+        .debug_trace_call(call.tx, None, GethDebugTracingCallOptions::default())
+        .await
+        .unwrap();
+    assert!(!traces.failed);
+}
+
 // <https://github.com/foundry-rs/foundry/issues/2656>
 #[tokio::test(flavor = "multi_thread")]
 async fn test_trace_address_fork() {