wip

Author: kariy

Cargo.lock

@@ -8,6 +8,8 @@ version.workspace = true
 [dependencies]
 katana-gateway-types.workspace = true
 katana-primitives.workspace = true
+katana-executor.workspace = true
+katana-core.workspace = true
 katana-metrics.workspace = true
 katana-rpc.workspace = true
 katana-pool-api.workspace = true

crates/gateway/gateway-server/Cargo.toml

@@ -2,6 +2,7 @@ use axum::extract::{Query, State};
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Json, Response};
 use katana_core::service::block_producer::BlockProducer;
+use katana_executor::implementation::blockifier::BlockifierFactory;
 use katana_gateway_types::{
     Block, ConfirmedReceipt, ConfirmedTransaction, ContractClass, ErrorCode, GatewayError,
     ReceiptBody, StateUpdate, StateUpdateWithBlock,

crates/gateway/gateway-server/src/handlers.rs

@@ -5,6 +5,7 @@ use std::time::Duration;
 use axum::routing::get;
 use axum::Router;
 use katana_core::service::block_producer::BlockProducer;
+use katana_executor::implementation::blockifier::BlockifierFactory;
 use katana_pool_api::TransactionPool;
 use katana_rpc::cors::Cors;
 use katana_rpc::starknet::StarknetApi;
@@ -83,9 +84,7 @@ where
     Pool: TransactionPool + Clone + Send + Sync + 'static,
 {
     /// Create a new feeder gateway server.
-    pub fn new(
-        starknet_api: StarknetApi<Pool, BlockProducer<BlockifierFactory>>,
-    <P>) -> Self {
+    pub fn new(starknet_api: StarknetApi<Pool, BlockProducer<BlockifierFactory>>) -> Self {
         Self {
             timeout: DEFAULT_GATEWAY_TIMEOUT,
             cors: None,

crates/gateway/gateway-server/src/lib.rs

@@ -8,7 +8,10 @@ use katana_rpc_types::RpcTxWithHash;
 
 use crate::full::pending::PreconfStateFactory;
 
-impl<P: StateFactoryProvider + Debug> PendingBlockProvider for PreconfStateFactory<P> {
+impl<P> PendingBlockProvider for PreconfStateFactory<P>
+where
+    P: StateFactoryProvider + Debug + 'static,
+{
     fn get_pending_block_with_txs(
         &self,
     ) -> StarknetApiResult<Option<katana_rpc_types::PreConfirmedBlockWithTxs>> {
@@ -114,4 +117,11 @@ impl<P: StateFactoryProvider + Debug> PendingBlockProvider for PreconfStateFacto
     fn pending_state(&self) -> StarknetApiResult<Option<Box<dyn StateProvider>>> {
         Ok(Some(Box::new(self.state())))
     }
+
+    fn get_pending_trace(
+        &self,
+        hash: TxHash,
+    ) -> StarknetApiResult<Option<katana_rpc_types::TxTrace>> {
+        Ok(None)
+    }
 }

crates/node/src/full/pending/provider.rs

@@ -544,14 +544,7 @@ where
                 {
                     Result::<_, StarknetApiError>::Ok(pending_tx)
                 } else {
-                    let tx = this
-                        .inner
-                        .backend
-                        .blockchain
-                        .provider()
-                        .transaction_by_hash(hash)?
-                        .map(RpcTxWithHash::from);
-
+                    let tx = this.inner.storage.transaction_by_hash(hash)?.map(RpcTxWithHash::from);
                     Result::<_, StarknetApiError>::Ok(tx)
                 }
             })
@@ -574,7 +567,7 @@ where
                 {
                     StarknetApiResult::Ok(pending_receipt)
                 } else {
-                    let provider = this.inner.backend.blockchain.provider();
+                    let provider = &this.inner.storage;
                     StarknetApiResult::Ok(ReceiptBuilder::new(hash, provider).build()?)
                 }
             })
@@ -662,11 +655,9 @@ where
                         .build()?
                         .map(MaybePreConfirmedBlock::Confirmed);
 
-                            StarknetApiResult::Ok(block)
-                        } else {
-                            StarknetApiResult::Ok(None)
-                        }
-                    }
+                    StarknetApiResult::Ok(block)
+                } else {
+                    StarknetApiResult::Ok(None)
                 }
             })
             .await??;
@@ -701,11 +692,9 @@ where
                         .build_with_receipts()?
                         .map(GetBlockWithReceiptsResponse::Block);
 
-                            StarknetApiResult::Ok(block)
-                        } else {
-                            StarknetApiResult::Ok(None)
-                        }
-                    }
+                    StarknetApiResult::Ok(block)
+                } else {
+                    StarknetApiResult::Ok(None)
                 }
             })
             .await??;
@@ -740,11 +729,9 @@ where
                         .build_with_tx_hash()?
                         .map(GetBlockWithTxHashesResponse::Block);
 
-                            StarknetApiResult::Ok(block)
-                        } else {
-                            StarknetApiResult::Ok(None)
-                        }
-                    }
+                    StarknetApiResult::Ok(block)
+                } else {
+                    StarknetApiResult::Ok(None)
                 }
             })
             .await??;

crates/rpc/rpc/src/starknet/mod.rs

@@ -156,8 +156,8 @@ where
             Ok(pending_trace)
         } else {
             // If not found in pending block, fallback to the provider
-            let provider = self.inner.backend.blockchain.provider();
-            let trace = provider.transaction_execution(tx_hash)?.ok_or(TxnHashNotFound)?;
+            let trace =
+                self.inner.storage.transaction_execution(tx_hash)?.ok_or(TxnHashNotFound)?;
             Ok(TxTrace::from(trace))
         }
     }