feat test block 260

Author: MdTeach

crates/reth/evm/src/constants.rs

@@ -16,6 +16,3 @@ pub const BASEFEE_ADDRESS: Address = address!("540000000000000000000000000000000
 
 /// The address to send transaction priority fees to.
 pub const COINBASE_ADDRESS: Address = address!("5400000000000000000000000000000000000011");
-
-/// The maximum depth of the ancestor chain that can be accessed by BLOCKHASH opcode.
-pub const MAX_ANCESTOR_DEPTH: u64 = 256;

crates/reth/exex/src/cache_db_provider.rs

@@ -19,12 +19,20 @@ pub struct CacheDBProvider {
     accounts: RefCell<HashMap<Address, AccountInfo>>,
     storage: RefCell<HashMap<Address, HashMap<U256, U256>>>,
     bytecodes: RefCell<HashSet<Bytes>>,
+    accessed_blkd_ids: RefCell<HashSet<u64>>,
 }
 
 #[derive(Debug)]
 pub struct AccessedState {
     pub accessed_accounts: HashMap<Address, Vec<Uint<256, 4>>>,
     pub accessed_contracts: Vec<Bytes>,
+    accessed_block_ids: HashSet<u64>,
+}
+
+impl AccessedState {
+    pub fn accessed_block_ids(&self) -> &HashSet<u64> {
+        &self.accessed_block_ids
+    }
 }
 
 impl CacheDBProvider {
@@ -34,6 +42,7 @@ impl CacheDBProvider {
             accounts: Default::default(),
             storage: Default::default(),
             bytecodes: Default::default(),
+            accessed_blkd_ids: Default::default(),
         }
     }
 
@@ -44,6 +53,7 @@ impl CacheDBProvider {
         AccessedState {
             accessed_accounts,
             accessed_contracts,
+            accessed_block_ids: self.accessed_blkd_ids.borrow().clone(),
         }
     }
 
@@ -130,8 +140,13 @@ impl DatabaseRef for CacheDBProvider {
 
     /// Get block hash by block number.
     fn block_hash_ref(&self, number: u64) -> Result<B256, Self::Error> {
-        self.provider
+        let blk_id = self
+            .provider
             .block_hash(number)?
-            .ok_or(ProviderError::BlockBodyIndicesNotFound(number))
+            .ok_or(ProviderError::BlockBodyIndicesNotFound(number))?;
+
+        self.accessed_blkd_ids.borrow_mut().insert(number);
+
+        Ok(blk_id)
     }
 }

crates/reth/exex/src/prover_exex.rs

@@ -1,4 +1,7 @@
-use std::{collections::HashMap, sync::Arc};
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
 
 use alloy_consensus::Header;
 use alloy_rpc_types::{serde_helpers::JsonStorageKey, BlockNumHash, EIP1186AccountProofResponse};
@@ -15,7 +18,6 @@ use reth_trie_common::KeccakKeyHasher;
 use revm_primitives::alloy_primitives::{Address, B256};
 use strata_proofimpl_evm_ee_stf::{mpt::proofs_to_tries, EvmBlockStfInput};
 use strata_reth_db::WitnessStore;
-use strata_reth_evm::constants::MAX_ANCESTOR_DEPTH;
 use tracing::{debug, error};
 
 use crate::{
@@ -140,7 +142,7 @@ fn extract_zkvm_input<Node: FullNodeComponents<Types: NodeTypes<Primitives = Eth
 
     let mut parent_proofs: HashMap<Address, EIP1186AccountProofResponse> = HashMap::new();
     let mut current_proofs: HashMap<Address, EIP1186AccountProofResponse> = HashMap::new();
-    let contracts = accessed_states.accessed_contracts;
+    let contracts = accessed_states.accessed_contracts.clone();
 
     // Accumulate account proof of account in previous block
     for (accessed_address, accessed_slots) in accessed_states.accessed_accounts.iter() {
@@ -186,14 +188,8 @@ fn extract_zkvm_input<Node: FullNodeComponents<Types: NodeTypes<Primitives = Eth
     )
     .expect("Proof to tries infallible");
 
-    // Get ancestor headers
-    let ancestor_headers = get_ancestor_headers(ctx, current_block_idx)?;
-
-    println!(
-        "Abishek got ancestor_headers: num {:?} {:?}",
-        ancestor_headers.len(),
-        ancestor_headers
-    );
+    let ancestor_headers =
+        get_ancestor_headers(ctx, current_block_idx, accessed_states.accessed_block_ids())?;
 
     let input = EvmBlockStfInput {
         beneficiary: current_block.header.beneficiary,
@@ -213,21 +209,30 @@ fn extract_zkvm_input<Node: FullNodeComponents<Types: NodeTypes<Primitives = Eth
     Ok(input)
 }
 
-fn get_ancestor_headers<Node: FullNodeComponents<Types: NodeTypes<Primitives = EthPrimitives>>>(
+fn get_ancestor_headers<Node>(
     ctx: &ExExContext<Node>,
-    block_idx: u64,
-) -> eyre::Result<Vec<Header>> {
-    let oldest_parent = block_idx.saturating_sub(MAX_ANCESTOR_DEPTH);
-    let prev_block_idx = block_idx.saturating_sub(1);
-    let provider = ctx.provider();
-    let mut headers = Vec::with_capacity((block_idx - oldest_parent) as usize);
+    current_blk_idx: u64,
+    accessed_block_idxs: &HashSet<u64>,
+) -> eyre::Result<Vec<Header>>
+where
+    Node: FullNodeComponents,
+    Node::Types: NodeTypes<Primitives = EthPrimitives>,
+{
+    let Some(oldest_parent_idx) = accessed_block_idxs.iter().copied().min_by(|a, b| a.cmp(b))
+    else {
+        return Ok(Vec::new());
+    };
 
-    for block_num in (oldest_parent..prev_block_idx).rev() {
-        let block = provider
-            .block_by_number(block_num)?
-            .ok_or_else(|| eyre!("Block not found for block number {block_num}"))?;
-        headers.push(block.header);
-    }
+    let provider = ctx.provider();
+    let headers = (oldest_parent_idx..current_blk_idx.saturating_sub(1))
+        .rev()
+        .map(|block_num| {
+            provider
+                .block_by_number(block_num)?
+                .map(|block| block.header)
+                .ok_or_else(|| eyre!("Block not found for block number {block_num}"))
+        })
+        .collect::<eyre::Result<Vec<_>>>()?;
 
     Ok(headers)
 }

functional-tests/load/reth/contracts/BlockhashOpCode.sol

@@ -5,8 +5,8 @@ contract BlockhashOpCode {
     bytes32 public lastBlockHash;
 
     function updateBlockHash() external {
-        bytes32 lastBlockHash1 = blockhash(block.number - 1);
-        bytes32 lastBlockHash2 = blockhash(block.number - 2);
+        bytes32 lastBlockHash1 = blockhash(block.number - 10);
+        bytes32 lastBlockHash2 = blockhash(block.number - 50);
         lastBlockHash = lastBlockHash1 ^ lastBlockHash2;
     }
 }

functional-tests/tests/prover/prover_el_dispatch.py

@@ -5,7 +5,6 @@
 from utils import (
     el_slot_to_block_commitment,
     wait_for_proof_with_time_out,
-    wait_until,
     wait_until_with_value,
 )
 from utils.eth import make_native_token_transfer
@@ -56,12 +55,6 @@ def main(self, ctx: flexitest.RunContext):
         start_block = el_slot_to_block_commitment(reth_rpc, ee_prover_params["start_block"])
         end_block = el_slot_to_block_commitment(reth_rpc, ee_prover_params["end_block"])
 
-        # Wait until the prover client reports readiness
-        wait_until(
-            lambda: prover_client_rpc.dev_strata_getReport() is not None,
-            error_with="Prover did not start on time",
-        )
-
         task_ids = prover_client_rpc.dev_strata_proveElBlocks((start_block, end_block))
         self.debug(f"Prover task IDs received: {task_ids}")