refactor

Author: LeoPatOZ

src/builder.rs

@@ -6,6 +6,7 @@ use crate::{
 pub struct ScannerBuilder {
     rpc_url: String,
     start_block: Option<u64>,
+    end_block: Option<u64>,
     max_blocks_per_filter: u64,
     tracked_events: Vec<EventFilter>,
     callback_config: CallbackConfig,
@@ -16,6 +17,7 @@ impl ScannerBuilder {
         Self {
             rpc_url: rpc_url.into(),
             start_block: None,
+            end_block: None,
             max_blocks_per_filter: 1000,
             tracked_events: Vec::new(),
             callback_config: CallbackConfig::default(),
@@ -27,6 +29,11 @@ impl ScannerBuilder {
         self
     }
 
+    pub fn end_block(mut self, end_block: u64) -> Self {
+        self.end_block = Some(end_block);
+        self
+    }
+
     pub fn max_blocks_per_filter(mut self, max_blocks: u64) -> Self {
         self.max_blocks_per_filter = max_blocks;
         self
@@ -51,6 +58,7 @@ impl ScannerBuilder {
         Scanner::new(
             self.rpc_url,
             self.start_block,
+            self.end_block,
             self.max_blocks_per_filter,
             self.tracked_events,
             self.callback_config,

src/scanner.rs

@@ -22,6 +22,7 @@ pub struct Scanner {
     provider: Arc<dyn Provider>,
     current_head: Option<u64>,
     start_block: Option<u64>,
+    end_block: Option<u64>,
     max_blocks_per_filter: u64,
     tracked_events: Vec<EventFilter>,
     callback_config: CallbackConfig,
@@ -31,34 +32,41 @@ impl Scanner {
     pub async fn new(
         rpc_url: String,
         start_block: Option<u64>,
+        end_block: Option<u64>,
         max_blocks_per_filter: u64,
         tracked_events: Vec<EventFilter>,
         callback_config: CallbackConfig,
     ) -> anyhow::Result<Self> {
-        let provider = match Self::detect_provider_type(&rpc_url) {
-            Ok(ProviderType::WebSocket) => {
-                info!("connecting to provider via WebSocket: {}", &rpc_url);
-                let ws = WsConnect::new(&rpc_url);
-                ProviderBuilder::new().connect_ws(ws).await?
-            }
-            Ok(ProviderType::Ipc) => {
-                info!("connecting to provider via IPC: {}", &rpc_url);
-                let ipc = IpcConnect::new(rpc_url.clone());
-                ProviderBuilder::new().connect_ipc(ipc).await?
-            }
-            Err(e) => return Err(e),
-        };
+        let provider = Self::get_provider(&rpc_url).await?;
 
         Ok(Self {
-            provider: Arc::new(provider),
+            provider,
             current_head: start_block,
             start_block,
+            end_block,
             max_blocks_per_filter,
             tracked_events,
             callback_config,
         })
     }
 
+    async fn get_provider(url: &str) -> anyhow::Result<Arc<dyn Provider>> {
+        let provider = match Self::detect_provider_type(url) {
+            Ok(ProviderType::WebSocket) => {
+                info!("connecting to provider via WebSocket: {}", url);
+                let ws = WsConnect::new(url);
+                ProviderBuilder::new().connect_ws(ws).await?
+            }
+            Ok(ProviderType::Ipc) => {
+                info!("connecting to provider via IPC: {}", url);
+                let ipc = IpcConnect::new(url.to_string());
+                ProviderBuilder::new().connect_ipc(ipc).await?
+            }
+            Err(e) => return Err(e),
+        };
+        Ok(Arc::new(provider))
+    }
+
     fn detect_provider_type(url: &str) -> anyhow::Result<ProviderType> {
         if url.starts_with("ws://") || url.starts_with("wss://") {
             Ok(ProviderType::WebSocket)