Refactor robust provider (#173)

Author: LeoPatOZ

src/robust_provider/builder.rs

@@ -0,0 +1,96 @@
+use std::{marker::PhantomData, time::Duration};
+
+use alloy::{network::Network, providers::Provider};
+
+use crate::robust_provider::{Error, IntoProvider, RobustProvider};
+
+// RPC retry and timeout settings
+/// Default timeout used by `RobustProvider`
+pub const DEFAULT_MAX_TIMEOUT: Duration = Duration::from_secs(60);
+/// Default maximum number of retry attempts.
+pub const DEFAULT_MAX_RETRIES: usize = 3;
+/// Default base delay between retries.
+pub const DEFAULT_MIN_DELAY: Duration = Duration::from_secs(1);
+
+#[derive(Clone)]
+pub struct RobustProviderBuilder<N: Network, P: IntoProvider<N>> {
+    providers: Vec<P>,
+    max_timeout: Duration,
+    max_retries: usize,
+    min_delay: Duration,
+    _network: PhantomData<N>,
+}
+
+impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
+    /// Create a new `RobustProvider` with default settings.
+    ///
+    /// The provided provider is treated as the primary provider.
+    #[must_use]
+    pub fn new(provider: P) -> Self {
+        Self {
+            providers: vec![provider],
+            max_timeout: DEFAULT_MAX_TIMEOUT,
+            max_retries: DEFAULT_MAX_RETRIES,
+            min_delay: DEFAULT_MIN_DELAY,
+            _network: PhantomData,
+        }
+    }
+
+    /// Create a new `RobustProvider` with no retry attempts and only timeout set.
+    ///
+    /// The provided provider is treated as the primary provider.
+    #[must_use]
+    pub fn fragile(provider: P) -> Self {
+        Self::new(provider).max_retries(0).min_delay(Duration::ZERO)
+    }
+
+    /// Add a fallback provider to the list.
+    ///
+    /// Fallback providers are used when the primary provider times out or fails.
+    #[must_use]
+    pub fn fallback(mut self, provider: P) -> Self {
+        self.providers.push(provider);
+        self
+    }
+
+    /// Set the maximum timeout for RPC operations.
+    #[must_use]
+    pub fn max_timeout(mut self, timeout: Duration) -> Self {
+        self.max_timeout = timeout;
+        self
+    }
+
+    /// Set the maximum number of retry attempts.
+    #[must_use]
+    pub fn max_retries(mut self, max_retries: usize) -> Self {
+        self.max_retries = max_retries;
+        self
+    }
+
+    /// Set the base delay for exponential backoff retries.
+    #[must_use]
+    pub fn min_delay(mut self, min_delay: Duration) -> Self {
+        self.min_delay = min_delay;
+        self
+    }
+
+    /// Build the `RobustProvider`.
+    ///
+    /// Final builder method: consumes the builder and returns the built [`RobustProvider`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any of the providers fail to connect.
+    pub async fn build(self) -> Result<RobustProvider<N>, Error> {
+        let mut providers = vec![];
+        for p in self.providers {
+            providers.push(p.into_provider().await?.root().to_owned());
+        }
+        Ok(RobustProvider {
+            providers,
+            max_timeout: self.max_timeout,
+            max_retries: self.max_retries,
+            min_delay: self.min_delay,
+        })
+    }
+}

src/robust_provider/error.rs

@@ -0,0 +1,30 @@
+use std::sync::Arc;
+
+use alloy::{
+    eips::BlockId,
+    transports::{RpcError, TransportErrorKind},
+};
+use thiserror::Error;
+use tokio::time::error as TokioError;
+
+#[derive(Error, Debug, Clone)]
+pub enum Error {
+    #[error("Operation timed out")]
+    Timeout,
+    #[error("RPC call failed after exhausting all retry attempts: {0}")]
+    RpcError(Arc<RpcError<TransportErrorKind>>),
+    #[error("Block not found, Block Id: {0}")]
+    BlockNotFound(BlockId),
+}
+
+impl From<RpcError<TransportErrorKind>> for Error {
+    fn from(err: RpcError<TransportErrorKind>) -> Self {
+        Error::RpcError(Arc::new(err))
+    }
+}
+
+impl From<TokioError::Elapsed> for Error {
+    fn from(_: TokioError::Elapsed) -> Self {
+        Error::Timeout
+    }
+}

src/robust_provider/mod.rs

@@ -0,0 +1,9 @@
+pub mod builder;
+pub mod error;
+pub mod provider;
+pub mod provider_conversion;
+
+pub use builder::*;
+pub use error::Error;
+pub use provider::RobustProvider;
+pub use provider_conversion::{IntoProvider, IntoRobustProvider};

src/robust_provider.rs src/robust_provider/provider.rssrc/robust_provider.rs renamed to src/robust_provider/provider.rs

@@ -1,216 +1,18 @@
-use std::{fmt::Debug, future::Future, marker::PhantomData, sync::Arc, time::Duration};
+use std::{fmt::Debug, time::Duration};
 
 use alloy::{
-    eips::{BlockId, BlockNumberOrTag},
+    eips::BlockNumberOrTag,
     network::{Ethereum, Network},
-    providers::{
-        DynProvider, Provider, RootProvider,
-        fillers::{FillProvider, TxFiller},
-        layers::{CacheProvider, CallBatchProvider},
-    },
+    providers::{Provider, RootProvider},
     pubsub::Subscription,
     rpc::types::{Filter, Log},
-    transports::{RpcError, TransportErrorKind, http::reqwest::Url},
+    transports::{RpcError, TransportErrorKind},
 };
 use backon::{ExponentialBuilder, Retryable};
-use thiserror::Error;
-use tokio::time::{error as TokioError, timeout};
+use tokio::time::timeout;
 use tracing::{error, info};
 
-#[derive(Error, Debug, Clone)]
-pub enum Error {
-    #[error("Operation timed out")]
-    Timeout,
-    #[error("RPC call failed after exhausting all retry attempts: {0}")]
-    RpcError(Arc<RpcError<TransportErrorKind>>),
-    #[error("Block not found, Block Id: {0}")]
-    BlockNotFound(BlockId),
-}
-
-impl From<RpcError<TransportErrorKind>> for Error {
-    fn from(err: RpcError<TransportErrorKind>) -> Self {
-        Error::RpcError(Arc::new(err))
-    }
-}
-
-impl From<TokioError::Elapsed> for Error {
-    fn from(_: TokioError::Elapsed) -> Self {
-        Error::Timeout
-    }
-}
-
-pub trait IntoProvider<N: Network = Ethereum> {
-    fn into_provider(
-        self,
-    ) -> impl std::future::Future<Output = Result<impl Provider<N>, Error>> + Send;
-}
-
-impl<N: Network> IntoProvider<N> for RobustProvider<N> {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self.primary().to_owned())
-    }
-}
-
-impl<N: Network> IntoProvider<N> for RootProvider<N> {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self)
-    }
-}
-
-impl<N: Network> IntoProvider<N> for &str {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(RootProvider::connect(self).await?)
-    }
-}
-
-impl<N: Network> IntoProvider<N> for Url {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(RootProvider::connect(self.as_str()).await?)
-    }
-}
-
-impl<F, P, N> IntoProvider<N> for FillProvider<F, P, N>
-where
-    F: TxFiller<N>,
-    P: Provider<N>,
-    N: Network,
-{
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self)
-    }
-}
-
-impl<P, N> IntoProvider<N> for CacheProvider<P, N>
-where
-    P: Provider<N>,
-    N: Network,
-{
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self)
-    }
-}
-
-impl<N> IntoProvider<N> for DynProvider<N>
-where
-    N: Network,
-{
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self)
-    }
-}
-
-impl<P, N> IntoProvider<N> for CallBatchProvider<P, N>
-where
-    P: Provider<N> + 'static,
-    N: Network,
-{
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self)
-    }
-}
-
-pub trait IntoRobustProvider<N: Network = Ethereum> {
-    fn into_robust_provider(
-        self,
-    ) -> impl std::future::Future<Output = Result<RobustProvider<N>, Error>> + Send;
-}
-
-impl<N: Network, P: IntoProvider<N> + Send> IntoRobustProvider<N> for P {
-    async fn into_robust_provider(self) -> Result<RobustProvider<N>, Error> {
-        RobustProviderBuilder::new(self).build().await
-    }
-}
-
-// RPC retry and timeout settings
-/// Default timeout used by `RobustProvider`
-pub const DEFAULT_MAX_TIMEOUT: Duration = Duration::from_secs(60);
-/// Default maximum number of retry attempts.
-pub const DEFAULT_MAX_RETRIES: usize = 3;
-/// Default base delay between retries.
-pub const DEFAULT_MIN_DELAY: Duration = Duration::from_secs(1);
-
-#[derive(Clone)]
-pub struct RobustProviderBuilder<N: Network, P: IntoProvider<N>> {
-    providers: Vec<P>,
-    max_timeout: Duration,
-    max_retries: usize,
-    min_delay: Duration,
-    _network: PhantomData<N>,
-}
-
-impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
-    /// Create a new `RobustProvider` with default settings.
-    ///
-    /// The provided provider is treated as the primary provider.
-    #[must_use]
-    pub fn new(provider: P) -> Self {
-        Self {
-            providers: vec![provider],
-            max_timeout: DEFAULT_MAX_TIMEOUT,
-            max_retries: DEFAULT_MAX_RETRIES,
-            min_delay: DEFAULT_MIN_DELAY,
-            _network: PhantomData,
-        }
-    }
-
-    /// Create a new `RobustProvider` with no retry attempts and only timeout set.
-    ///
-    /// The provided provider is treated as the primary provider.
-    #[must_use]
-    pub fn fragile(provider: P) -> Self {
-        Self::new(provider).max_retries(0).min_delay(Duration::ZERO)
-    }
-
-    /// Add a fallback provider to the list.
-    ///
-    /// Fallback providers are used when the primary provider times out or fails.
-    #[must_use]
-    pub fn fallback(mut self, provider: P) -> Self {
-        self.providers.push(provider);
-        self
-    }
-
-    /// Set the maximum timeout for RPC operations.
-    #[must_use]
-    pub fn max_timeout(mut self, timeout: Duration) -> Self {
-        self.max_timeout = timeout;
-        self
-    }
-
-    /// Set the maximum number of retry attempts.
-    #[must_use]
-    pub fn max_retries(mut self, max_retries: usize) -> Self {
-        self.max_retries = max_retries;
-        self
-    }
-
-    /// Set the base delay for exponential backoff retries.
-    #[must_use]
-    pub fn min_delay(mut self, min_delay: Duration) -> Self {
-        self.min_delay = min_delay;
-        self
-    }
-
-    /// Build the `RobustProvider`.
-    ///
-    /// Final builder method: consumes the builder and returns the built [`RobustProvider`].
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if any of the providers fail to connect.
-    pub async fn build(self) -> Result<RobustProvider<N>, Error> {
-        let mut providers = vec![];
-        for p in self.providers {
-            providers.push(p.into_provider().await?.root().to_owned());
-        }
-        Ok(RobustProvider {
-            providers,
-            max_timeout: self.max_timeout,
-            max_retries: self.max_retries,
-            min_delay: self.min_delay,
-        })
-    }
-}
+use crate::robust_provider::Error;
 
 /// Provider wrapper with built-in retry and timeout mechanisms.
 ///
@@ -219,10 +21,10 @@ impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
 /// The first provider in the vector is treated as the primary provider.
 #[derive(Clone)]
 pub struct RobustProvider<N: Network = Ethereum> {
-    providers: Vec<RootProvider<N>>,
-    max_timeout: Duration,
-    max_retries: usize,
-    min_delay: Duration,
+    pub(crate) providers: Vec<RootProvider<N>>,
+    pub(crate) max_timeout: Duration,
+    pub(crate) max_retries: usize,
+    pub(crate) min_delay: Duration,
 }
 
 impl<N: Network> RobustProvider<N> {
@@ -468,6 +270,7 @@ impl<N: Network> RobustProvider<N> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::robust_provider::RobustProviderBuilder;
     use alloy::{
         consensus::BlockHeader,
         providers::{ProviderBuilder, WsConnect, ext::AnvilApi},