fix: doctest + readme

Author: LeoPatOZ

README.md

@@ -58,20 +58,24 @@ event-scanner = "0.4.0-alpha"
 Create an event stream for the given event filters registered with the `EventScanner`:
 
 ```rust
-use alloy::{network::Ethereum, sol_types::SolEvent};
-use event_scanner::{EventFilter, EventScannerBuilder, Message};
+use alloy::{network::Ethereum, providers::{Provider, ProviderBuilder}, sol_types::SolEvent};
+use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
 use tokio_stream::StreamExt;
 
 use crate::MyContract;
 
 async fn run_scanner(
-    ws_url: alloy::transports::http::reqwest::Url,
+    ws_url: &str,
     contract: alloy::primitives::Address,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    // Connect to provider
+    let provider = ProviderBuilder::new().connect(ws_url).await?;
+    let robust_provider = RobustProvider::new(provider.root().to_owned());
+    
     // Configure scanner with custom batch size (optional)
     let mut scanner = EventScannerBuilder::live()
         .max_block_range(500)  // Process up to 500 blocks per batch
-        .connect_ws::<Ethereum>(ws_url).await?;
+        .connect(robust_provider);
 
     // Register an event listener
     let filter = EventFilter::new()
@@ -108,48 +112,53 @@ async fn run_scanner(
 
 ### Building a Scanner
 
-`EventScannerBuilder` provides mode-specific constructors and a functions to configure settings before connecting.
-Once configured, connect using one of:
+`EventScannerBuilder` provides mode-specific constructors and functions to configure settings before connecting.
+Once configured, connect using:
 
-- `connect_ws::<Ethereum>(ws_url)`
-- `connect_ipc::<Ethereum>(path)`
-- `connect::<Ethereum>(robust_provider)`
+- `connect(robust_provider)` - Connect using a `RobustProvider` wrapping your alloy provider
 
 This will connect the `EventScanner` and allow you to create event streams and start scanning in various [modes](#scanning-modes).
 
 ```rust
+use alloy::providers::{Provider, ProviderBuilder};
+use event_scanner::robust_provider::RobustProvider;
+
+// Connect to provider (example with WebSocket)
+let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+let robust_provider = RobustProvider::new(provider.root().to_owned());
+
 // Live streaming mode
 let scanner = EventScannerBuilder::live()
     .max_block_range(500)  // Optional: set max blocks per read (default: 1000)
     .block_confirmations(12)  // Optional: set block confirmations (default: 12)
-    .connect_ws::<Ethereum>(ws_url).await?;
+    .connect(robust_provider.clone());
 
 // Historical block range mode
 let scanner = EventScannerBuilder::historic()
     .from_block(1_000_000)
     .to_block(2_000_000)
     .max_block_range(500)
-    .connect_ws::<Ethereum>(ws_url).await?;
+    .connect(robust_provider.clone());
 
 // Latest events mode
 let scanner = EventScannerBuilder::latest(100)
     // .from_block(1_000_000)  // Optional: set start of search range
     // .to_block(2_000_000)    // Optional: set end of search range
     .max_block_range(500)
-    .connect_ws::<Ethereum>(ws_url).await?;
+    .connect(robust_provider.clone());
 
 // Sync from block then switch to live mode
 let scanner = EventScannerBuilder::sync()
     .from_block(100)
     .max_block_range(500)
     .block_confirmations(12)
-    .connect_ws::<Ethereum>(ws_url).await?;
+    .connect(robust_provider.clone());
 
 // Sync the latest 60 events then switch to live mode
 let scanner = EventScannerBuilder::sync()
     .from_latest(60)
     .block_confirmations(12)
-    .connect_ws::<Ethereum>(ws_url).await?;
+    .connect(robust_provider);
 ```
 
 Invoking `scanner.start()` starts the scanner in the specified mode.

src/block_range_scanner.rs

@@ -5,13 +5,14 @@
 //! use std::ops::RangeInclusive;
 //! use tokio_stream::{StreamExt, wrappers::ReceiverStream};
 //!
-//! use alloy::transports::http::reqwest::Url;
+//! use alloy::providers::{Provider, ProviderBuilder};
 //! use event_scanner::{
 //!     ScannerError,
 //!     block_range_scanner::{
 //!         BlockRangeScanner, BlockRangeScannerClient, DEFAULT_BLOCK_CONFIRMATIONS,
 //!         DEFAULT_MAX_BLOCK_RANGE, Message,
 //!     },
+//!     robust_provider::RobustProvider,
 //! };
 //! use tokio::time::Duration;
 //! use tracing::{error, info};
@@ -22,9 +23,9 @@
 //!     tracing_subscriber::fmt::init();
 //!
 //!     // Configuration
-//!     let block_range_scanner = BlockRangeScanner::new()
-//!         .connect_ws::<Ethereum>(Url::parse("ws://localhost:8546").unwrap())
-//!         .await?;
+//!     let provider = ProviderBuilder::new().connect("ws://localhost:8546").await?;
+//!     let robust_provider = RobustProvider::new(provider.root().to_owned());
+//!     let block_range_scanner = BlockRangeScanner::new().connect(robust_provider);
 //!
 //!     // Create client to send subscribe command to block scanner
 //!     let client: BlockRangeScannerClient = block_range_scanner.run()?;

src/event_scanner/scanner/mod.rs

@@ -77,17 +77,16 @@ impl EventScannerBuilder<Unspecified> {
     /// # Example
     ///
     /// ```no_run
-    /// # use alloy::network::Ethereum;
-    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message};
+    /// # use alloy::{network::Ethereum, providers::{Provider, ProviderBuilder}};
+    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
     /// # use tokio_stream::StreamExt;
     /// #
     /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let ws_url = "ws://localhost:8545".parse()?;
     /// # let contract_address = alloy::primitives::address!("0xd8dA6BF26964af9d7eed9e03e53415d37aa96045");
     /// // Stream all events from genesis to latest block
-    /// let mut scanner = EventScannerBuilder::historic()
-    ///     .connect_ws::<Ethereum>(ws_url)
-    ///     .await?;
+    /// let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+    /// let robust_provider = RobustProvider::new(provider.root().to_owned());
+    /// let mut scanner = EventScannerBuilder::historic().connect(robust_provider);
     ///
     /// let filter = EventFilter::new().contract_address(contract_address);
     /// let mut stream = scanner.subscribe(filter);
@@ -104,17 +103,17 @@ impl EventScannerBuilder<Unspecified> {
     /// Specifying a custom block range:
     ///
     /// ```no_run
-    /// # use alloy::network::Ethereum;
-    /// # use event_scanner::EventScannerBuilder;
+    /// # use alloy::{network::Ethereum, providers::{Provider, ProviderBuilder}};
+    /// # use event_scanner::{EventScannerBuilder, robust_provider::RobustProvider};
     /// #
     /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let ws_url = "ws://localhost:8545".parse()?;
     /// // Stream events between blocks [1_000_000, 2_000_000]
+    /// let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+    /// let robust_provider = RobustProvider::new(provider.root().to_owned());
     /// let mut scanner = EventScannerBuilder::historic()
     ///     .from_block(1_000_000)
     ///     .to_block(2_000_000)
-    ///     .connect_ws::<Ethereum>(ws_url)
-    ///     .await?;
+    ///     .connect(robust_provider);
     /// # Ok(())
     /// # }
     /// ```
@@ -143,18 +142,18 @@ impl EventScannerBuilder<Unspecified> {
     /// # Example
     ///
     /// ```no_run
-    /// # use alloy::network::Ethereum;
-    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message};
+    /// # use alloy::{network::Ethereum, providers::{Provider, ProviderBuilder}};
+    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
     /// # use tokio_stream::StreamExt;
     /// #
     /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let ws_url = "ws://localhost:8545".parse()?;
     /// # let contract_address = alloy::primitives::address!("0xd8dA6BF26964af9d7eed9e03e53415d37aa96045");
     /// // Stream new events as they arrive
+    /// let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+    /// let robust_provider = RobustProvider::new(provider.root().to_owned());
     /// let mut scanner = EventScannerBuilder::live()
     ///     .block_confirmations(20)
-    ///     .connect_ws::<Ethereum>(ws_url)
-    ///     .await?;
+    ///     .connect(robust_provider);
     ///
     /// let filter = EventFilter::new().contract_address(contract_address);
     /// let mut stream = scanner.subscribe(filter);
@@ -229,17 +228,16 @@ impl EventScannerBuilder<Unspecified> {
     /// # Example
     ///
     /// ```no_run
-    /// # use alloy::{network::Ethereum, primitives::Address};
-    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message};
+    /// # use alloy::{network::Ethereum, primitives::Address, providers::{Provider, ProviderBuilder}};
+    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
     /// # use tokio_stream::StreamExt;
     /// #
     /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let ws_url = "ws://localhost:8545".parse()?;
     /// # let contract_address = alloy::primitives::address!("0xd8dA6BF26964af9d7eed9e03e53415d37aa96045");
     /// // Collect the latest 10 events across Earliest..=Latest
-    /// let mut scanner = EventScannerBuilder::latest(10)
-    ///     .connect_ws::<Ethereum>(ws_url)
-    ///     .await?;
+    /// let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+    /// let robust_provider = RobustProvider::new(provider.root().to_owned());
+    /// let mut scanner = EventScannerBuilder::latest(10).connect(robust_provider);
     ///
     /// let filter = EventFilter::new().contract_address(contract_address);
     /// let mut stream = scanner.subscribe(filter);
@@ -257,17 +255,17 @@ impl EventScannerBuilder<Unspecified> {
     /// Restricting to a specific block range:
     ///
     /// ```no_run
-    /// # use alloy::network::Ethereum;
-    /// # use event_scanner::EventScannerBuilder;
+    /// # use alloy::{network::Ethereum, providers::{Provider, ProviderBuilder}};
+    /// # use event_scanner::{EventScannerBuilder, robust_provider::RobustProvider};
     /// #
     /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let ws_url = "ws://localhost:8545".parse()?;
     /// // Collect the latest 5 events between blocks [1_000_000, 1_100_000]
+    /// let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+    /// let robust_provider = RobustProvider::new(provider.root().to_owned());
     /// let mut scanner = EventScannerBuilder::latest(5)
     ///     .from_block(1_000_000)
     ///     .to_block(1_100_000)
-    ///     .connect_ws::<Ethereum>(ws_url)
-    ///     .await?;
+    ///     .connect(robust_provider);
     /// # Ok(())
     /// # }
     /// ```

src/event_scanner/scanner/sync/mod.rs

@@ -24,18 +24,18 @@ impl EventScannerBuilder<Synchronize> {
     /// # Example
     ///
     /// ```no_run
-    /// # use alloy::network::Ethereum;
-    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message};
+    /// # use alloy::{network::Ethereum, providers::{Provider, ProviderBuilder}};
+    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
     /// # use tokio_stream::StreamExt;
     /// #
     /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let ws_url = "ws://localhost:8545".parse()?;
     /// # let contract_address = alloy::primitives::address!("0xd8dA6BF26964af9d7eed9e03e53415d37aa96045");
     /// // Fetch the latest 10 events, then stream new events continuously
+    /// let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+    /// let robust_provider = RobustProvider::new(provider.root().to_owned());
     /// let mut scanner = EventScannerBuilder::sync()
     ///     .from_latest(10)
-    ///     .connect_ws::<Ethereum>(ws_url)
-    ///     .await?;
+    ///     .connect(robust_provider);
     ///
     /// let filter = EventFilter::new().contract_address(contract_address);
     /// let mut stream = scanner.subscribe(filter);
@@ -120,18 +120,18 @@ impl EventScannerBuilder<Synchronize> {
     /// # Example
     ///
     /// ```no_run
-    /// # use alloy::network::Ethereum;
-    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message};
+    /// # use alloy::{network::Ethereum, providers::{Provider, ProviderBuilder}};
+    /// # use event_scanner::{EventFilter, EventScannerBuilder, Message, robust_provider::RobustProvider};
     /// # use tokio_stream::StreamExt;
     /// #
     /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let ws_url = "ws://localhost:8545".parse()?;
     /// # let contract_address = alloy::primitives::address!("0xd8dA6BF26964af9d7eed9e03e53415d37aa96045");
     /// // Sync from block 1_000_000 to present, then stream new events
+    /// let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+    /// let robust_provider = RobustProvider::new(provider.root().to_owned());
     /// let mut scanner = EventScannerBuilder::sync()
     ///     .from_block(1_000_000)
-    ///     .connect_ws::<Ethereum>(ws_url)
-    ///     .await?;
+    ///     .connect(robust_provider);
     ///
     /// let filter = EventFilter::new().contract_address(contract_address);
     /// let mut stream = scanner.subscribe(filter);
@@ -159,16 +159,16 @@ impl EventScannerBuilder<Synchronize> {
     /// Using block tags:
     ///
     /// ```no_run
-    /// # use alloy::{network::Ethereum, eips::BlockNumberOrTag};
-    /// # use event_scanner::EventScannerBuilder;
+    /// # use alloy::{network::Ethereum, eips::BlockNumberOrTag, providers::{Provider, ProviderBuilder}};
+    /// # use event_scanner::{EventScannerBuilder, robust_provider::RobustProvider};
     /// #
     /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let ws_url = "ws://localhost:8545".parse()?;
     /// // Sync from genesis block
+    /// let provider = ProviderBuilder::new().connect("ws://localhost:8545").await?;
+    /// let robust_provider = RobustProvider::new(provider.root().to_owned());
     /// let mut scanner = EventScannerBuilder::sync()
     ///     .from_block(BlockNumberOrTag::Earliest)
-    ///     .connect_ws::<Ethereum>(ws_url)
-    ///     .await?;
+    ///     .connect(robust_provider);
     /// # Ok(())
     /// # }
     /// ```