feat: add logic for creating header proof for pectra types

Author: morph-dev

bin/e2hs-writer/src/reader.rs

@@ -14,8 +14,8 @@ use ethportal_api::{
             block_body::BlockBody,
             header_with_proof::{
                 build_capella_historical_summaries_proof, build_deneb_historical_summaries_proof,
-                build_historical_roots_proof, BlockHeaderProof,
-                BlockProofHistoricalHashesAccumulator, HeaderWithProof,
+                build_electra_historical_summaries_proof, build_historical_roots_proof,
+                BlockHeaderProof, BlockProofHistoricalHashesAccumulator, HeaderWithProof,
             },
         },
         network_spec::network_spec,
@@ -33,6 +33,7 @@ use crate::{
     utils::{
         bellatrix_execution_payload_to_header, capella_execution_payload_to_header,
         lookup_epoch_acc, post_deneb_execution_payload_to_header,
+        post_electra_execution_payload_to_header,
     },
 };
 
@@ -241,6 +242,48 @@ impl EpochReader {
         })
     }
 
+    #[allow(dead_code)]
+    fn get_electra_block_data(&mut self, block_number: u64) -> anyhow::Result<AllBlockData> {
+        let (block, era) = self.era_provider.get_post_merge(block_number)?;
+        let block = block
+            .block
+            .message_electra()
+            .map_err(|e| anyhow!("Unable to decode ekectra block: {e:?}"))?;
+        let payload = &block.body.execution_payload;
+        let transactions = decode_transactions(&payload.transactions)?;
+        let withdrawals: Vec<Withdrawal> =
+            payload.withdrawals.iter().map(Withdrawal::from).collect();
+
+        let header_with_proof = HeaderWithProof {
+            header: post_electra_execution_payload_to_header(
+                payload,
+                block.parent_root,
+                &transactions,
+                &withdrawals,
+                &block.body.execution_requests,
+            )?,
+            proof: BlockHeaderProof::HistoricalSummariesDeneb(
+                build_electra_historical_summaries_proof(
+                    block.slot,
+                    &era.historical_batch.block_roots,
+                    block,
+                ),
+            ),
+        };
+        let body = BlockBody(AlloyBlockBody {
+            transactions,
+            ommers: vec![],
+            withdrawals: Some(Withdrawals::new(withdrawals)),
+        });
+        let receipts = self.get_receipts(block_number, header_with_proof.header.receipts_root)?;
+        Ok(AllBlockData {
+            block_number,
+            header_with_proof,
+            body,
+            receipts,
+        })
+    }
+
     pub fn iter_blocks(mut self) -> impl Iterator<Item = anyhow::Result<AllBlockData>> {
         (self.starting_block..self.ending_block).map(move |current_block| {
             if current_block

bin/e2hs-writer/src/utils.rs

@@ -10,7 +10,10 @@ use alloy::{
 };
 use anyhow::{anyhow, ensure};
 use ethportal_api::{
-    consensus::execution_payload::ExecutionPayloadDeneb,
+    consensus::{
+        execution_payload::{ExecutionPayloadDeneb, ExecutionPayloadElectra},
+        execution_requests::ExecutionRequests,
+    },
     types::{
         consensus::execution_payload::{ExecutionPayloadBellatrix, ExecutionPayloadCapella},
         execution::accumulator::EpochAccumulator,
@@ -134,6 +137,46 @@ pub fn post_deneb_execution_payload_to_header(
     Ok(header)
 }
 
+pub fn post_electra_execution_payload_to_header(
+    payload: &ExecutionPayloadElectra,
+    parent_beacon_block_root: B256,
+    transactions: &[TxEnvelope],
+    withdrawals: &[Withdrawal],
+    _requests: &ExecutionRequests,
+) -> anyhow::Result<Header> {
+    let transactions_root = calculate_transaction_root(transactions);
+    let withdrawals_root = calculate_withdrawals_root(withdrawals);
+    let header = Header {
+        parent_hash: payload.parent_hash,
+        ommers_hash: EMPTY_UNCLE_ROOT_HASH,
+        beneficiary: payload.fee_recipient,
+        state_root: payload.state_root,
+        transactions_root,
+        receipts_root: payload.receipts_root,
+        logs_bloom: Bloom::from_slice(payload.logs_bloom.to_vec().as_slice()),
+        difficulty: U256::ZERO,
+        number: payload.block_number,
+        gas_limit: payload.gas_limit,
+        gas_used: payload.gas_used,
+        timestamp: payload.timestamp,
+        extra_data: payload.extra_data.to_vec().into(),
+        mix_hash: payload.prev_randao,
+        nonce: B64::ZERO,
+        base_fee_per_gas: Some(payload.base_fee_per_gas.to()),
+        withdrawals_root: Some(withdrawals_root),
+        blob_gas_used: Some(payload.blob_gas_used),
+        excess_blob_gas: Some(payload.excess_blob_gas),
+        parent_beacon_block_root: Some(parent_beacon_block_root),
+        requests_hash: None, // TODO
+    };
+
+    ensure!(
+        payload.block_hash == header.hash_slow(),
+        "Block hash mismatch"
+    );
+    Ok(header)
+}
+
 /// Lookup the epoch accumulator & epoch hash for the given epoch index.
 pub async fn lookup_epoch_acc(
     epoch_index: u64,

crates/ethportal-api/src/types/consensus/beacon_block.rs

@@ -144,6 +144,29 @@ impl BeaconBlockDeneb {
     }
 }
 
+impl BeaconBlockElectra {
+    pub fn build_body_root_proof(&self) -> Vec<B256> {
+        let leaves = [
+            self.slot.tree_hash_root(),
+            self.proposer_index.tree_hash_root(),
+            self.parent_root.tree_hash_root(),
+            self.state_root.tree_hash_root(),
+            self.body.tree_hash_root(),
+        ];
+        // We want to prove the body root, which is the 5th leaf
+        build_merkle_proof_for_index(leaves, 4)
+    }
+
+    pub fn build_execution_block_hash_proof(&self) -> Vec<B256> {
+        [
+            self.body.execution_payload.build_block_hash_proof(),
+            self.body.build_execution_payload_proof(),
+            self.build_body_root_proof(),
+        ]
+        .concat()
+    }
+}
+
 /// A `BeaconBlock` and a signature from its proposer.
 #[superstruct(
     variants(Bellatrix, Capella, Deneb, Electra),

crates/ethportal-api/src/types/consensus/body.rs

@@ -168,6 +168,28 @@ impl BeaconBlockBodyDeneb {
     }
 }
 
+impl BeaconBlockBodyElectra {
+    pub fn build_execution_payload_proof(&self) -> Vec<B256> {
+        let leaves = [
+            self.randao_reveal.tree_hash_root(),
+            self.eth1_data.tree_hash_root(),
+            self.graffiti.tree_hash_root(),
+            self.proposer_slashings.tree_hash_root(),
+            self.attester_slashings.tree_hash_root(),
+            self.attestations.tree_hash_root(),
+            self.deposits.tree_hash_root(),
+            self.voluntary_exits.tree_hash_root(),
+            self.sync_aggregate.tree_hash_root(),
+            self.execution_payload.tree_hash_root(),
+            self.bls_to_execution_changes.tree_hash_root(),
+            self.blob_kzg_commitments.tree_hash_root(),
+            self.execution_requests.tree_hash_root(),
+        ];
+        // We want to prove the 10th leaf
+        build_merkle_proof_for_index(leaves, 9)
+    }
+}
+
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize, Decode, Encode, TreeHash)]
 pub struct SyncAggregate {
     pub sync_committee_bits: BitVector<typenum::U512>,

crates/ethportal-api/src/types/consensus/execution_payload.rs

@@ -163,6 +163,31 @@ impl ExecutionPayloadDeneb {
     }
 }
 
+impl ExecutionPayloadElectra {
+    pub fn build_block_hash_proof(&self) -> Vec<B256> {
+        let leaves = [
+            self.parent_hash.tree_hash_root(),
+            self.fee_recipient.tree_hash_root(),
+            self.state_root.tree_hash_root(),
+            self.receipts_root.tree_hash_root(),
+            self.logs_bloom.tree_hash_root(),
+            self.prev_randao.tree_hash_root(),
+            self.block_number.tree_hash_root(),
+            self.gas_limit.tree_hash_root(),
+            self.gas_used.tree_hash_root(),
+            self.timestamp.tree_hash_root(),
+            self.extra_data.tree_hash_root(),
+            self.base_fee_per_gas.tree_hash_root(),
+            self.block_hash.tree_hash_root(),
+            self.transactions.tree_hash_root(),
+            self.withdrawals.tree_hash_root(),
+            self.blob_gas_used.tree_hash_root(),
+            self.excess_blob_gas.tree_hash_root(),
+        ];
+        build_merkle_proof_for_index(leaves, 12)
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize, Encode, Decode, TreeHash)]
 pub struct Withdrawal {
     #[serde(deserialize_with = "as_u64")]

crates/ethportal-api/src/types/execution/header_with_proof.rs

@@ -9,7 +9,8 @@ use tree_hash::TreeHash;
 
 use crate::{
     consensus::{
-        beacon_block::BeaconBlockDeneb, beacon_state::RootsPerHistoricalRoot,
+        beacon_block::{BeaconBlockDeneb, BeaconBlockElectra},
+        beacon_state::RootsPerHistoricalRoot,
         constants::SLOTS_PER_HISTORICAL_ROOT,
     },
     types::{
@@ -200,7 +201,7 @@ pub fn build_historical_roots_proof(
     }
 }
 
-/// Builds `BlockProofHistoricalSummariesCapella` for a given slot.
+/// Builds `BlockProofHistoricalSummariesCapella` for a given slot, from Capella `BeaconBlock`.
 ///
 /// The `block_roots` represents the `block_roots` fields from `BeaconState`.
 pub fn build_capella_historical_summaries_proof(
@@ -227,7 +228,7 @@ pub fn build_capella_historical_summaries_proof(
     }
 }
 
-/// Builds `BlockProofHistoricalSummariesDeneb` for a given slot.
+/// Builds `BlockProofHistoricalSummariesDeneb` for a given slot, from Deneb `BeaconBlock`.
 ///
 /// The `block_roots` represents the `block_roots` fields from `BeaconState`.
 pub fn build_deneb_historical_summaries_proof(
@@ -254,6 +255,33 @@ pub fn build_deneb_historical_summaries_proof(
     }
 }
 
+/// Builds `BlockProofHistoricalSummariesDeneb` for a given slot, from Electra `BeaconBlock`.
+///
+/// The `block_roots` represents the `block_roots` fields from `BeaconState`.
+pub fn build_electra_historical_summaries_proof(
+    slot: u64,
+    block_roots: &RootsPerHistoricalRoot,
+    beacon_block: &BeaconBlockElectra,
+) -> BlockProofHistoricalSummariesDeneb {
+    let beacon_block_proof = build_merkle_proof_for_index(
+        block_roots.clone(),
+        slot as usize % SLOTS_PER_HISTORICAL_ROOT,
+    );
+    let beacon_block_proof = BeaconBlockProofHistoricalSummaries::new(beacon_block_proof)
+        .expect("error creating BeaconBlockProofHistoricalSummaries");
+
+    let execution_block_proof =
+        ExecutionBlockProofDeneb::new(beacon_block.build_execution_block_hash_proof())
+            .expect("error creating ExecutionBlockProofDeneb");
+
+    BlockProofHistoricalSummariesDeneb {
+        beacon_block_proof,
+        beacon_block_root: beacon_block.tree_hash_root(),
+        execution_block_proof,
+        slot,
+    }
+}
+
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod tests {