refactor: move block/header builder for ephemeral bridge (#1828)

Author: KolbyML

Cargo.lock

@@ -69,6 +69,7 @@ quickcheck = "1.0.3"
 r2d2 = "0.8.9"
 r2d2_sqlite = "0.24.0"
 rand = "0.8.5"
+rayon = "1.10.0"
 reqwest = { version = "0.12.7", features = ["native-tls-vendored", "json"] }
 reth-ipc = { tag = "v1.0.8", git = "https://github.com/paradigmxyz/reth.git"}
 revm = { version = "22.0", default-features = false, features = ["std", "secp256k1", "serde-json", "c-kzg"] }

Cargo.toml

@@ -2,20 +2,20 @@ use std::path::PathBuf;
 
 use anyhow::ensure;
 use e2store::e2hs::{E2HSWriter, BLOCKS_PER_E2HS};
-use ethportal_api::consensus::{
-    beacon_block::BeaconBlockElectra, beacon_state::HistoricalBatch,
-    historical_summaries::historical_summary_index,
+use ethportal_api::{
+    consensus::{
+        beacon_block::BeaconBlockElectra, beacon_state::HistoricalBatch,
+        historical_summaries::historical_summary_index,
+    },
+    types::execution::builders::block::ExecutionBlockBuilder,
 };
 use ssz_types::FixedVector;
 use tempfile::TempDir;
 use tracing::info;
 use trin_validation::header_validator::HeaderValidator;
 
 use super::ethereum_api::EthereumApi;
-use crate::{
-    cli::HeadGeneratorConfig,
-    subcommands::{execution_block_builder::ExecutionBlockBuilder, full_block::FullBlock},
-};
+use crate::{cli::HeadGeneratorConfig, subcommands::full_block::FullBlock};
 
 struct ProvingAnchors {
     current_historical_batch: HistoricalBatch,

bin/e2hs-writer/src/subcommands/head_generator/e2hs_builder.rs

@@ -1,5 +1,3 @@
-pub mod execution_block_builder;
-pub mod execution_header_builder;
 pub mod full_block;
 pub mod head_generator;
 pub mod single_generator;

bin/e2hs-writer/src/subcommands/mod.rs

@@ -11,10 +11,10 @@ use anyhow::{anyhow, bail, ensure};
 use async_stream::stream;
 use e2store::e2hs::{E2HSWriter, BLOCKS_PER_E2HS};
 use ethportal_api::{
-    consensus::beacon_block::SignedBeaconBlock,
     types::{
         execution::{
             accumulator::EpochAccumulator,
+            builders::block::ExecutionBlockBuilder,
             header_with_proof::{
                 BlockHeaderProof, BlockProofHistoricalHashesAccumulator, HeaderWithProof,
             },
@@ -32,7 +32,7 @@ use trin_validation::{accumulator::PreMergeAccumulator, header_validator::Header
 use url::Url;
 
 use super::provider::EraProvider;
-use crate::subcommands::{execution_block_builder::ExecutionBlockBuilder, full_block::FullBlock};
+use crate::subcommands::full_block::FullBlock;
 
 // This struct reads all blocks in an index and creates the block data
 // along with the corresponding proofs required to create an E2HS file.
@@ -148,20 +148,7 @@ impl E2HSBuilder {
             block.execution_block_number()
         );
 
-        let (header_with_proof, body) = match &block {
-            SignedBeaconBlock::Bellatrix(beacon_block) => {
-                ExecutionBlockBuilder::bellatrix(&beacon_block.message, historical_batch)?
-            }
-            SignedBeaconBlock::Capella(beacon_block) => {
-                ExecutionBlockBuilder::capella(&beacon_block.message, historical_batch)?
-            }
-            SignedBeaconBlock::Deneb(beacon_block) => {
-                ExecutionBlockBuilder::deneb(&beacon_block.message, historical_batch)?
-            }
-            SignedBeaconBlock::Electra(beacon_block) => {
-                ExecutionBlockBuilder::electra(&beacon_block.message, historical_batch)?
-            }
-        };
+        let (header_with_proof, body) = ExecutionBlockBuilder::build(block, historical_batch)?;
 
         let receipts = self.get_receipts(block_number, header_with_proof.header.receipts_root)?;
 

bin/e2hs-writer/src/subcommands/single_generator/e2hs_builder.rs

@@ -28,7 +28,7 @@ lazy_static.workspace = true
 parking_lot.workspace = true
 prometheus_exporter.workspace = true
 rand.workspace = true
-rayon = "1.10.0"
+rayon.workspace = true
 reqwest =  { workspace = true, features = ["stream"] }
 revm.workspace = true
 revm-inspectors = "0.20.0"

bin/trin-execution/Cargo.toml

@@ -1,27 +1,15 @@
-use alloy::{
-    consensus::{
-        proofs::{calculate_transaction_root, calculate_withdrawals_root},
-        Header, TxEnvelope,
-    },
-    eips::eip4895::Withdrawal,
-    primitives::{Bloom, B64},
-    rlp::Decodable,
-};
-use ethportal_api::consensus::{
-    beacon_block::{
+use alloy::{consensus::TxEnvelope, eips::eip4895::Withdrawal};
+use ethportal_api::{
+    consensus::beacon_block::{
         SignedBeaconBlock, SignedBeaconBlockBellatrix, SignedBeaconBlockCapella,
         SignedBeaconBlockDeneb, SignedBeaconBlockElectra,
     },
-    body::Transactions,
+    types::execution::builders::{block::decode_transactions, header::ExecutionHeaderBuilder},
 };
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use revm_primitives::{b256, B256, U256};
 
 use super::types::{ProcessedBlock, TransactionsWithSender};
 
-pub const EMPTY_UNCLE_ROOT_HASH: B256 =
-    b256!("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347");
-
 pub trait ProcessBeaconBlock {
     fn process_beacon_block(&self) -> anyhow::Result<ProcessedBlock>;
 }
@@ -42,35 +30,11 @@ impl ProcessBeaconBlock for SignedBeaconBlockBellatrix {
         let payload = &self.message.body.execution_payload;
 
         let transactions = decode_transactions(&payload.transactions)?;
-        let transactions_root = calculate_transaction_root(&transactions);
+        let header = ExecutionHeaderBuilder::bellatrix(payload, &transactions)?;
         let transactions = process_transactions(transactions)?;
 
-        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: None,
-            blob_gas_used: None,
-            excess_blob_gas: None,
-            parent_beacon_block_root: None,
-            requests_hash: None,
-        };
-
         Ok(ProcessedBlock {
-            header: header.clone(),
+            header,
             uncles: None,
             withdrawals: None,
             transactions,
@@ -83,39 +47,13 @@ impl ProcessBeaconBlock for SignedBeaconBlockCapella {
         let payload = &self.message.body.execution_payload;
 
         let transactions = decode_transactions(&payload.transactions)?;
-        let transactions_root = calculate_transaction_root(&transactions);
-        let transactions = process_transactions(transactions)?;
-
         let withdrawals: Vec<Withdrawal> =
             payload.withdrawals.iter().map(Withdrawal::from).collect();
-        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: None,
-            excess_blob_gas: None,
-            parent_beacon_block_root: None,
-            requests_hash: None,
-        };
+        let header = ExecutionHeaderBuilder::capella(payload, &transactions, &withdrawals)?;
+        let transactions = process_transactions(transactions)?;
 
         Ok(ProcessedBlock {
-            header: header.clone(),
+            header,
             uncles: None,
             withdrawals: Some(withdrawals),
             transactions,
@@ -128,39 +66,18 @@ impl ProcessBeaconBlock for SignedBeaconBlockDeneb {
         let payload = &self.message.body.execution_payload;
 
         let transactions = decode_transactions(&payload.transactions)?;
-        let transactions_root = calculate_transaction_root(&transactions);
-        let transactions = process_transactions(transactions)?;
-
         let withdrawals: Vec<Withdrawal> =
             payload.withdrawals.iter().map(Withdrawal::from).collect();
-        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(self.message.parent_root),
-            requests_hash: None,
-        };
+        let header = ExecutionHeaderBuilder::deneb(
+            payload,
+            self.message.parent_root,
+            &transactions,
+            &withdrawals,
+        )?;
+        let transactions = process_transactions(transactions)?;
 
         Ok(ProcessedBlock {
-            header: header.clone(),
+            header,
             uncles: None,
             withdrawals: Some(withdrawals),
             transactions,
@@ -173,36 +90,16 @@ impl ProcessBeaconBlock for SignedBeaconBlockElectra {
         let payload = &self.message.body.execution_payload;
 
         let transactions = decode_transactions(&payload.transactions)?;
-        let transactions_root = calculate_transaction_root(&transactions);
-        let transactions = process_transactions(transactions)?;
-
         let withdrawals: Vec<Withdrawal> =
             payload.withdrawals.iter().map(Withdrawal::from).collect();
-        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(self.message.parent_root),
-            requests_hash: Some(self.message.body.execution_requests.requests_hash()),
-        };
+        let header = ExecutionHeaderBuilder::electra(
+            payload,
+            self.message.parent_root,
+            &transactions,
+            &withdrawals,
+            &self.message.body.execution_requests,
+        )?;
+        let transactions = process_transactions(transactions)?;
 
         Ok(ProcessedBlock {
             header: header.clone(),
@@ -213,16 +110,6 @@ impl ProcessBeaconBlock for SignedBeaconBlockElectra {
     }
 }
 
-pub fn decode_transactions(transactions: &Transactions) -> anyhow::Result<Vec<TxEnvelope>> {
-    transactions
-        .into_par_iter()
-        .map(|raw_tx| {
-            TxEnvelope::decode(&mut &**raw_tx)
-                .map_err(|err| anyhow::anyhow!("Failed decoding transaction rlp: {err:?}"))
-        })
-        .collect::<anyhow::Result<Vec<_>>>()
-}
-
 fn process_transactions(
     transactions: Vec<TxEnvelope>,
 ) -> anyhow::Result<Vec<TransactionsWithSender>> {

bin/trin-execution/src/era/beacon.rs

@@ -37,6 +37,7 @@ once_cell = "1.17"
 parking_lot.workspace = true
 quickcheck.workspace = true
 rand.workspace = true
+rayon.workspace = true
 rs_merkle = "1.4.2"
 secp256k1 = { version = "0.29.0", features = ["global-context", "recovery", "rand"] }
 serde = { workspace = true, features = ["rc"] }