ref: rename safe to robust provider

Author: LeoPatOZ

src/block_range_scanner.rs

@@ -72,8 +72,8 @@ use tokio_stream::{StreamExt, wrappers::ReceiverStream};
 
 use crate::{
     error::ScannerError,
-    safe_provider::{
-        DEFAULT_MAX_RETRIES, DEFAULT_MAX_TIMEOUT, DEFAULT_RETRY_INTERVAL, SafeProvider,
+    robust_provider::{
+        DEFAULT_MAX_RETRIES, DEFAULT_MAX_TIMEOUT, DEFAULT_RETRY_INTERVAL, RobustProvider,
     },
     types::{ScannerMessage, ScannerStatus},
 };
@@ -198,26 +198,26 @@ impl BlockRangeScanner {
     /// Returns an error if the connection fails
     #[must_use]
     pub fn connect<N: Network>(self, provider: RootProvider<N>) -> ConnectedBlockRangeScanner<N> {
-        let safe_provider = SafeProvider::new(provider)
+        let robust_provider = RobustProvider::new(provider)
             .max_timeout(self.max_timeout)
             .max_retries(self.max_retries)
             .retry_interval(self.retry_interval);
         ConnectedBlockRangeScanner {
-            provider: safe_provider,
+            provider: robust_provider,
             max_block_range: self.max_block_range,
         }
     }
 }
 
 pub struct ConnectedBlockRangeScanner<N: Network> {
-    provider: SafeProvider<N>,
+    provider: RobustProvider<N>,
     max_block_range: u64,
 }
 
 impl<N: Network> ConnectedBlockRangeScanner<N> {
-    /// Returns the `SafeProvider`
+    /// Returns the `RobustProvider`
     #[must_use]
-    pub fn provider(&self) -> &SafeProvider<N> {
+    pub fn provider(&self) -> &RobustProvider<N> {
         &self.provider
     }
 
@@ -269,7 +269,7 @@ pub enum Command {
 }
 
 struct Service<N: Network> {
-    provider: SafeProvider<N>,
+    provider: RobustProvider<N>,
     max_block_range: u64,
     subscriber: Option<mpsc::Sender<Message>>,
     websocket_connected: bool,
@@ -280,7 +280,7 @@ struct Service<N: Network> {
 }
 
 impl<N: Network> Service<N> {
-    pub fn new(provider: SafeProvider<N>, max_block_range: u64) -> (Self, mpsc::Sender<Command>) {
+    pub fn new(provider: RobustProvider<N>, max_block_range: u64) -> (Self, mpsc::Sender<Command>) {
         let (cmd_tx, cmd_rx) = mpsc::channel(100);
 
         let service = Self {
@@ -678,7 +678,7 @@ impl<N: Network> Service<N> {
 
     async fn stream_live_blocks(
         mut range_start: BlockNumber,
-        provider: SafeProvider<N>,
+        provider: RobustProvider<N>,
         sender: mpsc::Sender<Message>,
         block_confirmations: u64,
         max_block_range: u64,
@@ -783,7 +783,7 @@ impl<N: Network> Service<N> {
     }
 
     async fn get_block_subscription(
-        provider: &SafeProvider<N>,
+        provider: &RobustProvider<N>,
     ) -> Result<Subscription<N::HeaderResponse>, ScannerError> {
         let ws_stream = provider
             .subscribe_blocks()
@@ -1018,9 +1018,9 @@ mod tests {
     use tokio::sync::mpsc;
     use tokio_stream::StreamExt;
 
-    fn mocked_provider(asserter: Asserter) -> SafeProvider<Ethereum> {
+    fn mocked_provider(asserter: Asserter) -> RobustProvider<Ethereum> {
         let root_provider = RootProvider::new(RpcClient::mocked(asserter));
-        SafeProvider::new(root_provider)
+        RobustProvider::new(root_provider)
     }
 
     #[test]

src/error.rs

@@ -7,7 +7,7 @@ use alloy::{
 };
 use thiserror::Error;
 
-use crate::{block_range_scanner::Message, safe_provider::SafeProviderError};
+use crate::{block_range_scanner::Message, robust_provider::RobustProviderError};
 
 #[derive(Error, Debug, Clone)]
 pub enum ScannerError {
@@ -50,12 +50,12 @@ pub enum ScannerError {
     RetryFail(usize),
 }
 
-impl From<SafeProviderError> for ScannerError {
-    fn from(error: SafeProviderError) -> ScannerError {
+impl From<RobustProviderError> for ScannerError {
+    fn from(error: RobustProviderError) -> ScannerError {
         match error {
-            SafeProviderError::RpcError(err) => ScannerError::RpcError(err),
-            SafeProviderError::Timeout => ScannerError::Timeout,
-            SafeProviderError::RetryFail(num) => ScannerError::RetryFail(num),
+            RobustProviderError::RpcError(err) => ScannerError::RpcError(err),
+            RobustProviderError::Timeout => ScannerError::Timeout,
+            RobustProviderError::RetryFail(num) => ScannerError::RetryFail(num),
         }
     }
 }

src/event_scanner/message.rs

@@ -1,6 +1,6 @@
 use alloy::{rpc::types::Log, sol_types::SolEvent};
 
-use crate::{ScannerError, ScannerMessage, safe_provider::SafeProviderError};
+use crate::{ScannerError, ScannerMessage, robust_provider::RobustProviderError};
 
 pub type Message = ScannerMessage<Vec<Log>, ScannerError>;
 
@@ -10,8 +10,8 @@ impl From<Vec<Log>> for Message {
     }
 }
 
-impl From<SafeProviderError> for Message {
-    fn from(error: SafeProviderError) -> Message {
+impl From<RobustProviderError> for Message {
+    fn from(error: RobustProviderError) -> Message {
         let scanner_error: ScannerError = error.into();
         scanner_error.into()
     }

src/event_scanner/modes/common.rs

@@ -3,7 +3,7 @@ use std::ops::RangeInclusive;
 use crate::{
     block_range_scanner::{MAX_BUFFERED_MESSAGES, Message as BlockRangeMessage},
     event_scanner::{filter::EventFilter, listener::EventListener, message::Message},
-    safe_provider::{SafeProvider, SafeProviderError},
+    robust_provider::{RobustProvider, RobustProviderError},
 };
 use alloy::{
     network::Network,
@@ -24,7 +24,7 @@ pub enum ConsumerMode {
 
 pub async fn handle_stream<N: Network>(
     mut stream: ReceiverStream<BlockRangeMessage>,
-    provider: &SafeProvider<N>,
+    provider: &RobustProvider<N>,
     listeners: &[EventListener],
     mode: ConsumerMode,
 ) {
@@ -41,7 +41,7 @@ pub async fn handle_stream<N: Network>(
 }
 
 pub fn spawn_log_consumers<N: Network>(
-    provider: &SafeProvider<N>,
+    provider: &RobustProvider<N>,
     listeners: &[EventListener],
     range_tx: &Sender<BlockRangeMessage>,
     mode: ConsumerMode,
@@ -128,8 +128,8 @@ async fn get_logs<N: Network>(
     range: RangeInclusive<u64>,
     event_filter: &EventFilter,
     log_filter: &Filter,
-    provider: &SafeProvider<N>,
-) -> Result<Vec<Log>, SafeProviderError> {
+    provider: &RobustProvider<N>,
+) -> Result<Vec<Log>, RobustProviderError> {
     let log_filter = log_filter.clone().from_block(*range.start()).to_block(*range.end());
 
     match provider.get_logs(&log_filter).await {

src/lib.rs

@@ -1,7 +1,7 @@
 pub mod block_range_scanner;
 pub mod error;
 pub mod event_scanner;
-mod safe_provider;
+mod robust_provider;
 #[cfg(any(test, feature = "test-utils"))]
 pub mod test_utils;
 pub mod types;

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

@@ -13,7 +13,7 @@ use thiserror::Error;
 use tracing::{error, info};
 
 #[derive(Error, Debug, Clone)]
-pub enum SafeProviderError {
+pub enum RobustProviderError {
     #[error("RPC error: {0}")]
     RpcError(Arc<RpcError<TransportErrorKind>>),
     #[error("Operation timed out")]
@@ -22,9 +22,9 @@ pub enum SafeProviderError {
     RetryFail(usize),
 }
 
-impl From<RpcError<TransportErrorKind>> for SafeProviderError {
+impl From<RpcError<TransportErrorKind>> for RobustProviderError {
     fn from(err: RpcError<TransportErrorKind>) -> Self {
-        SafeProviderError::RpcError(Arc::new(err))
+        RobustProviderError::RpcError(Arc::new(err))
     }
 }
 
@@ -33,23 +33,23 @@ impl From<RpcError<TransportErrorKind>> for SafeProviderError {
 /// This wrapper around Alloy providers automatically handles retries,
 /// timeouts, and error logging for RPC calls.
 #[derive(Clone)]
-pub struct SafeProvider<N: Network> {
+pub struct RobustProvider<N: Network> {
     provider: RootProvider<N>,
     max_timeout: Duration,
     max_retries: usize,
     retry_interval: Duration,
 }
 
 // RPC retry and timeout settings
-/// Default timeout used by `SafeProvider`
+/// Default timeout used by `RobustProvider`
 pub const DEFAULT_MAX_TIMEOUT: Duration = Duration::from_secs(30);
 /// Default maximum number of retry attempts.
 pub const DEFAULT_MAX_RETRIES: usize = 5;
 /// Default base delay between retries.
 pub const DEFAULT_RETRY_INTERVAL: Duration = Duration::from_secs(1);
 
-impl<N: Network> SafeProvider<N> {
-    /// Create a new `SafeProvider` with default settings.
+impl<N: Network> RobustProvider<N> {
+    /// Create a new `RobustProvider` with default settings.
     #[must_use]
     pub fn new(provider: RootProvider<N>) -> Self {
         Self {
@@ -87,10 +87,10 @@ impl<N: Network> SafeProvider<N> {
     pub async fn get_block_by_number(
         &self,
         number: BlockNumberOrTag,
-    ) -> Result<Option<N::BlockResponse>, SafeProviderError> {
+    ) -> Result<Option<N::BlockResponse>, RobustProviderError> {
         info!("eth_getBlockByNumber called");
         let operation = async || {
-            self.provider.get_block_by_number(number).await.map_err(SafeProviderError::from)
+            self.provider.get_block_by_number(number).await.map_err(RobustProviderError::from)
         };
         let result = self.retry_with_total_timeout(operation).await;
         if let Err(e) = &result {
@@ -105,10 +105,10 @@ impl<N: Network> SafeProvider<N> {
     ///
     /// Returns an error if RPC call fails repeatedly even
     /// after exhausting retries or if the call times out.
-    pub async fn get_block_number(&self) -> Result<u64, SafeProviderError> {
+    pub async fn get_block_number(&self) -> Result<u64, RobustProviderError> {
         info!("eth_getBlockNumber called");
         let operation =
-            async || self.provider.get_block_number().await.map_err(SafeProviderError::from);
+            async || self.provider.get_block_number().await.map_err(RobustProviderError::from);
         let result = self.retry_with_total_timeout(operation).await;
         if let Err(e) = &result {
             error!(error = %e, "eth_getBlockNumber failed");
@@ -125,10 +125,10 @@ impl<N: Network> SafeProvider<N> {
     pub async fn get_block_by_hash(
         &self,
         hash: alloy::primitives::BlockHash,
-    ) -> Result<Option<N::BlockResponse>, SafeProviderError> {
+    ) -> Result<Option<N::BlockResponse>, RobustProviderError> {
         info!("eth_getBlockByHash called");
         let operation =
-            async || self.provider.get_block_by_hash(hash).await.map_err(SafeProviderError::from);
+            async || self.provider.get_block_by_hash(hash).await.map_err(RobustProviderError::from);
         let result = self.retry_with_total_timeout(operation).await;
         if let Err(e) = &result {
             error!(error = %e, "eth_getBlockByHash failed");
@@ -142,10 +142,10 @@ impl<N: Network> SafeProvider<N> {
     ///
     /// Returns an error if RPC call fails repeatedly even
     /// after exhausting retries or if the call times out.
-    pub async fn get_logs(&self, filter: &Filter) -> Result<Vec<Log>, SafeProviderError> {
+    pub async fn get_logs(&self, filter: &Filter) -> Result<Vec<Log>, RobustProviderError> {
         info!("eth_getLogs called");
         let operation =
-            async || self.provider.get_logs(filter).await.map_err(SafeProviderError::from);
+            async || self.provider.get_logs(filter).await.map_err(RobustProviderError::from);
         let result = self.retry_with_total_timeout(operation).await;
         if let Err(e) = &result {
             error!(error = %e, "eth_getLogs failed");
@@ -161,12 +161,12 @@ impl<N: Network> SafeProvider<N> {
     /// after exhausting retries or if the call times out.
     pub async fn subscribe_blocks(
         &self,
-    ) -> Result<Subscription<N::HeaderResponse>, SafeProviderError> {
+    ) -> Result<Subscription<N::HeaderResponse>, RobustProviderError> {
         info!("eth_subscribe called");
         let provider = self.provider.clone();
         let result = self
             .retry_with_total_timeout(|| async {
-                provider.subscribe_blocks().await.map_err(SafeProviderError::from)
+                provider.subscribe_blocks().await.map_err(RobustProviderError::from)
             })
             .await;
         if let Err(e) = &result {
@@ -189,10 +189,10 @@ impl<N: Network> SafeProvider<N> {
     async fn retry_with_total_timeout<T, F, Fut>(
         &self,
         operation: F,
-    ) -> Result<T, SafeProviderError>
+    ) -> Result<T, RobustProviderError>
     where
         F: Fn() -> Fut,
-        Fut: Future<Output = Result<T, SafeProviderError>>,
+        Fut: Future<Output = Result<T, RobustProviderError>>,
     {
         let retry_strategy = ExponentialBuilder::default()
             .with_max_times(self.max_retries)
@@ -205,8 +205,8 @@ impl<N: Network> SafeProvider<N> {
         .await
         {
             Ok(Ok(res)) => Ok(res),
-            Ok(Err(_)) => Err(SafeProviderError::RetryFail(self.max_retries + 1)),
-            Err(_) => Err(SafeProviderError::Timeout),
+            Ok(Err(_)) => Err(RobustProviderError::RetryFail(self.max_retries + 1)),
+            Err(_) => Err(RobustProviderError::Timeout),
         }
     }
 }
@@ -222,8 +222,8 @@ mod tests {
         timeout: u64,
         max_retries: usize,
         retry_interval: u64,
-    ) -> SafeProvider<Ethereum> {
-        SafeProvider {
+    ) -> RobustProvider<Ethereum> {
+        RobustProvider {
             provider: RootProvider::new_http("http://localhost:8545".parse().unwrap()),
             max_timeout: Duration::from_millis(timeout),
             max_retries,
@@ -257,7 +257,7 @@ mod tests {
             .retry_with_total_timeout(|| async {
                 call_count.fetch_add(1, Ordering::SeqCst);
                 if call_count.load(Ordering::SeqCst) < 3 {
-                    Err(SafeProviderError::RpcError(Arc::new(TransportErrorKind::custom_str(
+                    Err(RobustProviderError::RpcError(Arc::new(TransportErrorKind::custom_str(
                         "temp error",
                     ))))
                 } else {
@@ -279,12 +279,12 @@ mod tests {
             .retry_with_total_timeout(|| async {
                 call_count.fetch_add(1, Ordering::SeqCst);
                 // permanent error
-                Err::<i32, SafeProviderError>(SafeProviderError::Timeout)
+                Err::<i32, RobustProviderError>(RobustProviderError::Timeout)
             })
             .await;
 
         let err = result.unwrap_err();
-        assert!(matches!(err, SafeProviderError::RetryFail(3)));
+        assert!(matches!(err, RobustProviderError::RetryFail(3)));
         assert_eq!(call_count.load(Ordering::SeqCst), 3);
     }
 
@@ -301,6 +301,6 @@ mod tests {
             .await;
 
         let err = result.unwrap_err();
-        assert!(matches!(err, SafeProviderError::Timeout));
+        assert!(matches!(err, RobustProviderError::Timeout));
     }
 }