feat: add ci

.github/workflows/ci.yml

@@ -0,0 +1,92 @@
+name: CI
+
+on:
+  pull_request:
+    types: [synchronize, opened, reopened, ready_for_review]
+  push:
+    branches:
+      - master
+
+env:
+  CARGO_NET_GIT_FETCH_WITH_CLI: true
+  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
+
+jobs:
+  skip_check:
+    runs-on: ubuntu-latest
+    outputs:
+      should_skip: ${{ steps.skip_check.outputs.should_skip }}
+    steps:
+      - id: skip_check
+        uses: fkirc/skip-duplicate-actions@v5
+        with:
+          cancel_others: 'true'
+          concurrent_skipping: 'same_content_newer'
+          paths_ignore: '["**/README.md"]'
+
+  fmt:
+    needs: [ skip_check ]
+    if: |
+      github.event.pull_request.draft == false &&
+      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
+    name: Rustfmt
+    timeout-minutes: 30
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: "nightly-2024-07-07"
+          components: rustfmt
+      - name: Cargo fmt
+        run: cargo fmt --all -- --check
+
+  clippy:
+    needs: [ fmt ]
+    if: |
+      github.event.pull_request.draft == false &&
+      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
+    name: Clippy
+    timeout-minutes: 30
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [ "--all-targets", "--bin stateless-block-verifier" ]
+        features: [ "--features=\"bin-deps\"", "--features=\"bin-deps, dev\"", "--all-features" ]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: "nightly-2024-07-07"
+          components: clippy
+      - name: cargo cache
+        uses: Swatinem/rust-cache@v2
+      - name: clippy
+        run: cargo clippy --workspace ${{ matrix.target }} ${{ matrix.features }} -- -D warnings
+
+  integration-tests:
+    needs: [ clippy ]
+    if: |
+      github.event.pull_request.draft == false &&
+      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
+    name: Integration Tests
+    timeout-minutes: 30
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [ "1.75", "nightly-2024-07-07" ]
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: checkout test data
+        uses: actions/checkout@v4
+        with:
+          repository: 'scroll-tech/block-testdata'
+          sparse-checkout: 'mainnet_blocks/flatten-proofs'
+          path: 'testdata'
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ matrix.rust }}
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo run --release --features bin-deps --package stateless-block-verifier --bin stateless-block-verifier -- -k run-file testdata/mainnet_blocks/flatten-proofs/*

src/bin/trace-verifier/commands/mod.rs

@@ -17,7 +17,7 @@ pub enum Commands {
 impl Commands {
     pub async fn run(
         self,
-        fork_config: impl Fn(u64) -> HardforkConfig,
+        fork_config: impl Fn(u64) -> HardforkConfig + Send + Sync + Copy + 'static,
         disable_checks: bool,
     ) -> anyhow::Result<()> {
         match self {

src/bin/trace-verifier/commands/run_file.rs

@@ -1,47 +1,66 @@
+use crate::utils;
+use anyhow::bail;
 use clap::Args;
 use eth_types::l2_types::BlockTrace;
-use stateless_block_verifier::{dev_info, HardforkConfig};
+use stateless_block_verifier::HardforkConfig;
 use std::path::PathBuf;
-
-use crate::utils;
+use tokio::task::JoinSet;
 
 #[derive(Args)]
 pub struct RunFileCommand {
     /// Path to the trace file
-    #[arg(short, long, default_value = "trace.json")]
+    #[arg(default_value = "trace.json")]
     path: Vec<PathBuf>,
 }
 
+fn deserialize_block_trace(trace: &str) -> anyhow::Result<BlockTrace> {
+    Ok(
+        // Try to deserialize `BlockTrace` from JSON. In case of failure, try to
+        // deserialize `BlockTrace` from a JSON-RPC response that has the actual block
+        // trace nested in the value of the key "result".
+        serde_json::from_str::<BlockTrace>(trace).or_else(|_| {
+            #[derive(serde::Deserialize, Default, Debug, Clone)]
+            pub struct BlockTraceJsonRpcResult {
+                pub result: BlockTrace,
+            }
+            Ok::<_, serde_json::Error>(
+                serde_json::from_str::<BlockTraceJsonRpcResult>(trace)?.result,
+            )
+        })?,
+    )
+}
+
+async fn run_trace(
+    path: PathBuf,
+    fork_config: impl Fn(u64) -> HardforkConfig,
+    disable_checks: bool,
+) -> anyhow::Result<()> {
+    let trace = tokio::fs::read_to_string(&path).await?;
+    let trace = tokio::task::spawn_blocking(move || deserialize_block_trace(&trace)).await??;
+    let fork_config = fork_config(trace.chain_id);
+    tokio::task::spawn_blocking(move || utils::verify(trace, &fork_config, disable_checks, false))
+        .await??;
+    Ok(())
+}
+
 impl RunFileCommand {
     pub async fn run(
         self,
-        fork_config: impl Fn(u64) -> HardforkConfig,
+        fork_config: impl Fn(u64) -> HardforkConfig + Send + Sync + Copy + 'static,
         disable_checks: bool,
     ) -> anyhow::Result<()> {
-        for path in self.path {
-            dev_info!("Reading trace from {:?}", path);
+        let mut tasks = JoinSet::new();
 
-            let trace: BlockTrace = tokio::fs::read_to_string(&path).await.and_then(|trace| {
-                Ok(
-                    // Try to deserialize `BlockTrace` from JSON. In case of failure, try to
-                    // deserialize `BlockTrace` from a JSON-RPC response that has the actual block
-                    // trace nested in the value of the key "result".
-                    serde_json::from_str::<BlockTrace>(&trace).or::<serde_json::Error>({
-                        #[derive(serde::Deserialize, Default, Debug, Clone)]
-                        pub struct BlockTraceJsonRpcResult {
-                            pub result: BlockTrace,
-                        }
-                        Ok(serde_json::from_str::<BlockTraceJsonRpcResult>(&trace)?.result)
-                    })?,
-                )
-            })?;
+        for path in self.path.into_iter() {
+            tasks.spawn(run_trace(path, fork_config, disable_checks));
+        }
 
-            let fork_config = fork_config(trace.chain_id);
-            tokio::task::spawn_blocking(move || {
-                utils::verify(trace, &fork_config, disable_checks, false)
-            })
-            .await??
+        while let Some(task) = tasks.join_next().await {
+            if let Err(err) = task? {
+                bail!("{:?}", err);
+            }
         }
+
         Ok(())
     }
 }

src/bin/trace-verifier/commands/run_rpc.rs

@@ -73,7 +73,7 @@ impl RunRpcCommand {
 
         let handles = {
             let mut handles = Vec::with_capacity(self.parallel);
-            for idx in 0..self.parallel {
+            for _idx in 0..self.parallel {
                 let _provider = provider.clone();
                 let rx = rx.clone();
                 let is_log_error = error_log.is_some();
@@ -88,11 +88,11 @@ impl RunRpcCommand {
                             .await?;
 
                         dev_info!(
-                            "worker#{idx}: load trace for block #{block_number}({})",
+                            "worker#{_idx}: load trace for block #{block_number}({})",
                             l2_trace.header.hash.unwrap()
                         );
 
-                        if let Err(err) = tokio::task::spawn_blocking(move || {
+                        if let Err(_err) = tokio::task::spawn_blocking(move || {
                             utils::verify(l2_trace, &fork_config, disable_checks, is_log_error)
                         })
                         .await?
@@ -126,9 +126,10 @@ impl RunRpcCommand {
                         break;
                     }
                 } else if current_block % 10 == 0 {
-                    let latest_block = provider.get_block_number().await?.as_u64();
-
-                    dev_info!("distance to latest block: {}", latest_block - current_block);
+                    dev_info!(
+                        "distance to latest block: {}",
+                        provider.get_block_number().await?.as_u64() - current_block
+                    );
                 }
 
                 tx.send(current_block).await?;

src/bin/trace-verifier/main.rs

@@ -1,11 +1,11 @@
-#![allow(unused_imports)]
-#![allow(unused_variables)]
 #[cfg(feature = "dev")]
 #[macro_use]
 extern crate tracing;
+#[macro_use]
+extern crate stateless_block_verifier;
 
 use clap::Parser;
-use stateless_block_verifier::{dev_info, HardforkConfig};
+use stateless_block_verifier::HardforkConfig;
 
 #[cfg(feature = "dev")]
 use tracing_subscriber::EnvFilter;
@@ -40,7 +40,7 @@ async fn main() -> anyhow::Result<()> {
 
     let cmd = Cli::parse();
 
-    let get_fork_config = |chain_id: u64| {
+    let get_fork_config = move |chain_id: u64| {
         let mut config = HardforkConfig::default_from_chain_id(chain_id);
 
         dev_info!("Using hardfork config: {:?}", config);

src/bin/trace-verifier/utils.rs

@@ -60,7 +60,7 @@ pub fn verify(
         dev_info!("Profiling report saved to: {:?}", path);
     }
 
-    let elapsed = now.elapsed();
+    let _elapsed = now.elapsed();
 
     if root_after != revm_root_after {
         dev_error!("Root after in trace: {:x}", root_after);
@@ -76,16 +76,16 @@ pub fn verify(
         });
     }
 
-    dev_info!("Root matches in: {} ms", elapsed.as_millis());
+    dev_info!("Root matches in: {} ms", _elapsed.as_millis());
 
     let block_counter = BLOCK_COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
     if block_counter > 50 {
         let mut last_time = LAST_TIME.lock().unwrap();
-        let blocks = BLOCK_COUNTER.swap(0, std::sync::atomic::Ordering::SeqCst);
-        let elapsed = last_time.elapsed().as_secs_f64();
-        let bps = blocks as f64 / elapsed;
-
-        dev_warn!("Verifying avg speed: {:.2} bps", bps);
+        dev_warn!(
+            "Verifying avg speed: {:.2} bps",
+            BLOCK_COUNTER.swap(0, std::sync::atomic::Ordering::SeqCst) as f64
+                / last_time.elapsed().as_secs_f64()
+        );
         *last_time = Instant::now();
     }
 

src/hardfork.rs

@@ -13,6 +13,7 @@ use crate::{dev_info, dev_warn};
 
 /// Hardfork heights for Scroll networks, grouped by chain id.
 static HARDFORK_HEIGHTS: LazyLock<HashMap<u64, HashMap<SpecId, u64>>> = LazyLock::new(|| {
+    #[allow(clippy::let_and_return)]
     let heights = hardfork_heights()
         .into_iter()
         .sorted_by_key(|(_, chain_id, _)| *chain_id)