fix: pre-audit fixes and correctness improvements

Cargo.toml

@@ -9,6 +9,7 @@ publish = false
 resolver = "3"
 members = [
     "bin/morph-reth",
+    "bin/state-root-check",
     "crates/chainspec",
     "crates/consensus",
     "crates/engine-api",
@@ -103,6 +104,7 @@ reth-storage-api = { git = "https://github.com/morph-l2/reth", rev = "1dd7227738
 reth-tasks = { git = "https://github.com/morph-l2/reth", rev = "1dd722773844d1a3c50a691dc09f6cdf8e6bd00e" }
 reth-tracing = { git = "https://github.com/morph-l2/reth", rev = "1dd722773844d1a3c50a691dc09f6cdf8e6bd00e" }
 reth-trie = { git = "https://github.com/morph-l2/reth", rev = "1dd722773844d1a3c50a691dc09f6cdf8e6bd00e" }
+reth-trie-db = { git = "https://github.com/morph-l2/reth", rev = "1dd722773844d1a3c50a691dc09f6cdf8e6bd00e" }
 reth-transaction-pool = { git = "https://github.com/morph-l2/reth", rev = "1dd722773844d1a3c50a691dc09f6cdf8e6bd00e" }
 reth-zstd-compressors = { git = "https://github.com/morph-l2/reth", rev = "1dd722773844d1a3c50a691dc09f6cdf8e6bd00e", default-features = false }
 

bin/morph-reth/src/main.rs

@@ -18,7 +18,9 @@ fn main() {
     // Install signal handler for segmentation faults
     sigsegv_handler::install();
 
-    // Enable backtraces by default
+    // Enable backtraces by default.
+    // SAFETY: Called at process startup before any other threads are spawned,
+    // so there are no concurrent readers of the environment.
     if std::env::var_os("RUST_BACKTRACE").is_none() {
         unsafe { std::env::set_var("RUST_BACKTRACE", "1") };
     }

bin/state-root-check/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "state-root-check"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+alloy-primitives.workspace = true
+clap.workspace = true
+eyre.workspace = true
+morph-chainspec.workspace = true
+morph-node.workspace = true
+reth-provider.workspace = true
+reth-storage-api.workspace = true
+reth-trie.workspace = true
+
+[[bin]]
+name = "state-root-check"
+path = "src/main.rs"

bin/state-root-check/src/lib.rs

@@ -0,0 +1,76 @@
+use alloy_primitives::B256;
+use eyre::{Result, ensure};
+
+#[cfg(test)]
+mod tests {
+    use super::find_first_mismatch;
+    use eyre::Result;
+
+    #[test]
+    fn returns_first_divergent_block_for_monotonic_range() -> Result<()> {
+        let mismatch_from = 103_u64;
+
+        let got = find_first_mismatch(100, 105, |block| Ok(block < mismatch_from))?;
+
+        assert_eq!(got, Some(mismatch_from));
+        Ok(())
+    }
+
+    #[test]
+    fn returns_none_when_everything_matches() -> Result<()> {
+        let got = find_first_mismatch(100, 105, |_block| Ok(true))?;
+
+        assert_eq!(got, None);
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockRootComparison {
+    pub block_number: u64,
+    pub reth_root: B256,
+    pub geth_disk_root: B256,
+}
+
+impl BlockRootComparison {
+    pub fn is_match(&self) -> bool {
+        self.reth_root == self.geth_disk_root
+    }
+}
+
+pub fn find_first_mismatch<F>(from: u64, to: u64, mut matches: F) -> Result<Option<u64>>
+where
+    F: FnMut(u64) -> Result<bool>,
+{
+    ensure!(
+        from <= to,
+        "invalid range: from-block {from} is greater than to-block {to}"
+    );
+
+    if !matches(from)? {
+        return Ok(Some(from));
+    }
+
+    if matches(to)? {
+        return Ok(None);
+    }
+
+    let mut low = from.saturating_add(1);
+    let mut high = to;
+    let mut first = to;
+
+    while low <= high {
+        let mid = low + (high - low) / 2;
+        if matches(mid)? {
+            low = mid.saturating_add(1);
+        } else {
+            first = mid;
+            if mid == 0 {
+                break;
+            }
+            high = mid - 1;
+        }
+    }
+
+    Ok(Some(first))
+}

bin/state-root-check/src/main.rs

@@ -0,0 +1,217 @@
+use alloy_primitives::B256;
+use clap::{Parser, ValueEnum};
+use eyre::{Context, ContextCompat, Result, ensure};
+use morph_chainspec::{MORPH_HOODI, MORPH_MAINNET, MorphChainSpec};
+use morph_node::{MorphNode, validator::fetch_geth_disk_root};
+use reth_provider::{
+    ProviderFactory,
+    providers::{ProviderNodeTypes, ReadOnlyConfig},
+};
+use reth_storage_api::{BlockNumReader, StateRootProvider};
+use reth_trie::HashedPostState;
+use state_root_check::{BlockRootComparison, find_first_mismatch};
+use std::{collections::HashMap, path::PathBuf, sync::Arc};
+
+#[derive(Debug, Clone, Copy, Default, ValueEnum)]
+enum ChainArg {
+    Morph,
+    #[default]
+    #[value(name = "morph-hoodi")]
+    MorphHoodi,
+}
+
+impl ChainArg {
+    fn chain_spec(self) -> Arc<MorphChainSpec> {
+        match self {
+            Self::Morph => MORPH_MAINNET.clone(),
+            Self::MorphHoodi => MORPH_HOODI.clone(),
+        }
+    }
+}
+
+#[derive(Debug, Parser)]
+#[command(name = "state-root-check")]
+#[command(about = "Compare local reth MPT roots with geth morph_diskRoot")]
+struct Args {
+    #[arg(long)]
+    datadir: PathBuf,
+    #[arg(long, default_value = "morph-hoodi")]
+    chain: ChainArg,
+    #[arg(long)]
+    geth_rpc_url: Option<String>,
+    #[arg(long, conflicts_with_all = ["fresh_root_at", "bisect"])]
+    block: Option<u64>,
+    #[arg(long, conflicts_with_all = ["block", "bisect"])]
+    fresh_root_at: Option<u64>,
+    #[arg(long, requires_all = ["from_block", "to_block"], conflicts_with_all = ["block", "fresh_root_at"])]
+    bisect: bool,
+    #[arg(long, requires = "bisect")]
+    from_block: Option<u64>,
+    #[arg(long, requires = "bisect")]
+    to_block: Option<u64>,
+}
+
+enum Mode {
+    LocalRoot {
+        block: u64,
+    },
+    Compare {
+        block: u64,
+        geth_rpc_url: String,
+    },
+    Bisect {
+        from: u64,
+        to: u64,
+        geth_rpc_url: String,
+    },
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+    ensure!(
+        args.datadir.exists(),
+        "datadir does not exist: {}",
+        args.datadir.display()
+    );
+
+    let factory = MorphNode::provider_factory_builder()
+        .open_read_only(
+            args.chain.chain_spec(),
+            ReadOnlyConfig::from_datadir(&args.datadir),
+        )
+        .with_context(|| format!("failed to open datadir {}", args.datadir.display()))?;
+
+    let latest_block = factory.best_block_number()?;
+    let mode = resolve_mode(&args, latest_block)?;
+
+    match mode {
+        Mode::LocalRoot { block } => {
+            let root = compute_local_state_root(&factory, block)?;
+            println!("fresh_root_at #{block}: {root:#x}");
+        }
+        Mode::Compare {
+            block,
+            geth_rpc_url,
+        } => {
+            let comparison = compare_block_roots(&factory, &geth_rpc_url, block)?;
+            print_comparison(&comparison);
+        }
+        Mode::Bisect {
+            from,
+            to,
+            geth_rpc_url,
+        } => {
+            let mut cache = HashMap::new();
+            let first = find_first_mismatch(from, to, |block| {
+                if let Some(is_match) = cache.get(&block) {
+                    return Ok(*is_match);
+                }
+
+                let comparison = compare_block_roots(&factory, &geth_rpc_url, block)?;
+                let is_match = comparison.is_match();
+                print_probe(&comparison);
+                cache.insert(block, is_match);
+                Ok(is_match)
+            })?;
+
+            match first {
+                Some(block) => println!("first_mismatch: {block}"),
+                None => println!("all blocks matched in range [{from}, {to}]"),
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn resolve_mode(args: &Args, latest_block: u64) -> Result<Mode> {
+    if let Some(block) = args.fresh_root_at {
+        return Ok(Mode::LocalRoot { block });
+    }
+
+    if args.bisect {
+        let from = args
+            .from_block
+            .context("--from-block is required when --bisect is set")?;
+        let to = args
+            .to_block
+            .context("--to-block is required when --bisect is set")?;
+        ensure!(
+            from <= to,
+            "--from-block must be less than or equal to --to-block"
+        );
+        return Ok(Mode::Bisect {
+            from,
+            to,
+            geth_rpc_url: args
+                .geth_rpc_url
+                .clone()
+                .context("--geth-rpc-url is required for --bisect")?,
+        });
+    }
+
+    let block = args.block.unwrap_or(latest_block);
+    if let Some(geth_rpc_url) = args.geth_rpc_url.clone() {
+        Ok(Mode::Compare {
+            block,
+            geth_rpc_url,
+        })
+    } else {
+        Ok(Mode::LocalRoot { block })
+    }
+}
+
+fn compute_local_state_root<N>(factory: &ProviderFactory<N>, block: u64) -> Result<B256>
+where
+    N: ProviderNodeTypes,
+{
+    let provider = factory
+        .history_by_block_number(block)
+        .with_context(|| format!("failed to open historical state at block {block}"))?;
+    let root = provider
+        .state_root(HashedPostState::default())
+        .with_context(|| format!("failed to compute local state root at block {block}"))?;
+    Ok(root)
+}
+
+fn compare_block_roots<N>(
+    factory: &ProviderFactory<N>,
+    geth_rpc_url: &str,
+    block: u64,
+) -> Result<BlockRootComparison>
+where
+    N: ProviderNodeTypes,
+{
+    let reth_root = compute_local_state_root(factory, block)?;
+    let geth_disk_root =
+        fetch_geth_disk_root(geth_rpc_url, block).map_err(|err| eyre::eyre!(err))?;
+    Ok(BlockRootComparison {
+        block_number: block,
+        reth_root,
+        geth_disk_root,
+    })
+}
+
+fn print_comparison(comparison: &BlockRootComparison) {
+    let status = if comparison.is_match() {
+        "MATCH"
+    } else {
+        "MISMATCH"
+    };
+    println!("block #{}", comparison.block_number);
+    println!("reth_root: {:#x}", comparison.reth_root);
+    println!("geth_disk_root: {:#x}", comparison.geth_disk_root);
+    println!("status: {status}");
+}
+
+fn print_probe(comparison: &BlockRootComparison) {
+    let status = if comparison.is_match() {
+        "MATCH"
+    } else {
+        "MISMATCH"
+    };
+    println!(
+        "probe #{} => {} reth={:#x} geth={:#x}",
+        comparison.block_number, status, comparison.reth_root, comparison.geth_disk_root
+    );
+}