fix: from_min --> from_sec

ref: better comments

Author: LeoPatOZ

src/robust_provider.rs

@@ -126,7 +126,7 @@ impl<N: Network, P: IntoProvider<N> + Send> IntoRobustProvider<N> for P {
 /// Default timeout used by `RobustProvider`
 pub const DEFAULT_MAX_TIMEOUT: Duration = Duration::from_secs(60);
 /// Default timeout for subscriptions (longer to accommodate slow block times)
-pub const DEFAULT_SUBSCRIPTION_TIMEOUT: Duration = Duration::from_mins(2);
+pub const DEFAULT_SUBSCRIPTION_TIMEOUT: Duration = Duration::from_secs(120);
 /// Default maximum number of retry attempts.
 pub const DEFAULT_MAX_RETRIES: usize = 3;
 /// Default base delay between retries.
@@ -143,7 +143,7 @@ pub struct RobustProviderBuilder<N: Network, P: IntoProvider<N>> {
 }
 
 impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
-    /// Create a new `RobustProvider` with default settings.
+    /// Create a new [`RobustProvider`] with default settings.
     ///
     /// The provided provider is treated as the primary provider.
     #[must_use]
@@ -158,7 +158,7 @@ impl<N: Network, P: IntoProvider<N>> RobustProviderBuilder<N, P> {
         }
     }
 
-    /// Create a new `RobustProvider` with no retry attempts and only timeout set.
+    /// Create a new [`RobustProvider`] with no retry attempts and only timeout set.
     ///
     /// The provided provider is treated as the primary provider.
     #[must_use]

src/robust_subscription.rs

@@ -19,7 +19,7 @@ use tracing::{error, info, warn};
 
 use crate::robust_provider::{Error, RobustProvider};
 
-/// Default time interval between primary provider reconnection attempts (30 seconds)
+/// Default time interval between primary provider reconnection attempts
 pub const DEFAULT_RECONNECT_INTERVAL: Duration = Duration::from_secs(30);
 
 /// Maximum number of consecutive lags before switching providers
@@ -58,13 +58,13 @@ impl<N: Network> RobustSubscription<N> {
     /// - Attempt to receive from the current subscription
     /// - Handle errors by switching to fallback providers
     /// - Periodically attempt to reconnect to the primary provider
+    /// - Will switch to fallback providers if [`subscription_timeout`] is exhausted
     ///
     /// # Errors
     ///
     /// Returns an error if all providers have been exhausted and failed.
     pub async fn recv(&mut self) -> Result<N::HeaderResponse, Error> {
         loop {
-            // Check if we should attempt to reconnect to primary
             if self.should_reconnect_to_primary() {
                 info!("Attempting to reconnect to primary provider");
                 if let Err(e) = self.try_reconnect_to_primary().await {
@@ -74,7 +74,6 @@ impl<N: Network> RobustSubscription<N> {
                 }
             }
 
-            // Try to receive from current subscription with timeout
             if let Some(subscription) = &mut self.subscription {
                 let subscription_timeout = self.robust_provider.subscription_timeout;
                 match timeout(subscription_timeout, subscription.recv()).await {
@@ -108,7 +107,6 @@ impl<N: Network> RobustSubscription<N> {
                         },
                     },
                     Err(e) => {
-                        // Timeout occurred - no block received within subscription_timeout
                         error!(
                             timeout_secs = subscription_timeout.as_secs(),
                             "Subscription timeout - no block received, switching provider"
@@ -125,7 +123,6 @@ impl<N: Network> RobustSubscription<N> {
 
     fn should_reconnect_to_primary(&self) -> bool {
         // Only attempt reconnection if enough time has passed since last attempt
-        // The RobustProvider will try the primary provider first automatically
         match self.last_reconnect_attempt {
             None => false,
             Some(last_attempt) => last_attempt.elapsed() >= self.reconnect_interval,