refactor(l2): remove expects in L2 monitor (#3615)

**Motivation**

We want to handle errors gracefully.

**Description**

Removes usage of .expect

**How to test**

- Add `--monitor` to the `init-l2-no-metrics` target in
`crates/l2/Makefile`.
- Run a Sequencer (I suggest `make restart` in `crates/l2`).
- Run the prover with `make init-prover` in `crates/l2`.
- Run `make test` in `crates/l2`.

Closes #3535

---------

Co-authored-by: Tomás Paradelo <[email protected]>

Author: iovoid

crates/l2/monitor/app.rs

@@ -62,13 +62,13 @@ impl EthrexMonitor {
         rollup_store: StoreRollup,
         cfg: &SequencerConfig,
     ) -> Result<Self, MonitorError> {
-        let eth_client = EthClient::new(cfg.eth.rpc_url.first().expect("No RPC URLs provided"))
-            .expect("Failed to create EthClient");
+        let eth_client = EthClient::new(cfg.eth.rpc_url.first().ok_or(MonitorError::RPCListEmpty)?)
+            .map_err(MonitorError::EthClientError)?;
         // TODO: De-hardcode the rollup client URL
         let rollup_client =
-            EthClient::new("http://localhost:1729").expect("Failed to create RollupClient");
+            EthClient::new("http://localhost:1729").map_err(MonitorError::EthClientError)?;
 
-        Ok(EthrexMonitor {
+        let mut monitor = EthrexMonitor {
             title: if cfg.based.based {
                 "Based Ethrex Monitor".to_string()
             } else {
@@ -77,41 +77,22 @@ impl EthrexMonitor {
             should_quit: false,
             tabs: TabsState::default(),
             tick_rate: cfg.monitor.tick_rate,
-            global_chain_status: GlobalChainStatusTable::new(
-                &eth_client,
-                cfg,
-                &store,
-                &rollup_store,
-            )
-            .await,
+            global_chain_status: GlobalChainStatusTable::new(cfg),
             logger: TuiWidgetState::new().set_default_display_level(tui_logger::LevelFilter::Info),
-            node_status: NodeStatusTable::new(sequencer_state.clone(), &store).await,
-            mempool: MempoolTable::new(&rollup_client).await,
-            batches_table: BatchesTable::new(
-                cfg.l1_committer.on_chain_proposer_address,
-                &eth_client,
-                &rollup_store,
-            )
-            .await?,
-            blocks_table: BlocksTable::new(&store).await?,
-            l1_to_l2_messages: L1ToL2MessagesTable::new(
-                cfg.l1_watcher.bridge_address,
-                &eth_client,
-                &store,
-            )
-            .await?,
-            l2_to_l1_messages: L2ToL1MessagesTable::new(
-                cfg.l1_watcher.bridge_address,
-                &eth_client,
-                &rollup_client,
-            )
-            .await?,
+            node_status: NodeStatusTable::new(sequencer_state.clone()),
+            mempool: MempoolTable::new(),
+            batches_table: BatchesTable::new(cfg.l1_committer.on_chain_proposer_address),
+            blocks_table: BlocksTable::new(),
+            l1_to_l2_messages: L1ToL2MessagesTable::new(cfg.l1_watcher.bridge_address),
+            l2_to_l1_messages: L2ToL1MessagesTable::new(cfg.l1_watcher.bridge_address),
             eth_client,
             rollup_client,
             store,
             rollup_store,
             last_scroll: Instant::now(),
-        })
+        };
+        monitor.on_tick().await?;
+        Ok(monitor)
     }
 
     pub async fn start(mut self) -> Result<(), MonitorError> {
@@ -219,11 +200,11 @@ impl EthrexMonitor {
     }
 
     pub async fn on_tick(&mut self) -> Result<(), MonitorError> {
-        self.node_status.on_tick(&self.store).await;
+        self.node_status.on_tick(&self.store).await?;
         self.global_chain_status
             .on_tick(&self.eth_client, &self.store, &self.rollup_store)
-            .await;
-        self.mempool.on_tick(&self.rollup_client).await;
+            .await?;
+        self.mempool.on_tick(&self.rollup_client).await?;
         self.batches_table
             .on_tick(&self.eth_client, &self.rollup_store)
             .await?;

crates/l2/monitor/mod.rs

@@ -1,5 +1,4 @@
 // TODO: Handle this expects
-#![expect(clippy::expect_used)]
 #![expect(clippy::indexing_slicing)]
 #[expect(clippy::result_large_err)]
 pub(crate) mod app;

crates/l2/monitor/utils.rs

@@ -15,7 +15,7 @@ pub async fn get_logs(
     let last_block_number = client
         .get_block_number()
         .await
-        .expect("Failed to get latest L1 block");
+        .map_err(|_| MonitorError::GetLatestBlock)?;
 
     let mut batch_committed_logs = Vec::new();
     while *last_block_fetched < last_block_number {

crates/l2/monitor/widget/batches.rs

@@ -14,6 +14,7 @@ use crate::{
     sequencer::errors::MonitorError,
 };
 
+#[derive(Default)]
 pub struct BatchesTable {
     pub state: TableState,
     // batch number | # blocks | # messages | commit tx hash | verify tx hash
@@ -24,25 +25,11 @@ pub struct BatchesTable {
 }
 
 impl BatchesTable {
-    pub async fn new(
-        on_chain_proposer_address: Address,
-        eth_client: &EthClient,
-        rollup_store: &StoreRollup,
-    ) -> Result<Self, MonitorError> {
-        let mut last_l1_block_fetched = 0;
-        let items = Self::fetch_new_items(
-            &mut last_l1_block_fetched,
+    pub fn new(on_chain_proposer_address: Address) -> Self {
+        Self {
             on_chain_proposer_address,
-            eth_client,
-            rollup_store,
-        )
-        .await?;
-        Ok(Self {
-            state: TableState::default(),
-            items,
-            last_l1_block_fetched,
-            on_chain_proposer_address,
-        })
+            ..Default::default()
+        }
     }
 
     pub async fn on_tick(
@@ -73,11 +60,11 @@ impl BatchesTable {
             return Ok(());
         }
 
-        let mut from = self.items.last().expect("Expected items in the table").0 - 1;
+        let mut from = self.items.last().ok_or(MonitorError::NoItemsInTable)?.0 - 1;
 
         let refreshed_batches = Self::get_batches(
             &mut from,
-            self.items.first().expect("Expected items in the table").0,
+            self.items.first().ok_or(MonitorError::NoItemsInTable)?.0,
             rollup_store,
         )
         .await?;
@@ -98,7 +85,7 @@ impl BatchesTable {
         let last_l2_batch_number = eth_client
             .get_last_committed_batch(on_chain_proposer_address)
             .await
-            .expect("Failed to get latest L2 batch");
+            .map_err(|_| MonitorError::GetLatestBatch)?;
 
         let new_batches =
             Self::get_batches(last_l2_batch_fetched, last_l2_batch_number, rollup_store).await?;
@@ -117,7 +104,7 @@ impl BatchesTable {
             let batch = rollup_store
                 .get_batch(batch_number)
                 .await
-                .map_err(|e| MonitorError::RollupStore(batch_number, e))?
+                .map_err(|e| MonitorError::GetBatchByNumber(batch_number, e))?
                 .ok_or(MonitorError::BatchNotFound(batch_number))?;
 
             *from = batch_number;

crates/l2/monitor/widget/blocks.rs

@@ -19,6 +19,7 @@ use crate::{
     sequencer::errors::MonitorError,
 };
 
+#[derive(Default)]
 pub struct BlocksTable {
     pub state: TableState,
     // block number | #transactions | hash | coinbase | gas | blob gas | size
@@ -27,14 +28,8 @@ pub struct BlocksTable {
 }
 
 impl BlocksTable {
-    pub async fn new(store: &Store) -> Result<Self, MonitorError> {
-        let mut last_l2_block_known = 0;
-        let items = Self::refresh_items(&mut last_l2_block_known, store).await?;
-        Ok(Self {
-            state: TableState::default(),
-            items,
-            last_l2_block_known,
-        })
+    pub fn new() -> Self {
+        Default::default()
     }
 
     pub async fn on_tick(&mut self, store: &Store) -> Result<(), MonitorError> {
@@ -80,7 +75,7 @@ impl BlocksTable {
         let last_l2_block_number = store
             .get_latest_block_number()
             .await
-            .expect("Failed to get latest L2 block");
+            .map_err(|_| MonitorError::GetLatestBlock)?;
 
         let mut new_blocks = Vec::new();
         while *last_l2_block_known < last_l2_block_number {

crates/l2/monitor/widget/chain_status.rs

@@ -11,8 +11,9 @@ use ratatui::{
     widgets::{Block, Row, StatefulWidget, Table, TableState},
 };
 
-use crate::SequencerConfig;
+use crate::{SequencerConfig, sequencer::errors::MonitorError};
 
+#[derive(Default)]
 pub struct GlobalChainStatusTable {
     pub state: TableState,
     pub items: Vec<(String, String)>,
@@ -21,30 +22,17 @@ pub struct GlobalChainStatusTable {
 }
 
 impl GlobalChainStatusTable {
-    pub async fn new(
-        eth_client: &EthClient,
-        cfg: &SequencerConfig,
-        store: &Store,
-        rollup_store: &StoreRollup,
-    ) -> Self {
+    pub fn new(cfg: &SequencerConfig) -> Self {
         let sequencer_registry_address =
             if cfg.based.state_updater.sequencer_registry == Address::default() {
                 None
             } else {
                 Some(cfg.based.state_updater.sequencer_registry)
             };
         Self {
-            state: TableState::default(),
-            items: Self::refresh_items(
-                eth_client,
-                cfg.l1_committer.on_chain_proposer_address,
-                sequencer_registry_address,
-                store,
-                rollup_store,
-            )
-            .await,
             on_chain_proposer_address: cfg.l1_committer.on_chain_proposer_address,
             sequencer_registry_address,
+            ..Default::default()
         }
     }
 
@@ -53,15 +41,16 @@ impl GlobalChainStatusTable {
         eth_client: &EthClient,
         store: &Store,
         rollup_store: &StoreRollup,
-    ) {
+    ) -> Result<(), MonitorError> {
         self.items = Self::refresh_items(
             eth_client,
             self.on_chain_proposer_address,
             self.sequencer_registry_address,
             store,
             rollup_store,
         )
-        .await;
+        .await?;
+        Ok(())
     }
 
     async fn refresh_items(
@@ -70,12 +59,12 @@ impl GlobalChainStatusTable {
         sequencer_registry_address: Option<Address>,
         store: &Store,
         rollup_store: &StoreRollup,
-    ) -> Vec<(String, String)> {
+    ) -> Result<Vec<(String, String)>, MonitorError> {
         let last_update = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
 
         let lead_sequencer = if let Some(sequencer_registry_address) = sequencer_registry_address {
             let calldata = encode_calldata("leaderSequencer()", &[])
-                .expect("Failed to encode leadSequencer calldata");
+                .map_err(MonitorError::CalldataEncodeError)?;
 
             let raw_lead_sequencer: H256 = eth_client
                 .call(
@@ -84,7 +73,7 @@ impl GlobalChainStatusTable {
                     Overrides::default(),
                 )
                 .await
-                .expect("Failed to call leaderSequencer")
+                .map_err(MonitorError::EthClientError)?
                 .parse()
                 .unwrap_or_default();
 
@@ -96,20 +85,20 @@ impl GlobalChainStatusTable {
         let last_committed_batch = eth_client
             .get_last_committed_batch(on_chain_proposer_address)
             .await
-            .expect("Failed to get last committed batch");
+            .map_err(|_| MonitorError::GetLatestCommittedBatch)?;
 
         let last_verified_batch = eth_client
             .get_last_verified_batch(on_chain_proposer_address)
             .await
-            .expect("Failed to get last verified batch");
+            .map_err(|_| MonitorError::GetLatestVerifiedBatch)?;
 
         let last_committed_block = if last_committed_batch == 0 {
             0
         } else {
             match rollup_store
                 .get_block_numbers_by_batch(last_committed_batch)
                 .await
-                .expect("Failed to get blocks by batch")
+                .map_err(|e| MonitorError::GetBlocksByBatch(last_committed_batch, e))?
             {
                 Some(block_numbers) => block_numbers.last().copied().unwrap_or(0),
                 None => 0,
@@ -122,7 +111,7 @@ impl GlobalChainStatusTable {
             match rollup_store
                 .get_block_numbers_by_batch(last_verified_batch)
                 .await
-                .expect("Failed to get blocks by batch")
+                .map_err(|e| MonitorError::GetBlocksByBatch(last_verified_batch, e))?
             {
                 Some(block_numbers) => block_numbers.last().copied().unwrap_or(0),
                 None => 0,
@@ -132,7 +121,7 @@ impl GlobalChainStatusTable {
         let current_block = store
             .get_latest_block_number()
             .await
-            .expect("Failed to get latest L1 block")
+            .map_err(|_| MonitorError::GetLatestBlock)?
             + 1;
 
         let current_batch = if sequencer_registry_address.is_some() {
@@ -141,7 +130,7 @@ impl GlobalChainStatusTable {
             (last_committed_batch + 1).to_string()
         };
 
-        if sequencer_registry_address.is_some() {
+        let items = if sequencer_registry_address.is_some() {
             vec![
                 ("Last Update:".to_string(), last_update),
                 (
@@ -189,7 +178,8 @@ impl GlobalChainStatusTable {
                     last_verified_block.to_string(),
                 ),
             ]
-        }
+        };
+        Ok(items)
     }
 }