chore(anvil): use Block and Header from Alloy (#12533)

* chore(anvil): replace `PartialHeader` with `Header` from Alloy

* chore(anvil): replace `Block` w/ Alloy's `Block`/`BlockBody` structs

* fix: `BlockchainStorage` header init

Author: mablr

crates/anvil/core/src/eth/block.rs

@@ -1,11 +1,14 @@
 use super::transaction::{TransactionInfo, TypedReceipt};
-use alloy_consensus::{EMPTY_OMMER_ROOT_HASH, Header, proofs::calculate_transaction_root};
-use alloy_primitives::{Address, B64, B256, Bloom, Bytes, U256};
-use alloy_rlp::{RlpDecodable, RlpEncodable};
+use alloy_consensus::{
+    BlockBody, EMPTY_OMMER_ROOT_HASH, Header, proofs::calculate_transaction_root,
+};
 
 // Type alias to optionally support impersonated transactions
 type Transaction = crate::eth::transaction::MaybeImpersonatedTransaction;
 
+/// Type alias for Ethereum Block with Anvil's transaction type
+pub type Block = alloy_consensus::Block<Transaction>;
+
 /// Container type that gathers all block data
 #[derive(Clone, Debug)]
 pub struct BlockInfo {
@@ -14,110 +17,28 @@ pub struct BlockInfo {
     pub receipts: Vec<TypedReceipt>,
 }
 
-/// An Ethereum Block
-#[derive(Clone, Debug, PartialEq, Eq, RlpEncodable, RlpDecodable)]
-pub struct Block {
-    pub header: Header,
-    pub transactions: Vec<Transaction>,
-    pub ommers: Vec<Header>,
-}
-
-impl Block {
-    /// Creates a new block.
-    ///
-    /// Note: if the `impersonate-tx` feature is enabled this will also accept
-    /// `MaybeImpersonatedTransaction`.
-    pub fn new<T>(partial_header: PartialHeader, transactions: impl IntoIterator<Item = T>) -> Self
-    where
-        T: Into<Transaction>,
-    {
-        let transactions: Vec<_> = transactions.into_iter().map(Into::into).collect();
-        let transactions_root = calculate_transaction_root(&transactions);
-
-        Self {
-            header: Header {
-                parent_hash: partial_header.parent_hash,
-                beneficiary: partial_header.beneficiary,
-                ommers_hash: EMPTY_OMMER_ROOT_HASH,
-                state_root: partial_header.state_root,
-                transactions_root,
-                receipts_root: partial_header.receipts_root,
-                logs_bloom: partial_header.logs_bloom,
-                difficulty: partial_header.difficulty,
-                number: partial_header.number,
-                gas_limit: partial_header.gas_limit,
-                gas_used: partial_header.gas_used,
-                timestamp: partial_header.timestamp,
-                extra_data: partial_header.extra_data,
-                mix_hash: partial_header.mix_hash,
-                withdrawals_root: partial_header.withdrawals_root,
-                blob_gas_used: partial_header.blob_gas_used,
-                excess_blob_gas: partial_header.excess_blob_gas,
-                parent_beacon_block_root: partial_header.parent_beacon_block_root,
-                nonce: partial_header.nonce,
-                base_fee_per_gas: partial_header.base_fee,
-                requests_hash: partial_header.requests_hash,
-            },
-            transactions,
-            ommers: vec![],
-        }
-    }
-}
-
-/// Partial header definition without ommers hash and transactions root
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct PartialHeader {
-    pub parent_hash: B256,
-    pub beneficiary: Address,
-    pub state_root: B256,
-    pub receipts_root: B256,
-    pub logs_bloom: Bloom,
-    pub difficulty: U256,
-    pub number: u64,
-    pub gas_limit: u64,
-    pub gas_used: u64,
-    pub timestamp: u64,
-    pub extra_data: Bytes,
-    pub mix_hash: B256,
-    pub blob_gas_used: Option<u64>,
-    pub excess_blob_gas: Option<u64>,
-    pub parent_beacon_block_root: Option<B256>,
-    pub nonce: B64,
-    pub base_fee: Option<u64>,
-    pub withdrawals_root: Option<B256>,
-    pub requests_hash: Option<B256>,
-}
-
-impl From<Header> for PartialHeader {
-    fn from(value: Header) -> Self {
-        Self {
-            parent_hash: value.parent_hash,
-            beneficiary: value.beneficiary,
-            state_root: value.state_root,
-            receipts_root: value.receipts_root,
-            logs_bloom: value.logs_bloom,
-            difficulty: value.difficulty,
-            number: value.number,
-            gas_limit: value.gas_limit,
-            gas_used: value.gas_used,
-            timestamp: value.timestamp,
-            extra_data: value.extra_data,
-            mix_hash: value.mix_hash,
-            nonce: value.nonce,
-            base_fee: value.base_fee_per_gas,
-            blob_gas_used: value.blob_gas_used,
-            excess_blob_gas: value.excess_blob_gas,
-            parent_beacon_block_root: value.parent_beacon_block_root,
-            requests_hash: value.requests_hash,
-            withdrawals_root: value.withdrawals_root,
-        }
-    }
+/// Helper function to create a new block with Header and Anvil transactions
+///
+/// Note: if the `impersonate-tx` feature is enabled this will also accept
+/// `MaybeImpersonatedTransaction`.
+pub fn create_block<T>(mut header: Header, transactions: impl IntoIterator<Item = T>) -> Block
+where
+    T: Into<Transaction>,
+{
+    let transactions: Vec<_> = transactions.into_iter().map(Into::into).collect();
+    let transactions_root = calculate_transaction_root(&transactions);
+
+    header.transactions_root = transactions_root;
+    header.ommers_hash = EMPTY_OMMER_ROOT_HASH;
+
+    let body = BlockBody { transactions, ommers: Vec::new(), withdrawals: None };
+    Block::new(header, body)
 }
 
 #[cfg(test)]
 mod tests {
     use alloy_primitives::{
-        b256,
+        Address, B64, B256, Bloom, U256, b256,
         hex::{self, FromHex},
     };
     use alloy_rlp::Decodable;

crates/anvil/src/eth/api.rs

@@ -920,7 +920,7 @@ impl EthApi {
         let block_request = self.block_request(Some(block_number.into())).await?;
         if let BlockRequest::Pending(txs) = block_request {
             let block = self.backend.pending_block(txs).await;
-            return Ok(Some(U256::from(block.transactions.len())));
+            return Ok(Some(U256::from(block.block.body.transactions.len())));
         }
         let block = self.backend.block_by_number(block_number).await?;
         let txs = block.map(|b| match b.transactions() {
@@ -1126,7 +1126,7 @@ impl EthApi {
         }
         while let Some(notification) = stream.next().await {
             if let Some(block) = self.backend.get_block_by_hash(notification.hash)
-                && block.transactions.iter().any(|tx| tx.hash() == hash)
+                && block.body.transactions.iter().any(|tx| tx.hash() == hash)
                 && let Some(receipt) = self.backend.transaction_receipt(hash).await?
             {
                 return Ok(receipt);
@@ -3299,11 +3299,11 @@ impl EthApi {
 
         let mut partial_block = self.backend.convert_block(block.clone());
 
-        let mut block_transactions = Vec::with_capacity(block.transactions.len());
+        let mut block_transactions = Vec::with_capacity(block.body.transactions.len());
         let base_fee = self.backend.base_fee();
 
         for info in transactions {
-            let tx = block.transactions.get(info.transaction_index as usize)?.clone();
+            let tx = block.body.transactions.get(info.transaction_index as usize)?.clone();
 
             let tx = transaction_build(
                 Some(info.transaction_hash),

crates/anvil/src/eth/backend/db.rs

@@ -6,7 +6,7 @@ use std::{
     path::Path,
 };
 
-use alloy_consensus::Header;
+use alloy_consensus::{BlockBody, Header};
 use alloy_primitives::{Address, B256, Bytes, U256, keccak256, map::HashMap};
 use alloy_rpc_types::BlockId;
 use anvil_core::eth::{
@@ -584,19 +584,18 @@ impl From<Block> for SerializableBlock {
     fn from(block: Block) -> Self {
         Self {
             header: block.header,
-            transactions: block.transactions.into_iter().map(Into::into).collect(),
-            ommers: block.ommers.into_iter().collect(),
+            transactions: block.body.transactions.into_iter().map(Into::into).collect(),
+            ommers: block.body.ommers.into_iter().collect(),
         }
     }
 }
 
 impl From<SerializableBlock> for Block {
     fn from(block: SerializableBlock) -> Self {
-        Self {
-            header: block.header,
-            transactions: block.transactions.into_iter().map(Into::into).collect(),
-            ommers: block.ommers.into_iter().collect(),
-        }
+        let transactions = block.transactions.into_iter().map(Into::into).collect();
+        let ommers = block.ommers;
+        let body = BlockBody { transactions, ommers, withdrawals: None };
+        Self::new(block.header, body)
     }
 }
 

crates/anvil/src/eth/backend/executor.rs

@@ -14,7 +14,7 @@ use crate::{
     mem::inspector::AnvilInspector,
 };
 use alloy_consensus::{
-    Receipt, ReceiptWithBloom, constants::EMPTY_WITHDRAWALS, proofs::calculate_receipt_root,
+    Header, Receipt, ReceiptWithBloom, constants::EMPTY_WITHDRAWALS, proofs::calculate_receipt_root,
 };
 use alloy_eips::{eip7685::EMPTY_REQUESTS_HASH, eip7840::BlobParams};
 use alloy_evm::{
@@ -25,7 +25,7 @@ use alloy_evm::{
 use alloy_op_evm::OpEvm;
 use alloy_primitives::{B256, Bloom, BloomInput, Log};
 use anvil_core::eth::{
-    block::{Block, BlockInfo, PartialHeader},
+    block::{BlockInfo, create_block},
     transaction::{PendingTransaction, TransactionInfo, TypedReceipt, TypedTransaction},
 };
 use foundry_evm::{
@@ -243,10 +243,12 @@ impl<DB: Db + ?Sized, V: TransactionValidator> TransactionExecutor<'_, DB, V> {
 
         let receipts_root = calculate_receipt_root(&receipts);
 
-        let partial_header = PartialHeader {
+        let header = Header {
             parent_hash,
+            ommers_hash: Default::default(),
             beneficiary,
             state_root: self.db.maybe_state_root().unwrap_or_default(),
+            transactions_root: Default::default(), // Will be computed by create_block
             receipts_root,
             logs_bloom: bloom,
             difficulty,
@@ -257,15 +259,15 @@ impl<DB: Db + ?Sized, V: TransactionValidator> TransactionExecutor<'_, DB, V> {
             extra_data: Default::default(),
             mix_hash: mix_hash.unwrap_or_default(),
             nonce: Default::default(),
-            base_fee,
+            base_fee_per_gas: base_fee,
             parent_beacon_block_root: is_cancun.then_some(Default::default()),
             blob_gas_used: cumulative_blob_gas_used,
             excess_blob_gas,
             withdrawals_root: is_shanghai.then_some(EMPTY_WITHDRAWALS),
             requests_hash: is_prague.then_some(EMPTY_REQUESTS_HASH),
         };
 
-        let block = Block::new(partial_header, transactions);
+        let block = create_block(header, transactions);
         let block = BlockInfo { block, transactions: transaction_infos, receipts };
         ExecutedTransactions { block, included, invalid }
     }