feat: add deneb proofs

Author: ogenev

Diff for: bin/e2hs-writer/src/reader.rs

@@ -282,15 +282,16 @@ impl EpochReader {
 
 #[cfg(test)]
 mod tests {
-    use ethportal_api::types::{
-        consensus::{
-            beacon_block::{BeaconBlockBellatrix, BeaconBlockCapella},
-            beacon_state::BeaconState,
-            fork::ForkName,
-        },
-        execution::header_with_proof::{
-            build_historical_roots_proof, build_historical_summaries_proof,
-            BlockProofHistoricalRoots, BlockProofHistoricalSummaries,
+    use ethportal_api::{
+        consensus::beacon_block::BeaconBlock,
+        types::{
+            consensus::{
+                beacon_block::BeaconBlockBellatrix, beacon_state::BeaconState, fork::ForkName,
+            },
+            execution::header_with_proof::{
+                build_block_proof_historical_roots, build_historical_summaries_proof,
+                BlockProofHistoricalRoots, BlockProofHistoricalSummaries,
+            },
         },
     };
     use serde_yaml::Value;
@@ -336,7 +337,7 @@ mod tests {
         let block_path = format!("{test_assets_dir}/block.ssz");
         let block_raw = std::fs::read(block_path).unwrap();
         let block = BeaconBlockBellatrix::from_ssz_bytes(&block_raw).unwrap();
-        let proof = build_historical_roots_proof(slot, &historical_batch, block);
+        let proof = build_block_proof_historical_roots(slot, &historical_batch, &block);
 
         assert_eq!(actual_proof, proof);
     }
@@ -388,11 +389,41 @@ mod tests {
         let state_path = format!("{test_assets_dir}/beacon_state.ssz");
         let state_raw = std::fs::read(state_path).unwrap();
         let beacon_state = BeaconState::from_ssz_bytes(&state_raw, ForkName::Capella).unwrap();
-        let beacon_state = beacon_state.as_capella().unwrap();
         let block_path = format!("{test_assets_dir}/block.ssz");
         let block_raw = std::fs::read(block_path).unwrap();
-        let block = BeaconBlockCapella::from_ssz_bytes(&block_raw).unwrap();
-        let proof = build_historical_summaries_proof(slot, beacon_state, block);
+        let block = BeaconBlock::from_ssz_bytes(&block_raw, ForkName::Capella).unwrap();
+        let proof = build_historical_summaries_proof(slot, &beacon_state, &block);
+
+        assert_eq!(actual_proof, proof);
+    }
+    #[tokio::test]
+    async fn test_pre_pectra_proof_generation() {
+        let test_vector = std::fs::read_to_string(
+            "../../portal-spec-tests/tests/mainnet/history/headers_with_proof/block_proofs_deneb/beacon_block_proof-22162263.yaml"
+        )
+            .unwrap();
+        let test_vector: Value = serde_yaml::from_str(&test_vector).unwrap();
+        let actual_proof = BlockProofHistoricalSummaries {
+            beacon_block_proof: serde_yaml::from_value(test_vector["beacon_block_proof"].clone())
+                .unwrap(),
+            beacon_block_root: serde_yaml::from_value(test_vector["beacon_block_root"].clone())
+                .unwrap(),
+            execution_block_proof: serde_yaml::from_value(
+                test_vector["execution_block_proof"].clone(),
+            )
+            .unwrap(),
+            slot: serde_yaml::from_value(test_vector["slot"].clone()).unwrap(),
+        };
+
+        let test_assets_dir =
+            "../../portal-spec-tests/tests/mainnet/history/headers_with_proof/beacon_data/22162263";
+        let state_path = format!("{test_assets_dir}/beacon_state.ssz");
+        let state_raw = std::fs::read(state_path).unwrap();
+        let beacon_state = BeaconState::from_ssz_bytes(&state_raw, ForkName::Deneb).unwrap();
+        let block_path = format!("{test_assets_dir}/block.ssz");
+        let block_raw = std::fs::read(block_path).unwrap();
+        let block = BeaconBlock::from_ssz_bytes(&block_raw, ForkName::Deneb).unwrap();
+        let proof = build_historical_summaries_proof(11378687, &beacon_state, &block);
 
         assert_eq!(actual_proof, proof);
     }

Diff for: crates/ethportal-api/src/types/consensus/beacon_block.rs

@@ -69,31 +69,58 @@ impl BeaconBlock {
     }
 }
 
+/// Helper function to build a body root proof for a beacon block
+fn build_beacon_block_body_root_proof(
+    slot: u64,
+    proposer_index: u64,
+    parent_root: &B256,
+    state_root: &B256,
+    body_root: &B256,
+) -> Vec<B256> {
+    let leaves = vec![
+        slot.tree_hash_root().0,
+        proposer_index.tree_hash_root().0,
+        parent_root.tree_hash_root().0,
+        state_root.tree_hash_root().0,
+        body_root.tree_hash_root().0,
+    ];
+    // We want to prove the body root, which is the 5th leaf
+    build_merkle_proof_for_index(leaves, 4)
+}
+
 impl BeaconBlockCapella {
     pub fn build_body_root_proof(&self) -> Vec<B256> {
-        let leaves = vec![
-            self.slot.tree_hash_root().0,
-            self.proposer_index.tree_hash_root().0,
-            self.parent_root.tree_hash_root().0,
-            self.state_root.tree_hash_root().0,
-            self.body.tree_hash_root().0,
-        ];
-        // We want to prove the body root, which is the 5th leaf
-        build_merkle_proof_for_index(leaves, 4)
+        build_beacon_block_body_root_proof(
+            self.slot,
+            self.proposer_index,
+            &self.parent_root,
+            &self.state_root,
+            &self.body.tree_hash_root(),
+        )
     }
 }
 
 impl BeaconBlockBellatrix {
     pub fn build_body_root_proof(&self) -> Vec<B256> {
-        let leaves = vec![
-            self.slot.tree_hash_root().0,
-            self.proposer_index.tree_hash_root().0,
-            self.parent_root.tree_hash_root().0,
-            self.state_root.tree_hash_root().0,
-            self.body.tree_hash_root().0,
-        ];
-        // We want to prove the body root, which is the 5th leaf
-        build_merkle_proof_for_index(leaves, 4)
+        build_beacon_block_body_root_proof(
+            self.slot,
+            self.proposer_index,
+            &self.parent_root,
+            &self.state_root,
+            &self.body.tree_hash_root(),
+        )
+    }
+}
+
+impl BeaconBlockDeneb {
+    pub fn build_body_root_proof(&self) -> Vec<B256> {
+        build_beacon_block_body_root_proof(
+            self.slot,
+            self.proposer_index,
+            &self.parent_root,
+            &self.state_root,
+            &self.body.tree_hash_root(),
+        )
     }
 }
 

Diff for: crates/ethportal-api/src/types/consensus/beacon_state.rs

@@ -162,19 +162,29 @@ impl BeaconState {
     }
 }
 
+/// Helper function to build a block root proof from block roots
+fn build_block_root_proof_from_roots(
+    block_roots: &FixedVector<B256, SlotsPerHistoricalRoot>,
+    block_root_index: usize,
+) -> Vec<B256> {
+    let leaves: Vec<[u8; 32]> = block_roots
+        .iter()
+        .map(|root| root.tree_hash_root().0)
+        .collect();
+    build_merkle_proof_for_index(leaves, block_root_index)
+}
+
 impl BeaconStateCapella {
     pub fn build_block_root_proof(&self, block_root_index: usize) -> Vec<B256> {
-        // Build block hash proof for self.block_roots
-        let leaves: Vec<[u8; 32]> = self
-            .block_roots
-            .iter()
-            .map(|root| root.tree_hash_root().0)
-            .collect();
-        build_merkle_proof_for_index(leaves, block_root_index)
+        build_block_root_proof_from_roots(&self.block_roots, block_root_index)
     }
 }
 
 impl BeaconStateDeneb {
+    pub fn build_block_root_proof(&self, block_root_index: usize) -> Vec<B256> {
+        build_block_root_proof_from_roots(&self.block_roots, block_root_index)
+    }
+
     pub fn build_historical_summaries_proof(&self) -> Vec<B256> {
         let leaves = vec![
             self.genesis_time.tree_hash_root().0,

Diff for: crates/ethportal-api/src/types/consensus/body.rs

@@ -87,6 +87,34 @@ impl BeaconBlockBody {
     }
 }
 
+impl BeaconBlockBodyDeneb {
+    pub fn build_execution_payload_proof(&self) -> Vec<B256> {
+        let leaves = vec![
+            self.randao_reveal.tree_hash_root().0,
+            self.eth1_data.tree_hash_root().0,
+            self.graffiti.tree_hash_root().0,
+            self.proposer_slashings.tree_hash_root().0,
+            self.attester_slashings.tree_hash_root().0,
+            self.attestations.tree_hash_root().0,
+            self.deposits.tree_hash_root().0,
+            self.voluntary_exits.tree_hash_root().0,
+            self.sync_aggregate.tree_hash_root().0,
+            self.execution_payload.tree_hash_root().0,
+            self.bls_to_execution_changes.tree_hash_root().0,
+            self.blob_kzg_commitments.tree_hash_root().0,
+        ];
+        // We want to prove the 10th leaf
+        build_merkle_proof_for_index(leaves, 9)
+    }
+
+    pub fn build_execution_block_hash_proof(&self) -> Vec<B256> {
+        let mut block_hash_proof = self.execution_payload.build_block_hash_proof();
+        let execution_payload_proof = self.build_execution_payload_proof();
+        block_hash_proof.extend(execution_payload_proof);
+        block_hash_proof
+    }
+}
+
 impl BeaconBlockBodyCapella {
     pub fn build_execution_payload_proof(&self) -> Vec<B256> {
         let leaves = vec![

Diff for: crates/ethportal-api/src/types/consensus/execution_payload.rs

@@ -92,6 +92,31 @@ impl ExecutionPayload {
     }
 }
 
+impl ExecutionPayloadDeneb {
+    pub fn build_block_hash_proof(&self) -> Vec<B256> {
+        let leaves = vec![
+            self.parent_hash.tree_hash_root().0,
+            self.fee_recipient.tree_hash_root().0,
+            self.state_root.tree_hash_root().0,
+            self.receipts_root.tree_hash_root().0,
+            self.logs_bloom.tree_hash_root().0,
+            self.prev_randao.tree_hash_root().0,
+            self.block_number.tree_hash_root().0,
+            self.gas_limit.tree_hash_root().0,
+            self.gas_used.tree_hash_root().0,
+            self.timestamp.tree_hash_root().0,
+            self.extra_data.tree_hash_root().0,
+            self.base_fee_per_gas.tree_hash_root().0,
+            self.block_hash.tree_hash_root().0,
+            self.transactions.tree_hash_root().0,
+            self.withdrawals.tree_hash_root().0,
+            self.blob_gas_used.tree_hash_root().0,
+            self.excess_blob_gas.tree_hash_root().0,
+        ];
+        build_merkle_proof_for_index(leaves, 12)
+    }
+}
+
 impl ExecutionPayloadCapella {
     pub fn build_block_hash_proof(&self) -> Vec<B256> {
         let leaves = vec![