trace working

Author: chudkowsky

Cargo.lock

@@ -4,8 +4,8 @@ use katana_pool::TransactionPool;
 use katana_primitives::block::{BlockHashOrNumber, BlockIdOrTag, ConfirmedBlockIdOrTag};
 use katana_primitives::execution::TypedTransactionExecutionInfo;
 use katana_primitives::transaction::{ExecutableTx, ExecutableTxWithHash, TxHash};
-use katana_provider::api::block::{BlockNumberProvider, BlockProvider};
-use katana_provider::api::transaction::{TransactionTraceProvider, TransactionsProviderExt};
+use katana_provider::api::block::BlockNumberProvider;
+use katana_provider::api::transaction::TransactionTraceProvider;
 use katana_rpc_api::error::starknet::StarknetApiError;
 use katana_rpc_api::starknet::StarknetTraceApiServer;
 use katana_rpc_types::broadcasted::BroadcastedTx;
@@ -97,7 +97,6 @@ where
         block_id: ConfirmedBlockIdOrTag,
     ) -> Result<Vec<TxTraceWithHash>, StarknetApiError> {
         use StarknetApiError::BlockNotFound;
-
         let provider = &self.inner.storage;
 
         let block_id: BlockHashOrNumber = match block_id {
@@ -109,19 +108,14 @@ where
             ConfirmedBlockIdOrTag::Hash(hash) => hash.into(),
         };
 
-        let indices = provider.block_body_indices(block_id)?.ok_or(BlockNotFound)?;
-        let tx_hashes = provider.transaction_hashes_in_range(indices.into())?;
-
-        let traces = provider.transaction_executions_by_block(block_id)?.ok_or(BlockNotFound)?;
-        let traces = traces.into_iter().map(TxTrace::from);
-
-        let result = tx_hashes
-            .into_iter()
-            .zip(traces)
-            .map(|(h, r)| TxTraceWithHash { transaction_hash: h, trace_root: r })
-            .collect::<Vec<_>>();
+        let traces = self
+            .inner
+            .storage
+            .inner()
+            .transaction_executions_by_block(block_id)?
+            .ok_or(BlockNotFound)?;
 
-        Ok(result)
+        Ok(traces)
     }
 
     fn trace(&self, tx_hash: TxHash) -> Result<TxTrace, StarknetApiError> {

crates/rpc/rpc-server/src/starknet/trace.rs

@@ -31,8 +31,7 @@ use katana_rpc_client::starknet::{
 };
 use katana_rpc_types::class::Class;
 use katana_rpc_types::{
-    ContractStorageKeys, GetBlockWithReceiptsResponse, GetStorageProofResponse, StateUpdate,
-    TxReceiptWithBlockInfo,
+    ConfirmedBlockIdOrTag, ContractStorageKeys, GetBlockWithReceiptsResponse, GetStorageProofResponse, StateUpdate, TraceBlockTransactionsResponse, TxReceiptWithBlockInfo
 };
 use parking_lot::Mutex;
 use tracing::{error, trace};
@@ -349,6 +348,24 @@ impl Backend {
         }
     }
 
+    pub fn get_block_transactions_traces(
+        &self,
+        block_id: BlockHashOrNumber,
+    ) -> Result<Option<TraceBlockTransactionsResponse>, BackendClientError> {
+        trace!( block = %block_id, "Requesting trace block.");
+        let (req, rx) = BackendRequest::trace(block_id);
+        self.request(req)?;
+        match rx.recv()? {
+            BackendResponse::TraceBlockTransactions(res) => {
+                 if let Some(res) = handle_not_found_err(res)? {
+                    Ok(Some(res))
+                } else {
+                    Ok(None)
+                }
+}
+            response => Err(BackendClientError::UnexpectedResponse(anyhow!("{response:?}"))),
+        }
+    }
     /// Send a request to the backend thread.
     fn request(&self, req: BackendRequest) -> Result<(), BackendClientError> {
         self.sender.lock().try_send(req).map_err(|e| e.into_send_error())?;
@@ -383,6 +400,7 @@ enum BackendResponse {
     StorageRoot(BackendResult<Felt>),
     GlobalRoots(BackendResult<GetStorageProofResponse>),
     Proofs(BackendResult<GetStorageProofResponse>),
+    TraceBlockTransactions(BackendResult<TraceBlockTransactionsResponse>),
 }
 
 /// Errors that can occur when interacting with the backend.
@@ -423,6 +441,7 @@ enum BackendRequest {
     Nonce(Request<(ContractAddress, BlockNumber)>),
     ClassHash(Request<(ContractAddress, BlockNumber)>),
     Storage(Request<((ContractAddress, StorageKey), BlockNumber)>),
+    Trace(Request<BlockHashOrNumber>),
 }
 
 impl BackendRequest {
@@ -520,6 +539,11 @@ impl BackendRequest {
         let (sender, receiver) = oneshot();
         (BackendRequest::StorageRoot(Request { payload: (contract, block_id), sender }), receiver)
     }
+
+    fn trace(block_id: BlockHashOrNumber) -> (BackendRequest, OneshotReceiver<BackendResponse>) {
+        let (sender, receiver) = oneshot();
+        (BackendRequest::Trace(Request { payload: block_id, sender }), receiver)
+    }
 }
 
 type BackendRequestFuture = BoxFuture<'static, BackendResponse>;
@@ -538,6 +562,7 @@ enum BackendRequestIdentifier {
     Class(ClassHash, BlockNumber),
     ClassHash(ContractAddress, BlockNumber),
     Storage((ContractAddress, StorageKey), BlockNumber),
+    Trace(BlockHashOrNumber),
 }
 
 /// Metrics for the forking backend.
@@ -793,6 +818,25 @@ impl BackendWorker {
                     }),
                 );
             }
+            BackendRequest::Trace(Request { payload: block_id, sender }) => {
+                let req_key = BackendRequestIdentifier::Trace(block_id);
+                let block_id = match block_id {
+                    BlockHashOrNumber::Hash(h) => ConfirmedBlockIdOrTag::Hash(h),
+                    BlockHashOrNumber::Num(n) => ConfirmedBlockIdOrTag::Number(n),
+                };
+                
+                self.dedup_request(
+                    req_key,
+                    sender,
+                    Box::pin(async move {
+                        let result = provider
+                            .trace_block_transactions(block_id)
+                            .await
+                            .map_err(|e| BackendError::StarknetProvider(Arc::new(e)));
+                        BackendResponse::TraceBlockTransactions(result)
+                    }),
+                );
+            }
         }
     }
 

crates/storage/fork/src/lib.rs

@@ -8,6 +8,7 @@ version.workspace = true
 katana-db = { workspace = true, features = [ "test-utils" ] }
 katana-primitives.workspace = true
 katana-trie.workspace = true
+katana-rpc-types.workspace = true
 
 auto_impl.workspace = true
 starknet.workspace = true

crates/storage/provider/provider-api/Cargo.toml

@@ -4,6 +4,7 @@ use katana_primitives::block::{BlockHash, BlockHashOrNumber, BlockNumber, Finali
 use katana_primitives::execution::TypedTransactionExecutionInfo;
 use katana_primitives::receipt::Receipt;
 use katana_primitives::transaction::{TxHash, TxNumber, TxWithHash};
+use katana_rpc_types::TxTraceWithHash;
 
 use crate::ProviderResult;
 
@@ -68,7 +69,7 @@ pub trait TransactionTraceProvider: Send + Sync {
     fn transaction_executions_by_block(
         &self,
         block_id: BlockHashOrNumber,
-    ) -> ProviderResult<Option<Vec<TypedTransactionExecutionInfo>>>;
+    ) -> ProviderResult<Option<Vec<TxTraceWithHash>>>;
 
     /// Retrieves the execution traces for the given range of tx numbers.
     fn transaction_executions_in_range(

crates/storage/provider/provider-api/src/transaction.rs

@@ -30,6 +30,7 @@ use katana_provider_api::transaction::{
 };
 use katana_provider_api::trie::TrieWriter;
 pub use katana_provider_api::{ProviderError, ProviderResult};
+use katana_rpc_types::TxTraceWithHash;
 
 pub mod providers;
 #[cfg(any(test, feature = "test-utils"))]
@@ -217,7 +218,7 @@ where
     fn transaction_executions_by_block(
         &self,
         block_id: BlockHashOrNumber,
-    ) -> ProviderResult<Option<Vec<TypedTransactionExecutionInfo>>> {
+    ) -> ProviderResult<Option<Vec<TxTraceWithHash>>> {
         TransactionTraceProvider::transaction_executions_by_block(&self.provider, block_id)
     }
 

crates/storage/provider/provider/src/lib.rs

@@ -43,6 +43,7 @@ use katana_provider_api::transaction::{
     TransactionsProviderExt,
 };
 use katana_provider_api::ProviderError;
+use katana_rpc_types::{TxTrace, TxTraceWithHash};
 
 use crate::ProviderResult;
 
@@ -619,9 +620,19 @@ impl<Db: Database> TransactionTraceProvider for DbProvider<Db> {
     fn transaction_executions_by_block(
         &self,
         block_id: BlockHashOrNumber,
-    ) -> ProviderResult<Option<Vec<TypedTransactionExecutionInfo>>> {
+    ) -> ProviderResult<Option<Vec<TxTraceWithHash>>> {
         if let Some(index) = self.block_body_indices(block_id)? {
-            let traces = self.transaction_executions_in_range(index.into())?;
+            let traces = self.transaction_executions_in_range(index.clone().into())?;
+            let traces = traces.into_iter().map(TxTrace::from);
+
+            let tx_hashes = self.transaction_hashes_in_range(index.into())?;
+
+            let traces = tx_hashes
+                .into_iter()
+                .zip(traces)
+                .map(|(h, r)| TxTraceWithHash { transaction_hash: h, trace_root: r })
+                .collect::<Vec<_>>();
+
             Ok(Some(traces))
         } else {
             Ok(None)

crates/storage/provider/provider/src/providers/db/mod.rs

@@ -29,7 +29,7 @@ use katana_provider_api::transaction::{
 };
 use katana_provider_api::ProviderError;
 use katana_rpc_client::starknet::Client as StarknetClient;
-use katana_rpc_types::{GetBlockWithReceiptsResponse, RpcTxWithReceipt, StateUpdate};
+use katana_rpc_types::{GetBlockWithReceiptsResponse, RpcTxWithReceipt, StateUpdate, TxTraceWithHash};
 
 use super::db::{self, DbProvider};
 use crate::ProviderResult;
@@ -564,14 +564,20 @@ impl<Db: Database> TransactionTraceProvider for ForkedProvider<Db> {
     fn transaction_executions_by_block(
         &self,
         block_id: BlockHashOrNumber,
-    ) -> ProviderResult<Option<Vec<TypedTransactionExecutionInfo>>> {
+    ) -> ProviderResult<Option<Vec<TxTraceWithHash>>> {
         if let Some(result) = self.local_db.transaction_executions_by_block(block_id)? {
             return Ok(Some(result));
         }
 
-        // TODO: fetch from remote
-
-        Ok(None)
+        if let Some(value) = self.fork_db.db.transaction_executions_by_block(block_id)? {
+            return Ok(Some(value));
+        }
+        if let Some(value) = self.fork_db.backend.get_block_transactions_traces(block_id)? {
+            let traces = value.traces;
+            return Ok(Some(traces));
+        } else {
+            Ok(None)
+        }
     }
 
     fn transaction_executions_in_range(