use block read limit

Author: LeoPatOZ

README.md

@@ -70,7 +70,7 @@ async fn run_scanner(
 ) -> Result<(), Box<dyn std::error::Error>> {
     // Configure scanner with custom batch size (optional)
     let mut scanner = EventScanner::live()
-        .max_reads(500)  // Process up to 500 blocks per batch
+        .block_read_limit(500)  // Process up to 500 blocks per batch
         .connect_ws::<Ethereum>(ws_url).await?;
 
     let filter = EventFilter::new()
@@ -101,22 +101,22 @@ async fn run_scanner(
 ```rust
 // Live streaming mode
 let scanner = EventScanner::live()
-    .max_reads(500)  // Optional: set max blocks per read (default: 1000)
+    .block_read_limit(500)  // Optional: set max blocks per read (default: 1000)
     .connect_ws::<Ethereum>(ws_url).await?;
 
 // Historical scanning mode
 let scanner = EventScanner::historic()
-    .max_reads(500)
+    .block_read_limit(500)
     .connect_ws::<Ethereum>(ws_url).await?;
 
 // Sync mode (historical + live)
 let scanner = EventScanner::sync()
-    .max_reads(500)
+    .block_read_limit(500)
     .connect_ws::<Ethereum>(ws_url).await?;
 
 // Latest mode (recent blocks only)
 let scanner = EventScanner::latest()
-    .max_reads(500)
+    .block_read_limit(500)
     .connect_ws::<Ethereum>(ws_url).await?;
 ```
 
@@ -127,7 +127,7 @@ let scanner = EventScanner::latest()
 - `EventScanner::latest()` – Processes a specific number of events then optionally switches to live scanning mode
 
 **Global Configuration Options:**
-- `max_reads(usize)` – Sets the maximum number of blocks to process per read operation. This prevents RPC provider errors from overly large block range queries.
+- `block_read_limit(usize)` – Sets the maximum number of blocks to process per read operation. This prevents RPC provider errors from overly large block range queries.
 - Connect with `connect_ws::<Ethereum>(url)`, `connect_ipc::<Ethereum>(path)`, or `connect_provider(provider)`.
 
 **Mode-specific APIs:**
@@ -177,7 +177,7 @@ The flexibility provided by `EventFilter` allows you to build sophisticated even
 - **Latest mode** – `EventScanner::latest()` creates a scanner that processes a set number of events.
 
 **Configuration Tips:**
-- Set `max_reads` based on your RPC provider's limits (e.g., Alchemy, Infura may limit queries to 2000 blocks)
+- Set `block_read_limit` based on your RPC provider's limits (e.g., Alchemy, Infura may limit queries to 2000 blocks)
 - For live mode, if the WebSocket subscription lags significantly (e.g., >2000 blocks), ranges are automatically capped to prevent RPC errors
 - Each mode has its own configuration options for start block, end block, confirmations, etc. where it makes sense
 - The modes come with sensible defaults for example not specify a start block for historic mode automatically sets the start block to the earliest one

src/event_lib/modes/historic.rs

@@ -133,7 +133,8 @@ mod tests {
 
     #[test]
     fn test_historic_scanner_builder_pattern() {
-        let config = HistoricScannerConfig::new().from_block(100u64).to_block(200u64).max_reads(50);
+        let config =
+            HistoricScannerConfig::new().from_block(100u64).to_block(200u64).block_read_limit(50);
 
         assert!(matches!(config.from_block, BlockNumberOrTag::Number(100)));
         assert!(matches!(config.to_block, BlockNumberOrTag::Number(200)));
@@ -143,7 +144,7 @@ mod tests {
     #[test]
     fn test_historic_scanner_builder_pattern_chaining() {
         let config = HistoricScannerConfig::new()
-            .max_reads(25)
+            .block_read_limit(25)
             .from_block(BlockNumberOrTag::Number(50))
             .to_block(BlockNumberOrTag::Number(150));
 

src/event_lib/modes/latest.rs

@@ -216,7 +216,7 @@ mod tests {
             .to_block(200)
             .block_confirmations(10)
             .then_live()
-            .max_reads(50);
+            .block_read_limit(50);
 
         assert_eq!(config.count, 5);
         assert!(matches!(config.from_block, BlockNumberOrTag::Number(100)));
@@ -229,7 +229,7 @@ mod tests {
     #[test]
     fn test_latest_scanner_builder_pattern_chaining() {
         let config = LatestScannerConfig::new()
-            .max_reads(25)
+            .block_read_limit(25)
             .block_confirmations(5)
             .count(3)
             .from_block(BlockNumberOrTag::Number(50))

src/event_lib/modes/live.rs

@@ -119,23 +119,23 @@ mod tests {
 
     #[test]
     fn test_live_scanner_builder_pattern() {
-        let config = LiveScannerConfig::new().block_confirmations(10).max_reads(50);
+        let config = LiveScannerConfig::new().block_confirmations(10).block_read_limit(50);
 
         assert_eq!(config.block_confirmations, 10);
         assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 50);
     }
 
     #[test]
     fn test_live_scanner_builder_pattern_chaining() {
-        let config = LiveScannerConfig::new().max_reads(25).block_confirmations(5);
+        let config = LiveScannerConfig::new().block_read_limit(25).block_confirmations(5);
 
         assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 25);
         assert_eq!(config.block_confirmations, 5);
     }
 
     #[test]
     fn test_live_scanner_builder_with_zero_confirmations() {
-        let config = LiveScannerConfig::new().block_confirmations(0).max_reads(100);
+        let config = LiveScannerConfig::new().block_confirmations(0).block_read_limit(100);
 
         assert_eq!(config.block_confirmations, 0);
         assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 100);

src/event_lib/modes/mod.rs

@@ -49,7 +49,7 @@ pub trait BaseConfigBuilder: Sized {
     fn base_mut(&mut self) -> &mut BaseConfig;
 
     #[must_use]
-    fn max_reads(mut self, max: usize) -> Self {
+    fn block_read_limit(mut self, max: usize) -> Self {
         self.base_mut().block_range_scanner.max_read_per_epoch = max;
         self
     }

src/event_lib/modes/sync.rs

@@ -133,7 +133,7 @@ mod tests {
 
     #[test]
     fn test_sync_scanner_builder_pattern() {
-        let config = SyncScannerConfig::new().from_block(100).block_confirmations(10).max_reads(50);
+        let config = SyncScannerConfig::new().from_block(100).block_confirmations(10).block_read_limit(50);
 
         assert!(matches!(config.from_block, BlockNumberOrTag::Number(100)));
         assert_eq!(config.block_confirmations, 10);
@@ -143,7 +143,7 @@ mod tests {
     #[test]
     fn test_sync_scanner_builder_pattern_chaining() {
         let config = SyncScannerConfig::new()
-            .max_reads(25)
+            .block_read_limit(25)
             .block_confirmations(5)
             .from_block(BlockNumberOrTag::Number(50));
 
@@ -157,7 +157,7 @@ mod tests {
         let config = SyncScannerConfig::new()
             .from_block(BlockNumberOrTag::Earliest)
             .block_confirmations(20)
-            .max_reads(100);
+            .block_read_limit(100);
 
         assert!(matches!(config.from_block, BlockNumberOrTag::Earliest));
         assert_eq!(config.block_confirmations, 20);
@@ -166,7 +166,7 @@ mod tests {
 
     #[test]
     fn test_sync_scanner_builder_with_zero_confirmations() {
-        let config = SyncScannerConfig::new().from_block(0).block_confirmations(0).max_reads(75);
+        let config = SyncScannerConfig::new().from_block(0).block_confirmations(0).block_read_limit(75);
 
         assert!(matches!(config.from_block, BlockNumberOrTag::Number(0)));
         assert_eq!(config.block_confirmations, 0);