Abstract block looping to seperate crate

src/block_range_scanner/batch_iterator.rs

@@ -1,4 +1,3 @@
-#![allow(dead_code)]
 use alloy::primitives::BlockNumber;
 use std::{marker::PhantomData, ops::RangeInclusive};
 use tracing::debug;
@@ -9,10 +8,11 @@ pub struct Reverse;
 /// An iterator that yields block ranges in batches of a configurable size.
 #[derive(Debug, Clone)]
 pub struct BatchIterator<D> {
-    current: Option<BlockNumber>,
+    current: BlockNumber,
     end: BlockNumber,
     batch_size: u64,
     batch_count: u64,
+    total_batches: u64,
     _direction: PhantomData<D>,
 }
 
@@ -25,13 +25,15 @@ impl BatchIterator<Forward> {
     ///
     /// Panics if `max_block_range` is 0.
     #[must_use]
-    pub fn forward(start: BlockNumber, end: BlockNumber, max_block_range: u64) -> Self {
+    pub const fn forward(start: BlockNumber, end: BlockNumber, max_block_range: u64) -> Self {
         assert!(max_block_range >= 1, "max_block_range must be at least 1");
+        let total_batches = if start > end { 0 } else { (end - start) / max_block_range + 1 };
         Self {
-            current: if start > end { None } else { Some(start) },
+            current: start,
             end,
             batch_size: max_block_range,
             batch_count: 0,
+            total_batches,
             _direction: PhantomData,
         }
     }
@@ -40,7 +42,12 @@ impl BatchIterator<Forward> {
     ///
     /// Useful after detecting a reorg to rescan from a common ancestor.
     pub fn reset_to(&mut self, block: BlockNumber) {
-        self.current = if block > self.end { None } else { Some(block) };
+        self.current = block;
+        self.total_batches = if block > self.end {
+            self.batch_count + (block - self.end) / self.batch_size + 1
+        } else {
+            self.batch_count
+        };
     }
 }
 
@@ -54,23 +61,18 @@ impl BatchIterator<Reverse> {
     ///
     /// Panics if `max_block_range` is 0.
     #[must_use]
-    pub fn reverse(start: BlockNumber, end: BlockNumber, max_block_range: u64) -> Self {
+    pub const fn reverse(start: BlockNumber, end: BlockNumber, max_block_range: u64) -> Self {
         assert!(max_block_range >= 1, "max_block_range must be at least 1");
+        let total_batches = if start < end { 0 } else { (start - end) / max_block_range + 1 };
         Self {
-            current: if start < end { None } else { Some(start) },
+            current: start,
             end,
             batch_size: max_block_range,
             batch_count: 0,
+            total_batches,
             _direction: PhantomData,
         }
     }
-
-    /// Resets the iterator to continue from a new position.
-    ///
-    /// Useful after detecting a reorg to rescan from a common ancestor.
-    pub fn reset_to(&mut self, block: BlockNumber) {
-        self.current = if block < self.end { None } else { Some(block) };
-    }
 }
 
 impl<D> BatchIterator<D> {
@@ -79,34 +81,24 @@ impl<D> BatchIterator<D> {
     pub fn batch_count(&self) -> u64 {
         self.batch_count
     }
-
-    /// Returns the current position, or `None` if exhausted.
-    #[must_use]
-    pub fn current(&self) -> Option<BlockNumber> {
-        self.current
-    }
-
-    /// Returns the end boundary.
-    #[must_use]
-    pub fn end(&self) -> BlockNumber {
-        self.end
-    }
 }
 
 impl Iterator for BatchIterator<Forward> {
     type Item = RangeInclusive<BlockNumber>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let batch_start = self.current?;
+        if self.current > self.end {
+            return None;
+        }
 
         self.batch_count += 1;
         if self.batch_count % 10 == 0 {
             debug!(batch_count = self.batch_count, "Processed batches");
         }
 
+        let batch_start = self.current;
         let batch_end = batch_start.saturating_add(self.batch_size - 1).min(self.end);
-
-        self.current = if batch_end >= self.end { None } else { Some(batch_end + 1) };
+        self.current = batch_end + 1;
 
         Some(batch_start..=batch_end)
     }
@@ -116,21 +108,31 @@ impl Iterator for BatchIterator<Reverse> {
     type Item = RangeInclusive<BlockNumber>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let batch_high = self.current?;
+        if self.batch_count >= self.total_batches {
+            return None;
+        }
 
         self.batch_count += 1;
         if self.batch_count % 10 == 0 {
             debug!(batch_count = self.batch_count, "Processed batches");
         }
 
+        let batch_high = self.current;
         let batch_low = batch_high.saturating_sub(self.batch_size - 1).max(self.end);
-
-        self.current = if batch_low <= self.end { None } else { Some(batch_low - 1) };
+        self.current = batch_low.saturating_sub(1);
 
         Some(batch_low..=batch_high)
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining =
+            usize::try_from(self.total_batches - self.batch_count).unwrap_or(usize::MAX);
+        (remaining, Some(remaining))
+    }
 }
 
+impl ExactSizeIterator for BatchIterator<Reverse> {}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -245,22 +247,6 @@ mod tests {
         assert_eq!(iter.next(), None);
     }
 
-    #[test]
-    fn reset_to_rewinds_reverse_iteration() {
-        let mut iter = BatchIterator::reverse(300, 100, 50);
-        assert_eq!(iter.next(), Some(251..=300));
-        assert_eq!(iter.next(), Some(201..=250));
-
-        // Reset to re-scan from a higher block (simulating reorg detection)
-        iter.reset_to(280);
-
-        assert_eq!(iter.next(), Some(231..=280));
-        assert_eq!(iter.next(), Some(181..=230));
-        assert_eq!(iter.next(), Some(131..=180));
-        assert_eq!(iter.next(), Some(100..=130));
-        assert_eq!(iter.next(), None);
-    }
-
     #[test]
     fn reset_to_after_exhausted() {
         let mut iter = BatchIterator::forward(100, 120, 50);
@@ -283,34 +269,6 @@ mod tests {
         assert_eq!(iter.next(), None);
     }
 
-    #[test]
-    fn reset_to_beyond_end_exhausts_reverse() {
-        let mut iter = BatchIterator::reverse(200, 100, 50);
-        assert_eq!(iter.next(), Some(151..=200));
-
-        iter.reset_to(50);
-
-        assert_eq!(iter.next(), None);
-    }
-
-    #[test]
-    fn current_returns_position() {
-        let mut iter = BatchIterator::forward(100, 300, 50);
-        assert_eq!(iter.current(), Some(100));
-
-        iter.next();
-        assert_eq!(iter.current(), Some(150));
-
-        iter.next();
-        assert_eq!(iter.current(), Some(200));
-    }
-
-    #[test]
-    fn end_returns_boundary() {
-        let iter = BatchIterator::forward(100, 300, 50);
-        assert_eq!(iter.end(), 300);
-    }
-
     #[test]
     fn forward_starting_from_zero() {
         let mut iter = BatchIterator::forward(0, 100, 50);