ref: only connect to robust provider

Author: LeoPatOZ

README.md

@@ -113,7 +113,7 @@ Once configured, connect using one of:
 
 - `connect_ws::<Ethereum>(ws_url)`
 - `connect_ipc::<Ethereum>(path)`
-- `connect::<Ethereum>(provider)`
+- `connect::<Ethereum>(robust_provider)`
 
 This will connect the `EventScanner` and allow you to create event streams and start scanning in various [modes](#scanning-modes).
 

examples/historical_scanning/main.rs

@@ -6,7 +6,7 @@ use alloy::{
 };
 use alloy_node_bindings::Anvil;
 
-use event_scanner::{EventFilter, EventScannerBuilder, Message};
+use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
 use tokio_stream::StreamExt;
 use tracing::{error, info};
 use tracing_subscriber::EnvFilter;
@@ -57,8 +57,8 @@ async fn main() -> anyhow::Result<()> {
 
     let _ = counter_contract.increase().send().await?.get_receipt().await?;
 
-    let mut scanner =
-        EventScannerBuilder::historic().connect::<Ethereum>(provider.root().to_owned());
+    let robust_provider = RobustProvider::new(provider.root().clone());
+    let mut scanner = EventScannerBuilder::historic().connect::<Ethereum>(robust_provider);
 
     let mut stream = scanner.subscribe(increase_filter);
 

examples/latest_events_scanning/main.rs

@@ -5,7 +5,7 @@ use alloy::{
     sol_types::SolEvent,
 };
 use alloy_node_bindings::Anvil;
-use event_scanner::{EventFilter, EventScannerBuilder, Message};
+use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
 use tokio_stream::StreamExt;
 use tracing::{error, info};
 use tracing_subscriber::EnvFilter;
@@ -54,8 +54,8 @@ async fn main() -> anyhow::Result<()> {
         .contract_address(*contract_address)
         .event(Counter::CountIncreased::SIGNATURE);
 
-    let mut scanner =
-        EventScannerBuilder::latest(5).connect::<Ethereum>(provider.root().to_owned());
+    let robust_provider = RobustProvider::new(provider.root().clone());
+    let mut scanner = EventScannerBuilder::latest(5).connect::<Ethereum>(robust_provider);
 
     let mut stream = scanner.subscribe(increase_filter);
 

examples/live_scanning/main.rs

@@ -5,7 +5,7 @@ use alloy::{
     sol_types::SolEvent,
 };
 use alloy_node_bindings::Anvil;
-use event_scanner::{EventFilter, EventScannerBuilder, Message};
+use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
 
 use tokio_stream::StreamExt;
 use tracing::{error, info};
@@ -55,7 +55,8 @@ async fn main() -> anyhow::Result<()> {
         .contract_address(*contract_address)
         .event(Counter::CountIncreased::SIGNATURE);
 
-    let mut scanner = EventScannerBuilder::live().connect::<Ethereum>(provider.root().to_owned());
+    let robust_provider = RobustProvider::new(provider.root().clone());
+    let mut scanner = EventScannerBuilder::live().connect::<Ethereum>(robust_provider);
 
     let mut stream = scanner.subscribe(increase_filter);
 

examples/sync_from_block_scanning/main.rs

@@ -7,7 +7,7 @@ use alloy::{
     sol_types::SolEvent,
 };
 use alloy_node_bindings::Anvil;
-use event_scanner::{EventFilter, EventScannerBuilder, Message};
+use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
 use tokio::time::sleep;
 use tokio_stream::StreamExt;
 use tracing::{error, info};
@@ -63,8 +63,9 @@ async fn main() -> anyhow::Result<()> {
         info!("Historical event {} created", i + 1);
     }
 
+    let robust_provider = RobustProvider::new(provider.root().clone());
     let mut scanner =
-        EventScannerBuilder::sync().from_block(0).connect::<Ethereum>(provider.root().to_owned());
+        EventScannerBuilder::sync().from_block(0).connect::<Ethereum>(robust_provider);
 
     let mut stream = scanner.subscribe(increase_filter);
 

examples/sync_from_latest_scanning/main.rs

@@ -5,7 +5,7 @@ use alloy::{
     sol_types::SolEvent,
 };
 use alloy_node_bindings::Anvil;
-use event_scanner::{EventFilter, EventScannerBuilder, Message};
+use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
 
 use tokio_stream::StreamExt;
 use tracing::{error, info};
@@ -55,8 +55,9 @@ async fn main() -> anyhow::Result<()> {
         .contract_address(*contract_address)
         .event(Counter::CountIncreased::SIGNATURE);
 
+    let robust_provider = RobustProvider::new(provider.root().clone());
     let mut client =
-        EventScannerBuilder::sync().from_latest(5).connect::<Ethereum>(provider.root().to_owned());
+        EventScannerBuilder::sync().from_latest(5).connect::<Ethereum>(robust_provider);
 
     let mut stream = client.subscribe(increase_filter);
 

src/block_range_scanner.rs

@@ -147,20 +147,9 @@ impl BlockRangeScanner {
     }
 
     /// Connects to an existing provider
-    ///
-    /// This method also tries to connect any fallback providers (both WebSocket and IPC)
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if any fallback connection fails
-    pub fn connect<N: Network>(
-        self,
-        provider: impl Into<RobustProvider<N>>,
-    ) -> ConnectedBlockRangeScanner<N> {
-        ConnectedBlockRangeScanner {
-            provider: provider.into(),
-            max_block_range: self.max_block_range,
-        }
+    #[must_use]
+    pub fn connect<N: Network>(self, provider: RobustProvider<N>) -> ConnectedBlockRangeScanner<N> {
+        ConnectedBlockRangeScanner { provider, max_block_range: self.max_block_range }
     }
 }
 
@@ -905,11 +894,12 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
 
+        let robust_provider = RobustProvider::new(provider.root().clone());
+
         provider.subscribe_blocks();
         // --- Zero block confirmations -> stream immediately ---
 
-        let client =
-            BlockRangeScanner::new().connect::<Ethereum>(provider.root().to_owned()).run()?;
+        let client = BlockRangeScanner::new().connect::<Ethereum>(robust_provider).run()?;
 
         let mut stream = client.stream_live(0).await?;
 
@@ -953,12 +943,12 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
         provider.anvil_mine(Some(20), None).await?;
 
         let block_confirmations = 5;
 
-        let client =
-            BlockRangeScanner::new().connect::<Ethereum>(provider.root().to_owned()).run()?;
+        let client = BlockRangeScanner::new().connect::<Ethereum>(robust_provider).run()?;
 
         let stream = client.stream_from(BlockNumberOrTag::Latest, block_confirmations).await?;
 
@@ -987,11 +977,11 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         let block_confirmations = 5;
 
-        let client =
-            BlockRangeScanner::new().connect::<Ethereum>(provider.root().to_owned()).run()?;
+        let client = BlockRangeScanner::new().connect::<Ethereum>(robust_provider).run()?;
 
         let mut receiver = client.stream_live(block_confirmations).await?;
 
@@ -1029,11 +1019,11 @@ mod tests {
         let anvil = Anvil::new().block_time(1).try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         let block_confirmations = 3;
 
-        let client =
-            BlockRangeScanner::new().connect::<Ethereum>(provider.root().to_owned()).run()?;
+        let client = BlockRangeScanner::new().connect::<Ethereum>(robust_provider).run()?;
 
         let mut receiver = client.stream_live(block_confirmations).await?;
 
@@ -1092,14 +1082,15 @@ mod tests {
     async fn historical_emits_correction_range_when_reorg_below_end() -> anyhow::Result<()> {
         let anvil = Anvil::new().try_spawn()?;
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         provider.anvil_mine(Some(120), None).await?;
 
         let end_num = 110;
 
         let client = BlockRangeScanner::new()
             .max_block_range(30)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client
@@ -1126,14 +1117,15 @@ mod tests {
     async fn historical_emits_correction_range_when_end_num_reorgs() -> anyhow::Result<()> {
         let anvil = Anvil::new().try_spawn()?;
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         provider.anvil_mine(Some(120), None).await?;
 
         let end_num = 120;
 
         let client = BlockRangeScanner::new()
             .max_block_range(30)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client
@@ -1162,12 +1154,13 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         provider.anvil_mine(Some(100), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(5)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider.clone())
             .run()?;
 
         // ranges where each batch is of max blocks per epoch size
@@ -1197,7 +1190,7 @@ mod tests {
         // range where blocks per epoch is larger than the number of blocks on chain
         let client = BlockRangeScanner::new()
             .max_block_range(200)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client.stream_historical(0, 20).await?;
@@ -1216,11 +1209,12 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
         provider.anvil_mine(Some(11), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(5)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client.stream_historical(10, 0).await?;
@@ -1333,12 +1327,13 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         provider.anvil_mine(Some(150), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(100)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client.rewind(100, 150).await?;
@@ -1356,12 +1351,13 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         provider.anvil_mine(Some(15), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(5)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client.rewind(0, 14).await?;
@@ -1380,12 +1376,13 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         provider.anvil_mine(Some(15), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(4)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client.rewind(3, 12).await?;
@@ -1404,12 +1401,13 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
 
         provider.anvil_mine(Some(15), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(5)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client.rewind(7, 7).await?;
@@ -1425,12 +1423,13 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().to_owned());
 
         provider.anvil_mine(Some(15), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(1)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client.rewind(5, 8).await?;
@@ -1450,12 +1449,13 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
         // Mine 20 blocks, so the total number of blocks is 21 (including 0th block)
         provider.anvil_mine(Some(20), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(7)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream =
@@ -1474,12 +1474,13 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().clone());
         // Ensure blocks at 3 and 15 exist
         provider.anvil_mine(Some(16), None).await?;
 
         let client = BlockRangeScanner::new()
             .max_block_range(5)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let mut stream = client.rewind(15, 3).await?;
@@ -1504,11 +1505,12 @@ mod tests {
         let anvil = Anvil::new().try_spawn()?;
 
         let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+        let robust_provider = RobustProvider::new(provider.root().to_owned());
 
         // Do not mine up to 999 so start won't exist
         let client = BlockRangeScanner::new()
             .max_block_range(5)
-            .connect::<Ethereum>(provider.root().to_owned())
+            .connect::<Ethereum>(robust_provider)
             .run()?;
 
         let stream = client.rewind(0, 999).await;