feat(l2): enhance monitor performance (#3757)

**Motivation**
If a sequencer runs for a long time, it stops, and we run it again
activating the monitor, it takes a long time to start and is slow.
<!-- Why does this pull request exist? What are its goals? -->

**Description**
Makes the monitor load and work faster by simplifying the batches
processing.
<!-- A clear and concise general description of the changes this PR
introduces -->

**How to Test**

- Run a Sequencer (I suggest `make restart` in `crates/l2`).
- Run the prover with `make init-prover` in `crates/l2`.
- Let the sequencer ran for some time (at least 60 batches)
- Kill the sequencer
- Add `--monitor` to the `init-l2-no-metrics` target in
`crates/l2/Makefile`.
- Run `make init-l2-no-metrics`

<!-- Link to issues: Resolves #111, Resolves #222 -->

Author: gianbelinche

crates/l2/monitor/widget/batches.rs

@@ -14,6 +14,8 @@ use crate::{
     sequencer::errors::MonitorError,
 };
 
+const BATCH_WINDOW_SIZE: usize = 50;
+
 #[derive(Clone, Default)]
 pub struct BatchesTable {
     pub state: TableState,
@@ -44,10 +46,11 @@ impl BatchesTable {
             rollup_store,
         )
         .await?;
-        new_latest_batches.truncate(50);
+        new_latest_batches.truncate(BATCH_WINDOW_SIZE);
 
         let n_new_latest_batches = new_latest_batches.len();
-        self.items.truncate(50 - n_new_latest_batches);
+        self.items
+            .truncate(BATCH_WINDOW_SIZE - n_new_latest_batches);
         self.refresh_items(rollup_store).await?;
         self.items.extend_from_slice(&new_latest_batches);
         self.items.rotate_right(n_new_latest_batches);
@@ -60,18 +63,27 @@ impl BatchesTable {
             return Ok(());
         }
 
-        let mut from = self.items.last().ok_or(MonitorError::NoItemsInTable)?.0 - 1;
-
-        let refreshed_batches = Self::get_batches(
-            &mut from,
-            self.items.first().ok_or(MonitorError::NoItemsInTable)?.0,
-            rollup_store,
-        )
-        .await?;
+        let mut refreshed_batches = Vec::new();
+
+        for batch in self.items.iter() {
+            if batch.3.is_some() && batch.4.is_some() {
+                // Both commit and verify tx hashes are present
+                refreshed_batches.push(*batch);
+            } else {
+                let batch_number = batch.0;
+                let new_batch = rollup_store
+                    .get_batch(batch_number)
+                    .await
+                    .map_err(|e| MonitorError::GetBatchByNumber(batch_number, e))?
+                    .ok_or(MonitorError::BatchNotFound(batch_number))?;
+
+                refreshed_batches.push(Self::process_batch(&new_batch));
+            }
+        }
 
-        let refreshed_items = Self::process_batches(refreshed_batches).await;
+        Self::reorder_batches(&mut refreshed_batches);
 
-        self.items = refreshed_items;
+        self.items = refreshed_batches;
 
         Ok(())
     }
@@ -87,10 +99,18 @@ impl BatchesTable {
             .await
             .map_err(|_| MonitorError::GetLatestBatch)?;
 
+        *last_l2_batch_fetched = (*last_l2_batch_fetched).max(
+            last_l2_batch_number.saturating_sub(
+                BATCH_WINDOW_SIZE
+                    .try_into()
+                    .map_err(|_| MonitorError::BatchWindow)?,
+            ),
+        );
+
         let new_batches =
             Self::get_batches(last_l2_batch_fetched, last_l2_batch_number, rollup_store).await?;
 
-        Ok(Self::process_batches(new_batches).await)
+        Ok(Self::process_batches(new_batches))
     }
 
     async fn get_batches(
@@ -115,24 +135,32 @@ impl BatchesTable {
         Ok(new_batches)
     }
 
-    async fn process_batches(
+    fn process_batch(batch: &Batch) -> (u64, u64, usize, Option<H256>, Option<H256>) {
+        (
+            batch.number,
+            batch.last_block - batch.first_block + 1,
+            batch.message_hashes.len(),
+            batch.commit_tx,
+            batch.verify_tx,
+        )
+    }
+
+    #[expect(clippy::type_complexity)]
+    fn reorder_batches(new_blocks_processed: &mut [(u64, u64, usize, Option<H256>, Option<H256>)]) {
+        new_blocks_processed
+            .sort_by(|(number_a, _, _, _, _), (number_b, _, _, _, _)| number_b.cmp(number_a));
+    }
+
+    #[expect(clippy::type_complexity)]
+    fn process_batches(
         new_batches: Vec<Batch>,
     ) -> Vec<(u64, u64, usize, Option<H256>, Option<H256>)> {
         let mut new_blocks_processed = new_batches
             .iter()
-            .map(|batch| {
-                (
-                    batch.number,
-                    batch.last_block - batch.first_block + 1,
-                    batch.message_hashes.len(),
-                    batch.commit_tx,
-                    batch.verify_tx,
-                )
-            })
+            .map(Self::process_batch)
             .collect::<Vec<_>>();
 
-        new_blocks_processed
-            .sort_by(|(number_a, _, _, _, _), (number_b, _, _, _, _)| number_b.cmp(number_a));
+        Self::reorder_batches(&mut new_blocks_processed);
 
         new_blocks_processed
     }

crates/l2/sequencer/errors.rs

@@ -347,4 +347,6 @@ pub enum MonitorError {
     NoItemsInTable,
     #[error("RPC List can't be empty")]
     RPCListEmpty,
+    #[error("Error converting batch window")]
+    BatchWindow,
 }