update rpc and default optimistic sync threshold

Author: frisitano

.github/workflows/lint.yaml

@@ -92,7 +92,7 @@ jobs:
         with:
           cache-on-failure: true
       - name: Run doc
-        run: cargo docs --document-private-items
+        run: cargo docs --document-private-items --exclude rollup-node-chain-orchestrator
         env:
           RUSTDOCFLAGS: --cfg docsrs --show-type-layout --generate-link-to-definition --enable-index-page -Zunstable-options -D warnings
 

Makefile

@@ -97,7 +97,7 @@ export-sample-test-data:
 
 .PHONY: docs
 docs:
-	cargo docs --document-private-items
+	cargo docs --document-private-items --exclude rollup-node-chain-orchestrator
 
 .PHONY: pr
 pr: lint test docs

crates/chain-orchestrator/src/lib.rs

@@ -329,10 +329,16 @@ impl<
                 let _ = tx.send(self.event_listener());
             }
             ChainOrchestratorCommand::Status(tx) => {
-                let status = ChainOrchestratorStatus {
-                    sync_state: self.sync_state.clone(),
-                    forkchoice_state: self.engine.fcs().clone(),
-                };
+                let db_tx = self.database.tx_mut().await?;
+                let l1_latest = db_tx.get_latest_l1_block_number().await?;
+                let l1_finalized = db_tx.get_finalized_l1_block_number().await?;
+                db_tx.commit().await?;
+                let status = ChainOrchestratorStatus::new(
+                    &self.sync_state,
+                    l1_latest,
+                    l1_finalized,
+                    self.engine.fcs().clone(),
+                );
                 let _ = tx.send(status);
             }
             ChainOrchestratorCommand::NetworkHandle(tx) => {
@@ -697,10 +703,7 @@ impl<
 
                 // Get all unprocessed batches that have been finalized by this L1 block
                 // finalization.
-                let finalized_block_number = tx
-                    .get_finalized_l1_block_number()
-                    .await?
-                    .expect("finalized block number must exist");
+                let finalized_block_number = tx.get_finalized_l1_block_number().await?;
                 if finalized_block_number >= block_number {
                     let finalized_batches = tx
                         .fetch_and_update_unprocessed_finalized_batches(finalized_block_number)
@@ -987,7 +990,7 @@ impl<
 
             // If we did not find a common ancestor, we add all the fetched headers to the front of
             // the deque and continue fetching.
-            for header in headers.into_iter() {
+            for header in headers {
                 new_headers.push_front(header);
             }
         }

crates/chain-orchestrator/src/status.rs

@@ -1,12 +1,54 @@
-use super::SyncState;
+use crate::sync::{SyncMode, SyncState};
 use scroll_engine::ForkchoiceState;
 
 /// The current status of the chain orchestrator.
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ChainOrchestratorStatus {
-    /// The current sync state of the orchestrator.
-    pub sync_state: SyncState,
-    /// The current FCS for the manager.
-    pub forkchoice_state: ForkchoiceState,
+    /// The chain status for L1.
+    pub l1: L1ChainStatus,
+    /// The chain status for L2.
+    pub l2: L2ChainStatus,
+}
+
+impl ChainOrchestratorStatus {
+    /// Creates a new [`ChainOrchestratorStatus`] from the given sync state, latest L1 block number,
+    pub fn new(
+        sync_state: &SyncState,
+        l1_latest: u64,
+        l1_finalized: u64,
+        l2_fcs: ForkchoiceState,
+    ) -> Self {
+        Self {
+            l1: L1ChainStatus {
+                status: sync_state.l1().clone(),
+                latest: l1_latest,
+                finalized: l1_finalized,
+            },
+            l2: L2ChainStatus { status: sync_state.l2().clone(), fcs: l2_fcs },
+        }
+    }
+}
+
+/// The status of the L1 chain.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct L1ChainStatus {
+    /// The sync mode of the chain.
+    pub status: SyncMode,
+    /// The latest block number of the chain.
+    pub latest: u64,
+    /// The finalized block number of the chain.
+    pub finalized: u64,
+}
+
+/// The status of the L2 chain.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct L2ChainStatus {
+    /// The sync mode of the chain.
+    pub status: SyncMode,
+    /// The current fork choice state of the chain.
+    #[cfg_attr(feature = "serde", serde(flatten))]
+    pub fcs: ForkchoiceState,
 }

crates/database/db/src/error.rs

@@ -19,10 +19,4 @@ pub enum DatabaseError {
     /// The L1 message was not found in database.
     #[error("L1 message at key [{0}] not found in database")]
     L1MessageNotFound(L1MessageKey),
-    /// The finalized L1 block was not found in database.
-    #[error("Finalized L1 block not found in database")]
-    FinalizedL1BlockNotFound,
-    /// The latest L1 block was not found in database.
-    #[error("Latest L1 block not found in database")]
-    LatestL1BlockNotFound,
 }

crates/database/db/src/operations.rs

@@ -231,7 +231,7 @@ pub trait DatabaseWriteOperations: WriteConnectionProvider + DatabaseReadOperati
         tracing::trace!(target: "scroll::db", "Fetching startup safe block from database.");
 
         // Unwind the database to the last finalized L1 block saved in database.
-        let finalized_block_number = self.get_finalized_l1_block_number().await?.unwrap_or(0);
+        let finalized_block_number = self.get_finalized_l1_block_number().await?;
         self.unwind(genesis_hash, finalized_block_number).await?;
 
         // Delete all unprocessed batches from the database and return starting l2 safe head and l1
@@ -528,27 +528,31 @@ pub trait DatabaseReadOperations: ReadConnectionProvider + Sync {
     }
 
     /// Get the latest L1 block number from the database.
-    async fn get_latest_l1_block_number(&self) -> Result<Option<u64>, DatabaseError> {
+    async fn get_latest_l1_block_number(&self) -> Result<u64, DatabaseError> {
         Ok(models::metadata::Entity::find()
             .filter(models::metadata::Column::Key.eq("l1_latest_block"))
             .select_only()
             .column(models::metadata::Column::Value)
             .into_tuple::<String>()
             .one(self.get_connection())
-            .await
-            .map(|x| x.and_then(|x| x.parse::<u64>().ok()))?)
+            .await?
+            .expect("l1_latest_block should always be set")
+            .parse::<u64>()
+            .expect("l1_latest_block should always be a valid u64"))
     }
 
     /// Get the finalized L1 block number from the database.
-    async fn get_finalized_l1_block_number(&self) -> Result<Option<u64>, DatabaseError> {
+    async fn get_finalized_l1_block_number(&self) -> Result<u64, DatabaseError> {
         Ok(models::metadata::Entity::find()
             .filter(models::metadata::Column::Key.eq("l1_finalized_block"))
             .select_only()
             .column(models::metadata::Column::Value)
             .into_tuple::<String>()
             .one(self.get_connection())
-            .await
-            .map(|x| x.and_then(|x| x.parse::<u64>().ok()))?)
+            .await?
+            .expect("l1_finalized_block should always be set")
+            .parse::<u64>()
+            .expect("l1_finalized_block should always be a valid u64"))
     }
 
     /// Get the latest L2 head block info.
@@ -701,10 +705,7 @@ pub trait DatabaseReadOperations: ReadConnectionProvider + Sync {
                 }
             }
             Some(L1MessageKey::NotIncluded(NotIncludedStart::Finalized)) => {
-                let finalized_block_number = self
-                    .get_finalized_l1_block_number()
-                    .await?
-                    .ok_or(DatabaseError::FinalizedL1BlockNotFound)?;
+                let finalized_block_number = self.get_finalized_l1_block_number().await?;
                 let condition = Condition::all()
                     .add(
                         models::l1_message::Column::L1BlockNumber
@@ -721,10 +722,7 @@ pub trait DatabaseReadOperations: ReadConnectionProvider + Sync {
                 ))
             }
             Some(L1MessageKey::NotIncluded(NotIncludedStart::BlockDepth(depth))) => {
-                let latest_block_number = self
-                    .get_latest_l1_block_number()
-                    .await?
-                    .ok_or(DatabaseError::LatestL1BlockNotFound)?;
+                let latest_block_number = self.get_latest_l1_block_number().await?;
 
                 let target_block_number = latest_block_number.checked_sub(depth);
                 if let Some(target_block_number) = target_block_number {

crates/node/src/constants.rs

@@ -27,7 +27,7 @@ pub(crate) const DEFAULT_PAYLOAD_BUILDING_DURATION: u64 = 800;
 pub(crate) const DEFAULT_PAYLOAD_SIZE_LIMIT: u64 = 122_880;
 
 /// The gap in blocks between the P2P and EN which triggers sync.
-pub(crate) const BLOCK_GAP_TRIGGER: u64 = 100_000;
+pub(crate) const BLOCK_GAP_TRIGGER: u64 = 1_000;
 
 /// The number of block headers to keep in the in-memory chain buffer in the chain orchestrator.
 pub(crate) const CHAIN_BUFFER_SIZE: usize = 2000;

crates/node/tests/e2e.rs

@@ -1184,7 +1184,7 @@ async fn graceful_shutdown_sets_fcs_to_latest_sequenced_block_in_db_on_start_up(
     let status = handle.status().await?;
 
     // The fcs should be set to the database head.
-    assert_eq!(status.forkchoice_state.head_block_info(), &db_head_block_info);
+    assert_eq!(status.l2.fcs.head_block_info(), &db_head_block_info);
 
     Ok(())
 }
@@ -1269,8 +1269,8 @@ async fn can_handle_batch_revert() -> eyre::Result<()> {
     let status = handle.status().await?;
 
     // Assert the forkchoice state is above 4
-    assert!(status.forkchoice_state.head_block_info().number > 4);
-    assert!(status.forkchoice_state.safe_block_info().number > 4);
+    assert!(status.l2.fcs.head_block_info().number > 4);
+    assert!(status.l2.fcs.safe_block_info().number > 4);
 
     // Send the third batch which should trigger the revert.
     l1_watcher_tx.send(Arc::new(L1Notification::BatchCommit(revert_batch_data))).await?;
@@ -1281,8 +1281,8 @@ async fn can_handle_batch_revert() -> eyre::Result<()> {
     let status = handle.status().await?;
 
     // Assert the forkchoice state was reset to 4.
-    assert_eq!(status.forkchoice_state.head_block_info().number, 4);
-    assert_eq!(status.forkchoice_state.safe_block_info().number, 4);
+    assert_eq!(status.l2.fcs.head_block_info().number, 4);
+    assert_eq!(status.l2.fcs.safe_block_info().number, 4);
 
     Ok(())
 }