apollo_node: integrate proof manager client into node

Author: einat-starkware

Cargo.lock

@@ -43,6 +43,7 @@ apollo_mempool_p2p_types.workspace = true
 apollo_mempool_types.workspace = true
 apollo_monitoring_endpoint.workspace = true
 apollo_proof_manager.workspace = true
+apollo_proof_manager_types.workspace = true
 apollo_signature_manager.workspace = true
 apollo_signature_manager_types.workspace = true
 apollo_state_sync.workspace = true

crates/apollo_node/Cargo.toml

@@ -73,6 +73,14 @@ use apollo_mempool_types::communication::{
 };
 use apollo_node_config::component_execution_config::ReactiveComponentExecutionMode;
 use apollo_node_config::node_config::SequencerNodeConfig;
+use apollo_proof_manager::metrics::PROOF_MANAGER_INFRA_METRICS;
+use apollo_proof_manager_types::{
+    LocalProofManagerClient,
+    ProofManagerRequest,
+    ProofManagerResponse,
+    RemoteProofManagerClient,
+    SharedProofManagerClient,
+};
 use apollo_signature_manager::metrics::SIGNATURE_MANAGER_INFRA_METRICS;
 use apollo_signature_manager_types::{
     LocalSignatureManagerClient,
@@ -104,6 +112,7 @@ pub struct SequencerNodeClients {
     mempool_client: Client<MempoolRequest, MempoolResponse>,
     mempool_p2p_propagator_client:
         Client<MempoolP2pPropagatorRequest, MempoolP2pPropagatorResponse>,
+    proof_manager_client: Client<ProofManagerRequest, ProofManagerResponse>,
     sierra_compiler_client: Client<SierraCompilerRequest, SierraCompilerResponse>,
     signature_manager_client: Client<SignatureManagerRequest, SignatureManagerResponse>,
     state_sync_client: Client<StateSyncRequest, StateSyncResponse>,
@@ -239,6 +248,16 @@ impl SequencerNodeClients {
         get_shared_client!(self, mempool_p2p_propagator_client)
     }
 
+    pub fn get_proof_manager_local_client(
+        &self,
+    ) -> Option<LocalComponentClient<ProofManagerRequest, ProofManagerResponse>> {
+        self.proof_manager_client.get_local_client()
+    }
+
+    pub fn get_proof_manager_shared_client(&self) -> Option<SharedProofManagerClient> {
+        get_shared_client!(self, proof_manager_client)
+    }
+
     pub fn get_sierra_compiler_local_client(
         &self,
     ) -> Option<LocalComponentClient<SierraCompilerRequest, SierraCompilerResponse>> {
@@ -460,6 +479,17 @@ pub fn create_node_clients(
         &MEMPOOL_P2P_INFRA_METRICS.get_remote_client_metrics()
     );
 
+    let proof_manager_client = create_client!(
+        &config.components.proof_manager.execution_mode,
+        LocalProofManagerClient,
+        RemoteProofManagerClient,
+        channels.take_proof_manager_tx(),
+        &config.components.proof_manager.remote_client_config,
+        &config.components.proof_manager.url,
+        config.components.proof_manager.port,
+        &PROOF_MANAGER_INFRA_METRICS.get_local_client_metrics(),
+        &PROOF_MANAGER_INFRA_METRICS.get_remote_client_metrics()
+    );
     let sierra_compiler_client = create_client!(
         &config.components.sierra_compiler.execution_mode,
         LocalSierraCompilerClient,
@@ -507,6 +537,7 @@ pub fn create_node_clients(
         mempool_client,
         mempool_p2p_propagator_client,
         sierra_compiler_client,
+        proof_manager_client,
         signature_manager_client,
         state_sync_client,
     }

crates/apollo_node/src/clients.rs

@@ -11,6 +11,7 @@ use apollo_mempool_p2p_types::communication::MempoolP2pPropagatorRequestWrapper;
 use apollo_mempool_types::communication::MempoolRequestWrapper;
 use apollo_node_config::component_execution_config::ExpectedComponentConfig;
 use apollo_node_config::node_config::SequencerNodeConfig;
+use apollo_proof_manager_types::ProofManagerRequestWrapper;
 use apollo_signature_manager_types::SignatureManagerRequestWrapper;
 use apollo_state_sync_types::communication::StateSyncRequestWrapper;
 use tokio::sync::mpsc::{channel, Receiver, Sender};
@@ -26,6 +27,7 @@ pub struct SequencerNodeCommunication {
     l1_gas_price_channel: ComponentCommunication<L1GasPriceRequestWrapper>,
     mempool_channel: ComponentCommunication<MempoolRequestWrapper>,
     mempool_p2p_propagator_channel: ComponentCommunication<MempoolP2pPropagatorRequestWrapper>,
+    proof_manager_channel: ComponentCommunication<ProofManagerRequestWrapper>,
     sierra_compiler_channel: ComponentCommunication<SierraCompilerRequestWrapper>,
     signature_manager_channel: ComponentCommunication<SignatureManagerRequestWrapper>,
     state_sync_channel: ComponentCommunication<StateSyncRequestWrapper>,
@@ -104,6 +106,14 @@ impl SequencerNodeCommunication {
         self.mempool_channel.take_rx()
     }
 
+    pub fn take_proof_manager_tx(&mut self) -> Sender<ProofManagerRequestWrapper> {
+        self.proof_manager_channel.take_tx()
+    }
+
+    pub fn take_proof_manager_rx(&mut self) -> Receiver<ProofManagerRequestWrapper> {
+        self.proof_manager_channel.take_rx()
+    }
+
     pub fn take_sierra_compiler_tx(&mut self) -> Sender<SierraCompilerRequestWrapper> {
         self.sierra_compiler_channel.take_tx()
     }
@@ -285,6 +295,23 @@ pub fn create_node_channels(config: &SequencerNodeConfig) -> SequencerNodeCommun
             false => (None, None),
         };
 
+    let (tx_proof_manager, rx_proof_manager) =
+        match config.components.proof_manager.execution_mode.is_running_locally() {
+            true => {
+                let (tx_proof_manager, rx_proof_manager) = channel::<ProofManagerRequestWrapper>(
+                    config
+                        .components
+                        .proof_manager
+                        .local_server_config
+                        .as_ref()
+                        .expect("Proof manager local server config should be available.")
+                        .inbound_requests_channel_capacity,
+                );
+                (Some(tx_proof_manager), Some(rx_proof_manager))
+            }
+            false => (None, None),
+        };
+
     let (tx_sierra_compiler, rx_sierra_compiler) =
         match config.components.sierra_compiler.execution_mode.is_running_locally() {
             true => {
@@ -351,6 +378,7 @@ pub fn create_node_channels(config: &SequencerNodeConfig) -> SequencerNodeCommun
             tx_mempool_p2p_propagator,
             rx_mempool_p2p_propagator,
         ),
+        proof_manager_channel: ComponentCommunication::new(tx_proof_manager, rx_proof_manager),
         sierra_compiler_channel: ComponentCommunication::new(
             tx_sierra_compiler,
             rx_sierra_compiler,