tests: migrate remaining tests

Author: greged93

crates/node/src/test_utils/event_utils.rs

@@ -232,9 +232,9 @@ impl<'a> MultiNodeEventWaiter<'a> {
     }
 
     /// Wait for chain extended event on all specified nodes.
-    pub async fn chain_extended(self) -> eyre::Result<()> {
+    pub async fn chain_extended(self, target: u64) -> eyre::Result<()> {
         self.wait_for_event_on_all(|e| {
-            matches!(e, ChainOrchestratorEvent::ChainExtended(_)).then_some(())
+            matches!(e, ChainOrchestratorEvent::ChainExtended(ChainImport{chain,..}) if chain.last().map(|b| b.header.number) >= Some(target)).then_some(())
         })
         .await?;
         Ok(())

crates/node/src/test_utils/fixture.rs

@@ -60,6 +60,15 @@ pub type ScrollNetworkHandle =
 pub type TestBlockChainProvider =
     BlockchainProvider<NodeTypesWithDBAdapter<ScrollRollupNode, TmpDB>>;
 
+/// The node type (sequencer or follower).
+#[derive(Debug)]
+pub enum NodeType {
+    /// A sequencer node.
+    Sequencer,
+    /// A follower node.
+    Follower,
+}
+
 /// Handle to a single test node with its components.
 pub struct NodeHandle {
     /// The underlying node context.
@@ -74,6 +83,20 @@ pub struct NodeHandle {
     pub rollup_manager_handle: ChainOrchestratorHandle<ScrollNetworkHandle>,
     /// Node index in the test setup.
     pub index: usize,
+    /// The type of the node.
+    pub typ: NodeType,
+}
+
+impl NodeHandle {
+    /// Returns true if this is a handle to the sequencer.
+    pub fn is_sequencer(&self) -> bool {
+        matches!(self.typ, NodeType::Sequencer)
+    }
+
+    /// Returns true if this is a handle to a follower.
+    pub fn is_follower(&self) -> bool {
+        matches!(self.typ, NodeType::Follower)
+    }
 }
 
 impl Debug for NodeHandle {
@@ -95,18 +118,25 @@ impl TestFixture {
     }
 
     /// Get the sequencer node (assumes first node is sequencer).
-    pub fn sequencer_node(&mut self) -> &mut NodeHandle {
-        &mut self.nodes[0]
+    pub fn sequencer(&mut self) -> &mut NodeHandle {
+        let handle = &mut self.nodes[0];
+        if !handle.is_sequencer() {
+            panic!("expected sequencer, got follower")
+        }
+        handle
     }
 
     /// Get a follower node by index.
-    pub fn follower_node(&mut self, index: usize) -> &mut NodeHandle {
-        &mut self.nodes[index + 1]
+    pub fn follower(&mut self, index: usize) -> &mut NodeHandle {
+        if index == 0 && self.nodes[0].is_sequencer() {
+            return &mut self.nodes[index + 1];
+        }
+        &mut self.nodes[index]
     }
 
-    /// Get the wallet address.
-    pub fn wallet_address(&self) -> Address {
-        self.wallet.blocking_lock().inner.address()
+    /// Get the wallet.
+    pub fn wallet(&self) -> Arc<Mutex<Wallet>> {
+        self.wallet.clone()
     }
 
     /// Start building a block using the sequencer.
@@ -246,7 +276,7 @@ impl TestFixtureBuilder {
     pub fn new() -> Self {
         Self {
             config: Self::default_config(),
-            num_nodes: 1,
+            num_nodes: 0,
             chain_spec: None,
             is_dev: false,
             no_local_transactions_propagation: false,
@@ -289,12 +319,14 @@ impl TestFixtureBuilder {
             L1MessageInclusionMode::BlockDepth(0);
         self.config.sequencer_args.allow_empty_blocks = true;
         self.config.database_args.rn_db_path = Some(PathBuf::from("sqlite::memory:"));
+
+        self.num_nodes += 1;
         self
     }
 
     /// Adds `count`s follower nodes to the test.
     pub fn followers(mut self, count: usize) -> TestFixtureBuilder {
-        self.num_nodes = count;
+        self.num_nodes += count;
         self
     }
 
@@ -459,7 +491,7 @@ impl TestFixtureBuilder {
         let chain_spec = self.chain_spec.unwrap_or_else(|| SCROLL_DEV.clone());
 
         let (nodes, _tasks, wallet) = setup_engine(
-            config,
+            config.clone(),
             self.num_nodes,
             chain_spec.clone(),
             self.is_dev,
@@ -495,6 +527,11 @@ impl TestFixtureBuilder {
                 l1_watcher_tx,
                 rollup_manager_handle,
                 index,
+                typ: if config.sequencer_args.sequencer_enabled && index == 0 {
+                    NodeType::Sequencer
+                } else {
+                    NodeType::Follower
+                },
             });
         }
 

crates/node/src/test_utils/l1_helpers.rs

@@ -173,7 +173,9 @@ impl<'a> L1MessageBuilder<'a> {
 
     /// Send the L1 message to the database and notify nodes.
     pub async fn send(self) -> eyre::Result<TxL1Message> {
-        let sender = self.sender.unwrap_or_else(|| self.l1_helper.fixture.wallet_address());
+        let sender = self
+            .sender
+            .unwrap_or_else(|| self.l1_helper.fixture.wallet().blocking_lock().inner.address());
 
         let tx_l1_message = TxL1Message {
             queue_index: self.queue_index,

crates/node/tests/e2e.rs

@@ -971,7 +971,7 @@ async fn can_handle_batch_revert() -> eyre::Result<()> {
         .where_event_n(42, |e| matches!(e, ChainOrchestratorEvent::BlockConsolidated(_)))
         .await?;
 
-    let status = fixture.follower_node(0).rollup_manager_handle.status().await?;
+    let status = fixture.follower(0).rollup_manager_handle.status().await?;
 
     // Assert the forkchoice state is above 4
     assert!(status.l2.fcs.head_block_info().number > 4);
@@ -983,7 +983,7 @@ async fn can_handle_batch_revert() -> eyre::Result<()> {
     // Wait for the third batch to be proceeded.
     tokio::time::sleep(Duration::from_millis(300)).await;
 
-    let status = fixture.follower_node(0).rollup_manager_handle.status().await?;
+    let status = fixture.follower(0).rollup_manager_handle.status().await?;
 
     // Assert the forkchoice state was reset to 4.
     assert_eq!(status.l2.fcs.head_block_info().number, 4);
@@ -1261,7 +1261,7 @@ async fn can_rpc_enable_disable_sequencing() -> eyre::Result<()> {
     assert_ne!(fixture.get_sequencer_block().await?.header.number, 0, "Should produce blocks");
 
     // Disable automatic sequencing via RPC
-    let client = fixture.sequencer_node().node.rpc_client().expect("Should have rpc client");
+    let client = fixture.sequencer().node.rpc_client().expect("Should have rpc client");
     let result = RollupNodeExtApiClient::disable_automatic_sequencing(&client).await?;
     assert!(result, "Disable automatic sequencing should return true");
 
@@ -1432,7 +1432,7 @@ async fn can_gossip_over_eth_wire() -> eyre::Result<()> {
     fixture.expect_event().l1_synced().await?;
 
     let mut eth_wire_blocks =
-        fixture.follower_node(0).node.inner.network.eth_wire_block_listener().await?;
+        fixture.follower(0).node.inner.network.eth_wire_block_listener().await?;
 
     if let Some(block) = eth_wire_blocks.next().await {
         println!("Received block from eth-wire network: {block:?}");
@@ -1485,7 +1485,7 @@ async fn signer_rotation() -> eyre::Result<()> {
     fixture2.l1().for_node(0).sync().await?;
 
     // connect the two sequencers
-    fixture1.sequencer_node().node.connect(&mut fixture2.sequencer_node().node).await;
+    fixture1.sequencer().node.connect(&mut fixture2.sequencer().node).await;
 
     // wait for 5 blocks to be produced.
     for i in 1..=5 {