wip

kariy · kariy · commit e35b307520e5 · 2026-02-23T10:23:29.000-06:00
diff --git a/crates/gateway/gateway-server/src/lib.rs b/crates/gateway/gateway-server/src/lib.rs
@@ -7,7 +7,7 @@ use axum::Router;
 use katana_core::service::block_producer::BlockProducer;
 use katana_pool_api::TransactionPool;
 use katana_provider::{ProviderFactory, ProviderRO, ProviderRW};
-use katana_rpc_server::cors::Cors;
+use katana_rpc_server::middleware::cors::Cors;
 use katana_rpc_server::starknet::StarknetApi;
 use tokio::net::TcpListener;
 use tokio::sync::watch;
diff --git a/crates/grpc/src/handlers/starknet.rs b/crates/grpc/src/handlers/starknet.rs
@@ -1,6 +1,6 @@
 //! Starknet service handler implementation.
 
-use katana_pool::TransactionPool;
+use katana_pool::api::TransactionPool;
 use katana_primitives::transaction::TxHash;
 use katana_primitives::Felt;
 use katana_provider::{ProviderFactory, ProviderRO};
diff --git a/crates/node/full/src/lib.rs b/crates/node/full/src/lib.rs
@@ -26,7 +26,7 @@ use katana_pool::ordering::TipOrdering;
 use katana_provider::DbProviderFactory;
 use katana_rpc_api::katana::KatanaApiServer;
 use katana_rpc_api::starknet::{StarknetApiServer, StarknetTraceApiServer, StarknetWriteApiServer};
-use katana_rpc_server::cors::Cors;
+use katana_rpc_server::middleware::cors::Cors;
 use katana_rpc_server::starknet::{StarknetApi, StarknetApiConfig};
 use katana_rpc_server::{RpcServer, RpcServerHandle};
 use katana_stage::blocks::BatchBlockDownloader;
diff --git a/crates/node/sequencer/src/lib.rs b/crates/node/sequencer/src/lib.rs
@@ -238,11 +238,15 @@ where
 
         let mut rpc_modules = RpcModule::new(());
 
-        let cors = Cors::new()
-        .allow_origins(config.rpc.cors_origins.clone())
         // Allow `POST` when accessing the resource
-        .allow_methods([Method::POST, Method::GET])
-        .allow_headers([CONTENT_TYPE, "argent-client".parse().unwrap(), "argent-version".parse().unwrap()]);
+        let cors = Cors::new()
+            .allow_origins(config.rpc.cors_origins.clone())
+            .allow_methods([Method::POST, Method::GET])
+            .allow_headers([
+                CONTENT_TYPE,
+                "argent-client".parse().unwrap(),
+                "argent-version".parse().unwrap(),
+            ]);
 
         #[cfg(feature = "paymaster")]
         if let Some(cfg) = &config.paymaster {
@@ -251,8 +255,12 @@ where
         };
 
         #[cfg(feature = "cartridge")]
-        if let Some(cfg) = &config.paymaster {
+        let controller_deployment_layer = if let Some(cfg) = &config.paymaster {
             if let Some(cartridge_api_cfg) = &cfg.cartridge_api {
+                use katana_rpc_client::HttpClient;
+                use katana_rpc_server::cartridge::VrfService;
+                use katana_rpc_server::middleware::cartridge::ControllerDeploymentLayer;
+
                 anyhow::ensure!(
                     config.rpc.apis.contains(&RpcModuleKind::Cartridge),
                     "Cartridge API should be enabled when paymaster is set"
@@ -274,6 +282,9 @@ where
                     None
                 };
 
+                let cartridge_api_client =
+                    cartridge::CartridgeApiClient::new(cartridge_api_cfg.cartridge_api_url.clone());
+
                 let cartridge_api_config = CartridgeConfig {
                     paymaster_url: cfg.url.clone(),
                     paymaster_api_key: cfg.api_key.clone(),
@@ -282,7 +293,7 @@ where
                     controller_deployer_private_key: cartridge_api_cfg
                         .controller_deployer_private_key,
                     #[cfg(feature = "vrf")]
-                    vrf,
+                    vrf: vrf.clone(),
                 };
 
                 let cartrige_api = CartridgeApi::new(
@@ -295,11 +306,16 @@ where
 
                 rpc_modules.merge(CartridgeApiServer::into_rpc(cartrige_api))?;
 
-                Some(CartridgePaymasterConfig {
-                    cartridge_api_url: cartridge_api_cfg.cartridge_api_url.clone(),
-                    paymaster_address: cartridge_api_cfg.controller_deployer_address,
-                    paymaster_private_key: cartridge_api_cfg.controller_deployer_private_key,
-                })
+                Some(ControllerDeploymentLayer::new(
+                    starknet_api.clone(),
+                    cartridge_api_client,
+                    HttpClient::builder().build(cfg.url)?,
+                    cartridge_api_cfg.controller_deployer_address,
+                    SigningKey::from_secret_scalar(
+                        cartridge_api_cfg.controller_deployer_private_key,
+                    ),
+                    vrf.map(VrfService::new),
+                ))
             } else {
                 None
             }
@@ -381,54 +397,14 @@ where
             }
         }
 
-        // --- build paymaster tower layer (if configured)
-
-        #[cfg(feature = "cartridge")]
-        let paymaster = if let Some(cfg) = &config.paymaster {
-            if let Some(cartridge_api_cfg) = &cfg.cartridge_api {
-                if let Some(vrf_cfg) = &cartridge_api_cfg.vrf {
-                    info!(target: "cartridge", "Paymaster tower layer enabled");
-
-                    let cartridge_api_client = cartridge::CartridgeApiClient::new(
-                        cartridge_api_cfg.cartridge_api_url.clone(),
-                    );
-
-                    let rpc_url = url::Url::parse(&format!("http://{}", config.rpc.socket_addr()))
-                        .expect("valid rpc url");
-
-                    let vrf_client = cartridge::VrfClient::new(vrf_cfg.url.clone());
-
-                    Some(Paymaster::new(
-                        provider.clone(),
-                        cartridge_api_client,
-                        pool.clone(),
-                        config.chain.id(),
-                        cartridge_api_cfg.controller_deployer_address,
-                        SigningKey::from_secret_scalar(
-                            cartridge_api_cfg.controller_deployer_private_key,
-                        ),
-                        vrf_client,
-                        vrf_cfg.vrf_account,
-                        rpc_url,
-                    ))
-                } else {
-                    None
-                }
-            } else {
-                None
-            }
-        } else {
-            None
-        };
-
         // --- build rpc middleware
 
         let rpc_middleware = RpcServiceBuilder::new()
             .layer(RpcServerMetricsLayer::new(&rpc_modules))
             .layer(RpcLoggerLayer::new());
 
         #[cfg(feature = "cartridge")]
-        let rpc_middleware = rpc_middleware.option_layer(paymaster.map(|p| p.layer()));
+        let rpc_middleware = rpc_middleware.option_layer(controller_deployment_layer);
 
         #[allow(unused_mut)]
         let mut rpc_server = RpcServer::new()
diff --git a/crates/rpc/rpc-server/src/cartridge/mod.rs b/crates/rpc/rpc-server/src/cartridge/mod.rs
@@ -36,7 +36,7 @@ use http::{HeaderMap, HeaderName, HeaderValue};
 use jsonrpsee::core::{async_trait, RpcResult};
 use jsonrpsee::http_client::{HttpClient, HttpClientBuilder};
 use katana_core::backend::Backend;
-use katana_core::service::block_producer::{BlockProducer, BlockProducerMode};
+use katana_core::service::block_producer::BlockProducer;
 use katana_genesis::constant::{DEFAULT_STRK_FEE_TOKEN_ADDRESS, DEFAULT_UDC_ADDRESS};
 use katana_pool::api::TransactionPool;
 use katana_pool::TxPool;
@@ -161,20 +161,6 @@ where
         })
     }
 
-    fn nonce(&self, address: ContractAddress) -> Result<Option<Nonce>, CartridgeApiError> {
-        match self.pool.get_nonce(address) {
-            pending_nonce @ Some(..) => Ok(pending_nonce),
-            None => Ok(self.state()?.nonce(address)?),
-        }
-    }
-
-    fn state(&self) -> Result<Box<dyn StateProvider>, CartridgeApiError> {
-        match &*self.block_producer.producer.read() {
-            BlockProducerMode::Instant(_) => Ok(self.backend.storage.provider().latest()?),
-            BlockProducerMode::Interval(producer) => Ok(producer.executor().read().state()),
-        }
-    }
-
     pub async fn execute_outside(
         &self,
         contract_address: ContractAddress,
@@ -261,6 +247,7 @@ where
     where
         T: FnOnce(Self) -> F,
         F: Future + Send + 'static,
+        F::Output: Send + 'static,
     {
         use tokio::runtime::Builder;
 
diff --git a/crates/rpc/rpc-server/src/middleware/cartridge.rs b/crates/rpc/rpc-server/src/middleware/cartridge.rs
@@ -1,5 +1,4 @@
 use std::borrow::Cow;
-use std::collections::HashSet;
 use std::future::Future;
 
 use cartridge::vrf::VrfClientError;
@@ -27,6 +26,7 @@ use starknet::core::types::SimulationFlagForEstimateFee;
 use starknet::macros::selector;
 use starknet::signers::local_wallet::SignError;
 use starknet::signers::{LocalWallet, Signer, SigningKey};
+use tower::Layer;
 use tracing::{debug, trace};
 
 use crate::cartridge::{encode_calls, VrfService};
@@ -37,9 +37,10 @@ const CARTRIDGE_ADD_EXECUTE_FROM_OUTSIDE: &str = "cartridge_addExecuteFromOutsid
 const CARTRIDGE_ADD_EXECUTE_FROM_OUTSIDE_TX: &str = "cartridge_addExecuteOutsideTransaction";
 
 #[derive(Debug)]
-pub struct ControllerDeploymentLayer<Pool, PP, PF>
+pub struct ControllerDeploymentLayer<Pool, PoolTx, PP, PF>
 where
-    Pool: TransactionPool + 'static,
+    Pool: TransactionPool<Transaction = PoolTx> + 'static,
+    PoolTx: From<BroadcastedTxWithChainId>,
     PP: PendingBlockProvider,
     PF: ProviderFactory,
     <PF as ProviderFactory>::Provider: ProviderRO,
@@ -52,6 +53,56 @@ where
     vrf_service: Option<VrfService>,
 }
 
+impl<Pool, PoolTx, PP, PF> ControllerDeploymentLayer<Pool, PoolTx, PP, PF>
+where
+    Pool: TransactionPool<Transaction = PoolTx> + 'static,
+    PoolTx: From<BroadcastedTxWithChainId>,
+    PP: PendingBlockProvider,
+    PF: ProviderFactory,
+    <PF as ProviderFactory>::Provider: ProviderRO,
+{
+    pub fn new(
+        starknet: StarknetApi<Pool, PP, PF>,
+        cartridge_api: CartridgeApiClient,
+        paymaster_client: HttpClient,
+        deployer_address: ContractAddress,
+        deployer_private_key: SigningKey,
+        vrf_service: Option<VrfService>,
+    ) -> Self {
+        Self {
+            starknet,
+            cartridge_api,
+            paymaster_client,
+            deployer_address,
+            deployer_private_key,
+            vrf_service,
+        }
+    }
+}
+
+impl<S, Pool, PoolTx, PP, PF> Layer<S> for ControllerDeploymentLayer<Pool, PoolTx, PP, PF>
+where
+    Pool: TransactionPool<Transaction = PoolTx> + 'static,
+    PoolTx: From<BroadcastedTxWithChainId>,
+    PP: PendingBlockProvider,
+    PF: ProviderFactory,
+    <PF as ProviderFactory>::Provider: ProviderRO,
+{
+    type Service = ControllerDeploymentService<S, Pool, PP, PF>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        ControllerDeploymentService {
+            service: inner,
+            starknet: self.starknet.clone(),
+            cartridge_api: self.cartridge_api.clone(),
+            paymaster_client: self.paymaster_client.clone(),
+            vrf_service: self.vrf_service.clone(),
+            deployer_address: self.deployer_address,
+            deployer_private_key: self.deployer_private_key.clone(),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ControllerDeploymentService<S, Pool, PP, PF>
 where
@@ -89,7 +140,7 @@ where
         request: Request<'a>,
     ) -> S::MethodResponse {
         let request_id = request.id().clone();
-        match self.handle_estimate_fee_inner(params, request).await {
+        match self.starknet_estimate_fee_inner(params, request).await {
             Ok(response) => response,
             Err(err) => MethodResponse::error(request_id, ErrorObjectOwned::from(err)),
         }
@@ -100,14 +151,14 @@ where
         params: AddExecuteOutsideParams,
         request: Request<'a>,
     ) -> S::MethodResponse {
-        if let Err(err) = self.handle_execute_outside_inner(params).await {
+        if let Err(err) = self.cartridge_add_execute_from_outside_inner(params).await {
             MethodResponse::error(request.id().clone(), ErrorObjectOwned::from(err))
         } else {
             self.service.call(request).await
         }
     }
 
-    async fn handle_estimate_fee_inner<'a>(
+    async fn starknet_estimate_fee_inner<'a>(
         &self,
         params: EstimateFeeParams,
         request: Request<'a>,
@@ -169,7 +220,7 @@ where
         }
     }
 
-    async fn handle_execute_outside_inner(
+    async fn cartridge_add_execute_from_outside_inner(
         &self,
         params: AddExecuteOutsideParams,
     ) -> Result<(), CartridgeApiError> {
@@ -180,6 +231,7 @@ where
         let is_deployed = match self.starknet.class_hash_at_address(block_id, address).await {
             Ok(..) => true,
             Err(StarknetApiError::ContractNotFound) => false,
+
             Err(e) => {
                 return Err(CartridgeApiError::ControllerDeployment {
                     reason: format!("failed to check Controller deployment status: {e}"),
