wip

Author: kariy

crates/node/sequencer/src/lib.rs

@@ -7,8 +7,6 @@ use std::future::IntoFuture;
 use std::sync::Arc;
 
 use anyhow::{bail, Context, Result};
-#[cfg(feature = "cartridge")]
-use cartridge::rpc::{layer::PaymasterLayer, Paymaster};
 use config::rpc::RpcModuleKind;
 use config::Config;
 use http::header::CONTENT_TYPE;
@@ -52,10 +50,12 @@ use katana_rpc_api::tee::TeeApiServer;
 use katana_rpc_client::starknet::Client as StarknetClient;
 #[cfg(feature = "cartridge")]
 use katana_rpc_server::cartridge::{CartridgeApi, CartridgeConfig};
-use katana_rpc_server::cors::Cors;
 use katana_rpc_server::dev::DevApi;
-use katana_rpc_server::logger::RpcLoggerLayer;
-use katana_rpc_server::metrics::RpcServerMetricsLayer;
+#[cfg(feature = "cartridge")]
+use katana_rpc_server::middleware::cartridge::ControllerDeploymentLayer;
+use katana_rpc_server::middleware::cors::Cors;
+use katana_rpc_server::middleware::logger::RpcLoggerLayer;
+use katana_rpc_server::middleware::metrics::RpcServerMetricsLayer;
 #[cfg(feature = "paymaster")]
 use katana_rpc_server::paymaster::PaymasterProxy;
 use katana_rpc_server::starknet::{StarknetApi, StarknetApiConfig};
@@ -75,16 +75,16 @@ use crate::exit::NodeStoppedFuture;
 
 /// The concrete type of the RPC middleware stack used by the node.
 #[cfg(feature = "cartridge")]
-type NodeRpcMiddleware<P> = Stack<
-    Either<PaymasterLayer<P>, Identity>,
+type NodeRpcMiddleware<Pool, PP, PF> = Stack<
+    Either<ControllerDeploymentLayer<Pool, PP, PF>, Identity>,
     Stack<RpcLoggerLayer, Stack<RpcServerMetricsLayer, Identity>>,
 >;
 
 #[cfg(not(feature = "cartridge"))]
 type NodeRpcMiddleware = Stack<RpcLoggerLayer, Stack<RpcServerMetricsLayer, Identity>>;
 
 #[cfg(feature = "cartridge")]
-pub type NodeRpcServer<P> = RpcServer<NodeRpcMiddleware<P>>;
+pub type NodeRpcServer<Pool, PP, PF> = RpcServer<NodeRpcMiddleware<Pool, PP, PF>>;
 
 #[cfg(not(feature = "cartridge"))]
 pub type NodeRpcServer = RpcServer<NodeRpcMiddleware>;
@@ -254,14 +254,60 @@ where
             rpc_modules.merge(proxy.into_rpc())?;
         };
 
+        // --- build starknet api
+
+        let starknet_api_cfg = StarknetApiConfig {
+            max_event_page_size: config.rpc.max_event_page_size,
+            max_proof_keys: config.rpc.max_proof_keys,
+            max_call_gas: config.rpc.max_call_gas,
+            max_concurrent_estimate_fee_requests: config.rpc.max_concurrent_estimate_fee_requests,
+            simulation_flags: execution_flags,
+            versioned_constant_overrides,
+        };
+
+        let chain_spec = backend.chain_spec.clone();
+
+        let starknet_api = StarknetApi::new(
+            chain_spec.clone(),
+            pool.clone(),
+            task_spawner.clone(),
+            block_producer.clone(),
+            gas_oracle.clone(),
+            starknet_api_cfg,
+            provider.clone(),
+        );
+
+        if config.rpc.apis.contains(&RpcModuleKind::Starknet) {
+            #[cfg(feature = "explorer")]
+            if config.rpc.explorer {
+                rpc_modules.merge(StarknetApiExtServer::into_rpc(starknet_api.clone()))?;
+            }
+
+            rpc_modules.merge(StarknetApiServer::into_rpc(starknet_api.clone()))?;
+            rpc_modules.merge(StarknetWriteApiServer::into_rpc(starknet_api.clone()))?;
+            rpc_modules.merge(StarknetTraceApiServer::into_rpc(starknet_api.clone()))?;
+        }
+
+        if config.rpc.apis.contains(&RpcModuleKind::Starknet) {
+            rpc_modules.merge(KatanaApiServer::into_rpc(starknet_api.clone()))?;
+        }
+
+        if config.rpc.apis.contains(&RpcModuleKind::Dev) {
+            let api = DevApi::new(backend.clone(), block_producer.clone());
+            rpc_modules.merge(DevApiServer::into_rpc(api))?;
+        }
+
+        // --- build cartridge api (plus middleware)
+
         #[cfg(feature = "cartridge")]
         let controller_deployment_layer = if let Some(cfg) = &config.paymaster {
             if let Some(cartridge_api_cfg) = &cfg.cartridge_api {
+                use anyhow::ensure;
                 use katana_rpc_client::HttpClient;
                 use katana_rpc_server::cartridge::VrfService;
                 use katana_rpc_server::middleware::cartridge::ControllerDeploymentLayer;
 
-                anyhow::ensure!(
+                ensure!(
                     config.rpc.apis.contains(&RpcModuleKind::Cartridge),
                     "Cartridge API should be enabled when paymaster is set"
                 );
@@ -289,9 +335,6 @@ where
                     paymaster_url: cfg.url.clone(),
                     paymaster_api_key: cfg.api_key.clone(),
                     api_url: cartridge_api_cfg.cartridge_api_url.clone(),
-                    controller_deployer_address: cartridge_api_cfg.controller_deployer_address,
-                    controller_deployer_private_key: cartridge_api_cfg
-                        .controller_deployer_private_key,
                     #[cfg(feature = "vrf")]
                     vrf: vrf.clone(),
                 };
@@ -323,49 +366,6 @@ where
             None
         };
 
-        // --- build starknet api
-
-        let starknet_api_cfg = StarknetApiConfig {
-            max_event_page_size: config.rpc.max_event_page_size,
-            max_proof_keys: config.rpc.max_proof_keys,
-            max_call_gas: config.rpc.max_call_gas,
-            max_concurrent_estimate_fee_requests: config.rpc.max_concurrent_estimate_fee_requests,
-            simulation_flags: execution_flags,
-            versioned_constant_overrides,
-        };
-
-        let chain_spec = backend.chain_spec.clone();
-
-        let starknet_api = StarknetApi::new(
-            chain_spec.clone(),
-            pool.clone(),
-            task_spawner.clone(),
-            block_producer.clone(),
-            gas_oracle.clone(),
-            starknet_api_cfg,
-            provider.clone(),
-        );
-
-        if config.rpc.apis.contains(&RpcModuleKind::Starknet) {
-            #[cfg(feature = "explorer")]
-            if config.rpc.explorer {
-                rpc_modules.merge(StarknetApiExtServer::into_rpc(starknet_api.clone()))?;
-            }
-
-            rpc_modules.merge(StarknetApiServer::into_rpc(starknet_api.clone()))?;
-            rpc_modules.merge(StarknetWriteApiServer::into_rpc(starknet_api.clone()))?;
-            rpc_modules.merge(StarknetTraceApiServer::into_rpc(starknet_api.clone()))?;
-        }
-
-        if config.rpc.apis.contains(&RpcModuleKind::Starknet) {
-            rpc_modules.merge(KatanaApiServer::into_rpc(starknet_api.clone()))?;
-        }
-
-        if config.rpc.apis.contains(&RpcModuleKind::Dev) {
-            let api = DevApi::new(backend.clone(), block_producer.clone());
-            rpc_modules.merge(DevApiServer::into_rpc(api))?;
-        }
-
         // --- build tee api (if configured)
         #[cfg(feature = "tee")]
         if config.rpc.apis.contains(&RpcModuleKind::Tee) {

crates/rpc/rpc-server/src/cartridge/mod.rs

@@ -74,8 +74,6 @@ pub struct CartridgeConfig {
     pub api_url: Url,
     pub paymaster_url: Url,
     pub paymaster_api_key: Option<String>,
-    pub controller_deployer_address: ContractAddress,
-    pub controller_deployer_private_key: Felt,
     #[cfg(feature = "vrf")]
     pub vrf: Option<vrf::VrfServiceConfig>,
 }
@@ -88,10 +86,6 @@ pub struct CartridgeApi<PF: ProviderFactory> {
     pool: TxPool,
     api_client: cartridge::CartridgeApiClient,
     paymaster_client: HttpClient,
-    /// The paymaster account address used for controller deployment.
-    controller_deployer_address: ContractAddress,
-    /// The paymaster account private key.
-    controller_deployer_private_key: Felt,
     #[cfg(feature = "vrf")]
     vrf_service: Option<VrfService>,
 }
@@ -108,8 +102,6 @@ where
             pool: self.pool.clone(),
             api_client: self.api_client.clone(),
             paymaster_client: self.paymaster_client.clone(),
-            controller_deployer_address: self.controller_deployer_address,
-            controller_deployer_private_key: self.controller_deployer_private_key,
             #[cfg(feature = "vrf")]
             vrf_service: self.vrf_service.clone(),
         }
@@ -154,8 +146,6 @@ where
             pool,
             api_client,
             paymaster_client,
-            controller_deployer_address: config.controller_deployer_address,
-            controller_deployer_private_key: config.controller_deployer_private_key,
             #[cfg(feature = "vrf")]
             vrf_service,
         })

crates/rpc/rpc-server/src/middleware/cartridge.rs

@@ -37,10 +37,9 @@ 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, PoolTx, PP, PF>
+pub struct ControllerDeploymentLayer<Pool, PP, PF>
 where
-    Pool: TransactionPool<Transaction = PoolTx> + 'static,
-    PoolTx: From<BroadcastedTxWithChainId>,
+    Pool: TransactionPool + 'static,
     PP: PendingBlockProvider,
     PF: ProviderFactory,
     <PF as ProviderFactory>::Provider: ProviderRO,
@@ -53,10 +52,9 @@ where
     vrf_service: Option<VrfService>,
 }
 
-impl<Pool, PoolTx, PP, PF> ControllerDeploymentLayer<Pool, PoolTx, PP, PF>
+impl<Pool, PP, PF> ControllerDeploymentLayer<Pool, PP, PF>
 where
-    Pool: TransactionPool<Transaction = PoolTx> + 'static,
-    PoolTx: From<BroadcastedTxWithChainId>,
+    Pool: TransactionPool + 'static,
     PP: PendingBlockProvider,
     PF: ProviderFactory,
     <PF as ProviderFactory>::Provider: ProviderRO,
@@ -80,7 +78,7 @@ where
     }
 }
 
-impl<S, Pool, PoolTx, PP, PF> Layer<S> for ControllerDeploymentLayer<Pool, PoolTx, PP, PF>
+impl<S, Pool, PoolTx, PP, PF> Layer<S> for ControllerDeploymentLayer<Pool, PP, PF>
 where
     Pool: TransactionPool<Transaction = PoolTx> + 'static,
     PoolTx: From<BroadcastedTxWithChainId>,