feat test block 260

Author: MdTeach

Cargo.lock

@@ -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/evm/src/constants.rs

@@ -6,7 +6,6 @@ version = "0.1.0"
 [dependencies]
 strata-proofimpl-evm-ee-stf.workspace = true
 strata-reth-db.workspace = true
-strata-reth-evm.workspace = true
 strata-reth-node.workspace = true
 
 alloy-consensus.workspace = true

crates/reth/exex/Cargo.toml

@@ -19,12 +19,28 @@ 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_accounts: HashMap<Address, Vec<Uint<256, 4>>>,
+    accessed_contracts: Vec<Bytes>,
+    accessed_block_idxs: HashSet<u64>,
+}
+
+impl AccessedState {
+    pub fn accessed_block_idxs(&self) -> &HashSet<u64> {
+        &self.accessed_block_idxs
+    }
+
+    pub fn accessed_accounts(&self) -> &HashMap<Address, Vec<Uint<256, 4>>> {
+        &self.accessed_accounts
+    }
+
+    pub fn accessed_contracts(&self) -> &Vec<Bytes> {
+        &self.accessed_contracts
+    }
 }
 
 impl CacheDBProvider {
@@ -34,6 +50,7 @@ impl CacheDBProvider {
             accounts: Default::default(),
             storage: Default::default(),
             bytecodes: Default::default(),
+            accessed_blkd_ids: Default::default(),
         }
     }
 
@@ -44,6 +61,7 @@ impl CacheDBProvider {
         AccessedState {
             accessed_accounts,
             accessed_contracts,
+            accessed_block_idxs: self.accessed_blkd_ids.borrow().clone(),
         }
     }
 
@@ -130,8 +148,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/cache_db_provider.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,10 +142,10 @@ 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() {
+    for (accessed_address, accessed_slots) in accessed_states.accessed_accounts().iter() {
         let slots: Vec<B256> = accessed_slots
             .iter()
             .map(|el| B256::from_slice(&el.to_be_bytes::<32>()))
@@ -162,7 +164,7 @@ fn extract_zkvm_input<Node: FullNodeComponents<Types: NodeTypes<Primitives = Eth
     }
 
     // Accumulate account proof of account in current block
-    for (accessed_address, accessed_slots) in accessed_states.accessed_accounts.iter() {
+    for (accessed_address, accessed_slots) in accessed_states.accessed_accounts().iter() {
         let slots: Vec<B256> = accessed_slots
             .iter()
             .map(|el| B256::from_slice(&el.to_be_bytes::<32>()))
@@ -186,14 +188,11 @@ 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_idxs(),
+    )?;
 
     let input = EvmBlockStfInput {
         beneficiary: current_block.header.beneficiary,
@@ -213,21 +212,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)
 }

crates/reth/exex/src/prover_exex.rs

@@ -3,16 +3,16 @@
 from web3 import Web3
 
 from envs import testenv
-from load.reth.transaction import SmartContracts
 from utils import (
     el_slot_to_block_commitment,
     wait_for_proof_with_time_out,
     wait_until_with_value,
 )
+from utils.transaction import SmartContracts
 
 
 @flexitest.register
-class ElShaPrecompileTest(testenv.StrataTester):
+class ElBlockhashOpcodeTest(testenv.StrataTester):
     def __init__(self, ctx: flexitest.InitContext):
         install_solc(version="0.8.16")
         set_solc_version("0.8.16")

functional-tests/tests/prover/prover_el_blockhash_opcode.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}")
 

functional-tests/tests/prover/prover_el_dispatch.py

@@ -12,7 +12,7 @@
 
 
 @flexitest.register
-class ElShaPrecompileTest(testenv.StrataTester):
+class ElPrecompileTest(testenv.StrataTester):
     def __init__(self, ctx: flexitest.InitContext):
         install_solc(version="0.8.16")
         set_solc_version("0.8.16")