Merge branch 'main' into integration-tests

Author: LeoPatOZ

.github/workflows/check.yml

@@ -69,11 +69,7 @@ jobs:
           components: clippy
 
       - name: Clippy Check
-        uses: giraffate/clippy-action@v1
-        with:
-          reporter: "github-pr-check"
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          clippy_flags: --all-targets --all-features -- -D warnings -D clippy::pedantic
+        run: cargo clippy --all-targets --all-features -- -D warnings -D clippy::pedantic
 
   typos-cli:
     name: typos

.github/workflows/test.yml

@@ -25,6 +25,9 @@ jobs:
       - name: Install stable toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
 
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
       - name: Cache cargo-nextest binary
         id: cache-cargo-nextest
         uses: actions/cache@v4
@@ -39,7 +42,7 @@ jobs:
           tool: cargo-nextest
 
       - name: Cargo test
-        run: cargo nextest run --locked --all-targets --all-features --no-tests=pass
+        run: cargo nextest run --locked --all-targets --all-features --no-tests=pass --no-fail-fast
 
         # https://github.com/rust-lang/cargo/issues/6669
       - name: Run doc tests

src/block_scanner.rs

@@ -1,4 +1,6 @@
-use std::{marker::PhantomData, time::Duration};
+#![allow(unused)]
+
+use std::{future, marker::PhantomData, time::Duration};
 
 use tokio::sync::mpsc::{self, Receiver, Sender};
 use tokio_stream::wrappers::ReceiverStream;
@@ -16,7 +18,7 @@ use alloy::{
 };
 
 // copied form https://github.com/taikoxyz/taiko-mono/blob/f4b3a0e830e42e2fee54829326389709dd422098/packages/taiko-client/pkg/chain_iterator/block_batch_iterator.go#L19
-const DEFAULT_BLOCKS_READ_PER_EPOCH: u64 = 1000;
+const DEFAULT_BLOCKS_READ_PER_EPOCH: usize = 1000;
 const DEFAULT_RETRY_INTERVAL: Duration = Duration::from_secs(12);
 const DEFAULT_BLOCK_CONFIRMATIONS: u64 = 0;
 const BACK_OFF_MAX_RETRIES: u64 = 5;
@@ -41,7 +43,7 @@ impl std::fmt::Display for BlockScannerError {
             BlockScannerError::ErrEOF => write!(f, "end of block batch iterator"),
             BlockScannerError::ErrContinue => write!(f, "continue"),
             BlockScannerError::TerminalError(height) => {
-                write!(f, "terminal error at block height {}", height)
+                write!(f, "terminal error at block height {height}")
             }
         }
     }
@@ -53,7 +55,7 @@ pub type OnBlocksFunc<N> =
     fn(<N as Network>::BlockResponse, UpdateCurrentFunc, EndIterFunc) -> anyhow::Result<()>;
 
 pub struct BlockScannerBuilder<N: Network> {
-    blocks_read_per_epoch: u64,
+    blocks_read_per_epoch: usize,
     start_height: BlockNumberOrTag,
     end_height: BlockNumberOrTag,
     on_blocks: OnBlocksFunc<N>,
@@ -69,6 +71,7 @@ impl<N: Network> Default for BlockScannerBuilder<N> {
 }
 
 impl<N: Network> BlockScannerBuilder<N> {
+    #[must_use]
     pub fn new() -> Self {
         Self {
             blocks_read_per_epoch: DEFAULT_BLOCKS_READ_PER_EPOCH,
@@ -81,41 +84,53 @@ impl<N: Network> BlockScannerBuilder<N> {
         }
     }
 
-    pub fn with_blocks_read_per_epoch(&mut self, blocks_read_per_epoch: u64) -> &mut Self {
+    #[must_use]
+    pub fn with_blocks_read_per_epoch(&mut self, blocks_read_per_epoch: usize) -> &mut Self {
         self.blocks_read_per_epoch = blocks_read_per_epoch;
         self
     }
 
+    #[must_use]
     pub fn with_start_height(&mut self, start_height: BlockNumberOrTag) -> &mut Self {
         self.start_height = start_height;
         self
     }
 
+    #[must_use]
     pub fn with_end_height(&mut self, end_height: BlockNumberOrTag) -> &mut Self {
         self.end_height = end_height;
         self
     }
 
+    #[must_use]
     pub fn with_on_blocks(&mut self, on_blocks: OnBlocksFunc<N>) -> &mut Self {
         self.on_blocks = on_blocks;
         self
     }
 
+    #[must_use]
     pub fn with_reorg_rewind_depth(&mut self, reorg_rewind_depth: u64) -> &mut Self {
         self.reorg_rewind_depth = reorg_rewind_depth;
         self
     }
 
+    #[must_use]
     pub fn with_retry_interval(&mut self, retry_interval: Duration) -> &mut Self {
         self.retry_interval = retry_interval;
         self
     }
 
+    #[must_use]
     pub fn with_block_confirmations(&mut self, block_confirmations: u64) -> &mut Self {
         self.block_confirmations = block_confirmations;
         self
     }
 
+    /// Connects to the provider via WebSocket
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the connection fails
     pub async fn connect_ws(
         self,
         connect: WsConnect,
@@ -124,6 +139,11 @@ impl<N: Network> BlockScannerBuilder<N> {
         Ok(self.connect_client(client))
     }
 
+    /// Connects to the provider via IPC
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the connection fails
     pub async fn connect_ipc<T>(
         self,
         connect: IpcConnect<T>,
@@ -135,6 +155,7 @@ impl<N: Network> BlockScannerBuilder<N> {
         Ok(self.connect_client(client))
     }
 
+    #[must_use]
     pub fn connect_client(self, client: RpcClient) -> BlockScanner<RootProvider<N>, N> {
         let provider = RootProvider::new(client);
         self.connect_provider(provider)
@@ -144,7 +165,7 @@ impl<N: Network> BlockScannerBuilder<N> {
     where
         P: Provider<N>,
     {
-        let (sender, receiver) = mpsc::channel(self.blocks_read_per_epoch.try_into().unwrap());
+        let (sender, receiver) = mpsc::channel(self.blocks_read_per_epoch);
 
         BlockScanner {
             provider,
@@ -170,7 +191,7 @@ pub struct BlockScanner<P: Provider<N>, N: Network> {
     provider: P,
     sender: Sender<Result<N::BlockResponse, BlockScannerError>>,
     receiver: Receiver<Result<N::BlockResponse, BlockScannerError>>,
-    blocks_read_per_epoch: u64,
+    blocks_read_per_epoch: usize,
     start_height: BlockNumberOrTag,
     end_height: BlockNumberOrTag,
     current: Header,
@@ -190,6 +211,8 @@ where
     pub async fn start(self) -> ReceiverStream<Result<N::BlockResponse, BlockScannerError>> {
         let receiver_stream = ReceiverStream::new(self.receiver);
 
+        future::ready(()).await;
+
         tokio::spawn(async move {
             if self.sender.send(Err(BlockScannerError::ErrEOF {})).await.is_err() {}
         });
@@ -205,6 +228,7 @@ mod tests {
     use alloy_node_bindings::Anvil;
     use tokio_stream::StreamExt;
 
+    #[allow(clippy::unnecessary_wraps)]
     fn no_op_on_blocks<N: Network>(
         _block: <N as Network>::BlockResponse,
         _update_current: UpdateCurrentFunc,
@@ -266,7 +290,7 @@ mod tests {
         let first = stream.next().await;
         match first {
             Some(Err(BlockScannerError::ErrEOF)) => {}
-            other => panic!("expected first stream item to be ErrEOF, got: {:?}", other),
+            other => panic!("expected first stream item to be ErrEOF, got: {other:?}"),
         }
     }
 

src/builder.rs

@@ -24,36 +24,47 @@ impl ScannerBuilder {
         }
     }
 
+    #[must_use]
     pub fn start_block(mut self, start_block: u64) -> Self {
         self.start_block = Some(start_block);
         self
     }
 
+    #[must_use]
     pub fn end_block(mut self, end_block: u64) -> Self {
         self.end_block = Some(end_block);
         self
     }
 
+    #[must_use]
     pub fn max_blocks_per_filter(mut self, max_blocks: u64) -> Self {
         self.max_blocks_per_filter = max_blocks;
         self
     }
 
+    #[must_use]
     pub fn add_event_filter(mut self, filter: EventFilter) -> Self {
         self.tracked_events.push(filter);
         self
     }
 
+    #[must_use]
     pub fn add_event_filters(mut self, filters: Vec<EventFilter>) -> Self {
         self.tracked_events.extend(filters);
         self
     }
 
+    #[must_use]
     pub fn callback_config(mut self, cfg: CallbackConfig) -> Self {
         self.callback_config = cfg;
         self
     }
 
+    /// Builds the scanner
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the scanner fails to build
     pub async fn build(self) -> anyhow::Result<Scanner> {
         Scanner::new(
             self.rpc_url,

src/event_scanner.rs

@@ -1,4 +1,6 @@
-use std::time::Duration;
+#![allow(unused)]
+
+use std::{future, time::Duration};
 
 use crate::{
     block_scanner::{BlockScanner, BlockScannerBuilder, OnBlocksFunc},
@@ -26,6 +28,7 @@ impl<N: Network> Default for EventScannerBuilder<N> {
 }
 
 impl<N: Network> EventScannerBuilder<N> {
+    #[must_use]
     pub fn new() -> Self {
         Self {
             block_scanner: BlockScannerBuilder::new(),
@@ -34,56 +37,71 @@ impl<N: Network> EventScannerBuilder<N> {
         }
     }
 
+    #[must_use]
     pub fn with_event_filter(mut self, filter: EventFilter) -> Self {
         self.tracked_events.push(filter);
         self
     }
 
+    #[must_use]
     pub fn with_event_filters(mut self, filters: Vec<EventFilter>) -> Self {
         self.tracked_events.extend(filters);
         self
     }
 
+    #[must_use]
     pub fn with_callback_config(mut self, cfg: CallbackConfig) -> Self {
         self.callback_config = cfg;
         self
     }
 
-    pub fn with_blocks_read_per_epoch(&mut self, blocks_read_per_epoch: u64) -> &mut Self {
+    #[must_use]
+    pub fn with_blocks_read_per_epoch(&mut self, blocks_read_per_epoch: usize) -> &mut Self {
         self.block_scanner.with_blocks_read_per_epoch(blocks_read_per_epoch);
         self
     }
 
+    #[must_use]
     pub fn with_start_height(&mut self, start_height: BlockNumberOrTag) -> &mut Self {
         self.block_scanner.with_start_height(start_height);
         self
     }
 
+    #[must_use]
     pub fn with_end_height(&mut self, end_height: BlockNumberOrTag) -> &mut Self {
         self.block_scanner.with_end_height(end_height);
         self
     }
 
+    #[must_use]
     pub fn with_on_blocks(&mut self, on_blocks: OnBlocksFunc<N>) -> &mut Self {
         self.block_scanner.with_on_blocks(on_blocks);
         self
     }
 
+    #[must_use]
     pub fn with_reorg_rewind_depth(&mut self, reorg_rewind_depth: u64) -> &mut Self {
         self.block_scanner.with_reorg_rewind_depth(reorg_rewind_depth);
         self
     }
 
+    #[must_use]
     pub fn with_retry_interval(&mut self, retry_interval: Duration) -> &mut Self {
         self.block_scanner.with_retry_interval(retry_interval);
         self
     }
 
+    #[must_use]
     pub fn with_block_confirmations(&mut self, block_confirmations: u64) -> &mut Self {
         self.block_scanner.with_block_confirmations(block_confirmations);
         self
     }
 
+    /// Connects to the provider via WebSocket
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the connection fails
     pub async fn connect_ws(
         self,
         connect: WsConnect,
@@ -96,6 +114,11 @@ impl<N: Network> EventScannerBuilder<N> {
         })
     }
 
+    /// Connects to the provider via IPC
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the connection fails
     pub async fn connect_ipc<T>(
         self,
         connect: IpcConnect<T>,
@@ -111,6 +134,7 @@ impl<N: Network> EventScannerBuilder<N> {
         })
     }
 
+    #[must_use]
     pub fn connect_client(self, client: RpcClient) -> EventScanner<RootProvider<N>, N> {
         let block_scanner = self.block_scanner.connect_client(client);
         EventScanner {
@@ -120,6 +144,7 @@ impl<N: Network> EventScannerBuilder<N> {
         }
     }
 
+    #[must_use]
     pub fn connect_provider(self, provider: RootProvider<N>) -> EventScanner<RootProvider<N>, N> {
         let block_scanner = self.block_scanner.connect_provider(provider);
         EventScanner {
@@ -137,7 +162,13 @@ pub struct EventScanner<P: Provider<N>, N: Network> {
 }
 
 impl<P: Provider<N>, N: Network> EventScanner<P, N> {
+    /// Starts the scanner
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the scanner fails to start
     pub async fn start(&mut self) -> anyhow::Result<()> {
+        future::ready(()).await;
         todo!()
     }
 }