wip

Author: kariy

crates/cli/src/args.rs

@@ -1034,7 +1034,7 @@ explorer = true
     #[test]
     #[cfg(feature = "server")]
     fn parse_cors_origins() {
-        use katana_rpc_server::cors::HeaderValue;
+        use katana_rpc_server::middleware::cors::HeaderValue;
 
         let result = SequencerNodeArgs::parse_from([
             "katana",

crates/cli/src/options.rs

@@ -19,7 +19,7 @@ use katana_primitives::chain::ChainId;
 #[cfg(feature = "vrf")]
 use katana_primitives::ContractAddress;
 #[cfg(feature = "server")]
-use katana_rpc_server::cors::HeaderValue;
+use katana_rpc_server::middleware::cors::HeaderValue;
 use katana_sequencer_node::config::execution::{
     DEFAULT_INVOCATION_MAX_STEPS, DEFAULT_VALIDATION_MAX_STEPS,
 };

crates/cli/src/sidecar.rs

@@ -2,7 +2,7 @@ use std::net::SocketAddr;
 
 use anyhow::{anyhow, Result};
 #[cfg(feature = "vrf")]
-pub use cartridge::vrf::{
+pub use cartridge::vrf::server::{
     get_vrf_account, VrfAccountCredentials, VrfBootstrapResult, VrfServer, VrfServerConfig,
     VrfServiceProcess, VRF_SERVER_PORT,
 };
@@ -62,7 +62,7 @@ pub async fn bootstrap_vrf(
     let rpc_url = local_rpc_url(&rpc_addr);
     let (account_address, pk) = prefunded_account(chain, 0)?;
 
-    let result = cartridge::vrf::bootstrap_vrf(rpc_url, account_address, pk).await?;
+    let result = cartridge::vrf::server::bootstrap_vrf(rpc_url, account_address, pk).await?;
 
     let mut vrf_service = VrfServer::new(VrfServerConfig {
         secret_key: result.secret_key,

crates/cli/src/utils.rs

@@ -15,7 +15,7 @@ use katana_primitives::cairo::ShortString;
 use katana_primitives::chain::ChainId;
 use katana_primitives::class::ClassHash;
 use katana_primitives::contract::ContractAddress;
-use katana_rpc_server::cors::HeaderValue;
+use katana_rpc_server::middleware::cors::HeaderValue;
 use katana_tracing::LogFormat;
 use serde::{Deserialize, Deserializer, Serializer};
 use tracing::info;

crates/node/sequencer/src/lib.rs

@@ -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<Pool, PP, PF> = Stack<
-    Either<ControllerDeploymentLayer<Pool, PP, PF>, Identity>,
+type NodeRpcMiddleware<PF> = Stack<
+    Either<ControllerDeploymentLayer<TxPool, BlockProducer<PF>, PF>, Identity>,
     Stack<RpcLoggerLayer, Stack<RpcServerMetricsLayer, Identity>>,
 >;
 
 #[cfg(not(feature = "cartridge"))]
 type NodeRpcMiddleware = Stack<RpcLoggerLayer, Stack<RpcServerMetricsLayer, Identity>>;
 
 #[cfg(feature = "cartridge")]
-pub type NodeRpcServer<Pool, PP, PF> = RpcServer<NodeRpcMiddleware<Pool, PP, PF>>;
+pub type NodeRpcServer<PF> = RpcServer<NodeRpcMiddleware<PF>>;
 
 #[cfg(not(feature = "cartridge"))]
 pub type NodeRpcServer = RpcServer<NodeRpcMiddleware>;
@@ -105,7 +105,7 @@ where
     config: Arc<Config>,
     pool: TxPool,
     #[cfg(feature = "cartridge")]
-    rpc_server: NodeRpcServer<TxPool, PP, P>,
+    rpc_server: NodeRpcServer<P>,
     #[cfg(not(feature = "cartridge"))]
     rpc_server: NodeRpcServer,
     #[cfg(feature = "grpc")]
@@ -352,7 +352,7 @@ where
                 Some(ControllerDeploymentLayer::new(
                     starknet_api.clone(),
                     cartridge_api_client,
-                    HttpClient::builder().build(cfg.url)?,
+                    HttpClient::builder().build(cfg.url.clone())?,
                     cartridge_api_cfg.controller_deployer_address,
                     SigningKey::from_secret_scalar(
                         cartridge_api_cfg.controller_deployer_private_key,

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

@@ -38,15 +38,14 @@ use jsonrpsee::http_client::{HttpClient, HttpClientBuilder};
 use katana_core::backend::Backend;
 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;
 use katana_primitives::chain::ChainId;
 use katana_primitives::contract::Nonce;
 use katana_primitives::execution::Call;
 use katana_primitives::fee::{AllResourceBoundsMapping, ResourceBoundsMapping};
 use katana_primitives::transaction::{ExecutableTx, ExecutableTxWithHash, InvokeTx, InvokeTxV3};
 use katana_primitives::{ContractAddress, Felt};
-use katana_provider::api::state::{StateFactoryProvider, StateProvider};
+use katana_provider::api::state::StateProvider;
 use katana_provider::{ProviderFactory, ProviderRO, ProviderRW};
 use katana_rpc_api::cartridge::CartridgeApiServer;
 use katana_rpc_api::error::cartridge::CartridgeApiError;

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

@@ -91,15 +91,17 @@ mod tests {
     #[test]
     fn request_random_call_finds_position() {
         let vrf_address = ContractAddress::from(felt!("0x123"));
-        let other_call = katana_rpc_types::outside_execution::Call {
-            to: vrf_address,
-            selector: selector!("transfer"),
+
+        let other_call = Call {
             calldata: vec![Felt::ONE],
+            contract_address: vrf_address,
+            entry_point_selector: selector!("transfer"),
         };
-        let vrf_call = katana_rpc_types::outside_execution::Call {
-            to: vrf_address,
-            selector: selector!("request_random"),
+
+        let vrf_call = Call {
             calldata: vec![Felt::TWO],
+            contract_address: vrf_address,
+            entry_point_selector: selector!("request_random"),
         };
 
         let outside_execution = OutsideExecution::V2(OutsideExecutionV2 {
@@ -112,8 +114,9 @@ mod tests {
 
         let (call, position) =
             get_request_random_call(&outside_execution).expect("request_random found");
+
         assert_eq!(position, 1);
-        assert_eq!(call.selector, vrf_call.selector);
+        assert_eq!(call.entry_point_selector, vrf_call.entry_point_selector);
         assert_eq!(call.calldata, vrf_call.calldata);
     }
 }

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

@@ -42,7 +42,6 @@ where
     Pool: TransactionPool + 'static,
     PP: PendingBlockProvider,
     PF: ProviderFactory,
-    <PF as ProviderFactory>::Provider: ProviderRO,
 {
     starknet: StarknetApi<Pool, PP, PF>,
     cartridge_api: CartridgeApiClient,
@@ -57,7 +56,6 @@ where
     Pool: TransactionPool + 'static,
     PP: PendingBlockProvider,
     PF: ProviderFactory,
-    <PF as ProviderFactory>::Provider: ProviderRO,
 {
     pub fn new(
         starknet: StarknetApi<Pool, PP, PF>,
@@ -407,6 +405,24 @@ where
     }
 }
 
+impl<Pool, PP, PF> Clone for ControllerDeploymentLayer<Pool, PP, PF>
+where
+    Pool: TransactionPool,
+    PP: PendingBlockProvider,
+    PF: ProviderFactory,
+{
+    fn clone(&self) -> Self {
+        Self {
+            starknet: self.starknet.clone(),
+            vrf_service: self.vrf_service.clone(),
+            cartridge_api: self.cartridge_api.clone(),
+            paymaster_client: self.paymaster_client.clone(),
+            deployer_address: self.deployer_address.clone(),
+            deployer_private_key: self.deployer_private_key.clone(),
+        }
+    }
+}
+
 impl<S, Pool, PP, PF> Clone for ControllerDeploymentService<S, Pool, PP, PF>
 where
     S: Clone,

crates/utils/src/node.rs

@@ -194,7 +194,6 @@ where
     }
 
     /// Returns the address of the node's gRPC server (if enabled).
-    #[cfg(feature = "grpc")]
     pub fn grpc_addr(&self) -> Option<&SocketAddr> {
         self.node.grpc().map(|h| h.addr())
     }