fix: add WASM-compatible retry mechanism for RPC requests

Cargo.toml

@@ -90,6 +90,8 @@ helios-opstack = { path = "./opstack" }
 tokio = { version = "1", features = ["full"] }
 dotenv = "0.15.0"
 serde = { version = "1.0.154", features = ["derive"] }
+mockito = "0.31"
+tracing = "0.1"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 alloy = { version = "0.2.1", features = ["full"] }

core/execution/rpc/http_rpc.rs

@@ -0,0 +1,76 @@
+use std::time::Duration;
+use wasmtimer::tokio::sleep;
+
+/// Retry mechanism configuration
+#[derive(Clone, Debug)]
+pub struct RetryConfig {
+    /// Maximum number of attempts to execute the request
+    pub max_attempts: u32,
+    /// Initial delay between retry attempts
+    pub initial_backoff: Duration,
+    /// Maximum delay between retry attempts
+    pub max_backoff: Duration,
+}
+
+impl HttpProvider {
+    // Add the ability to configure retry settings
+    pub fn with_retry_config(mut self, config: RetryConfig) -> Self {
+        self.retry_config = config;
+        self
+    }
+
+    async fn execute_with_retry<T>(&self, request: Request<T>) -> Result<Response<T>, Error> 
+    where 
+        T: serde::Serialize + Send + Sync,
+    {
+        let mut attempts = 0;
+        let mut backoff = self.retry_config.initial_backoff;
+
+        loop {
+            attempts += 1;
+            match self.execute_internal(request.clone()).await {
+                Ok(response) => return Ok(response),
+                Err(err) => {
+                    if !should_retry(&err) || attempts >= self.retry_config.max_attempts {
+                        return Err(err.into());
+                    }
+
+                    tracing::debug!(
+                        "Request failed with error: {:?}. Retrying ({}/{})",
+                        err,
+                        attempts,
+                        self.retry_config.max_attempts
+                    );
+
+                    sleep(backoff).await;
+
+                    backoff = std::cmp::min(
+                        backoff * 2,
+                        self.retry_config.max_backoff
+                    );
+                }
+            }
+        }
+    }
+}
+
+// Extend the list of errors that can trigger a retry
+fn should_retry(error: &Error) -> bool {
+    match error {
+        Error::RateLimitExceeded(_) => true,
+        Error::ConnectionError(_) => true,
+        Error::TimeoutError => true,
+        Error::ServerError(status) => status.as_u16() >= 500,
+        _ => false,
+    }
+}
+
+// Update the existing execute method to use the retry mechanism
+impl Provider for HttpProvider {
+    async fn execute<T>(&self, request: Request<T>) -> Result<Response<T>, Error>
+    where
+        T: serde::Serialize + Send + Sync,
+    {
+        self.execute_with_retry(request).await
+    }
+}

core/execution/rpc/tests/http_rpc_tests.rs

@@ -0,0 +1,39 @@
+use mockito::{mock, Server};
+use std::time::Duration;
+
+#[tokio::test]
+async fn test_retry_mechanism() {
+    let mut server = Server::new();
+
+    // Test successful retry after a temporary error
+    let mock = server.mock("POST", "/")
+        .with_status(429) // Rate limit error
+        .create();
+
+    let provider = HttpProvider::new(server.url().as_str());
+    let request = Request::new("eth_blockNumber", ());
+
+    let result = provider.execute(request).await;
+    assert!(result.is_err());
+    mock.assert_hits(1);
+
+    // Test the maximum number of retry attempts
+    let mock = server.mock("POST", "/")
+        .with_status(429)
+        .expect(3) // Expect exactly 3 attempts
+        .create();
+
+    let result = provider.execute(request).await;
+    assert!(result.is_err());
+    mock.assert();
+
+    // Test for errors that should not trigger retries
+    let mock = server.mock("POST", "/")
+        .with_status(400) // Bad Request
+        .expect(1) // Expect only 1 attempt
+        .create();
+
+    let result = provider.execute(request).await;
+    assert!(result.is_err());
+    mock.assert();
+}