fix: use database handle from chain-orchastrator handle

Author: yiweichi

crates/node/src/node.rs

@@ -15,7 +15,6 @@ use reth_scroll_node::{
     ScrollConsensusBuilder, ScrollExecutorBuilder, ScrollNode, ScrollPayloadBuilderBuilder,
     ScrollPoolBuilder,
 };
-use scroll_db::Database;
 use scroll_wire::{ScrollWireConfig, ScrollWireEvent, ScrollWireProtocolHandler};
 use std::sync::Arc;
 use tokio::sync::{mpsc::UnboundedReceiver, Mutex};
@@ -45,11 +44,6 @@ impl ScrollRollupNode {
 
         Self { config, scroll_wire_events: Arc::new(Mutex::new(None)) }
     }
-
-    /// Returns the database instance.
-    pub fn database(&self) -> Arc<Database> {
-        self.config.database.clone().expect("database is set via hydration")
-    }
 }
 
 impl<N> Node<N> for ScrollRollupNode

crates/node/src/test_utils/database.rs

@@ -18,8 +18,8 @@ impl<'a> DatabaseHelper<'a> {
     }
 
     /// Get the database for this node.
-    fn database(&self) -> Arc<Database> {
-        self.fixture.nodes[self.node_index].database.clone()
+    async fn database(&self) -> eyre::Result<Arc<Database>> {
+        Ok(self.fixture.nodes[self.node_index].rollup_manager_handle.get_database_handle().await?)
     }
 
     /// Get the finalized block number of a batch by its index.
@@ -29,8 +29,8 @@ impl<'a> DatabaseHelper<'a> {
     pub async fn get_batch_finalized_block_number_by_index(
         &self,
         index: u64,
-    ) -> Result<Option<Option<u64>>, DatabaseError> {
-        let db = self.database();
+    ) -> eyre::Result<Option<Option<u64>>> {
+        let db = self.database().await?;
         let batch = db
             .tx_mut(move |tx| async move {
                 let batch = tx.get_batch_by_index(index).await?;

crates/node/src/test_utils/fixture.rs

@@ -36,7 +36,6 @@ use rollup_node_watcher::L1Notification;
 use scroll_alloy_consensus::ScrollPooledTransaction;
 use scroll_alloy_provider::{ScrollAuthApiEngineClient, ScrollEngineApi};
 use scroll_alloy_rpc_types::Transaction;
-use scroll_db::Database;
 use scroll_engine::{Engine, ForkchoiceState};
 use std::{
     fmt::{Debug, Formatter},
@@ -100,8 +99,6 @@ pub struct NodeHandle {
     pub chain_orchestrator_rx: EventStream<ChainOrchestratorEvent>,
     /// Chain orchestrator handle.
     pub rollup_manager_handle: ChainOrchestratorHandle<ScrollNetworkHandle>,
-    /// Database instance.
-    pub database: Arc<Database>,
     /// The type of the node.
     pub typ: NodeType,
 }
@@ -595,7 +592,7 @@ impl TestFixtureBuilder {
             None
         };
 
-        let (nodes, databases, _tasks, wallet) = setup_engine(
+        let (nodes, _tasks, wallet) = setup_engine(
             config.clone(),
             self.num_nodes,
             chain_spec.clone(),
@@ -631,7 +628,6 @@ impl TestFixtureBuilder {
                 chain_orchestrator_rx,
                 l1_watcher_tx,
                 rollup_manager_handle,
-                database: databases[index].clone(),
                 typ: if config.sequencer_args.sequencer_enabled && index == 0 {
                     NodeType::Sequencer
                 } else {

crates/node/src/test_utils/mod.rs

@@ -99,7 +99,6 @@ use reth_provider::providers::BlockchainProvider;
 use reth_rpc_server_types::RpcModuleSelection;
 use reth_tasks::TaskManager;
 use rollup_node_sequencer::L1MessageInclusionMode;
-use scroll_db::Database;
 use std::{path::PathBuf, sync::Arc};
 use tokio::sync::Mutex;
 use tracing::{span, Level};
@@ -121,7 +120,6 @@ pub async fn setup_engine(
             BlockchainProvider<NodeTypesWithDBAdapter<ScrollRollupNode, TmpDB>>,
         >,
     >,
-    Vec<Arc<Database>>,
     TaskManager,
     Wallet,
 )>
@@ -143,7 +141,6 @@ where
 
     // Create nodes and peer them
     let mut nodes: Vec<NodeTestContext<_, _>> = Vec::with_capacity(num_nodes);
-    let mut databases: Vec<Arc<Database>> = Vec::with_capacity(num_nodes);
 
     for idx in 0..num_nodes {
         // disable sequencer nodes after the first one
@@ -166,9 +163,7 @@ where
         let _enter = span.enter();
         let testing_node = NodeBuilder::new(node_config.clone()).testing_node(exec.clone());
         let testing_config = testing_node.config().clone();
-        let node: ScrollRollupNode =
-            ScrollRollupNode::new(scroll_node_config.clone(), testing_config).await;
-        let database = node.database();
+        let node = ScrollRollupNode::new(scroll_node_config.clone(), testing_config).await;
         let RethNodeHandle { node, node_exit_future: _ } = testing_node
             .with_types_and_provider::<ScrollRollupNode, BlockchainProvider<_>>()
             .with_components(node.components_builder())
@@ -206,11 +201,10 @@ where
             }
         }
 
-        databases.push(database);
         nodes.push(node);
     }
 
-    Ok((nodes, databases, tasks, Wallet::default().with_chain_id(chain_spec.chain().into())))
+    Ok((nodes, tasks, Wallet::default().with_chain_id(chain_spec.chain().into())))
 }
 
 /// Generate a transfer transaction with the given wallet.

crates/node/tests/e2e.rs

@@ -296,12 +296,12 @@ async fn can_forward_tx_to_sequencer() -> eyre::Result<()> {
 
     // Create the chain spec for scroll mainnet with Euclid v2 activated and a test genesis.
     let chain_spec = (*SCROLL_DEV).clone();
-    let (mut sequencer_node, _databases, _tasks, _) =
+    let (mut sequencer_node, _tasks, _) =
         setup_engine(sequencer_node_config, 1, chain_spec.clone(), false, true).await.unwrap();
 
     let sequencer_url = format!("http://localhost:{}", sequencer_node[0].rpc_url().port().unwrap());
     follower_node_config.network_args.sequencer_url = Some(sequencer_url);
-    let (mut follower_node, _databases, _tasks, wallet) =
+    let (mut follower_node, _tasks, wallet) =
         setup_engine(follower_node_config, 1, chain_spec, false, true).await.unwrap();
 
     let wallet = Arc::new(Mutex::new(wallet));
@@ -459,7 +459,7 @@ async fn can_bridge_blocks() -> eyre::Result<()> {
     let chain_spec = (*SCROLL_DEV).clone();
 
     // Setup the bridge node and a standard node.
-    let (mut nodes, _databases, tasks, _) =
+    let (mut nodes, tasks, _) =
         setup_engine(default_test_scroll_rollup_node_config(), 1, chain_spec.clone(), false, false)
             .await?;
     let mut bridge_node = nodes.pop().unwrap();
@@ -559,7 +559,7 @@ async fn shutdown_consolidates_most_recent_batch_on_startup() -> eyre::Result<()
     let chain_spec = (*SCROLL_MAINNET).clone();
 
     // Launch a node
-    let (mut nodes, _databases, _tasks, _) =
+    let (mut nodes, _tasks, _) =
         setup_engine(default_test_scroll_rollup_node_config(), 1, chain_spec.clone(), false, false)
             .await?;
     let node = nodes.pop().unwrap();
@@ -829,7 +829,7 @@ async fn graceful_shutdown_sets_fcs_to_latest_signed_block_in_db_on_start_up() -
     config.signer_args.private_key = Some(PrivateKeySigner::random());
 
     // Launch a node
-    let (mut nodes, _databases, _tasks, _) =
+    let (mut nodes, _tasks, _) =
         setup_engine(config.clone(), 1, chain_spec.clone(), false, false).await?;
     let node = nodes.pop().unwrap();
 

crates/node/tests/sync.rs

@@ -79,7 +79,7 @@ async fn test_should_consolidate_to_block_15k() -> eyre::Result<()> {
     };
 
     let chain_spec = (*SCROLL_SEPOLIA).clone();
-    let (mut nodes, _databases, _tasks, _) =
+    let (mut nodes, _tasks, _) =
         setup_engine(node_config, 1, chain_spec.clone(), false, false).await?;
     let node = nodes.pop().unwrap();
 
@@ -550,7 +550,7 @@ async fn test_chain_orchestrator_l1_reorg() -> eyre::Result<()> {
     let chain_spec = (*SCROLL_DEV).clone();
 
     // Create a sequencer node and an unsynced node.
-    let (mut nodes, _databases, _tasks, _) =
+    let (mut nodes, _tasks, _) =
         setup_engine(sequencer_node_config.clone(), 1, chain_spec.clone(), false, false)
             .await
             .unwrap();
@@ -559,7 +559,7 @@ async fn test_chain_orchestrator_l1_reorg() -> eyre::Result<()> {
     let mut sequencer_events = sequencer_handle.get_event_listener().await?;
     let sequencer_l1_watcher_tx = sequencer.inner.add_ons_handle.l1_watcher_tx.clone().unwrap();
 
-    let (mut nodes, _databases, _tasks, _) =
+    let (mut nodes, _tasks, _) =
         setup_engine(node_config.clone(), 1, chain_spec.clone(), false, false).await.unwrap();
     let mut follower = nodes.pop().unwrap();
     let mut follower_events = follower.inner.rollup_manager_handle.get_event_listener().await?;

crates/sequencer/tests/e2e.rs

@@ -211,7 +211,7 @@ async fn can_build_blocks_with_delayed_l1_messages() {
     const L1_MESSAGE_DELAY: u64 = 2;
 
     // setup a test node
-    let (mut nodes, _databases, _tasks, wallet) =
+    let (mut nodes, _tasks, wallet) =
         setup_engine(default_test_scroll_rollup_node_config(), 1, chain_spec, false, false)
             .await
             .unwrap();
@@ -336,7 +336,7 @@ async fn can_build_blocks_with_finalized_l1_messages() {
 
     let chain_spec = SCROLL_DEV.clone();
     // setup a test node
-    let (mut nodes, _databases, _tasks, wallet) =
+    let (mut nodes, _tasks, wallet) =
         setup_engine(default_test_scroll_rollup_node_config(), 1, chain_spec, false, false)
             .await
             .unwrap();
@@ -513,7 +513,7 @@ async fn can_sequence_blocks_with_private_key_file() -> eyre::Result<()> {
         rpc_args: RpcArgs::default(),
     };
 
-    let (nodes, _databases, _tasks, wallet) =
+    let (nodes, _tasks, wallet) =
         setup_engine(rollup_manager_args, 1, chain_spec, false, false).await?;
     let wallet = Arc::new(Mutex::new(wallet));
 
@@ -616,7 +616,7 @@ async fn can_sequence_blocks_with_hex_key_file_without_prefix() -> eyre::Result<
         rpc_args: RpcArgs::default(),
     };
 
-    let (nodes, _databases, _tasks, wallet) =
+    let (nodes, _tasks, wallet) =
         setup_engine(rollup_manager_args, 1, chain_spec, false, false).await?;
     let wallet = Arc::new(Mutex::new(wallet));
 
@@ -677,7 +677,7 @@ async fn can_build_blocks_and_exit_at_gas_limit() {
 
     // setup a test node. use a high value for the payload building duration to be sure we don't
     // exit early.
-    let (mut nodes, _databases, _tasks, wallet) = setup_engine(
+    let (mut nodes, _tasks, wallet) = setup_engine(
         ScrollRollupNodeConfig {
             sequencer_args: SequencerArgs { payload_building_duration: 1000, ..Default::default() },
             ..default_test_scroll_rollup_node_config()
@@ -763,7 +763,7 @@ async fn can_build_blocks_and_exit_at_time_limit() {
 
     // setup a test node. use a low payload building duration in order to exit before we reach the
     // gas limit.
-    let (mut nodes, _databases, _tasks, wallet) = setup_engine(
+    let (mut nodes, _tasks, wallet) = setup_engine(
         ScrollRollupNodeConfig {
             sequencer_args: SequencerArgs { payload_building_duration: 10, ..Default::default() },
             ..default_test_scroll_rollup_node_config()
@@ -851,7 +851,7 @@ async fn should_limit_l1_message_cumulative_gas() {
 
     // setup a test node
     let chain_spec = SCROLL_DEV.clone();
-    let (mut nodes, _databases, _tasks, wallet) =
+    let (mut nodes, _tasks, wallet) =
         setup_engine(default_test_scroll_rollup_node_config(), 1, chain_spec, false, false)
             .await
             .unwrap();
@@ -968,7 +968,7 @@ async fn should_not_add_skipped_messages() {
 
     // setup a test node
     let chain_spec = SCROLL_DEV.clone();
-    let (mut nodes, _databases, _tasks, wallet) =
+    let (mut nodes, _tasks, wallet) =
         setup_engine(default_test_scroll_rollup_node_config(), 1, chain_spec, false, false)
             .await
             .unwrap();