fix features

Author: frisitano

crates/chain-orchestrator/src/handle/mod.rs

@@ -22,13 +22,32 @@ use metrics::ChainOrchestratorHandleMetrics;
 pub struct ChainOrchestratorHandle<N: FullNetwork<Primitives = ScrollNetworkPrimitives>> {
     /// The channel used to send commands to the rollup manager.
     to_manager_tx: mpsc::UnboundedSender<ChainOrchestratorCommand<N>>,
+    /// The metrics for the handle.
     handle_metrics: ChainOrchestratorHandleMetrics,
+    /// Mock for the L1 Watcher used in tests.
+    #[cfg(feature = "test-utils")]
+    pub l1_watcher_mock: Option<rollup_node_watcher::test_utils::L1WatcherMock>,
 }
 
 impl<N: FullNetwork<Primitives = ScrollNetworkPrimitives>> ChainOrchestratorHandle<N> {
     /// Create a new rollup manager handle.
     pub fn new(to_manager_tx: mpsc::UnboundedSender<ChainOrchestratorCommand<N>>) -> Self {
-        Self { to_manager_tx, handle_metrics: ChainOrchestratorHandleMetrics::default() }
+        Self {
+            to_manager_tx,
+            handle_metrics: ChainOrchestratorHandleMetrics::default(),
+            #[cfg(feature = "test-utils")]
+            l1_watcher_mock: None,
+        }
+    }
+
+    /// Sets the L1 watcher mock for the handle.
+    #[cfg(feature = "test-utils")]
+    pub fn with_l1_watcher_mock(
+        mut self,
+        l1_watcher_mock: Option<rollup_node_watcher::test_utils::L1WatcherMock>,
+    ) -> Self {
+        self.l1_watcher_mock = l1_watcher_mock;
+        self
     }
 
     /// Sends a command to the rollup manager.

crates/node/src/add_ons/handle.rs

@@ -1,5 +1,3 @@
-#[cfg(feature = "test-utils")]
-use crate::test_utils::l1_helpers::L1WatcherMock;
 use reth_network_api::FullNetwork;
 use reth_node_api::FullNodeComponents;
 use reth_node_builder::rpc::{RpcHandle, RpcHandleProvider};
@@ -17,9 +15,6 @@ pub struct ScrollAddOnsHandle<
     pub rollup_manager_handle: ChainOrchestratorHandle<Node::Network>,
     /// The handle used to send commands to the RPC server.
     pub rpc_handle: RpcHandle<Node, EthApi>,
-    /// An optional channel used to send `L1Watcher` notifications to the `RollupNodeManager`.
-    #[cfg(feature = "test-utils")]
-    pub l1_watcher_tx: Option<L1WatcherMock>,
 }
 
 impl<

crates/node/src/add_ons/mod.rs

@@ -152,7 +152,7 @@ where
         });
 
         let rpc_handle = rpc_add_ons.launch_add_ons_with(ctx.clone(), |_| Ok(())).await?;
-        let (rollup_manager_handle, l1_watcher_tx) =
+        let rollup_manager_handle =
             rollup_node_manager_addon.launch(ctx.clone(), rpc_handle.clone()).await?;
 
         // Only send handle if RPC is enabled
@@ -161,12 +161,7 @@ where
                 .map_err(|_| eyre::eyre!("failed to send rollup manager handle"))?;
         }
 
-        Ok(ScrollAddOnsHandle {
-            rollup_manager_handle,
-            rpc_handle,
-            #[cfg(feature = "test-utils")]
-            l1_watcher_tx,
-        })
+        Ok(ScrollAddOnsHandle { rollup_manager_handle, rpc_handle })
     }
 }
 

crates/node/src/add_ons/rollup.rs

@@ -1,4 +1,4 @@
-use crate::{args::ScrollRollupNodeConfig, test_utils::l1_helpers::L1WatcherMock};
+use crate::args::ScrollRollupNodeConfig;
 
 use reth_chainspec::NamedChain;
 use reth_network::NetworkProtocols;
@@ -53,13 +53,13 @@ impl RollupManagerAddOn {
         self,
         ctx: AddOnsContext<'_, N>,
         rpc: RpcHandle<N, EthApi>,
-    ) -> eyre::Result<(ChainOrchestratorHandle<N::Network>, Option<L1WatcherMock>)>
+    ) -> eyre::Result<ChainOrchestratorHandle<N::Network>>
     where
         <<N as FullNodeTypes>::Types as NodeTypes>::ChainSpec:
             ChainConfig<Config = ScrollChainConfig> + ScrollHardforks + IsDevChain,
         N::Network: NetworkProtocols + FullNetwork<Primitives = ScrollNetworkPrimitives>,
     {
-        let (chain_orchestrator, handle, l1_watcher_mock) = self
+        let (chain_orchestrator, handle) = self
             .config
             .build((&ctx).into(), self.scroll_wire_event, rpc.rpc_server_handles)
             .await?;
@@ -68,6 +68,6 @@ impl RollupManagerAddOn {
             .spawn_critical_with_shutdown_signal("rollup_node_manager", |shutdown| {
                 chain_orchestrator.run_until_shutdown(shutdown)
             });
-        Ok((handle, l1_watcher_mock))
+        Ok(handle)
     }
 }

crates/node/src/args.rs

@@ -6,7 +6,6 @@ use crate::{
 use scroll_migration::MigratorTrait;
 use std::{fs, path::PathBuf, sync::Arc};
 
-use super::test_utils::l1_helpers::L1WatcherMock;
 use alloy_chains::NamedChain;
 use alloy_primitives::{hex, Address, U128};
 use alloy_provider::{layers::CacheLayer, Provider, ProviderBuilder};
@@ -167,7 +166,6 @@ impl ScrollRollupNodeConfig {
             impl ScrollEngineApi,
         >,
         ChainOrchestratorHandle<N>,
-        Option<L1WatcherMock>,
     )>
     where
         N: FullNetwork<Primitives = ScrollNetworkPrimitives> + NetworkProtocols,
@@ -351,42 +349,49 @@ impl ScrollRollupNodeConfig {
         };
         let consensus = self.consensus_args.consensus(authorized_signer)?;
 
-        let (l1_watcher_mock, l1_watcher_handle) = if let Some(provider) =
-            l1_provider.filter(|_| !self.test)
-        {
-            tracing::info!(target: "scroll::node::args", ?l1_block_startup_info, "Starting L1 watcher");
-            (
-                None,
-                Some(
-                    L1Watcher::spawn(
-                        provider,
-                        l1_block_startup_info,
-                        node_config,
-                        self.l1_provider_args.logs_query_block_range,
-                    )
-                    .await,
-                ),
-            )
-        } else {
-            // Create a channel for L1 notifications that we can use to inject L1 messages for
-            // testing
-            #[cfg(feature = "test-utils")]
-            {
-                let (notification_tx, notification_rx) = tokio::sync::mpsc::channel(1000);
-                let (command_tx, command_rx) = tokio::sync::mpsc::unbounded_channel();
-                let handle = L1WatcherHandle::new(command_tx, notification_rx);
-                let watcher_mock = L1WatcherMock {
-                    command_rx: Arc::new(tokio::sync::Mutex::new(command_rx)),
-                    notification_tx,
-                };
-                (Some(watcher_mock), Some(handle))
-            }
-
-            #[cfg(not(feature = "test-utils"))]
-            {
-                (None, None)
-            }
-        };
+        // Define some types to support definitions of return type of following function in no_std.
+        #[cfg(feature = "test-utils")]
+        type L1WatcherMockOpt = Option<rollup_node_watcher::test_utils::L1WatcherMock>;
+
+        #[cfg(not(feature = "test-utils"))]
+        type L1WatcherMockOpt = Option<std::convert::Infallible>;
+
+        let (_l1_watcher_mock, l1_watcher_handle): (L1WatcherMockOpt, Option<L1WatcherHandle>) =
+            if let Some(provider) = l1_provider.filter(|_| !self.test) {
+                tracing::info!(target: "scroll::node::args", ?l1_block_startup_info, "Starting L1 watcher");
+                (
+                    None,
+                    Some(
+                        L1Watcher::spawn(
+                            provider,
+                            l1_block_startup_info,
+                            node_config,
+                            self.l1_provider_args.logs_query_block_range,
+                        )
+                        .await,
+                    ),
+                )
+            } else {
+                // Create a channel for L1 notifications that we can use to inject L1 messages for
+                // testing
+                #[cfg(feature = "test-utils")]
+                {
+                    let (notification_tx, notification_rx) = tokio::sync::mpsc::channel(1000);
+                    let (command_tx, command_rx) = tokio::sync::mpsc::unbounded_channel();
+                    let handle =
+                        rollup_node_watcher::L1WatcherHandle::new(command_tx, notification_rx);
+                    let watcher_mock = rollup_node_watcher::test_utils::L1WatcherMock {
+                        command_rx: Arc::new(tokio::sync::Mutex::new(command_rx)),
+                        notification_tx,
+                    };
+                    (Some(watcher_mock), Some(handle))
+                }
+
+                #[cfg(not(feature = "test-utils"))]
+                {
+                    (None, None)
+                }
+            };
 
         // Construct the l1 provider.
         let l1_messages_provider = db.clone();
@@ -475,7 +480,10 @@ impl ScrollRollupNodeConfig {
         )
         .await?;
 
-        Ok((chain_orchestrator, handle, l1_watcher_mock))
+        #[cfg(feature = "test-utils")]
+        let handle = handle.with_l1_watcher_mock(_l1_watcher_mock);
+
+        Ok((chain_orchestrator, handle))
     }
 }
 

crates/node/src/test_utils/fixture.rs

@@ -4,10 +4,9 @@ use super::{
     block_builder::BlockBuilder, l1_helpers::L1Helper, setup_engine, tx_helpers::TxHelper,
 };
 use crate::{
-    test_utils::l1_helpers::L1WatcherMock, BlobProviderArgs, ChainOrchestratorArgs,
-    ConsensusAlgorithm, ConsensusArgs, EngineDriverArgs, L1ProviderArgs, RollupNodeDatabaseArgs,
-    RollupNodeGasPriceOracleArgs, RollupNodeNetworkArgs, RpcArgs, ScrollRollupNode,
-    ScrollRollupNodeConfig, SequencerArgs, SignerArgs,
+    BlobProviderArgs, ChainOrchestratorArgs, ConsensusAlgorithm, ConsensusArgs, EngineDriverArgs,
+    L1ProviderArgs, RollupNodeDatabaseArgs, RollupNodeGasPriceOracleArgs, RollupNodeNetworkArgs,
+    RpcArgs, ScrollRollupNode, ScrollRollupNodeConfig, SequencerArgs, SignerArgs,
 };
 
 use alloy_eips::BlockNumberOrTag;
@@ -75,8 +74,6 @@ pub struct NodeHandle {
     pub node: NodeHelperType<ScrollRollupNode, TestBlockChainProvider>,
     /// Engine instance for this node.
     pub engine: Engine<Arc<dyn ScrollEngineApi + Send + Sync + 'static>>,
-    /// L1 watcher notification channel.
-    pub l1_watcher_tx: Option<L1WatcherMock>,
     /// Chain orchestrator listener.
     pub chain_orchestrator_rx: EventStream<ChainOrchestratorEvent>,
     /// Chain orchestrator handle.
@@ -102,7 +99,6 @@ impl Debug for NodeHandle {
         f.debug_struct("NodeHandle")
             .field("node", &"NodeHelper")
             .field("engine", &"Box<dyn ScrollEngineApi>")
-            .field("l1_watcher_tx", &self.l1_watcher_tx)
             .field("rollup_manager_handle", &self.rollup_manager_handle)
             .finish()
     }
@@ -436,7 +432,7 @@ impl TestFixtureBuilder {
         .await?;
 
         let mut node_handles = Vec::with_capacity(nodes.len());
-        for (index, mut node) in nodes.into_iter().enumerate() {
+        for (index, node) in nodes.into_iter().enumerate() {
             let genesis_hash = node.inner.chain_spec().genesis_hash();
 
             // Create engine for the node
@@ -451,7 +447,6 @@ impl TestFixtureBuilder {
             let engine = Engine::new(Arc::new(engine_client), fcs);
 
             // Get handles if available
-            let l1_watcher_tx = node.inner.add_ons_handle.l1_watcher_tx.take();
             let rollup_manager_handle = node.inner.add_ons_handle.rollup_manager_handle.clone();
             let chain_orchestrator_rx =
                 node.inner.add_ons_handle.rollup_manager_handle.get_event_listener().await?;
@@ -460,7 +455,6 @@ impl TestFixtureBuilder {
                 node,
                 engine,
                 chain_orchestrator_rx,
-                l1_watcher_tx,
                 rollup_manager_handle,
                 typ: if config.sequencer_args.sequencer_enabled && index == 0 {
                     NodeType::Sequencer

crates/node/src/test_utils/l1_helpers.rs

@@ -5,18 +5,8 @@ use std::{fmt::Debug, str::FromStr, sync::Arc};
 
 use alloy_primitives::{Address, Bytes, B256, U256};
 use rollup_node_primitives::{BatchCommitData, BlockInfo, ConsensusUpdate};
-use rollup_node_watcher::{L1Notification, L1WatcherCommand};
+use rollup_node_watcher::L1Notification;
 use scroll_alloy_consensus::TxL1Message;
-use tokio::sync::{mpsc, Mutex};
-
-/// Mock for the L1 Watcher.
-#[derive(Clone, Debug)]
-pub struct L1WatcherMock {
-    /// Receiver for L1 watcher commands.
-    pub command_rx: Arc<Mutex<mpsc::UnboundedReceiver<L1WatcherCommand>>>,
-    /// Sender for L1 notifications.
-    pub notification_tx: mpsc::Sender<Arc<L1Notification>>,
-}
 
 /// Helper for managing L1 interactions in tests.
 #[derive(Debug)]
@@ -126,7 +116,7 @@ impl<'a> L1Helper<'a> {
         };
 
         for node in nodes {
-            if let Some(tx) = &node.l1_watcher_tx {
+            if let Some(tx) = &node.rollup_manager_handle.l1_watcher_mock {
                 tx.notification_tx.send(notification.clone()).await?;
             }
         }
@@ -232,7 +222,7 @@ impl<'a> L1MessageBuilder<'a> {
         };
 
         for node in nodes {
-            if let Some(tx) = &node.l1_watcher_tx {
+            if let Some(tx) = &node.rollup_manager_handle.l1_watcher_mock {
                 tx.notification_tx.send(notification.clone()).await?;
             }
         }