Add support for block hashes

Author: antoniolocascio

tests/instances/eth_runner/src/block_hashes.rs

@@ -0,0 +1,30 @@
+use alloy::primitives::{B256, U256};
+use serde::Deserialize;
+use std::collections::HashMap;
+
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct BlockInfo {
+    pub number: u64,
+    pub hash: B256,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BlockHashes(pub Vec<BlockInfo>);
+
+impl BlockHashes {
+    pub fn into_array(self, block_number: u64) -> [U256; 256] {
+        let mut array = [U256::ZERO; 256];
+        let mut map = HashMap::<u64, U256>::new();
+        self.0.into_iter().for_each(|info| {
+            map.insert(info.number, info.hash.into());
+        });
+        // Add values for most recent 256 block, if present
+        for offset in 1..=256 {
+            if let Some(hash) = map.get(&(block_number - offset)) {
+                array[(offset - 1) as usize] = *hash;
+            }
+        }
+        array
+    }
+}

tests/instances/eth_runner/src/main.rs

@@ -1,5 +1,6 @@
 #![feature(slice_as_array)]
 
+use block_hashes::BlockHashes;
 use clap::Parser;
 use post_check::post_check;
 use prestate::{populate_prestate, DiffTrace, PrestateTrace};
@@ -8,6 +9,7 @@ use std::fs::{self, File};
 use std::io::BufReader;
 
 mod block;
+mod block_hashes;
 mod post_check;
 mod prestate;
 mod receipts;
@@ -35,6 +37,10 @@ struct Args {
     #[arg(long)]
     receipts: String,
 
+    /// Path to the block hashes JSON file (optional)
+    #[arg(long)]
+    block_hashes: Option<String>,
+
     /// If set, the leaves of the tree are put in random
     /// positions to emulate real-world costs
     #[arg(long, action = clap::ArgAction::SetTrue)]
@@ -51,9 +57,14 @@ fn run<const RANDOMIZED: bool>(
     transactions: Vec<Vec<u8>>,
     receipts: Vec<receipts::TransactionReceipt>,
     diff_trace: DiffTrace,
+    block_hashes: Option<BlockHashes>,
 ) -> anyhow::Result<()> {
     chain.set_last_block_number(block_number - 1);
 
+    if let Some(block_hashes) = block_hashes {
+        chain.set_block_hashes(block_hashes.into_array(block_number))
+    }
+
     let prestate_cache = populate_prestate(&mut chain, ps_trace);
 
     let output = chain.run_block(transactions, Some(block_context), None);
@@ -84,6 +95,10 @@ fn main() -> anyhow::Result<()> {
     let diff_file = File::open(&args.difftrace)?;
     let diff_reader = BufReader::new(diff_file);
     let diff_trace: DiffTrace = serde_json::from_reader(diff_reader)?;
+    let block_hashes: Option<BlockHashes> = args.block_hashes.map(|path| {
+        let hashes = fs::read_to_string(&path).expect("valid block hashes path");
+        serde_json::from_str(&hashes).expect("valid block hashes JSON")
+    });
 
     let block: block::Block = serde_json::from_str(&block).expect("valid block JSON");
     let block_number = block.result.header.number;
@@ -130,6 +145,7 @@ fn main() -> anyhow::Result<()> {
             transactions,
             receipts,
             diff_trace,
+            block_hashes,
         )
     } else {
         let chain = Chain::empty(Some(1));
@@ -142,6 +158,7 @@ fn main() -> anyhow::Result<()> {
             transactions,
             receipts,
             diff_trace,
+            block_hashes,
         )
     }
 }

tests/rig/src/chain.rs

@@ -110,6 +110,10 @@ impl<const RANDOMIZED_TREE: bool> Chain<RANDOMIZED_TREE> {
         self.block_number = prev
     }
 
+    pub fn set_block_hashes(&mut self, block_hashes: [U256; 256]) {
+        self.block_hashes = block_hashes
+    }
+
     ///
     /// Run block with given transactions and block context.
     /// If block context is `None` default testing values will be used.