use debug_traceTransaction instead

crates/autopilot/src/domain/eth/mod.rs

@@ -312,11 +312,15 @@ pub struct TradeEvent {
     pub order_uid: domain::OrderUid,
 }
 
-/// A trace of a Call type of action.
-#[derive(Debug, Clone, Default)]
-pub struct TraceCall {
-    pub to: Address,
+/// Call frames of a transaction.
+#[derive(Clone, Debug, Default)]
+pub struct CallFrame {
+    /// The address of the contract that was called.
+    pub to: Option<Address>,
+    /// Calldata input.
     pub input: Calldata,
+    /// Recorded child calls.
+    pub calls: Vec<CallFrame>,
 }
 
 /// Any type of on-chain transaction.
@@ -335,5 +339,5 @@ pub struct Transaction {
     /// The effective gas price of the transaction.
     pub gas_price: EffectiveGasPrice,
     /// Traces of all Calls contained in the transaction.
-    pub trace_calls: Vec<TraceCall>,
+    pub trace_calls: CallFrame,
 }

crates/autopilot/src/domain/settlement/mod.rs

@@ -434,10 +434,11 @@ mod tests {
         )));
         let transaction = super::transaction::Transaction::try_new(
             &domain::eth::Transaction {
-                trace_calls: vec![domain::eth::TraceCall {
-                    to: settlement_contract,
+                trace_calls: domain::eth::CallFrame {
+                    to: Some(settlement_contract),
                     input: calldata.into(),
-                }],
+                    ..Default::default()
+                },
                 ..Default::default()
             },
             &domain_separator,
@@ -540,10 +541,11 @@ mod tests {
         )));
         let transaction = super::transaction::Transaction::try_new(
             &domain::eth::Transaction {
-                trace_calls: vec![domain::eth::TraceCall {
-                    to: settlement_contract,
+                trace_calls: domain::eth::CallFrame {
+                    to: Some(settlement_contract),
                     input: calldata.into(),
-                }],
+                    ..Default::default()
+                },
                 ..Default::default()
             },
             &domain_separator,
@@ -683,10 +685,11 @@ mod tests {
         )));
         let transaction = super::transaction::Transaction::try_new(
             &domain::eth::Transaction {
-                trace_calls: vec![domain::eth::TraceCall {
-                    to: settlement_contract,
+                trace_calls: domain::eth::CallFrame {
+                    to: Some(settlement_contract),
                     input: calldata.into(),
-                }],
+                    ..Default::default()
+                },
                 ..Default::default()
             },
             &domain_separator,
@@ -858,10 +861,11 @@ mod tests {
         )));
         let transaction = super::transaction::Transaction::try_new(
             &domain::eth::Transaction {
-                trace_calls: vec![domain::eth::TraceCall {
-                    to: settlement_contract,
+                trace_calls: domain::eth::CallFrame {
+                    to: Some(settlement_contract),
                     input: calldata.into(),
-                }],
+                    ..Default::default()
+                },
                 ..Default::default()
             },
             &domain_separator,
@@ -1039,10 +1043,11 @@ mod tests {
         )));
         let transaction = super::transaction::Transaction::try_new(
             &domain::eth::Transaction {
-                trace_calls: vec![domain::eth::TraceCall {
-                    to: settlement_contract,
+                trace_calls: domain::eth::CallFrame {
+                    to: Some(settlement_contract),
                     input: calldata.into(),
-                }],
+                    ..Default::default()
+                },
                 ..Default::default()
             },
             &domain_separator,

crates/autopilot/src/domain/settlement/transaction/mod.rs

@@ -35,11 +35,7 @@ impl Transaction {
         settlement_contract: eth::Address,
     ) -> Result<Self, Error> {
         // find trace call to settlement contract
-        let calldata = transaction
-            .trace_calls
-            .iter()
-            .find(|trace| is_settlement_trace(trace, settlement_contract))
-            .map(|trace| trace.input.clone())
+        let calldata = find_settlement_trace(&transaction.trace_calls, settlement_contract).map(|trace| trace.input.clone())
             // all transactions emitting settlement events should have a /settle call, 
             // otherwise it's an execution client bug
             .ok_or(Error::MissingCalldata)?;
@@ -132,12 +128,31 @@ impl Transaction {
     }
 }
 
-fn is_settlement_trace(trace: &eth::TraceCall, settlement_contract: eth::Address) -> bool {
+fn find_settlement_trace(
+    call_frame: &eth::CallFrame,
+    settlement_contract: eth::Address,
+) -> Option<&eth::CallFrame> {
+    // Use a stack to keep track of frames to process
+    let mut stack = vec![call_frame];
+
+    while let Some(call_frame) = stack.pop() {
+        if is_settlement_trace(call_frame, settlement_contract) {
+            return Some(call_frame);
+        }
+        // Add all nested calls to the stack
+        stack.extend(&call_frame.calls);
+    }
+
+    None
+}
+
+fn is_settlement_trace(trace: &eth::CallFrame, settlement_contract: eth::Address) -> bool {
     static SETTLE_FUNCTION_SELECTOR: LazyLock<[u8; 4]> = LazyLock::new(|| {
         let abi = &contracts::GPv2Settlement::raw_contract().interface.abi;
         abi.function("settle").unwrap().selector()
     });
-    trace.to == settlement_contract && trace.input.0.starts_with(&*SETTLE_FUNCTION_SELECTOR)
+    trace.to.unwrap_or_default() == settlement_contract
+        && trace.input.0.starts_with(&*SETTLE_FUNCTION_SELECTOR)
 }
 
 /// Trade containing onchain observable data specific to a settlement

crates/autopilot/src/infra/blockchain/mod.rs

@@ -1,13 +1,15 @@
 use {
     self::contracts::Contracts,
     crate::{boundary, domain::eth},
+    ::serde::Deserialize,
     chain::Chain,
     ethcontract::dyns::DynWeb3,
     ethrpc::block_stream::CurrentBlockWatcher,
     primitive_types::U256,
     std::time::Duration,
     thiserror::Error,
     url::Url,
+    web3::{types::Bytes, Transport},
 };
 
 pub mod contracts;
@@ -106,7 +108,15 @@ impl Ethereum {
         let (transaction, receipt, traces) = tokio::try_join!(
             self.web3.eth().transaction(hash.0.into()),
             self.web3.eth().transaction_receipt(hash.0),
-            self.web3.trace().transaction(hash.0),
+            {
+                let hash = web3::helpers::serialize(&hash.0);
+                let tracing_options = serde_json::json!({ "tracer": "callTracer" });
+                web3::helpers::CallFuture::new(
+                    self.web3
+                        .transport()
+                        .execute("debug_traceTransaction", vec![hash, tracing_options]),
+                )
+            }
         )?;
         let transaction = transaction.ok_or(Error::TransactionNotFound)?;
         let receipt = receipt.ok_or(Error::TransactionNotFound)?;
@@ -130,7 +140,7 @@ impl Ethereum {
 fn into_domain(
     transaction: web3::types::Transaction,
     receipt: web3::types::TransactionReceipt,
-    traces: Vec<web3::types::Trace>,
+    trace_calls: CallFrame,
     timestamp: U256,
 ) -> anyhow::Result<eth::Transaction> {
     Ok(eth::Transaction {
@@ -153,19 +163,33 @@ fn into_domain(
             .ok_or(anyhow::anyhow!("missing effective_gas_price"))?
             .into(),
         timestamp: timestamp.as_u32(),
-        trace_calls: traces
-            .into_iter()
-            .filter_map(|trace| match trace.action {
-                web3::types::Action::Call(call) => Some(eth::TraceCall {
-                    to: call.to.into(),
-                    input: call.input.0.into(),
-                }),
-                _ => None,
-            })
-            .collect(),
+        trace_calls: trace_calls.into(),
     })
 }
 
+/// Taken from alloy::rpc::types::trace::geth::CallFrame
+#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize)]
+pub struct CallFrame {
+    /// The address of the contract that was called.
+    #[serde(default)]
+    pub to: Option<primitive_types::H160>,
+    /// Calldata input.
+    pub input: Bytes,
+    /// Recorded child calls.
+    #[serde(default)]
+    pub calls: Vec<CallFrame>,
+}
+
+impl From<CallFrame> for eth::CallFrame {
+    fn from(frame: CallFrame) -> Self {
+        eth::CallFrame {
+            to: frame.to.map(Into::into),
+            input: frame.input.0.into(),
+            calls: frame.calls.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("web3 error: {0:?}")]