Remove the backon dependency

Author: maximopalopoli

aggregation_mode/Cargo.lock

@@ -21,7 +21,6 @@ reqwest = { version = "0.12" }
 ciborium = "=0.2.2"
 lambdaworks-crypto = { git = "https://github.com/lambdaclass/lambdaworks.git", rev = "5f8f2cfcc8a1a22f77e8dff2d581f1166eefb80b", features = ["serde"]}
 rayon = "1.10.0"
-backon = "1.2.0"
 sqlx = { version = "0.8", features = [ "runtime-tokio", "postgres", "uuid", "bigdecimal" ] }
 
 # zkvms

aggregation_mode/proof_aggregator/Cargo.toml

@@ -1,5 +1,3 @@
-use backon::ExponentialBuilder;
-use backon::Retryable;
 use std::future::Future;
 use std::time::Duration;
 
@@ -29,28 +27,58 @@ impl<E> RetryError<E> {
 
 impl<E: std::fmt::Display> std::error::Error for RetryError<E> where E: std::fmt::Debug {}
 
-/// Supports retries only on async functions. See: https://docs.rs/backon/latest/backon/#retry-an-async-function
-/// Runs with `jitter: false`.
 pub async fn retry_function<FutureFn, Fut, T, E>(
-    function: FutureFn,
-    min_delay: u64,
+    mut function: FutureFn,
+    min_delay_ms: u64,
     factor: f32,
     max_times: usize,
-    max_delay: u64,
+    max_delay_seconds: u64,
 ) -> Result<T, RetryError<E>>
 where
     Fut: Future<Output = Result<T, RetryError<E>>>,
     FutureFn: FnMut() -> Fut,
 {
-    let backoff = ExponentialBuilder::default()
-        .with_min_delay(Duration::from_millis(min_delay))
-        .with_max_times(max_times)
-        .with_factor(factor)
-        .with_max_delay(Duration::from_secs(max_delay));
-
-    function
-        .retry(backoff)
-        .sleep(tokio::time::sleep)
-        .when(|e| matches!(e, RetryError::Transient(_)))
-        .await
+    let mut delay = Duration::from_millis(min_delay_ms);
+
+    let factor = (factor as f64).max(1.0);
+
+    let mut attempt: usize = 0;
+
+    loop {
+        match function().await {
+            Ok(v) => return Ok(v),
+            Err(RetryError::Permanent(e)) => return Err(RetryError::Permanent(e)),
+            Err(RetryError::Transient(e)) => {
+                if attempt >= max_times {
+                    return Err(RetryError::Transient(e));
+                }
+
+                tokio::time::sleep(delay).await;
+
+                delay = next_backoff_delay(delay, max_delay_seconds, factor);
+
+                attempt += 1;
+            }
+        }
+    }
+}
+
+/// TODO: Replace with the one in aggregation_mode/db/src/orchestrator.rs, or use a common method.
+fn next_backoff_delay(current_delay: Duration, max_delay_seconds: u64, factor: f64) -> Duration {
+    let max: Duration = Duration::from_secs(max_delay_seconds);
+    // Defensive: factor should be >= 1.0 for backoff, we clamp it to avoid shrinking/NaN.
+
+    let scaled_secs = current_delay.as_secs_f64() * factor;
+    let scaled_secs = if scaled_secs.is_finite() {
+        scaled_secs
+    } else {
+        max.as_secs_f64()
+    };
+
+    let scaled = Duration::from_secs_f64(scaled_secs);
+    if scaled > max {
+        max
+    } else {
+        scaled
+    }
 }