fix: ci

Author: yiweichi

crates/node/src/args.rs

@@ -366,15 +366,15 @@ impl ScrollRollupNodeConfig {
                 .filter(|_| !self.test_args.test || self.blob_provider_args.anvil_url.is_some())
             {
                 tracing::info!(target: "scroll::node::args", ?l1_block_startup_info, "Starting L1 watcher");
-                    let (tx, rx) = L1Watcher::spawn(
-                        provider,
-                        l1_block_startup_info,
-                        node_config,
-                        self.l1_provider_args.logs_query_block_range,
-                        self.test_args.test && self.test_args.skip_l1_synced,
-                    )
-                    .await;
-                    (Some(tx), Some(rx))
+                let (tx, rx) = L1Watcher::spawn(
+                    provider,
+                    l1_block_startup_info,
+                    node_config,
+                    self.l1_provider_args.logs_query_block_range,
+                    self.test_args.test && self.test_args.skip_l1_synced,
+                )
+                .await;
+                (Some(tx), Some(rx))
             } else {
                 // Create a channel for L1 notifications that we can use to inject L1 messages for
                 // testing

crates/node/src/test_utils/fixture.rs

@@ -216,17 +216,12 @@ impl TestFixture {
         self.get_status(0).await
     }
 
-    /// Get the Anvil instance if one was started.
-    pub const fn anvil(&self) -> Option<&anvil::NodeHandle> {
-        self.anvil.as_ref()
-    }
-
     /// Get the Anvil HTTP endpoint if Anvil was started.
     pub fn anvil_endpoint(&self) -> Option<String> {
         self.anvil.as_ref().map(|a| a.http_endpoint())
     }
 
-    /// Generate Anvil blocks by calling anvil_mine RPC method.
+    /// Generate Anvil blocks by calling `anvil_mine` RPC method.
     pub async fn anvil_mine_blocks(&self, num_blocks: u64) -> eyre::Result<()> {
         // Ensure Anvil is running
         let anvil_endpoint =
@@ -277,9 +272,7 @@ impl TestFixture {
         // Parameters: (depth, transactions)
         // - depth: number of blocks to rewind from current head
         // - transactions: empty array means reorg without adding new transactions
-        let _: () = client
-            .request("anvil_reorg", (depth, Vec::<String>::new()))
-            .await?;
+        let _: () = client.request("anvil_reorg", (depth, Vec::<String>::new())).await?;
 
         tracing::info!("Reorged Anvil by {} blocks", depth);
 
@@ -371,14 +364,14 @@ impl TestFixtureBuilder {
     }
 
     /// Toggle the test field.
-    pub fn with_test(mut self, test: bool) -> Self {
+    pub const fn with_test(mut self, test: bool) -> Self {
         self.config.test_args.test = test;
         self
     }
 
     /// Enable test mode to skip L1 watcher Synced notifications.
     /// This is useful for tests that don't want to wait for L1 sync completion events.
-    pub fn skip_l1_synced_notifications(mut self) -> Self {
+    pub const fn skip_l1_synced_notifications(mut self) -> Self {
         self.config.test_args.skip_l1_synced = true;
         self
     }
@@ -520,21 +513,15 @@ impl TestFixtureBuilder {
         &mut self.config
     }
 
-    /// Enable Anvil with default settings.
-    pub const fn with_anvil(mut self) -> Self {
-        self.enable_anvil = true;
-        self
-    }
-
     /// Enable Anvil with the default state file (`./tests/testdata/anvil_state.json`).
-    pub fn with_anvil_default_state(mut self) -> Self {
+    pub fn with_anvil(mut self) -> Self {
         self.enable_anvil = true;
         self.anvil_state_path = Some(PathBuf::from("./tests/testdata/anvil_state.json"));
         self
     }
 
     /// Enable Anvil with a custom state file.
-    pub fn with_anvil_state(mut self, path: impl Into<PathBuf>) -> Self {
+    pub fn with_anvil_custom_state(mut self, path: impl Into<PathBuf>) -> Self {
         self.enable_anvil = true;
         self.anvil_state_path = Some(path.into());
         self

crates/node/tests/l1_sync.rs

@@ -3,14 +3,13 @@
 //! This test suite covers the behavior of the rollup node when consuming events from L1
 //! in different sync states, handling reorgs, and recovering from shutdowns.
 //!
-//! Related to: https://github.com/scroll-tech/rollup-node/issues/420
+//! Related to: <https://github.com/scroll-tech/rollup-node/issues/420>
 
 use alloy_primitives::Bytes;
 use rollup_node::test_utils::{EventAssertions, TestFixture};
 use serde_json::Value;
 
-
-/// Helper to read transaction from test_transactions.json
+/// Helper to read transaction from `test_transactions.json`
 fn read_test_transaction(tx_type: &str, index: &str) -> eyre::Result<Bytes> {
     let tx_json_path = "./tests/testdata/test_transactions.json";
     let tx_json_content = std::fs::read_to_string(tx_json_path)
@@ -43,18 +42,18 @@ fn read_test_transaction(tx_type: &str, index: &str) -> eyre::Result<Bytes> {
 // Test Suite 1: Correct behavior when consuming events from L1
 // =============================================================================
 
-/// Test: BatchCommit during Syncing state should have no effect.
+/// Test: `BatchCommit` during Syncing state should have no effect.
 ///
 /// Expected: The node should not update the safe head since we only process
-/// BatchCommit eventds after the node is synced (post L1Synced notification).
+/// `BatchCommit` eventds after the node is synced (post `L1Synced` notification).
 #[tokio::test]
 async fn test_l1_sync_batch_commit() -> eyre::Result<()> {
     reth_tracing::init_test_tracing();
 
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil_default_state()
+        .with_anvil()
         .with_anvil_chain_id(22222222)
         .build()
         .await?;
@@ -94,15 +93,14 @@ async fn test_l1_sync_batch_commit() -> eyre::Result<()> {
     Ok(())
 }
 
-
 #[tokio::test]
 async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
     reth_tracing::init_test_tracing();
 
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil_default_state()
+        .with_anvil()
         .with_anvil_chain_id(22222222)
         .build()
         .await?;
@@ -173,11 +171,13 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
     // Check that finalized head was updated
     let batch_finalized_status = fixture.get_sequencer_status().await?;
     assert!(
-        batch_finalized_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 ==
+            l1_synced_status.l2.fcs.safe_block_info().number,
         "Safe head should not advance after BatchFinalized event when L1 Synced"
     );
     assert!(
-        batch_finalized_status.l2.fcs.finalized_block_info().number > l1_synced_status.l2.fcs.finalized_block_info().number,
+        batch_finalized_status.l2.fcs.finalized_block_info().number >
+            l1_synced_status.l2.fcs.finalized_block_info().number,
         "Finalized head should advance after BatchFinalized event when L1 Synced"
     );
 
@@ -191,7 +191,7 @@ async fn test_l1_sync_batch_revert() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil_default_state()
+        .with_anvil()
         .with_anvil_chain_id(22222222)
         .build()
         .await?;
@@ -206,10 +206,11 @@ async fn test_l1_sync_batch_revert() -> eyre::Result<()> {
         fixture.anvil_send_raw_transaction(commit_batch_tx).await?;
     }
 
+    fixture.anvil_mine_blocks(64).await?;
+
+    // Trigger L1 synced event
     fixture.l1().sync().await?;
     fixture.expect_event().l1_synced().await?;
-    fixture.expect_event().batch_consolidated().await?;
-    fixture.anvil_mine_blocks(64).await?;
 
     // Wait for l1 blocks to be processed
     tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
@@ -218,13 +219,13 @@ async fn test_l1_sync_batch_revert() -> eyre::Result<()> {
     let new_status = fixture.get_sequencer_status().await?;
     assert!(
         new_status.l2.fcs.safe_block_info().number > initial_safe,
-        "Safe head should advance after BatchCommit when synced and L1Synced"
+        "Safe head should advance after BatchCommit when L1Synced"
     );
 
     // Send BatchRevert transactions
     let revert_batch_tx = read_test_transaction("revertBatch", "0")?;
     fixture.anvil_send_raw_transaction(revert_batch_tx).await?;
-    fixture.anvil_mine_blocks(64).await?;
+    fixture.anvil_mine_blocks(10).await?;
 
     // Wait for l1 blocks to be processed
     tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
@@ -243,18 +244,18 @@ async fn test_l1_sync_batch_revert() -> eyre::Result<()> {
 // Test Suite 2: L1 Reorg handling for different batch events
 // =============================================================================
 
-/// Test: L1 reorg of BatchCommit after L1Synced.
+/// Test: L1 reorg of `BatchCommit` after `L1Synced`.
 ///
-/// Expected: When a BatchCommit is reorged after the node has synced (L1Synced),
-/// the safe head should revert to the last block of the previous BatchCommit.
+/// Expected: When a `BatchCommit` is reorged after the node has synced (`L1Synced`),
+/// the safe head should revert to the last block of the previous `BatchCommit`.
 #[tokio::test]
 async fn test_l1_reorg_batch_commit() -> eyre::Result<()> {
     reth_tracing::init_test_tracing();
 
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil_default_state()
+        .with_anvil()
         .with_anvil_chain_id(22222222)
         .build()
         .await?;
@@ -267,7 +268,9 @@ async fn test_l1_reorg_batch_commit() -> eyre::Result<()> {
     for i in 0..=3 {
         let commit_batch_tx = read_test_transaction("commitBatch", &i.to_string())?;
         fixture.anvil_send_raw_transaction(commit_batch_tx).await?;
-        if i!=0 {fixture.expect_event().batch_consolidated().await?;}
+        if i != 0 {
+            fixture.expect_event().batch_consolidated().await?;
+        }
     }
 
     // Check that safe head was updated to batch 2
@@ -285,7 +288,8 @@ async fn test_l1_reorg_batch_commit() -> eyre::Result<()> {
     tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
 
     // Check that safe head advanced to batch 3
-    let status_after_batch_6: rollup_node_chain_orchestrator::ChainOrchestratorStatus = fixture.get_sequencer_status().await?;
+    let status_after_batch_6: rollup_node_chain_orchestrator::ChainOrchestratorStatus =
+        fixture.get_sequencer_status().await?;
     let safe_after_batch_6 = status_after_batch_6.l2.fcs.safe_block_info().number;
     tracing::info!("Safe head after batch 6: {}", safe_after_batch_6);
     assert!(
@@ -311,10 +315,10 @@ async fn test_l1_reorg_batch_commit() -> eyre::Result<()> {
     Ok(())
 }
 
-/// Test: L1 reorg of BatchFinalized event.
+/// Test: L1 reorg of `BatchFinalized` event.
 ///
-/// Expected: Reorging BatchFinalized should have no effect because we only update
-/// the finalized head after the BatchFinalized event is itself finalized on L1,
+/// Expected: Reorging `BatchFinalized` should have no effect because we only update
+/// the finalized head after the `BatchFinalized` event is itself finalized on L1,
 /// meaning it can never be reorged in practice.
 #[tokio::test]
 async fn test_l1_reorg_batch_finalized() -> eyre::Result<()> {
@@ -323,7 +327,7 @@ async fn test_l1_reorg_batch_finalized() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil_default_state()
+        .with_anvil()
         .with_anvil_chain_id(22222222)
         .build()
         .await?;
@@ -372,9 +376,9 @@ async fn test_l1_reorg_batch_finalized() -> eyre::Result<()> {
     Ok(())
 }
 
-/// Test: L1 reorg of BatchRevert event.
+/// Test: L1 reorg of `BatchRevert` event.
 ///
-/// Expected: When a BatchRevert is reorged, the safe head should be restored to
+/// Expected: When a `BatchRevert` is reorged, the safe head should be restored to
 /// the state before the revert was applied. If the reverted batches are re-committed
 /// after the reorg, the safe head should advance again.
 #[tokio::test]
@@ -384,7 +388,7 @@ async fn test_l1_reorg_batch_revert() -> eyre::Result<()> {
     let mut fixture = TestFixture::builder()
         .followers(1)
         .skip_l1_synced_notifications()
-        .with_anvil_default_state()
+        .with_anvil()
         .with_anvil_chain_id(22222222)
         .build()
         .await?;
@@ -420,10 +424,7 @@ async fn test_l1_reorg_batch_revert() -> eyre::Result<()> {
     let status_after_revert = fixture.get_sequencer_status().await?;
     let safe_after_revert = status_after_revert.l2.fcs.safe_block_info().number;
     tracing::info!("Safe head after revert: {}", safe_after_revert);
-    assert!(
-        safe_after_revert < safe_after_commits,
-        "Safe head should decrease after BatchRevert"
-    );
+    assert!(safe_after_revert < safe_after_commits, "Safe head should decrease after BatchRevert");
 
     // Reorg to remove the BatchRevert event (reorg depth 1)
     fixture.anvil_reorg(2).await?;
@@ -442,4 +443,4 @@ async fn test_l1_reorg_batch_revert() -> eyre::Result<()> {
     );
 
     Ok(())
-}
+}

crates/providers/src/l1/blob/anvil.rs

@@ -21,6 +21,7 @@ impl AnvilBlobProvider {
 
 #[async_trait::async_trait]
 impl BlobProvider for AnvilBlobProvider {
+    #[allow(clippy::large_stack_frames)]
     async fn blob(
         &self,
         _block_timestamp: u64,

crates/watcher/src/lib.rs

@@ -99,7 +99,7 @@ pub struct L1Watcher<EP> {
     is_synced: bool,
     /// The log query block range.
     log_query_block_range: u64,
-    /// Test mode: skip sending L1Notification::Synced events.
+    /// Test mode: skip sending `L1Notification::Synced` events.
     test_mode_skip_synced_notification: bool,
 }