fix(rpc/v0.4): apply trace caching changes

crates/rpc/src/v04/method/trace_block_transactions.rs

@@ -99,8 +99,10 @@ pub async fn trace_block_transactions(
             .map(|transaction| compose_executor_transaction(transaction, &db))
             .collect::<Result<Vec<_>, _>>()?;
 
+        let hash = header.hash;
         let state = ExecutionState::trace(&db, context.chain_id, header, None);
-        let traces = pathfinder_executor::trace_all(state, transactions, true, true)?;
+        let traces =
+            pathfinder_executor::trace(state, context.cache, hash, transactions, true, true)?;
 
         let result = traces
             .into_iter()

crates/rpc/src/v04/method/trace_transaction.rs

@@ -1,6 +1,6 @@
 use anyhow::Context;
 use pathfinder_common::TransactionHash;
-use pathfinder_executor::{ExecutionState, TransactionExecutionError};
+use pathfinder_executor::{ExecutionState, TraceCache, TransactionExecutionError};
 use serde::{Deserialize, Serialize};
 use starknet_gateway_client::GatewayApi;
 
@@ -104,11 +104,11 @@ pub async fn trace_transaction(
             .get(&db)
             .context("Querying pending data")?;
 
-        let (header, transactions) = if let Some(pending_idx) = pending
+        let (header, transactions, cache) = if let Some(pending_tx) = pending
             .block
             .transactions
             .iter()
-            .position(|tx| tx.hash() == input.transaction_hash)
+            .find(|tx| tx.hash() == input.transaction_hash)
         {
             let header = pending.header();
 
@@ -120,20 +120,15 @@ pub async fn trace_transaction(
             if starknet_version
                 < VERSIONS_LOWER_THAN_THIS_SHOULD_FALL_BACK_TO_FETCHING_TRACE_FROM_GATEWAY
             {
-                return Ok(LocalExecution::Unsupported(
-                    pending.block.transactions[pending_idx].clone(),
-                ));
+                return Ok(LocalExecution::Unsupported(pending_tx.clone()));
             }
 
             (
                 header,
-                pending
-                    .block
-                    .transactions
-                    .iter()
-                    .take(pending_idx + 1)
-                    .cloned()
-                    .collect::<Vec<_>>(),
+                pending.block.transactions.clone(),
+                // Can't use cache for pending transactions since they are in a pending block, which
+                // has no block hash.
+                TraceCache::default(),
             )
         } else {
             let block_hash = db
@@ -166,26 +161,35 @@ pub async fn trace_transaction(
                 .context("Fetching block transactions")?
                 .context("Block transactions missing")?;
 
-            let index = transactions
-                .iter()
-                .position(|tx| tx.hash() == input.transaction_hash)
-                .context("Failed to find transaction in the batch")?;
-
-            (
-                header,
-                transactions.into_iter().take(index + 1).collect::<Vec<_>>(),
-            )
+            (header, transactions.clone(), context.cache.clone())
         };
 
+        let hash = header.hash;
         let state = ExecutionState::trace(&db, context.chain_id, header, None);
 
         let transactions = transactions
             .iter()
             .map(|transaction| compose_executor_transaction(transaction, &db))
             .collect::<Result<Vec<_>, _>>()?;
 
-        pathfinder_executor::trace_one(state, transactions, input.transaction_hash, true, true)
+        pathfinder_executor::trace(state, cache, hash, transactions, true, true)
             .map_err(TraceTransactionError::from)
+            .and_then(|txs| {
+                txs.into_iter()
+                    .find_map(|(tx_hash, trace)| {
+                        if tx_hash == input.transaction_hash {
+                            Some(trace)
+                        } else {
+                            None
+                        }
+                    })
+                    .ok_or_else(|| {
+                        TraceTransactionError::Internal(anyhow::anyhow!(
+                            "Transaction hash not found: {}",
+                            input.transaction_hash
+                        ))
+                    })
+            })
             .map(|x| LocalExecution::Success(x.into()))
     })
     .await