feat: add support for historical block proofs up to 24h (#36)

* feat: allow to prove onchain up to 24h using beacon roots

* chore: add docs

Author: leruaa

Cargo.lock

@@ -31,6 +31,7 @@ tokio = { version = "1.21", default-features = false, features = [
 ] }
 serde_json = "1.0.94"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
+reqwest = "0.12.15"
 url = "2.3"
 hex-literal = "0.4.1"
 bincode = "1.3.3"
@@ -96,7 +97,9 @@ revm-primitives = { version = "18.0.0", features = [
 # alloy
 alloy-primitives = "1.0"
 alloy-consensus = { version = "0.14.0", default-features = false }
+alloy-contract = { version = "0.14.0", default-features = false }
 alloy-eips = { version = "0.14.0", default-features = false }
+alloy-node-bindings = { version = "0.14.0", default-features = false }
 alloy-provider = { version = "0.14.0", default-features = false, features = [
     "reqwest",
 ] }
@@ -115,6 +118,11 @@ alloy = { version = "0.14.0" }
 
 alloy-evm = { version = "0.4.0", default-features = false }
 
+sha2 = "0.10.8"
+beacon-api-client = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "ba43147eb71b07e21e156e2904549405f87bc9a6" }
+ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "ba43147eb71b07e21e156e2904549405f87bc9a6" }
+async-trait = "0.1.88"
+
 [workspace.lints]
 rust.missing_debug_implementations = "warn"
 rust.unreachable_pub = "warn"

Cargo.toml

@@ -11,6 +11,7 @@ workspace = true
 [dependencies]
 eyre.workspace = true
 serde.workspace = true
+sha2.workspace = true
 serde_with = "3.12.0"
 thiserror.workspace = true
 

crates/client-executor/Cargo.toml

@@ -0,0 +1,105 @@
+use alloy_consensus::Header;
+use alloy_primitives::{B256, U256};
+use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
+use sha2::{Digest, Sha256};
+
+use crate::AnchorType;
+
+/// The generalized Merkle tree index of the `block_hash` field in the `BeaconBlock`.
+pub const BLOCK_HASH_LEAF_INDEX: usize = 6444;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum Anchor {
+    Header(HeaderAnchor),
+    Beacon(BeaconAnchor),
+}
+
+impl Anchor {
+    pub fn header(&self) -> &Header {
+        match self {
+            Anchor::Header(header_anchor) => &header_anchor.header,
+            Anchor::Beacon(beacon_anchor) => &beacon_anchor.inner.header,
+        }
+    }
+
+    pub fn id(&self) -> U256 {
+        match self {
+            Anchor::Header(header_anchor) => U256::from(header_anchor.header.number),
+            Anchor::Beacon(beacon_anchor) => U256::from(beacon_anchor.timestamp),
+        }
+    }
+
+    pub fn hash(&self) -> B256 {
+        match self {
+            Anchor::Header(header_anchor) => header_anchor.header.hash_slow(),
+            Anchor::Beacon(beacon_anchor) => {
+                let block_hash = beacon_anchor.inner.header.hash_slow();
+
+                rebuild_merkle_root(block_hash, BLOCK_HASH_LEAF_INDEX, &beacon_anchor.proof)
+            }
+        }
+    }
+
+    pub fn ty(&self) -> AnchorType {
+        match self {
+            Anchor::Header(_) => AnchorType::BlockHash,
+            Anchor::Beacon(_) => AnchorType::BeaconRoot,
+        }
+    }
+}
+
+impl From<Header> for Anchor {
+    fn from(header: Header) -> Self {
+        Self::Header(HeaderAnchor { header })
+    }
+}
+
+#[serde_as]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct HeaderAnchor {
+    #[serde_as(as = "alloy_consensus::serde_bincode_compat::Header")]
+    header: Header,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct BeaconAnchor {
+    inner: HeaderAnchor,
+    proof: Vec<B256>,
+    timestamp: u64,
+}
+
+impl BeaconAnchor {
+    pub fn new(header: Header, proof: Vec<B256>, timestamp: u64) -> Self {
+        Self { inner: HeaderAnchor { header }, proof, timestamp }
+    }
+}
+
+pub fn rebuild_merkle_root(leaf: B256, generalized_index: usize, branch: &[B256]) -> B256 {
+    let mut current_hash = leaf;
+    let depth = generalized_index.ilog2();
+    let mut index = generalized_index - (1 << depth);
+    let mut hasher = Sha256::new();
+
+    for sibling in branch {
+        // Determine if the current node is a left or right child
+        let is_left = index % 2 == 0;
+
+        // Combine the current hash with the sibling hash
+        if is_left {
+            // If current node is left child, hash(current + sibling)
+            hasher.update(current_hash);
+            hasher.update(sibling);
+        } else {
+            // If current node is right child, hash(sibling + current)
+            hasher.update(sibling);
+            hasher.update(current_hash);
+        }
+        current_hash.copy_from_slice(&hasher.finalize_reset());
+
+        // Move up to the parent level
+        index /= 2;
+    }
+
+    current_hash
+}

crates/client-executor/src/anchor.rs

@@ -10,19 +10,20 @@ use rsp_primitives::genesis::Genesis;
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 
+use crate::Anchor;
+
 /// Information about how the contract executions accessed state, which is needed to execute the
 /// contract in SP1.
 ///
 /// Instead of passing in the entire state, only the state roots and merkle proofs
 /// for the storage slots that were modified and accessed are passed in.
 #[serde_as]
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct EVMStateSketch {
+pub struct EvmSketchInput {
+    /// The current block anchor.
+    pub anchor: Anchor,
     /// The genesis block specification.
     pub genesis: Genesis,
-    /// The current block header.
-    #[serde_as(as = "alloy_consensus::serde_bincode_compat::Header")]
-    pub header: Header,
     /// The previous block headers starting from the most recent. These are used for calls to the
     /// blockhash opcode.
     #[serde_as(as = "Vec<alloy_consensus::serde_bincode_compat::Header>")]
@@ -34,19 +35,19 @@ pub struct EVMStateSketch {
     /// Account bytecodes.
     pub bytecodes: Vec<Bytecode>,
     /// Receipts.
-    #[serde_as(as = "Vec<alloy_consensus::serde_bincode_compat::ReceiptEnvelope>")]
-    pub receipts: Vec<ReceiptEnvelope>,
+    #[serde_as(as = "Option<Vec<alloy_consensus::serde_bincode_compat::ReceiptEnvelope>>")]
+    pub receipts: Option<Vec<ReceiptEnvelope>>,
 }
 
-impl WitnessInput for EVMStateSketch {
+impl WitnessInput for EvmSketchInput {
     #[inline(always)]
     fn state(&self) -> &EthereumState {
         &self.state
     }
 
     #[inline(always)]
     fn state_anchor(&self) -> B256 {
-        self.header.state_root
+        self.anchor.header().state_root
     }
 
     #[inline(always)]
@@ -61,6 +62,6 @@ impl WitnessInput for EVMStateSketch {
 
     #[inline(always)]
     fn headers(&self) -> impl Iterator<Item = &Header> {
-        once(&self.header).chain(self.ancestor_headers.iter())
+        once(self.anchor.header()).chain(self.ancestor_headers.iter())
     }
 }

crates/client-executor/src/io.rs

@@ -8,7 +8,7 @@ use alloy_rpc_types::{Filter, FilteredParams};
 use alloy_sol_types::{sol, SolCall, SolEvent};
 use alloy_trie::root::ordered_trie_root_with_encoder;
 use eyre::OptionExt;
-use io::EVMStateSketch;
+use io::EvmSketchInput;
 use reth_chainspec::ChainSpec;
 use reth_evm::{ConfigureEvm, EvmEnv};
 use reth_evm_ethereum::{EthEvm, EthEvmConfig};
@@ -20,6 +20,9 @@ use revm_primitives::{Address, Bytes, TxKind, B256, U256};
 use rsp_client_executor::io::{TrieDB, WitnessInput};
 use rsp_primitives::genesis::Genesis;
 
+mod anchor;
+pub use anchor::{rebuild_merkle_root, Anchor, BeaconAnchor, HeaderAnchor, BLOCK_HASH_LEAF_INDEX};
+
 mod errors;
 pub use errors::ClientError;
 
@@ -100,11 +103,17 @@ impl IntoTxEnv<TxEnv> for &ContractInput {
 }
 
 sol! {
+    #[derive(Debug)]
+    enum AnchorType { BlockHash, BeaconRoot }
+
     /// Public values of a contract call.
     ///
     /// These outputs can easily be abi-encoded, for use on-chain.
+    #[derive(Debug)]
     struct ContractPublicValues {
-        bytes32 blockHash;
+        uint256 id;
+        bytes32 anchorHash;
+        AnchorType anchorType;
         address callerAddress;
         address contractAddress;
         bytes contractCalldata;
@@ -117,46 +126,65 @@ impl ContractPublicValues {
     ///
     /// By default, commit the contract input, the output, and the block hash to public values of
     /// the proof. More can be committed if necessary.
-    pub fn new(call: ContractInput, output: Bytes, block_hash: B256) -> Self {
+    pub fn new(
+        call: ContractInput,
+        output: Bytes,
+        id: U256,
+        anchor: B256,
+        anchor_type: AnchorType,
+    ) -> Self {
         Self {
+            id,
+            anchorHash: anchor,
+            anchorType: anchor_type,
             contractAddress: call.contract_address,
             callerAddress: call.caller_address,
             contractCalldata: call.calldata.to_bytes(),
             contractOutput: output,
-            blockHash: block_hash,
         }
     }
 }
 
 /// An executor that executes smart contract calls inside a zkVM.
 #[derive(Debug)]
 pub struct ClientExecutor<'a> {
+    /// The block anchor.
+    pub anchor: &'a Anchor,
     /// The genesis block specification.
     pub genesis: &'a Genesis,
     /// The database that the executor uses to access state.
     pub witness_db: TrieDB<'a>,
-    /// The block header.
-    pub header: &'a Header,
     /// All logs in the block.
     pub logs: Vec<Log>,
 }
 
 impl<'a> ClientExecutor<'a> {
     /// Instantiates a new [`ClientExecutor`]
-    pub fn new(state_sketch: &'a EVMStateSketch) -> Result<Self, ClientError> {
-        if !state_sketch.receipts.is_empty() {
+    pub fn new(state_sketch: &'a EvmSketchInput) -> Result<Self, ClientError> {
+        assert_eq!(
+            state_sketch.anchor.header().state_root,
+            state_sketch.state.state_root(),
+            "State root mismatch"
+        );
+
+        if let Some(receipts) = &state_sketch.receipts {
             // verify the receipts root hash
-            let root =
-                ordered_trie_root_with_encoder(&state_sketch.receipts, |r, out| r.encode_2718(out));
-            assert_eq!(state_sketch.header.receipts_root, root, "Receipts root mismatch");
+            let root = ordered_trie_root_with_encoder(receipts, |r, out| r.encode_2718(out));
+            assert_eq!(state_sketch.anchor.header().receipts_root, root, "Receipts root mismatch");
         }
 
-        let logs = state_sketch.receipts.iter().flat_map(|r| r.logs().to_vec()).collect();
+        let logs = state_sketch
+            .receipts
+            .as_ref()
+            .unwrap_or(&vec![])
+            .iter()
+            .flat_map(|r| r.logs().to_vec())
+            .collect();
 
         Ok(Self {
+            anchor: &state_sketch.anchor,
             genesis: &state_sketch.genesis,
             witness_db: state_sketch.witness_db()?,
-            header: &state_sketch.header,
             logs,
         })
     }
@@ -166,10 +194,19 @@ impl<'a> ClientExecutor<'a> {
     /// Storage accesses are already validated against the `witness_db`'s state root.
     pub fn execute(&self, call: ContractInput) -> eyre::Result<ContractPublicValues> {
         let cache_db = CacheDB::new(&self.witness_db);
-        let mut evm = new_evm(cache_db, self.header, U256::ZERO, self.genesis);
+        let mut evm = new_evm(cache_db, self.anchor.header(), U256::ZERO, self.genesis);
         let tx_output = evm.transact(&call)?;
         let tx_output_bytes = tx_output.result.output().ok_or_eyre("Error decoding result")?;
-        Ok(ContractPublicValues::new(call, tx_output_bytes.clone(), self.header.hash_slow()))
+
+        let public_values = ContractPublicValues::new(
+            call,
+            tx_output_bytes.clone(),
+            self.anchor.id(),
+            self.anchor.hash(),
+            self.anchor.ty(),
+        );
+
+        Ok(public_values)
     }
 
     /// Returns the decoded logs matching the provided `filter`.

crates/client-executor/src/lib.rs

@@ -9,7 +9,10 @@ license.workspace = true
 workspace = true
 
 [dependencies]
+async-trait.workspace = true
 eyre.workspace = true
+reqwest.workspace = true
+serde.workspace = true
 url.workspace = true
 tokio.workspace = true
 tracing.workspace = true
@@ -38,8 +41,10 @@ alloy-sol-types.workspace = true
 alloy-rpc-types.workspace = true
 alloy-evm.workspace = true
 
+ethereum-consensus.workspace = true
+
 [dev-dependencies]
 alloy-primitives.workspace = true
+dotenv.workspace = true
 tracing-subscriber = "0.3.18"
 bincode = "1.3.3"
-dotenv.workspace = true