wip

Author: kariy

crates/cli/src/full.rs

@@ -2,10 +2,11 @@ use std::path::PathBuf;
 
 use anyhow::{Context, Result};
 pub use clap::Parser;
+use katana_node::config::db::DbConfig;
 use katana_node::config::metrics::MetricsConfig;
 use katana_node::config::rpc::RpcConfig;
 use katana_node::full;
-use katana_node::{config::db::DbConfig, full::Network};
+use katana_node::full::Network;
 use serde::{Deserialize, Serialize};
 use tracing::info;
 

crates/gateway/src/server/handlers.rs

@@ -1,7 +1,6 @@
 use axum::extract::{Query, State};
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Json, Response};
-use katana_executor::implementation::blockifier::BlockifierFactory;
 use katana_pool_api::TransactionPool;
 use katana_primitives::block::{BlockHash, BlockIdOrTag, BlockNumber};
 use katana_primitives::class::{ClassHash, CompiledClass, ContractClassCompilationError};

crates/gateway/src/server/mod.rs

@@ -4,7 +4,6 @@ use std::time::Duration;
 
 use axum::routing::get;
 use axum::Router;
-use katana_executor::implementation::blockifier::BlockifierFactory;
 use katana_pool_api::TransactionPool;
 use katana_rpc::cors::Cors;
 use katana_rpc::starknet::StarknetApi;

crates/node/src/full/mod.rs

@@ -1,6 +1,7 @@
 //! Experimental full node implementation.
 
 mod exit;
+mod pending;
 mod pool;
 mod tip_watcher;
 

crates/node/src/full/pending.rs

@@ -0,0 +1,101 @@
+use katana_gateway::types::{ErrorCode, GatewayError};
+use katana_primitives::block::BlockNumber;
+use katana_primitives::class::{ClassHash, CompiledClassHash, ContractClass};
+use katana_primitives::contract::{ContractAddress, Nonce, StorageKey, StorageValue};
+use katana_primitives::state::StateUpdates;
+use katana_primitives::Felt;
+use katana_provider::api::contract::ContractClassProvider;
+use katana_provider::api::state::{StateProofProvider, StateProvider, StateRootProvider};
+use katana_provider::{ProviderError, ProviderResult};
+use katana_trie::MultiProof;
+use tokio::runtime;
+
+pub struct PendingStateProvider {
+    base: Box<dyn StateProvider>,
+    pending_block_id: BlockNumber,
+    pending_state_updates: StateUpdates,
+    gateway: katana_gateway::client::Client,
+}
+
+impl StateProvider for PendingStateProvider {
+    fn nonce(&self, address: ContractAddress) -> ProviderResult<Option<Nonce>> {
+        if let Some(nonce) = self.pending_state_updates.nonce_updates.get(&address) {
+            return Ok(Some(*nonce));
+        }
+
+        self.base.nonce(address)
+    }
+
+    fn storage(
+        &self,
+        address: ContractAddress,
+        storage_key: StorageKey,
+    ) -> ProviderResult<Option<StorageValue>> {
+        if let Some(contract_storage) = self.pending_state_updates.storage_updates.get(&address) {
+            if let Some(value) = contract_storage.get(&storage_key) {
+                return Ok(Some(*value));
+            }
+        }
+
+        self.base.storage(address, storage_key)
+    }
+
+    fn class_hash_of_contract(
+        &self,
+        address: ContractAddress,
+    ) -> ProviderResult<Option<ClassHash>> {
+        if let Some(class_hash) = self.pending_state_updates.replaced_classes.get(&address) {
+            return Ok(Some(*class_hash));
+        }
+
+        if let Some(class_hash) = self.pending_state_updates.deployed_contracts.get(&address) {
+            return Ok(Some(*class_hash));
+        }
+
+        self.base.class_hash_of_contract(address)
+    }
+}
+
+impl ContractClassProvider for PendingStateProvider {
+    fn class(&self, hash: ClassHash) -> ProviderResult<Option<ContractClass>> {
+        if let Some(class) = self.base.class(hash)? {
+            return Ok(Some(class));
+        }
+
+        let result = runtime::Builder::new_current_thread()
+            .build()
+            .unwrap()
+            .block_on(self.gateway.get_class(hash, block_id));
+
+        match result {
+            Ok(class) => {
+                let class = class.try_into().map_err(|e| ProviderError::Other(e.to_string()))?;
+                Ok(Some(class))
+            }
+
+            Err(error) => {
+                if let katana_gateway::client::Error::Sequencer(GatewayError {
+                    code: ErrorCode::UndeclaredClass,
+                    ..
+                }) = error
+                {
+                    Ok(None)
+                } else {
+                    Err(ProviderError::Other(error.to_string()))
+                }
+            }
+        }
+    }
+
+    fn compiled_class_hash_of_class_hash(
+        &self,
+        hash: ClassHash,
+    ) -> ProviderResult<Option<CompiledClassHash>> {
+        if let Some(compiled_hash) = self.pending_state_updates.declared_classes.get(&hash) {
+            return Ok(Some(*compiled_hash));
+        }
+
+        // Fallback to the base provider
+        self.base.compiled_class_hash_of_class_hash(hash)
+    }
+}

crates/pool/pool-api/src/lib.rs

@@ -30,7 +30,7 @@ pub enum PoolError {
 pub type PoolResult<T> = Result<T, PoolError>;
 
 /// Represents a complete transaction pool.
-pub trait TransactionPool: Send + Sync + 'static {
+pub trait TransactionPool: Send + Sync {
     /// The pool's transaction type.
     type Transaction: PoolTransaction;
 

crates/rpc/rpc/src/starknet/blockifier.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use katana_chain_spec::ChainSpec;
+use katana_executor::implementation::blockifier::blockifier::context::BlockContext;
 use katana_executor::implementation::blockifier::cache::ClassCache;
 use katana_executor::implementation::blockifier::call::execute_call;
 use katana_executor::implementation::blockifier::state::CachedState;
@@ -15,6 +16,12 @@ use katana_rpc_types::{FeeEstimate, FunctionCall};
 
 use crate::starknet::StarknetApiResult;
 
+pub struct ExecutionCtx {
+    state: Box<dyn StateProvider>,
+    block_context: Arc<BlockContext>,
+    simulation_flags: ExecutionFlags,
+}
+
 #[tracing::instrument(level = "trace", target = "rpc", skip_all, fields(total_txs = transactions.len()))]
 pub fn simulate(
     chain_spec: &ChainSpec,

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

@@ -90,7 +90,10 @@ struct StarknetApiInner<P: TransactionPool> {
     config: StarknetApiConfig,
 }
 
-impl<P: TransactionPool> StarknetApi<P> {
+impl<P> StarknetApi<P>
+where
+    P: TransactionPool + 'static,
+{
     pub fn pool(&self) -> &P {
         &self.inner.pool
     }
@@ -112,7 +115,10 @@ impl<P: TransactionPool> StarknetApi<P> {
     }
 }
 
-impl<P: TransactionPool> StarknetApi<P> {
+impl<P> StarknetApi<P>
+where
+    P: TransactionPool + 'static,
+{
     pub fn new(
         chain_spec: Arc<ChainSpec>,
         storage: BlockchainProvider<Box<dyn Database>>,
@@ -1026,7 +1032,10 @@ impl<P: TransactionPool> StarknetApi<P> {
 // `StarknetApiExt` Implementations
 /////////////////////////////////////////////////////
 
-impl<P: TransactionPool> StarknetApi<P> {
+impl<P> StarknetApi<P>
+where
+    P: TransactionPool + 'static,
+{
     async fn blocks(&self, request: GetBlocksRequest) -> StarknetApiResult<GetBlocksResponse> {
         self.on_io_blocking_task(move |this| {
             let provider = &this.inner.storage;

crates/rpc/rpc/src/starknet/read.rs

@@ -40,7 +40,7 @@ use crate::cartridge;
 #[async_trait]
 impl<P> StarknetApiServer for StarknetApi<P>
 where
-    P: TransactionPool + Send + Sync + 'static,
+    P: TransactionPool + 'static,
 {
     async fn chain_id(&self) -> RpcResult<Felt> {
         Ok(self.inner.chain_spec.id().id())

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

@@ -13,9 +13,7 @@ pub trait PendingBlockProvider: Send + Sync {
 
     fn block_env(&self) -> ProviderResult<Option<BlockEnv>>;
 
-    fn transaction(&self, hash: TxHash) -> ProviderResult<Option<TxWithHash>>;
-
-    fn receipt(&self, hash: TxHash) -> ProviderResult<Option<Receipt>>;
+    fn transactions(&self) -> ProviderResult<Vec<(TxWithHash, Option<Receipt>)>>;
 
     fn state_update(&self) -> ProviderResult<Option<StateUpdates>>;
 }