fix: test_l1_sync_batch_finalized

Author: yiweichi

crates/node/src/test_utils/event_utils.rs

@@ -172,8 +172,15 @@ impl<'a> EventWaiter<'a> {
 
     /// Wait for L1 block finalized event on all specified nodes.
     pub async fn l1_block_finalized(self) -> eyre::Result<()> {
+        self.l1_block_finalized_at_least(0).await
+    }
+
+    /// Wait for L1 block finalized event on all specified nodes where the block number
+    /// is at least the specified target.
+    pub async fn l1_block_finalized_at_least(self, target_block_number: u64) -> eyre::Result<()> {
         self.wait_for_event_on_all(|e| {
-            matches!(e, ChainOrchestratorEvent::L1BlockFinalized(_, _)).then_some(())
+            matches!(e, ChainOrchestratorEvent::L1BlockFinalized(n, _) if n >= &target_block_number)
+                .then_some(())
         })
         .await?;
         Ok(())

crates/node/src/test_utils/fixture.rs

@@ -239,6 +239,20 @@ impl TestFixture {
         })
     }
 
+    /// Get the current block number from Anvil.
+    pub async fn anvil_get_block_number(&self) -> eyre::Result<u64> {
+        let provider = self.anvil_provider().ok_or_else(|| eyre::eyre!("Anvil is not running"))?;
+        let block_number = provider.get_block_number().await?;
+        Ok(block_number)
+    }
+
+    /// Get the finalized block number from Anvil.
+    pub async fn anvil_get_finalized_block_number(&self) -> eyre::Result<u64> {
+        let provider = self.anvil_provider().ok_or_else(|| eyre::eyre!("Anvil is not running"))?;
+        let finalized_block = provider.get_block(BlockNumberOrTag::Finalized.into()).await?;
+        Ok(finalized_block.map(|block| block.number()).unwrap_or(0u64))
+    }
+
     /// Generate Anvil blocks by calling `anvil_mine` RPC method.
     pub async fn anvil_mine_blocks(&self, num_blocks: u64) -> eyre::Result<()> {
         let provider = self.anvil_provider().ok_or_else(|| eyre::eyre!("Anvil is not running"))?;

crates/node/tests/l1_sync.rs

@@ -193,7 +193,7 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil(None, None, Some(22222222), None, Some(4))
+        .with_anvil(None, None, Some(22222222), None, Some(2))
         .build()
         .await?;
 
@@ -231,7 +231,9 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
         let finalize_batch_tx = read_test_transaction("finalizeBatch", &i.to_string())?;
         fixture.anvil_inject_tx(finalize_batch_tx).await?;
     }
-    fixture.anvil_mine_blocks(8).await?;
+    let anvil_block_number = fixture.anvil_get_block_number().await?;
+    fixture.anvil_mine_blocks(4).await?;
+    fixture.expect_event().l1_block_finalized_at_least(anvil_block_number).await?;
 
     for i in 1..=3 {
         fixture.expect_event().batch_consolidated().await?;
@@ -272,8 +274,8 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
     }
     let l1_synced_status = fixture.get_status(0).await?;
     assert!(
-        batch_finalized_status.l2.fcs.safe_block_info().number <
-            l1_synced_status.l2.fcs.safe_block_info().number,
+        l1_synced_status.l2.fcs.safe_block_info().number >
+            batch_finalized_status.l2.fcs.safe_block_info().number,
         "Safe head should advance after L1 Synced when processing buffered BatchCommit events"
     );
 
@@ -299,8 +301,9 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
         "Finalized head should not advance before BatchFinalized event are finalized on L1"
     );
 
-    fixture.anvil_mine_blocks(8).await?;
-    fixture.expect_event().l1_block_finalized().await?;
+    let anvil_block_number = fixture.anvil_get_block_number().await?;
+    fixture.anvil_mine_blocks(4).await?;
+    fixture.expect_event().l1_block_finalized_at_least(anvil_block_number).await?;
 
     // Step 8: Verify only finalized head advanced (safe head managed by BatchCommit)
     let batch_finalized_status = fixture.get_status(0).await?;