Allow for multiple provider types (#211)

Author: LeoPatOZ

src/robust_provider/builder.rs

@@ -1,11 +1,13 @@
-use std::{marker::PhantomData, time::Duration};
+use std::{pin::Pin, time::Duration};
 
-use alloy::{network::Network, providers::Provider};
+use alloy::{network::Network, providers::RootProvider};
 
 use crate::robust_provider::{
-    Error, IntoProvider, RobustProvider, subscription::DEFAULT_RECONNECT_INTERVAL,
+    Error, IntoRootProvider, RobustProvider, subscription::DEFAULT_RECONNECT_INTERVAL,
 };
 
+type BoxedProviderFuture<N> = Pin<Box<dyn Future<Output = Result<RootProvider<N>, Error>> + Send>>;
+
 // RPC retry and timeout settings
 /// Default timeout used by `RobustProvider`
 pub const DEFAULT_CALL_TIMEOUT: Duration = Duration::from_secs(60);
@@ -16,22 +18,21 @@ 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>> {
+pub struct RobustProviderBuilder<N: Network, P: IntoRootProvider<N>> {
     primary_provider: P,
-    fallback_providers: Vec<P>,
+    fallback_providers: Vec<BoxedProviderFuture<N>>,
     call_timeout: Duration,
     subscription_timeout: Duration,
     max_retries: usize,
     min_delay: Duration,
     reconnect_interval: Duration,
-    _network: PhantomData<N>,
 }
 
-impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
+impl<N: Network, P: IntoRootProvider<N>> RobustProviderBuilder<N, P> {
     /// Create a new [`RobustProvider`] with default settings.
     ///
     /// The provided provider is treated as the primary provider.
+    /// Any type implementing [`IntoRootProvider`] can be used.
     #[must_use]
     pub fn new(provider: P) -> Self {
         Self {
@@ -42,7 +43,6 @@ impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
             max_retries: DEFAULT_MAX_RETRIES,
             min_delay: DEFAULT_MIN_DELAY,
             reconnect_interval: DEFAULT_RECONNECT_INTERVAL,
-            _network: PhantomData,
         }
     }
 
@@ -58,8 +58,8 @@ impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
     ///
     /// Fallback providers are used when the primary provider times out or fails.
     #[must_use]
-    pub fn fallback(mut self, provider: P) -> Self {
-        self.fallback_providers.push(provider);
+    pub fn fallback<F: IntoRootProvider<N> + Send + 'static>(mut self, provider: F) -> Self {
+        self.fallback_providers.push(Box::pin(provider.into_root_provider()));
         self
     }
 
@@ -113,11 +113,11 @@ impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
     ///
     /// Returns an error if any of the providers fail to connect.
     pub async fn build(self) -> Result<RobustProvider<N>, Error> {
-        let primary_provider = self.primary_provider.into_provider().await?.root().to_owned();
+        let primary_provider = self.primary_provider.into_root_provider().await?;
 
-        let mut fallback_providers = vec![];
-        for p in self.fallback_providers {
-            fallback_providers.push(p.into_provider().await?.root().to_owned());
+        let mut fallback_providers = Vec::with_capacity(self.fallback_providers.len());
+        for fallback in self.fallback_providers {
+            fallback_providers.push(fallback.await?);
         }
 
         Ok(RobustProvider {
@@ -131,3 +131,55 @@ impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy::providers::{ProviderBuilder, WsConnect};
+    use alloy_node_bindings::Anvil;
+
+    #[tokio::test]
+    async fn test_builder_primary_type_different_to_fallback() -> anyhow::Result<()> {
+        let anvil = Anvil::new().try_spawn()?;
+
+        let fill_provider = ProviderBuilder::new()
+            .connect_ws(WsConnect::new(anvil.ws_endpoint_url().as_str()))
+            .await?;
+
+        let root_provider = RootProvider::new_http(anvil.endpoint_url());
+
+        let robust = RobustProviderBuilder::new(fill_provider)
+            .fallback(root_provider)
+            .call_timeout(Duration::from_secs(5))
+            .build()
+            .await?;
+
+        assert_eq!(robust.fallback_providers.len(), 1);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_builder_with_multiple_fallback_types() -> anyhow::Result<()> {
+        let anvil = Anvil::new().try_spawn()?;
+
+        let fill_provider = ProviderBuilder::new()
+            .connect_ws(WsConnect::new(anvil.ws_endpoint_url().as_str()))
+            .await?;
+
+        let root_provider = RootProvider::new_http(anvil.endpoint_url());
+
+        let url_provider = anvil.endpoint_url();
+
+        let robust = RobustProviderBuilder::new(fill_provider)
+            .fallback(root_provider)
+            .fallback(url_provider.clone())
+            .fallback(url_provider)
+            .build()
+            .await?;
+
+        assert_eq!(robust.fallback_providers.len(), 3);
+
+        Ok(())
+    }
+}

src/robust_provider/mod.rs

@@ -8,7 +8,7 @@
 //! * more robust WebSocket block subscriptions with automatic reconnection
 //!
 //! Use [`RobustProviderBuilder`] to construct a provider with sensible defaults
-//! and optional fallbacks, or implement the [`IntoRobustProvider`] and [`IntoProvider`]
+//! and optional fallbacks, or implement the [`IntoRobustProvider`] and [`IntoRootProvider`]
 //! traits to support custom providers.
 //!
 //! # How it works
@@ -68,5 +68,5 @@ pub mod subscription;
 pub use builder::*;
 pub use error::Error;
 pub use provider::RobustProvider;
-pub use provider_conversion::{IntoProvider, IntoRobustProvider};
+pub use provider_conversion::{IntoRobustProvider, IntoRootProvider};
 pub use subscription::RobustSubscription;

src/robust_provider/provider_conversion.rs

@@ -10,79 +10,79 @@ use alloy::{
 
 use crate::robust_provider::{Error, RobustProvider, RobustProviderBuilder};
 
-pub trait IntoProvider<N: Network = Ethereum> {
-    fn into_provider(self) -> impl Future<Output = Result<impl Provider<N>, Error>> + Send;
+pub trait IntoRootProvider<N: Network = Ethereum> {
+    fn into_root_provider(self) -> impl Future<Output = Result<RootProvider<N>, Error>> + Send;
 }
 
-impl<N: Network> IntoProvider<N> for RobustProvider<N> {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
+impl<N: Network> IntoRootProvider<N> for RobustProvider<N> {
+    async fn into_root_provider(self) -> Result<RootProvider<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> {
+impl<N: Network> IntoRootProvider<N> for RootProvider<N> {
+    async fn into_root_provider(self) -> Result<RootProvider<N>, Error> {
         Ok(self)
     }
 }
 
-impl<N: Network> IntoProvider<N> for &str {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
+impl<N: Network> IntoRootProvider<N> for &str {
+    async fn into_root_provider(self) -> Result<RootProvider<N>, Error> {
         Ok(RootProvider::connect(self).await?)
     }
 }
 
-impl<N: Network> IntoProvider<N> for Url {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
+impl<N: Network> IntoRootProvider<N> for Url {
+    async fn into_root_provider(self) -> Result<RootProvider<N>, Error> {
         Ok(RootProvider::connect(self.as_str()).await?)
     }
 }
 
-impl<F, P, N> IntoProvider<N> for FillProvider<F, P, N>
+impl<F, P, N> IntoRootProvider<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)
+    async fn into_root_provider(self) -> Result<RootProvider<N>, Error> {
+        Ok(self.root().to_owned())
     }
 }
 
-impl<P, N> IntoProvider<N> for CacheProvider<P, N>
+impl<P, N> IntoRootProvider<N> for CacheProvider<P, N>
 where
     P: Provider<N>,
     N: Network,
 {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self)
+    async fn into_root_provider(self) -> Result<RootProvider<N>, Error> {
+        Ok(self.root().to_owned())
     }
 }
 
-impl<N> IntoProvider<N> for DynProvider<N>
+impl<N> IntoRootProvider<N> for DynProvider<N>
 where
     N: Network,
 {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self)
+    async fn into_root_provider(self) -> Result<RootProvider<N>, Error> {
+        Ok(self.root().to_owned())
     }
 }
 
-impl<P, N> IntoProvider<N> for CallBatchProvider<P, N>
+impl<P, N> IntoRootProvider<N> for CallBatchProvider<P, N>
 where
     P: Provider<N> + 'static,
     N: Network,
 {
-    async fn into_provider(self) -> Result<impl Provider<N>, Error> {
-        Ok(self)
+    async fn into_root_provider(self) -> Result<RootProvider<N>, Error> {
+        Ok(self.root().to_owned())
     }
 }
 
 pub trait IntoRobustProvider<N: Network = Ethereum> {
     fn into_robust_provider(self) -> impl Future<Output = Result<RobustProvider<N>, Error>> + Send;
 }
 
-impl<N: Network, P: IntoProvider<N> + Send> IntoRobustProvider<N> for P {
+impl<N: Network, P: IntoRootProvider<N> + Send + 'static> IntoRobustProvider<N> for P {
     async fn into_robust_provider(self) -> Result<RobustProvider<N>, Error> {
         RobustProviderBuilder::new(self).build().await
     }