start

Author: lukeiannucci

Cargo.toml

@@ -17,6 +17,7 @@ members = [
     "timeboost-types",
     "timeboost-utils",
     "yapper",
+    "tests/block-verifier"
 ]
 resolver = "2"
 

tests/block-verifier/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "block_verifier"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+alloy = { workspace = true }
+anyhow = { workspace = true }
+clap = { workspace = true }
+futures = { workspace = true }
+timeboost-utils = { path = "../../timeboost-utils" }
+tokio = { workspace = true }
+tracing = { workspace = true }

tests/block-verifier/src/main.rs

@@ -0,0 +1,91 @@
+use alloy::{
+    eips::BlockNumberOrTag,
+    network::{Ethereum, Network},
+    providers::{Provider, RootProvider},
+    rpc::types::Block,
+};
+use anyhow::{Context, Result};
+use clap::Parser;
+use futures::future::join_all;
+use timeboost_utils::types::logging::init_logging;
+use tracing::{error, info};
+
+#[derive(Parser, Debug)]
+struct Cli {
+    /// Nitro node URLs used for gas estimations and getting nonce when sending transactions
+    /// Can be specified multiple times: --nitro-url url1 --nitro-url url2
+    #[clap(
+        long,
+        default_value = "http://localhost:8547;http://localhost:8647",
+        use_value_delimiter = true,
+        value_delimiter = ';'
+    )]
+    nitro_urls: Vec<String>,
+}
+
+async fn connect_to_chain<N: Network>(urls: &[String]) -> Result<Vec<RootProvider<N>>> {
+    let mut p = Vec::new();
+    for url in urls {
+        p.push(RootProvider::<N>::connect(url).await?)
+    }
+    Ok(p)
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    init_logging();
+    let cli = Cli::parse();
+
+    let providers = connect_to_chain::<Ethereum>(&cli.nitro_urls).await?;
+
+    // take the minimum block in to avoid race conditions
+    let min_block = join_all(providers.iter().map(|p| async {
+        p.get_block_number()
+            .await
+            .map(|b| b)
+            .context("provider request failed")
+    }))
+    .await
+    .into_iter()
+    .collect::<Result<Vec<u64>>>()?
+    .into_iter()
+    .min()
+    .context("failed to get min block")?;
+
+    for i in 0..=min_block {
+        info!(num = %i, "getting block number");
+        let blocks = join_all(providers.iter().map(|p| async {
+            p.get_block_by_number(BlockNumberOrTag::Number(i))
+                .await
+                .map(|b| b)
+                .context("provider request failed")
+        }))
+        .await
+        .into_iter()
+        .collect::<Result<Vec<Option<Block>>>>()?;
+        let first_block = blocks
+            .first()
+            .and_then(|b| b.as_ref())
+            .ok_or_else(|| anyhow::anyhow!("No blocks received from any provider"))?;
+        info!(hash = %first_block.hash(), "verifying against block hash");
+        for block in blocks.iter().skip(1) {
+            let b = block
+                .as_ref()
+                .ok_or_else(|| anyhow::anyhow!("provider returned no block"))?;
+            if b != first_block {
+                error!(
+                    block_a = ?b,
+                    block_b = ?first_block,
+                    "block mismatch between block state"
+                );
+                anyhow::bail!(
+                    "block mismatch between blocks: left: {:?}, right: {:?}",
+                    b,
+                    first_block
+                );
+            }
+        }
+    }
+
+    Ok(())
+}