fix: address comment

Author: yiweichi

crates/chain-orchestrator/src/event.rs

@@ -44,7 +44,7 @@ pub enum ChainOrchestratorEvent {
         l1_block_number: u64,
     },
     /// A batch has been finalized returning a list of finalized batches.
-    BatchFinalized {
+    BatchFinalizeIndexed {
         /// The L1 block info at which the batch finalization event was received.
         l1_block_info: BlockInfo,
         /// The list of batches that have been triggered for the derivation pipeline.

crates/chain-orchestrator/src/lib.rs

@@ -814,7 +814,7 @@ impl<
             self.derivation_pipeline.push_batch(*batch, BatchStatus::Finalized).await;
         }
 
-        Ok(Some(ChainOrchestratorEvent::BatchFinalized { l1_block_info, triggered_batches }))
+        Ok(Some(ChainOrchestratorEvent::BatchFinalizeIndexed { l1_block_info, triggered_batches }))
     }
 
     /// Handles a batch revert event by updating the database.

crates/node/src/test_utils/event_utils.rs

@@ -121,6 +121,15 @@ impl<'a> EventWaiter<'a> {
         Ok(())
     }
 
+    /// Wait for batch commit indexed event on all specified nodes.
+    pub async fn batch_commit_indexed(self) -> eyre::Result<()> {
+        self.wait_for_event_on_all(|e| {
+            matches!(e, ChainOrchestratorEvent::BatchCommitIndexed { .. }).then_some(())
+        })
+        .await?;
+        Ok(())
+    }
+
     /// Wait for batch consolidated event on all specified nodes.
     pub async fn batch_consolidated(self) -> eyre::Result<()> {
         self.wait_for_event_on_all(|e| {
@@ -143,10 +152,10 @@ impl<'a> EventWaiter<'a> {
         Ok(())
     }
 
-    /// Wait for batch finalized event on all specified nodes.
-    pub async fn batch_finalized(self) -> eyre::Result<()> {
+    /// Wait for batch finalize indexed event on all specified nodes.
+    pub async fn batch_finalize_indexed(self) -> eyre::Result<()> {
         self.wait_for_event_on_all(|e| {
-            matches!(e, ChainOrchestratorEvent::BatchFinalized { .. }).then_some(())
+            matches!(e, ChainOrchestratorEvent::BatchFinalizeIndexed { .. }).then_some(())
         })
         .await?;
         Ok(())

crates/node/src/test_utils/fixture.rs

@@ -275,6 +275,8 @@ pub struct AnvilConfig {
     pub chain_id: Option<u64>,
     /// Optional block time for Anvil (in seconds).
     pub block_time: Option<u64>,
+    /// Optional slots in an epoch for Anvil.
+    pub slots_in_an_epoch: Option<u64>,
 }
 
 /// Builder for creating test fixtures with a fluent API.
@@ -528,12 +530,14 @@ impl TestFixtureBuilder {
         state_path: Option<PathBuf>,
         chain_id: Option<u64>,
         block_time: Option<u64>,
+        slots_in_an_epoch: Option<u64>,
     ) -> Self {
         self.anvil_config.enabled = true;
         self.anvil_config.state_path =
             state_path.or_else(|| Some(PathBuf::from("./tests/testdata/anvil_state.json")));
         self.anvil_config.chain_id = chain_id;
         self.anvil_config.block_time = block_time;
+        self.anvil_config.slots_in_an_epoch = slots_in_an_epoch;
         self
     }
 
@@ -545,9 +549,11 @@ impl TestFixtureBuilder {
         // Start Anvil if requested
         let anvil = if self.anvil_config.enabled {
             let handle = Self::spawn_anvil(
+                None,
                 self.anvil_config.state_path.as_deref(),
                 self.anvil_config.chain_id,
                 self.anvil_config.block_time,
+                None,
             )
             .await?;
 
@@ -623,19 +629,18 @@ impl TestFixtureBuilder {
 
     /// Spawn an Anvil instance with the given configuration.
     async fn spawn_anvil(
+        port: Option<u16>,
         state_path: Option<&std::path::Path>,
         chain_id: Option<u64>,
         block_time: Option<u64>,
+        slots_in_an_epoch: Option<u64>,
     ) -> eyre::Result<anvil::NodeHandle> {
-        let mut config = anvil::NodeConfig::default();
+        let mut config = anvil::NodeConfig { port: port.unwrap_or(8544), ..Default::default() };
 
-        // Configure chain ID
         if let Some(id) = chain_id {
             config.chain_id = Some(id);
         }
 
-        config.port = 8544;
-
         // Configure block time
         if let Some(time) = block_time {
             config.block_time = Some(std::time::Duration::from_secs(time));
@@ -650,6 +655,8 @@ impl TestFixtureBuilder {
             config.init_state = Some(state);
         }
 
+        config.slots_in_an_epoch = slots_in_an_epoch.unwrap_or(1);
+
         // Spawn Anvil and return the NodeHandle
         let (_api, handle) = anvil::spawn(config).await;
         Ok(handle)

crates/node/tests/l1_sync.rs

@@ -125,7 +125,7 @@ async fn test_l1_sync_batch_commit() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications() // Prevents automatic L1Synced, simulates initial sync
-        .with_anvil(None, Some(22222222), None)
+        .with_anvil(None, Some(22222222), None, None)
         .build()
         .await?;
 
@@ -140,10 +140,9 @@ async fn test_l1_sync_batch_commit() -> eyre::Result<()> {
         let commit_batch_tx = read_test_transaction("commitBatch", &i.to_string())?;
         fixture.anvil_inject_tx(commit_batch_tx).await?;
     }
-    // fixture.anvil_mine_blocks(1).await?;
-
-    // Allow time for L1 block processing
-    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
+    for _ in 1..=6 {
+        fixture.expect_event().batch_commit_indexed().await?;
+    }
 
     // Step 3: Verify safe head hasn't moved - events should be buffered
     let status = fixture.get_status(0).await?;
@@ -194,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, Some(22222222), None)
+        .with_anvil(None, Some(22222222), None, None)
         .build()
         .await?;
 
@@ -213,8 +212,9 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
         let commit_batch_tx = read_test_transaction("commitBatch", &i.to_string())?;
         fixture.anvil_inject_tx(commit_batch_tx).await?;
     }
-
-    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
+    for _ in 1..=6 {
+        fixture.expect_event().batch_commit_indexed().await?;
+    }
 
     // Step 3: Verify safe head hasn't changed (still syncing)
     let status = fixture.get_status(0).await?;
@@ -225,16 +225,15 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
     );
 
     // Step 4: Send BatchFinalized transactions (batches 1-3) while syncing
-    // Mine 64 blocks to ensure the BatchFinalized events are themselves finalized on L1
+    // Mine blocks to ensure the BatchFinalized events are themselves finalized on L1
     // This should trigger all unprocessed BatchCommit events up to the finalized batch
     for i in 1..=3 {
         let finalize_batch_tx = read_test_transaction("finalizeBatch", &i.to_string())?;
         fixture.anvil_inject_tx(finalize_batch_tx).await?;
     }
-    fixture.anvil_mine_blocks(64).await?;
+    fixture.anvil_mine_blocks(2).await?;
 
     for _ in 1..=3 {
-        // fixture.expect_event().batch_finalized().await?;
         fixture.expect_event().batch_consolidated().await?;
     }
 
@@ -275,10 +274,11 @@ 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(64).await?;
     for _ in 1..=3 {
-        fixture.expect_event().batch_finalized().await?;
+        fixture.expect_event().batch_finalize_indexed().await?;
     }
+    fixture.anvil_mine_blocks(2).await?;
+    fixture.expect_event().l1_block_finalized().await?;
 
     // Step 8: Verify only finalized head advanced (safe head managed by BatchCommit)
     let batch_finalized_status = fixture.get_status(0).await?;
@@ -317,7 +317,7 @@ async fn test_l1_sync_batch_revert() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil(None, Some(22222222), None)
+        .with_anvil(None, Some(22222222), None, None)
         .build()
         .await?;
 
@@ -331,6 +331,9 @@ async fn test_l1_sync_batch_revert() -> eyre::Result<()> {
         let commit_batch_tx = read_test_transaction("commitBatch", &i.to_string())?;
         fixture.anvil_inject_tx(commit_batch_tx).await?;
     }
+    for _ in 1..=6 {
+        fixture.expect_event().batch_commit_indexed().await?;
+    }
 
     // Step 3: Complete L1 sync
     fixture.l1().sync().await?;
@@ -391,7 +394,7 @@ async fn test_l1_reorg_batch_commit() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil(None, Some(22222222), None)
+        .with_anvil(None, Some(22222222), None, None)
         .build()
         .await?;
 
@@ -432,6 +435,7 @@ async fn test_l1_reorg_batch_commit() -> eyre::Result<()> {
 
     // Step 4: Perform L1 reorg to remove batches 4-6 (reorg depth 3)
     fixture.anvil_reorg(3).await?;
+    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
 
     // Wait for reorg detection
     fixture.expect_event().l1_reorg().await?;
@@ -474,7 +478,7 @@ async fn test_l1_reorg_batch_finalized() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil(None, Some(22222222), None)
+        .with_anvil(None, Some(22222222), None, None)
         .build()
         .await?;
 
@@ -496,7 +500,7 @@ async fn test_l1_reorg_batch_finalized() -> eyre::Result<()> {
         fixture.anvil_inject_tx(finalize_batch_tx).await?;
     }
     for _ in 1..=2 {
-        fixture.expect_event().batch_finalized().await?;
+        fixture.expect_event().batch_finalize_indexed().await?;
     }
 
     // Record finalized head after finalization
@@ -553,7 +557,7 @@ async fn test_l1_reorg_batch_revert() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil(None, Some(22222222), None)
+        .with_anvil(None, Some(22222222), None, None)
         .build()
         .await?;