working version of rpc server integration

Author: kariy

Cargo.lock

@@ -63,8 +63,7 @@ use clap::builder::NonEmptyStringValueParser;
 use clap::{Args, Subcommand};
 use deployment::DeploymentOutcome;
 use katana_chain_spec::rollup::ChainConfigDir;
-use katana_chain_spec::FeeContracts;
-use katana_chain_spec::{rollup, SettlementLayer};
+use katana_chain_spec::{rollup, FeeContracts, SettlementLayer};
 use katana_genesis::allocation::DevAllocationsGenerator;
 use katana_genesis::constant::DEFAULT_PREFUNDED_ACCOUNT_BALANCE;
 use katana_genesis::Genesis;
@@ -249,7 +248,13 @@ impl RollupArgs {
         // At the moment, the fee token is limited to a predefined token.
         let fee_contracts = FeeContracts::default();
         let versioned_constants_overrides = None;
-        let chain_spec = rollup::ChainSpec { id, genesis, settlement, fee_contracts, versioned_constants_overrides };
+        let chain_spec = rollup::ChainSpec {
+            id,
+            genesis,
+            settlement,
+            fee_contracts,
+            versioned_constants_overrides,
+        };
 
         if let Some(path) = self.output_path {
             let dir = ChainConfigDir::create(path)?;
@@ -388,7 +393,13 @@ impl SovereignArgs {
         // At the moment, the fee token is limited to a predefined token.
         let fee_contracts = FeeContracts::default();
         let versioned_constants_overrides = None;
-        let chain_spec = rollup::ChainSpec { id, genesis, settlement, fee_contracts, versioned_constants_overrides };
+        let chain_spec = rollup::ChainSpec {
+            id,
+            genesis,
+            settlement,
+            fee_contracts,
+            versioned_constants_overrides,
+        };
 
         if let Some(path) = self.output_path {
             let dir = ChainConfigDir::create(path)?;

bin/katana/src/cli/init/mod.rs

@@ -10,6 +10,7 @@ katana-executor.workspace = true
 katana-metrics.workspace = true
 katana-primitives.workspace = true
 katana-rpc.workspace = true
+katana-pool-api.workspace = true
 katana-rpc-api.workspace = true
 katana-provider-api.workspace = true
 katana-rpc-types.workspace = true

crates/gateway/Cargo.toml

@@ -2,6 +2,7 @@ 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};
 use katana_provider_api::block::{BlockIdReader, BlockProvider, BlockStatusProvider};
@@ -19,11 +20,14 @@ use crate::types::{
 
 /// Shared application state containing the backend
 #[derive(Clone)]
-pub struct AppState {
-    pub api: StarknetApi,
+pub struct AppState<P: TransactionPool> {
+    pub api: StarknetApi<P>,
 }
 
-impl AppState {
+impl<P> AppState<P>
+where
+    P: TransactionPool + Send + Sync + 'static,
+{
     // TODO(kariy): support preconfirmed blocks
     async fn get_block(&self, id: BlockIdOrTag) -> Result<Option<Block>, ApiError> {
         self.api
@@ -153,10 +157,13 @@ pub async fn health() -> Json<serde_json::Value> {
 /// Handler for `/feeder_gateway/get_block` endpoint
 ///
 /// Returns block information for the specified block.
-pub async fn get_block(
-    State(state): State<AppState>,
+pub async fn get_block<P>(
+    State(state): State<AppState<P>>,
     Query(params): Query<BlockIdQuery>,
-) -> Result<Json<Block>, ApiError> {
+) -> Result<Json<Block>, ApiError>
+where
+    P: TransactionPool + Send + Sync + 'static,
+{
     let block_id = params.block_id()?;
     let block = state.get_block(block_id).await?.unwrap();
     Ok(Json(block))
@@ -174,10 +181,13 @@ pub enum GetStateUpdateResponse {
 /// Handler for `/feeder_gateway/get_state_update` endpoint
 ///
 /// Returns state update information for the specified block.
-pub async fn get_state_update(
-    State(state): State<AppState>,
+pub async fn get_state_update<P>(
+    State(state): State<AppState<P>>,
     Query(params): Query<StateUpdateQuery>,
-) -> Result<Json<GetStateUpdateResponse>, ApiError> {
+) -> Result<Json<GetStateUpdateResponse>, ApiError>
+where
+    P: TransactionPool + Send + Sync + 'static,
+{
     let include_block = params.include_block;
     let block_id = params.block_query.block_id()?;
 
@@ -196,10 +206,13 @@ pub async fn get_state_update(
 /// Handler for `/feeder_gateway/get_class_by_hash` endpoint
 ///
 /// Returns the contract class definition for a given class hash.
-pub async fn get_class_by_hash(
-    State(state): State<AppState>,
+pub async fn get_class_by_hash<P>(
+    State(state): State<AppState<P>>,
     Query(params): Query<ClassQuery>,
-) -> Result<Json<ContractClass>, ApiError> {
+) -> Result<Json<ContractClass>, ApiError>
+where
+    P: TransactionPool + Send + Sync + 'static,
+{
     let class_hash = params.class_hash;
     let block_id = params.block_query.block_id()?;
     let class = state.api.class_at_hash(block_id, class_hash).await?;
@@ -209,10 +222,13 @@ pub async fn get_class_by_hash(
 /// Handler for `/feeder_gateway/get_compiled_class_by_class_hash` endpoint
 ///
 /// Returns the compiled (CASM) contract class for a given class hash.
-pub async fn get_compiled_class_by_class_hash(
-    State(state): State<AppState>,
+pub async fn get_compiled_class_by_class_hash<P>(
+    State(state): State<AppState<P>>,
     Query(params): Query<ClassQuery>,
-) -> Result<Json<CompiledClass>, ApiError> {
+) -> Result<Json<CompiledClass>, ApiError>
+where
+    P: TransactionPool + Send + Sync + 'static,
+{
     let class_hash = params.class_hash;
     let block_id = params.block_query.block_id()?;
 

crates/gateway/src/server/handlers.rs

@@ -5,6 +5,7 @@ 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;
 use tokio::net::TcpListener;
@@ -68,18 +69,21 @@ impl GatewayServerHandle {
 
 /// The feeder gateway server.
 #[derive(Debug)]
-pub struct GatewayServer {
+pub struct GatewayServer<P: TransactionPool> {
     timeout: Duration,
     cors: Option<Cors>,
     health_check: bool,
     metered: bool,
 
-    starknet_api: StarknetApi,
+    starknet_api: StarknetApi<P>,
 }
 
-impl GatewayServer {
+impl<P> GatewayServer<P>
+where
+    P: TransactionPool + Clone + Send + Sync + 'static,
+{
     /// Create a new feeder gateway server.
-    pub fn new(starknet_api: StarknetApi) -> Self {
+    pub fn new(starknet_api: StarknetApi<P>) -> Self {
         Self {
             timeout: DEFAULT_GATEWAY_TIMEOUT,
             cors: None,

crates/gateway/src/server/mod.rs

@@ -12,6 +12,8 @@ use exit::NodeStoppedFuture;
 use http::header::CONTENT_TYPE;
 use http::Method;
 use jsonrpsee::RpcModule;
+use katana_chain_spec::ChainSpec;
+use katana_core::backend::storage::Database;
 use katana_executor::ExecutionFlags;
 use katana_gateway::client::Client as SequencerGateway;
 use katana_metrics::exporters::prometheus::PrometheusRecorder;
@@ -23,12 +25,13 @@ use katana_pool::validation::NoopValidator;
 use katana_pool::TxPool;
 use katana_primitives::transaction::ExecutableTxWithHash;
 use katana_provider::providers::db::DbProvider;
+use katana_provider::BlockchainProvider;
 use katana_rpc::cors::Cors;
 use katana_rpc::starknet::{StarknetApi, StarknetApiConfig};
 use katana_rpc::{RpcServer, RpcServerHandle};
 use katana_rpc_api::starknet::{StarknetApiServer, StarknetTraceApiServer, StarknetWriteApiServer};
 use katana_stage::blocks::BatchBlockDownloader;
-use katana_stage::{Blocks, Classes};
+use katana_stage::{Blocks, Classes, StateTrie};
 use katana_tasks::TaskManager;
 use tip_watcher::ChainTipWatcher;
 use tracing::info;
@@ -98,6 +101,7 @@ impl Node {
         let block_downloader = BatchBlockDownloader::new_gateway(gateway_client.clone(), 3);
         pipeline.add_stage(Blocks::new(provider.clone(), block_downloader));
         pipeline.add_stage(Classes::new(provider.clone(), gateway_client.clone(), 3));
+        pipeline.add_stage(StateTrie::new(provider.clone()));
 
         // --- build rpc server
 
@@ -121,11 +125,9 @@ impl Node {
             paymaster: None,
         };
 
-        let chain_spec = config.chain_spec.clone();
-
         let starknet_api = StarknetApi::new(
-            chain_spec.clone(),
-            provider.clone(),
+            Arc::new(ChainSpec::dev()),
+            BlockchainProvider::new(Box::new(provider.clone())),
             pool.clone(),
             task_spawner.clone(),
             starknet_api_cfg,

crates/node/src/full/mod.rs

@@ -66,7 +66,7 @@ pub struct Node {
     task_manager: TaskManager,
     backend: Arc<Backend<BlockifierFactory>>,
     block_producer: BlockProducer<BlockifierFactory>,
-    gateway_server: Option<GatewayServer>,
+    gateway_server: Option<GatewayServer<TxPool>>,
 }
 
 impl Node {

crates/node/src/lib.rs

@@ -26,9 +26,11 @@ where
 
             let tx = tx.into_inner(this.inner.chain_spec.id());
             let tx = ExecutableTxWithHash::new(ExecutableTx::Invoke(tx));
-            let transaction_hash = this.inner.pool.add_transaction(tx).await?;
+            // let transaction_hash = this.inner.pool.add_transaction(tx).await?;
 
-            Ok(AddInvokeTransactionResponse { transaction_hash })
+            // Ok(AddInvokeTransactionResponse { transaction_hash })
+
+            todo!()
         })
         .await?
     }
@@ -48,9 +50,10 @@ where
 
             let class_hash = tx.class_hash();
             let tx = ExecutableTxWithHash::new(ExecutableTx::Declare(tx));
-            let transaction_hash = this.inner.pool.add_transaction(tx).await?;
+            // let transaction_hash = this.inner.pool.add_transaction(tx).await?;
 
-            Ok(AddDeclareTransactionResponse { transaction_hash, class_hash })
+            // Ok(AddDeclareTransactionResponse { transaction_hash, class_hash })
+            todo!()
         })
         .await?
     }
@@ -68,9 +71,10 @@ where
             let contract_address = tx.contract_address();
 
             let tx = ExecutableTxWithHash::new(ExecutableTx::DeployAccount(tx));
-            let transaction_hash = this.inner.pool.add_transaction(tx).await?;
+            // let transaction_hash = this.inner.pool.add_transaction(tx).await?;
 
-            Ok(AddDeployAccountTransactionResponse { transaction_hash, contract_address })
+            // Ok(AddDeployAccountTransactionResponse { transaction_hash, contract_address })
+            todo!()
         })
         .await?
     }