feat: impl trace_filter

crates/rpc/rpc-types/src/eth/trace/filter.rs

@@ -1,6 +1,7 @@
 //! `trace_filter` types and support
 use reth_primitives::{serde_helper::num::u64_hex_or_decimal_opt, Address};
 use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
 
 /// Trace filter.
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -14,15 +15,66 @@ pub struct TraceFilter {
     #[serde(with = "u64_hex_or_decimal_opt")]
     pub to_block: Option<u64>,
     /// From address
-    pub from_address: Option<Vec<Address>>,
+    #[serde(default)]
+    pub from_address: Vec<Address>,
     /// To address
-    pub to_address: Option<Vec<Address>>,
+    #[serde(default)]
+    pub to_address: Vec<Address>,
+    /// How to apply `from_address` and `to_address` filters.
+    #[serde(default)]
+    pub mode: TraceFilterMode,
     /// Output offset
     pub after: Option<u64>,
     /// Output amount
     pub count: Option<u64>,
 }
 
+// === impl TraceFilter ===
+
+impl TraceFilter {
+    /// Returns a `TraceFilterMatcher` for this filter.
+    pub fn matcher(&self) -> TraceFilterMatcher {
+        let from_addresses = self.from_address.iter().cloned().collect();
+        let to_addresses = self.to_address.iter().cloned().collect();
+        TraceFilterMatcher { mode: self.mode, from_addresses, to_addresses }
+    }
+}
+
+/// How to apply `from_address` and `to_address` filters.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TraceFilterMode {
+    /// Return traces for transactions with matching `from` OR `to` addresses.
+    #[default]
+    Union,
+    /// Only return traces for transactions with matching `from` _and_ `to` addresses.
+    Intersection,
+}
+
+/// Helper type for matching `from` and `to` addresses.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TraceFilterMatcher {
+    mode: TraceFilterMode,
+    from_addresses: HashSet<Address>,
+    to_addresses: HashSet<Address>,
+}
+
+impl TraceFilterMatcher {
+    /// Returns `true` if the given `from` and `to` addresses match this filter.
+    pub fn matches(&self, from: Address, to: Option<Address>) -> bool {
+        match self.mode {
+            TraceFilterMode::Union => {
+                self.from_addresses.contains(&from) ||
+                    to.map_or(false, |to| self.to_addresses.contains(&to))
+            }
+            TraceFilterMode::Intersection => {
+                self.from_addresses.contains(&from) &&
+                    to.map_or(false, |to| self.to_addresses.contains(&to))
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/rpc/rpc/src/trace.rs

@@ -5,7 +5,6 @@ use crate::{
         utils::recover_raw_transaction,
         EthTransactions,
     },
-    result::internal_rpc_err,
     TracingCallGuard,
 };
 use async_trait::async_trait;
@@ -249,12 +248,16 @@ where
         }
     }
 
-    /// Returns all traces for the given transaction hash
+    /// Returns all transaction traces that match the given filter.
+    ///
+    /// This is similar to [Self::trace_block] but only returns traces for transactions that match
+    /// the filter.
     pub async fn trace_filter(
         &self,
         filter: TraceFilter,
     ) -> EthResult<Vec<LocalizedTransactionTrace>> {
-        let TraceFilter { from_block, to_block, from_address, to_address, after, count } = filter;
+        let matcher = filter.matcher();
+        let TraceFilter { from_block, to_block, after: _after, count: _count, .. } = filter;
         let start = from_block.unwrap_or(0);
         let end = if let Some(to_block) = to_block {
             to_block
@@ -265,15 +268,64 @@ where
         // ensure that the range is not too large, since we need to fetch all blocks in the range
         let distance = end.saturating_sub(start);
         if distance > 100 {
-            return Err(
-                EthApiError::InvalidParams("Block range too large; currently limited to 100 blocks".to_string())
-            )
+            return Err(EthApiError::InvalidParams(
+                "Block range too large; currently limited to 100 blocks".to_string(),
+            ))
+        }
+
+        // fetch all blocks in that range
+        let blocks = self.provider().block_range(start..=end)?;
+
+        // find relevant blocks to trace
+        let mut target_blocks = Vec::new();
+        for block in blocks {
+            let mut transaction_indices = HashSet::new();
+            for (tx_idx, tx) in block.body.iter().enumerate() {
+                let from = tx.recover_signer().ok_or(BlockError::InvalidSignature)?;
+                let to = tx.to();
+                if matcher.matches(from, to) {
+                    transaction_indices.insert(tx_idx as u64);
+                }
+            }
+            if !transaction_indices.is_empty() {
+                target_blocks.push((block.number, transaction_indices));
+            }
         }
 
-        self.provider().block_ran
+        // TODO: this could be optimized to only trace the block until the highest matching index in
+        // that block
+
+        // trace all relevant blocks
+        let mut block_traces = Vec::with_capacity(target_blocks.len());
+        for (num, indices) in target_blocks {
+            let traces = self.trace_block_with(
+                num.into(),
+                TracingInspectorConfig::default_parity(),
+                move |tx_info, inspector, res, _, _| {
+                    if let Some(idx) = tx_info.index {
+                        if !indices.contains(&idx) {
+                            // only record traces for relevant transactions
+                            return Ok(None)
+                        }
+                    }
+                    let traces = inspector
+                        .with_transaction_gas_used(res.gas_used())
+                        .into_parity_builder()
+                        .into_localized_transaction_traces(tx_info);
+                    Ok(Some(traces))
+                },
+            );
+            block_traces.push(traces);
+        }
 
+        let block_traces = futures::future::try_join_all(block_traces).await?;
+        let all_traces = block_traces
+            .into_iter()
+            .flatten()
+            .flat_map(|traces| traces.into_iter().flatten().flat_map(|traces| traces.into_iter()))
+            .collect();
 
-        todo!()
+        Ok(all_traces)
     }
 
     /// Returns all traces for the given transaction hash