ref: clippy

Author: 0xNeshi

src/block_range_scanner.rs

@@ -88,7 +88,7 @@ use alloy::{
 use thiserror::Error;
 use tracing::{debug, error, info, warn};
 
-pub const DEFAULT_BLOCKS_READ_PER_EPOCH: u32 = 1000;
+pub const DEFAULT_BLOCKS_READ_PER_EPOCH: usize = 1000;
 // copied form https://github.com/taikoxyz/taiko-mono/blob/f4b3a0e830e42e2fee54829326389709dd422098/packages/taiko-client/pkg/chain_iterator/block_batch_iterator.go#L19
 pub const DEFAULT_BLOCK_CONFIRMATIONS: u64 = 0;
 // const BACK_OFF_MAX_RETRIES: u64 = 5;
@@ -201,7 +201,7 @@ impl BlockHashAndNumber {
 
 #[derive(Clone)]
 struct Config {
-    blocks_read_per_epoch: u32,
+    blocks_read_per_epoch: usize,
     reorg_rewind_depth: u64,
     #[allow(
         dead_code,
@@ -211,7 +211,7 @@ struct Config {
 }
 
 pub struct BlockRangeScanner {
-    blocks_read_per_epoch: u32,
+    blocks_read_per_epoch: usize,
     reorg_rewind_depth: u64,
     block_confirmations: u64,
 }
@@ -233,7 +233,7 @@ impl BlockRangeScanner {
     }
 
     #[must_use]
-    pub fn with_blocks_read_per_epoch(mut self, blocks_read_per_epoch: u32) -> Self {
+    pub fn with_blocks_read_per_epoch(mut self, blocks_read_per_epoch: usize) -> Self {
         self.blocks_read_per_epoch = blocks_read_per_epoch;
         self
     }
@@ -620,8 +620,7 @@ impl<N: Network> Service<N> {
 
         // we're iterating in reverse
         let stream_end = *block_range.start();
-        // SAFETY: u32 can always be cast as usize
-        let range_iter = block_range.rev().step_by(blocks_read_per_epoch as usize);
+        let range_iter = block_range.rev().step_by(blocks_read_per_epoch);
 
         for batch_end in range_iter {
             let batch_start =

src/event_scanner.rs

@@ -86,7 +86,7 @@ impl EventScanner {
 
     /// Configures how many blocks are read per epoch during a historical sync.
     #[must_use]
-    pub fn with_blocks_read_per_epoch(mut self, blocks_read_per_epoch: u32) -> Self {
+    pub fn with_blocks_read_per_epoch(mut self, blocks_read_per_epoch: usize) -> Self {
         self.block_range_scanner =
             self.block_range_scanner.with_blocks_read_per_epoch(blocks_read_per_epoch);
         self
@@ -190,6 +190,11 @@ impl<N: Network> ConnectedEventScanner<N> {
         Ok(())
     }
 
+    /// Scans the latest blocks and returns the specified number of events.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the scanner fails to start
     pub async fn scan_latest(
         self,
         count: usize,
@@ -226,8 +231,8 @@ impl<N: Network> ConnectedEventScanner<N> {
                     match sub.recv().await {
                         Ok(BlockRangeMessage::Data(range)) => {
                             let logs = Self::get_logs(range, &filter, &log_filter, &provider).await;
-                            if let Ok(logs) = &logs
-                                && logs.is_empty()
+                            if let Ok(logs) = &logs &&
+                                logs.is_empty()
                             {
                                 continue;
                             }
@@ -268,7 +273,7 @@ impl<N: Network> ConnectedEventScanner<N> {
             let mut sub = range_tx.subscribe();
 
             tokio::spawn(async move {
-                let mut events = Vec::with_capacity(count as usize);
+                let mut events = Vec::with_capacity(count);
                 loop {
                     match sub.recv().await {
                         Ok(BlockRangeMessage::Data(range)) => {

tests/historic_to_live/basic.rs

@@ -1,9 +1,10 @@
 use alloy::{eips::BlockNumberOrTag, network::Ethereum, primitives::U256, sol_types::SolEvent};
-use event_scanner::types::ScannerStatus;
-use event_scanner::{event_filter::EventFilter, event_scanner::EventScanner};
+use event_scanner::{event_filter::EventFilter, event_scanner::EventScanner, types::ScannerStatus};
 
-use crate::common::{TestCounter, build_provider, deploy_counter, spawn_anvil};
-use crate::{assert_next_logs, assert_next_status};
+use crate::{
+    assert_next_logs, assert_next_status,
+    common::{TestCounter, build_provider, deploy_counter, spawn_anvil},
+};
 
 #[tokio::test]
 async fn replays_historical_then_switches_to_live() -> anyhow::Result<()> {

tests/latest_events/basic.rs

@@ -21,25 +21,23 @@ async fn collect_events(
     loop {
         match stream.next().await {
             Some(EventScannerMessage::Data(logs)) => return logs,
-            Some(EventScannerMessage::Error(_)) => continue,
-            Some(EventScannerMessage::Status(_)) => continue,
             None => return vec![],
+            _ => {}
         }
     }
 }
 
 fn assert_ordering(
-    logs: Vec<Log>,
+    logs: &[Log],
     expected_first_count: u64,
-    expected_hashes: Vec<FixedBytes<32>>,
+    expected_hashes: &[FixedBytes<32>],
     expected_address: &Address,
 ) {
     let mut expected_count = U256::from(expected_first_count);
     for (log, &expected_hash) in logs.iter().zip(expected_hashes.iter()) {
-        let event = log.log_decode::<TestCounter::CountIncreased>().expect(
-            format!("expected sig: 'TestCounter::CountIncreased', got: {:?}", log.topic0())
-                .as_str(),
-        );
+        let event = log.log_decode::<TestCounter::CountIncreased>().unwrap_or_else(|_| {
+            panic!("expected sig: 'TestCounter::CountIncreased', got: {:?}", log.topic0())
+        });
         assert_eq!(&event.address(), expected_address);
         assert_eq!(event.transaction_hash.unwrap(), expected_hash);
         assert_eq!(expected_count, event.inner.newCount);
@@ -70,9 +68,9 @@ async fn scan_latest_exact_count_returns_last_events_in_order() -> anyhow::Resul
 
     // Verify exact events (address, signature, tx hashes)
     let expected_first_count = 4;
-    let expected_hashes = tx_hashes[3..8].to_vec();
+    let expected_hashes = &tx_hashes[3..8];
 
-    assert_ordering(logs, expected_first_count, expected_hashes, contract.address());
+    assert_ordering(&logs, expected_first_count, expected_hashes, contract.address());
 
     Ok(())
 }
@@ -100,7 +98,7 @@ async fn scan_latest_fewer_available_than_count_returns_all() -> anyhow::Result<
     // Verify exact events
     let expected_first_count = 1;
 
-    assert_ordering(logs, expected_first_count, tx_hashes, contract.address());
+    assert_ordering(&logs, expected_first_count, &tx_hashes, contract.address());
 
     Ok(())
 }
@@ -155,10 +153,10 @@ async fn scan_latest_respects_range_subset() -> anyhow::Result<()> {
     // Expect last 4 emitted events exactly (the 2 empty blocks contain no events)
     assert_eq!(logs.len(), 2);
 
-    let expected_hashes = tx_hashes[4..6].to_vec(); // counts 5..6
+    let expected_hashes = &tx_hashes[4..6]; // counts 5..6
     let expected_first_count = 5;
 
-    assert_ordering(logs, expected_first_count, expected_hashes, contract.address());
+    assert_ordering(&logs, expected_first_count, expected_hashes, contract.address());
 
     Ok(())
 }
@@ -193,9 +191,9 @@ async fn scan_latest_multiple_listeners_to_same_event_receive_same_results() ->
     // since logs are equal, asserting for one, asserts for both
     assert_eq!(5, logs1.len());
 
-    let expected_hashes = tx_hashes[2..7].to_vec();
+    let expected_hashes = &tx_hashes[2..7];
     let expected_first_count = 3;
-    assert_ordering(logs1, expected_first_count, expected_hashes, contract.address());
+    assert_ordering(&logs1, expected_first_count, expected_hashes, contract.address());
 
     Ok(())
 }
@@ -243,7 +241,7 @@ async fn scan_latest_different_filters_receive_different_results() -> anyhow::Re
 
     // Validate increases: expect counts 3,4,5 and the corresponding tx hashes from inc_hashes[2..5]
     let expected_hashes_inc = inc_hashes[2..5].to_vec();
-    assert_ordering(logs_inc, 3, expected_hashes_inc, contract.address());
+    assert_ordering(&logs_inc, 3, &expected_hashes_inc, contract.address());
 
     // Validate decreases: expect counts 4,3 (after two decreases)
     let mut expected_count_dec = U256::from(4);
@@ -397,7 +395,7 @@ async fn scan_latest_large_gaps_and_empty_ranges() -> anyhow::Result<()> {
 
     assert_eq!(logs.len(), 3);
     // Expect counts 1,2,3 and hashes in order
-    assert_ordering(logs, 1, hashes, contract.address());
+    assert_ordering(&logs, 1, &hashes, contract.address());
 
     Ok(())
 }