Mark deposits/burns as failed when they exhaust the retry limit

Author: deuszx

linera-bridge/src/monitor/evm.rs

@@ -116,7 +116,11 @@ pub(crate) async fn process_pending_deposits<E: linera_core::environment::Enviro
             }
         }
 
-        monitor.write().await.mark_deposit_retried(&pending.key);
+        monitor
+            .write()
+            .await
+            .mark_deposit_retried(&pending.key, max_retries)
+            .await;
     }
 }
 

linera-bridge/src/monitor/linera.rs

@@ -105,11 +105,19 @@ pub(crate) async fn process_pending_burns<E: linera_core::environment::Environme
 
             match estimate_fits(evm_client.estimate_add_block_gas(&cert).await) {
                 Ok(true) => {
-                    submit_addblock(monitor, evm_client, &cert, height, &event_indices).await;
+                    submit_addblock(
+                        monitor,
+                        evm_client,
+                        &cert,
+                        height,
+                        &event_indices,
+                        max_retries,
+                    )
+                    .await;
                     relay::update_balance_metrics(evm_client, linera_client).await;
                 }
                 Ok(false) => {
-                    submit_chunked(monitor, evm_client, &cert, height, &by_tx).await;
+                    submit_chunked(monitor, evm_client, &cert, height, &by_tx, max_retries).await;
                     relay::update_balance_metrics(evm_client, linera_client).await;
                 }
                 Err(error) => {
@@ -130,6 +138,7 @@ async fn submit_addblock<P: Provider>(
     cert: &linera_chain::types::ConfirmedBlockCertificate,
     height: BlockHeight,
     event_indices: &[u32],
+    max_retries: u32,
 ) {
     match evm_client.forward_cert(cert).await {
         Ok(()) => {
@@ -143,7 +152,7 @@ async fn submit_addblock<P: Provider>(
             tracing::warn!(?height, ?error, "addBlock submission failed");
             let mut state = monitor.write().await;
             for ei in event_indices {
-                state.mark_burn_retried(height, *ei);
+                state.mark_burn_retried(height, *ei, max_retries).await;
             }
         }
     }
@@ -158,11 +167,21 @@ async fn submit_chunked<P: Provider>(
     cert: &linera_chain::types::ConfirmedBlockCertificate,
     height: BlockHeight,
     by_tx: &[(u32, Vec<u32>)],
+    max_retries: u32,
 ) {
     for (tx_index, positions) in by_tx {
         let (chunks, oversized) = split_to_fit(evm_client, cert, *tx_index, positions).await;
         mark_oversized_failed(monitor, height, *tx_index, &oversized).await;
-        submit_chunks_with_retry(monitor, evm_client, cert, height, *tx_index, chunks).await;
+        submit_chunks_with_retry(
+            monitor,
+            evm_client,
+            cert,
+            height,
+            *tx_index,
+            chunks,
+            max_retries,
+        )
+        .await;
     }
 }
 
@@ -246,6 +265,7 @@ async fn submit_chunks_with_retry<P: Provider>(
     height: BlockHeight,
     tx_index: u32,
     events_chunks: Vec<Vec<u32>>,
+    max_retries: u32,
 ) {
     for events_chunk in events_chunks {
         if let Err(error) = evm_client
@@ -267,7 +287,7 @@ async fn submit_chunks_with_retry<P: Provider>(
             };
             let mut state = monitor.write().await;
             for ei in to_bump {
-                state.mark_burn_retried(height, ei);
+                state.mark_burn_retried(height, ei, max_retries).await;
             }
         }
     }

linera-bridge/src/monitor/mod.rs

@@ -403,10 +403,20 @@ impl MonitorState {
         Ok(())
     }
 
-    pub fn mark_deposit_retried(&mut self, key: &DepositKey) {
-        if let Some(d) = self.deposits.get_mut(key) {
+    /// Bumps the deposit's retry counter; if the bump exhausts `max_retries`,
+    /// the deposit is marked `failed` (moved to `finished_deposits` in
+    /// SQLite) so it does not get loaded back as a pending item on the next
+    /// relayer start.
+    pub async fn mark_deposit_retried(&mut self, key: &DepositKey, max_retries: u32) {
+        let exhausted = if let Some(d) = self.deposits.get_mut(key) {
             d.retry_count += 1;
             d.last_retry_at = Some(Instant::now());
+            d.retry_count >= max_retries
+        } else {
+            false
+        };
+        if exhausted {
+            self.mark_deposit_failed(key).await;
         }
     }
 
@@ -440,10 +450,25 @@ impl MonitorState {
         })
     }
 
-    pub fn mark_burn_retried(&mut self, height: BlockHeight, event_index: u32) {
-        if let Some(b) = self.burns.get_mut(&(height, event_index)) {
+    /// Bumps the burn's retry counter; if the bump exhausts `max_retries`,
+    /// the burn is marked `failed` (moved to `finished_burns` in SQLite) so
+    /// it does not get loaded back as a pending item on the next relayer
+    /// start.
+    pub async fn mark_burn_retried(
+        &mut self,
+        height: BlockHeight,
+        event_index: u32,
+        max_retries: u32,
+    ) {
+        let exhausted = if let Some(b) = self.burns.get_mut(&(height, event_index)) {
             b.retry_count += 1;
             b.last_retry_at = Some(Instant::now());
+            b.retry_count >= max_retries
+        } else {
+            false
+        };
+        if exhausted {
+            self.mark_burn_failed(height, event_index).await;
         }
     }
 
@@ -703,7 +728,7 @@ mod tests {
 
         assert_eq!(state.deposits_ready_for_retry(10).len(), 1);
 
-        state.mark_deposit_retried(&key);
+        state.mark_deposit_retried(&key, 10).await;
         assert_eq!(state.deposits_ready_for_retry(10).len(), 0);
 
         state.mark_deposit_failed(&key).await;
@@ -736,7 +761,7 @@ mod tests {
         let next = state.next_deposit_for_retry(10);
         assert!(matches!(next, Some(p) if p.key == key));
 
-        state.mark_deposit_retried(&key);
+        state.mark_deposit_retried(&key, 10).await;
         assert!(state.next_deposit_for_retry(10).is_none());
 
         state.complete_deposit(&key).await;
@@ -837,7 +862,7 @@ mod tests {
             .await;
 
         assert!(state.next_burn_for_retry(10).is_some());
-        state.mark_burn_retried(height, 0);
+        state.mark_burn_retried(height, 0, 10).await;
         assert!(state.next_burn_for_retry(10).is_none());
 
         // Once forwarded, the item is no longer offered for retry.