feat: implement self-healing recovery mechanism for gaps in L1 data

crates/chain-orchestrator/Cargo.toml

@@ -69,10 +69,12 @@ alloy-transport.workspace = true
 # rollup-node
 scroll-db = { workspace = true, features = ["test-utils"] }
 rollup-node-primitives = { workspace = true, features = ["arbitrary"] }
+rollup-node-watcher = { workspace = true, features = ["test-utils"] }
 
 # scroll
 reth-scroll-chainspec.workspace = true
 reth-scroll-forks.workspace = true
+reth-scroll-node = { workspace = true, features = ["test-utils"] }
 
 # reth
 reth-eth-wire-types.workspace = true

crates/chain-orchestrator/src/error.rs

@@ -36,10 +36,6 @@ pub enum ChainOrchestratorError {
     /// An L1 message was not found in the database.
     #[error("L1 message not found at {0}")]
     L1MessageNotFound(L1MessageKey),
-    /// A gap was detected in the L1 message queue: the previous message before index {0} is
-    /// missing.
-    #[error("L1 message queue gap detected at index {0}, previous L1 message not found")]
-    L1MessageQueueGap(u64),
     /// An inconsistency was detected when trying to consolidate the chain.
     #[error("Chain inconsistency detected")]
     ChainInconsistency,
@@ -57,9 +53,6 @@ pub enum ChainOrchestratorError {
         /// The actual number of blocks.
         actual: usize,
     },
-    /// A gap was detected in batch commit events: the previous batch before index {0} is missing.
-    #[error("Batch commit gap detected at index {0}, previous batch commit not found")]
-    BatchCommitGap(u64),
     /// An error occurred while making a network request.
     #[error("Network request error: {0}")]
     NetworkRequestError(#[from] reth_network_p2p::error::RequestError),
@@ -92,6 +85,9 @@ pub enum ChainOrchestratorError {
     /// An error occurred while handling rollup node primitives.
     #[error("An error occurred while handling rollup node primitives: {0}")]
     RollupNodePrimitiveError(rollup_node_primitives::RollupNodePrimitiveError),
+    /// An error occurred during gap reset.
+    #[error("Gap reset error: {0}")]
+    GapResetError(String),
 }
 
 impl CanRetry for ChainOrchestratorError {

crates/chain-orchestrator/src/event.rs

@@ -43,6 +43,15 @@ pub enum ChainOrchestratorEvent {
         /// The L1 block number in which the batch was committed.
         l1_block_number: u64,
     },
+    /// A gap has been detected in the committed batches.
+    BatchCommitGap {
+        /// The missing batch index.
+        missing_index: u64,
+        /// The latest known L1 block number to reset to before the gap.
+        l1_block_number_reset: u64,
+    },
+    /// A duplicate batch commit has been detected.
+    BatchCommitDuplicate(u64),
     /// A batch has been finalized returning a list of finalized batches.
     BatchFinalized {
         /// The L1 block info at which the batch finalization event was received.
@@ -57,13 +66,31 @@ pub enum ChainOrchestratorEvent {
         /// The new safe head after the revert.
         safe_head: BlockInfo,
     },
+    /// A gap has been detected in the reverted batches.
+    BatchRevertGap {
+        /// The missing batch index.
+        missing_index: u64,
+        /// The latest known L1 block number to reset to before the gap.
+        l1_block_number_reset: u64,
+    },
+    /// A duplicate batch revert has been detected.
+    BatchRevertDuplicate(u64),
     /// A new L1 block has been received returning the L1 block number.
     NewL1Block(u64),
     /// An L1 block has been finalized returning the L1 block number and the list of finalized
     /// batches.
     L1BlockFinalized(u64, Vec<BatchInfo>),
     /// A `L1Message` event has been committed returning the message queue index.
     L1MessageCommitted(u64),
+    /// A gap has been detected in the L1 message queue.
+    L1MessageGap {
+        /// The missing L1 message queue index.
+        missing_index: u64,
+        /// The latest known L1 block number to reset to before the gap.
+        l1_block_number_reset: u64,
+    },
+    /// A duplicate L1 message has been detected.
+    L1MessageDuplicate(u64),
     /// A reorg has occurred on L1, returning the L1 block number of the new L1 head,
     /// the L1 message queue index of the new L1 head, and optionally the L2 head and safe block
     /// info if the reorg resulted in a new L2 head or safe block.