fix: chainspec dev l1 config

Author: yiweichi

crates/node/src/test_utils/fixture.rs

@@ -10,7 +10,7 @@ use crate::{
 };
 
 use alloy_eips::BlockNumberOrTag;
-use alloy_primitives::{address, Address};
+use alloy_primitives::Address;
 use alloy_provider::{Provider, ProviderBuilder};
 use alloy_rpc_types_eth::Block;
 use alloy_signer_local::PrivateKeySigner;
@@ -226,11 +226,6 @@ impl TestFixture {
         self.anvil.as_ref().map(|a| a.http_endpoint())
     }
 
-    /// Check if Anvil is running.
-    pub const fn has_anvil(&self) -> bool {
-        self.anvil.is_some()
-    }
-
     /// 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
@@ -557,23 +552,6 @@ impl TestFixtureBuilder {
         self
     }
 
-    /// Set custom L1 config addresses for Anvil testing.
-    /// This method reads contract addresses from tests/anvil.env.
-    pub fn with_anvil_l1_config(mut self) -> Self {
-        let chain_spec = self.chain_spec.take().unwrap_or_else(|| SCROLL_DEV.clone());
-        let mut spec = (*chain_spec).clone();
-        spec.config.l1_config.scroll_chain_address =
-            address!("0x5FC8d32690cc91D4c39d9d3abcBD16989F875707");
-        spec.config.l1_config.l1_message_queue_address =
-            address!("0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9");
-        spec.config.l1_config.l1_message_queue_v2_address =
-            address!("0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9");
-        spec.config.l1_config.l2_system_config_address =
-            address!("0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0");
-        self.chain_spec = Some(Arc::new(spec));
-        self
-    }
-
     /// Build the test fixture.
     pub async fn build(self) -> eyre::Result<TestFixture> {
         let mut config = self.config;

crates/node/tests/l1_sync.rs

@@ -6,7 +6,6 @@
 //! Related to: https://github.com/scroll-tech/rollup-node/issues/420
 
 use alloy_primitives::Bytes;
-use reth_scroll_chainspec::SCROLL_DEV;
 use rollup_node::test_utils::{EventAssertions, TestFixture};
 use serde_json::Value;
 
@@ -47,14 +46,13 @@ fn read_test_transaction(tx_type: &str, index: &str) -> eyre::Result<Bytes> {
 /// Test: BatchCommit during Syncing state should have no effect.
 ///
 /// Expected: The node should not update the safe head since we only process
-/// BatchCommit events 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)
-        .with_chain_spec(SCROLL_DEV.clone())
         .skip_l1_synced_notifications()
         .with_anvil_default_state()
         .with_anvil_chain_id(22222222)
@@ -103,7 +101,6 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
 
     let mut fixture = TestFixture::builder()
         .followers(1)
-        .with_chain_spec(SCROLL_DEV.clone())
         .skip_l1_synced_notifications()
         .with_anvil_default_state()
         .with_anvil_chain_id(22222222)
@@ -170,8 +167,8 @@ async fn test_l1_sync_batch_finalized() -> eyre::Result<()> {
     }
     fixture.anvil_mine_blocks(64).await?;
 
-    // Wait for l1 blocks to be processed
-    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
+    // Wait for batch finalized event
+    fixture.expect_event().batch_finalized().await?;
 
     // Check that finalized head was updated
     let batch_finalized_status = fixture.get_sequencer_status().await?;
@@ -193,7 +190,6 @@ async fn test_l1_sync_batch_revert() -> eyre::Result<()> {
 
     let mut fixture = TestFixture::builder()
         .followers(1)
-        .with_chain_spec(SCROLL_DEV.clone())
         .skip_l1_synced_notifications()
         .with_anvil_default_state()
         .with_anvil_chain_id(22222222)
@@ -257,58 +253,58 @@ async fn test_l1_reorg_batch_commit() -> eyre::Result<()> {
 
     let mut fixture = TestFixture::builder()
         .followers(1)
-        .with_chain_spec(SCROLL_DEV.clone())
         .skip_l1_synced_notifications()
         .with_anvil_default_state()
         .with_anvil_chain_id(22222222)
         .build()
         .await?;
 
-    // Send BatchCommit transactions 0-2
-    for i in 0..=2 {
+    // Trigger L1 synced event
+    fixture.l1().sync().await?;
+    fixture.expect_event().l1_synced().await?;
+
+    // Send BatchCommit transactions 0-3
+    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?;}
     }
 
-    // Trigger L1 sync
-    fixture.l1().sync().await?;
-    fixture.expect_event().l1_synced().await?;
-    fixture.expect_event().batch_consolidated().await?;
-
     // Check that safe head was updated to batch 2
-    let status_after_sync = fixture.get_sequencer_status().await?;
-    let safe_after_batch_2 = status_after_sync.l2.fcs.safe_block_info().number;
-    tracing::info!("Safe head after batch 2: {}", safe_after_batch_2);
+    let status_after_batch_3 = fixture.get_sequencer_status().await?;
+    let safe_after_batch_3 = status_after_batch_3.l2.fcs.safe_block_info().number;
+    tracing::info!("Safe head after batch 3: {}", safe_after_batch_3);
 
-    // Send BatchCommit transaction 3
-    let commit_batch_3_tx = read_test_transaction("commitBatch", "3")?;
-    fixture.anvil_send_raw_transaction(commit_batch_3_tx).await?;
+    // Send BatchCommit transactions 4-6
+    for i in 4..=6 {
+        let commit_batch_tx = read_test_transaction("commitBatch", &i.to_string())?;
+        fixture.anvil_send_raw_transaction(commit_batch_tx).await?;
+    }
 
     // Wait for processing
     tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
 
     // Check that safe head advanced to batch 3
-    let status_after_batch_3 = fixture.get_sequencer_status().await?;
-    let safe_after_batch_3 = status_after_batch_3.l2.fcs.safe_block_info().number;
-    tracing::info!("Safe head after batch 3: {}", safe_after_batch_3);
+    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!(
-        safe_after_batch_3 > safe_after_batch_2,
+        safe_after_batch_6 > safe_after_batch_6,
         "Safe head should advance after BatchCommit when L1Synced"
     );
 
     // Reorg to remove batch 3 (reorg depth 1)
-    fixture.anvil_reorg(1).await?;
+    fixture.anvil_reorg(3).await?;
     fixture.anvil_mine_blocks(1).await?;
 
-    // Wait for reorg to be detected and processed
-    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
+    fixture.expect_event().l1_reorg().await?;
 
-    // Check that safe head reverted to batch 2
+    // Check that safe head reverted
     let status_after_reorg = fixture.get_sequencer_status().await?;
     let safe_after_reorg = status_after_reorg.l2.fcs.safe_block_info().number;
     tracing::info!("Safe head after reorg: {}", safe_after_reorg);
     assert_eq!(
-        safe_after_reorg, safe_after_batch_2,
+        safe_after_reorg, safe_after_batch_3,
         "Safe head should revert to previous BatchCommit after reorg"
     );
 
@@ -326,7 +322,6 @@ async fn test_l1_reorg_batch_finalized() -> eyre::Result<()> {
 
     let mut fixture = TestFixture::builder()
         .followers(1)
-        .with_chain_spec(SCROLL_DEV.clone())
         .skip_l1_synced_notifications()
         .with_anvil_default_state()
         .with_anvil_chain_id(22222222)
@@ -388,7 +383,6 @@ async fn test_l1_reorg_batch_revert() -> eyre::Result<()> {
 
     let mut fixture = TestFixture::builder()
         .followers(1)
-        .with_chain_spec(SCROLL_DEV.clone())
         .skip_l1_synced_notifications()
         .with_anvil_default_state()
         .with_anvil_chain_id(22222222)

crates/node/tests/testdata/send_commit_batch.sh

@@ -14,7 +14,7 @@ pub const SEPOLIA_ROLLUP_CONTRACT_ADDRESS: Address =
 
 /// The address of the Scroll Rollup contract on Devnet.
 pub const DEVNET_ROLLUP_CONTRACT_ADDRESS: Address =
-    address!("000000000000000000000000000000000000dead");
+    address!("0x5FC8d32690cc91D4c39d9d3abcBD16989F875707");
 
 /// The address of the Scroll L1 message queue v1 contract on Mainnet.
 pub const MAINNET_L1_MESSAGE_QUEUE_V1_CONTRACT_ADDRESS: Address =
@@ -26,7 +26,7 @@ pub const SEPOLIA_L1_MESSAGE_QUEUE_V1_CONTRACT_ADDRESS: Address =
 
 /// The address of the Scroll L1 message queue v1 contract on Devnet.
 pub const DEVNET_L1_MESSAGE_QUEUE_V1_CONTRACT_ADDRESS: Address =
-    address!("000000000000000000000000000000000001dead");
+    address!("0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9");
 
 /// The address of the Scroll L1 message queue v2 contract on Mainnet.
 pub const MAINNET_L1_MESSAGE_QUEUE_V2_CONTRACT_ADDRESS: Address =
@@ -38,7 +38,7 @@ pub const SEPOLIA_L1_MESSAGE_QUEUE_V2_CONTRACT_ADDRESS: Address =
 
 /// The address of the Scroll L1 message queue v2 contract on Devnet.
 pub const DEVNET_L1_MESSAGE_QUEUE_V2_CONTRACT_ADDRESS: Address =
-    address!("000000000000000000000000000000000002dead");
+    address!("0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9");
 
 /// The address of the system contract on Mainnet.
 pub const MAINNET_SYSTEM_CONTRACT_ADDRESS: Address =
@@ -50,7 +50,7 @@ pub const SEPOLIA_SYSTEM_CONTRACT_ADDRESS: Address =
 
 /// The address of the system contract on Devnet.
 pub const DEV_SYSTEM_CONTRACT_ADDRESS: Address =
-    address!("000000000000000000000000000000000003dead");
+    address!("0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0");
 
 /// The L1 start block for Mainnet.
 pub const MAINNET_L1_START_BLOCK_NUMBER: u64 = 18306000;

crates/primitives/src/node/config.rs

@@ -11,7 +11,7 @@ pub use metrics::WatcherMetrics;
 pub mod test_utils;
 
 use alloy_network::Ethereum;
-use alloy_primitives::{address, ruint::UintTryTo, BlockNumber, B256};
+use alloy_primitives::{ruint::UintTryTo, BlockNumber, B256};
 use alloy_provider::{Network, Provider};
 use alloy_rpc_types_eth::{BlockNumberOrTag, Filter, Log, TransactionTrait};
 use alloy_sol_types::SolEvent;
@@ -826,16 +826,12 @@ where
     /// [`field@L1Watcher::log_query_block_range`]\].
     async fn next_filtered_logs(&self, latest_block_number: u64) -> L1WatcherResult<Vec<Log>> {
         // set the block range for the query
-        // let address_book = &self.config.address_book;
+        let address_book = &self.config.address_book;
         let mut filter = Filter::new()
             .address(vec![
-                address!("0x5FC8d32690cc91D4c39d9d3abcBD16989F875707"), /* address_book.rollup_node_contract_address,
-                                                                         * address_book.
-                                                                         * v1_message_queue_address,
-                                                                         *
-                                                                         * address_book.
-                                                                         * v2_message_queue_address,
-                                                                         */
+                address_book.rollup_node_contract_address,
+                address_book.v1_message_queue_address,
+                address_book.v2_message_queue_address,
             ])
             .event_signature(vec![
                 QueueTransaction::SIGNATURE_HASH,