primitives: use SealedHeader::seal (#12507)

crates/blockchain-tree/src/blockchain_tree.rs

@@ -1377,7 +1377,7 @@ mod tests {
     use alloy_consensus::{TxEip1559, EMPTY_ROOT_HASH};
     use alloy_eips::{eip1559::INITIAL_BASE_FEE, eip4895::Withdrawals};
     use alloy_genesis::{Genesis, GenesisAccount};
-    use alloy_primitives::{keccak256, Address, PrimitiveSignature as Signature, Sealable, B256};
+    use alloy_primitives::{keccak256, Address, PrimitiveSignature as Signature, B256};
     use assert_matches::assert_matches;
     use linked_hash_set::LinkedHashSet;
     use reth_chainspec::{ChainSpecBuilder, MAINNET, MIN_TRANSACTION_GAS};
@@ -1598,7 +1598,7 @@ mod tests {
             // receipts root computation is different for OP
             let receipts_root = calculate_receipt_root(&receipts);
 
-            let sealed = Header {
+            let header = Header {
                 number,
                 parent_hash: parent.unwrap_or_default(),
                 gas_used: body.len() as u64 * MIN_TRANSACTION_GAS,
@@ -1620,13 +1620,11 @@ mod tests {
                     ),
                 )])),
                 ..Default::default()
-            }
+            };
-            .seal_slow();
-            let (header, seal) = sealed.into_parts();
 
             SealedBlockWithSenders::new(
                 SealedBlock {
-                    header: SealedHeader::new(header, seal),
+                    header: SealedHeader::seal(header),
                     body: BlockBody {
                         transactions: body.clone().into_iter().map(|tx| tx.into_signed()).collect(),
                         ommers: Vec::new(),

crates/chain-state/src/test_utils.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use alloy_consensus::{Transaction as _, TxEip1559, EMPTY_ROOT_HASH};
 use alloy_eips::{eip1559::INITIAL_BASE_FEE, eip7685::Requests};
-use alloy_primitives::{Address, BlockNumber, Sealable, B256, U256};
+use alloy_primitives::{Address, BlockNumber, B256, U256};
 use alloy_signer::SignerSync;
 use alloy_signer_local::PrivateKeySigner;
 use rand::{thread_rng, Rng};
@@ -160,11 +160,8 @@ impl TestBlockBuilder {
             ..Default::default()
         };
 
-        let sealed = header.seal_slow();
-        let (header, seal) = sealed.into_parts();
-
         let block = SealedBlock {
-            header: SealedHeader::new(header, seal),
+            header: SealedHeader::seal(header),
             body: BlockBody {
                 transactions: transactions.into_iter().map(|tx| tx.into_signed()).collect(),
                 ommers: Vec::new(),

crates/consensus/beacon/src/engine/invalid_headers.rs

@@ -106,14 +106,12 @@ struct InvalidHeaderCacheMetrics {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_primitives::Sealable;
 
     #[test]
     fn test_hit_eviction() {
         let mut cache = InvalidHeaderCache::new(10);
-        let sealed = Header::default().seal_slow();
+        let header = Header::default();
-        let (header, seal) = sealed.into_parts();
+        let header = SealedHeader::seal(header);
-        let header = SealedHeader::new(header, seal);
         cache.insert(header.clone());
         assert_eq!(cache.headers.get(&header.hash()).unwrap().hit_count, 0);
 

crates/consensus/beacon/src/engine/sync.rs

@@ -410,7 +410,6 @@ impl<N: ProviderNodeTypes> PipelineState<N> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_primitives::Sealable;
     use assert_matches::assert_matches;
     use futures::poll;
     use reth_chainspec::{ChainSpec, ChainSpecBuilder, MAINNET};
@@ -599,9 +598,7 @@ mod tests {
             header.parent_hash = hash;
             header.number += 1;
             header.timestamp += 1;
-            let sealed = header.seal_slow();
+            sealed_header = SealedHeader::seal(header);
-            let (header, seal) = sealed.into_parts();
-            sealed_header = SealedHeader::new(header, seal);
             client.insert(sealed_header.clone(), body.clone());
         }
     }
@@ -617,14 +614,12 @@ mod tests {
         );
 
         let client = TestFullBlockClient::default();
-        let sealed = Header {
+        let header = Header {
             base_fee_per_gas: Some(7),
             gas_limit: chain_spec.max_gas_limit,
             ..Default::default()
-        }
+        };
-        .seal_slow();
+        let header = SealedHeader::seal(header);
-        let (header, seal) = sealed.into_parts();
-        let header = SealedHeader::new(header, seal);
         insert_headers_into_client(&client, header, 0..10);
 
         // set up a pipeline

crates/consensus/beacon/src/engine/test_utils.rs

@@ -4,7 +4,7 @@ use crate::{
     BeaconConsensusEngineError, BeaconConsensusEngineHandle, BeaconForkChoiceUpdateError,
     BeaconOnNewPayloadError, EthBeaconConsensus, MIN_BLOCKS_FOR_PIPELINE_RUN,
 };
-use alloy_primitives::{BlockNumber, Sealable, B256};
+use alloy_primitives::{BlockNumber, B256};
 use alloy_rpc_types_engine::{
     ExecutionPayload, ExecutionPayloadSidecar, ForkchoiceState, ForkchoiceUpdated, PayloadStatus,
 };
@@ -402,9 +402,8 @@ where
             BlockchainTree::new(externals, BlockchainTreeConfig::new(1, 2, 3, 2))
                 .expect("failed to create tree"),
         ));
-        let sealed = self.base_config.chain_spec.genesis_header().clone().seal_slow();
+        let header = self.base_config.chain_spec.genesis_header().clone();
-        let (header, seal) = sealed.into_parts();
+        let genesis_block = SealedHeader::seal(header);
-        let genesis_block = SealedHeader::new(header, seal);
 
         let blockchain_provider = BlockchainProvider::with_blocks(
             provider_factory.clone(),

crates/consensus/common/src/validation.rs

@@ -326,7 +326,7 @@ mod tests {
     };
     use alloy_primitives::{
         hex_literal::hex, Address, BlockHash, BlockNumber, Bytes, PrimitiveSignature as Signature,
-        Sealable, U256,
+        U256,
     };
     use mockall::mock;
     use rand::Rng;
@@ -495,12 +495,9 @@ mod tests {
         let ommers = Vec::new();
         let transactions = Vec::new();
 
-        let sealed = header.seal_slow();
-        let (header, seal) = sealed.into_parts();
-
         (
             SealedBlock {
-                header: SealedHeader::new(header, seal),
+                header: SealedHeader::seal(header),
                 body: BlockBody { transactions, ommers, withdrawals: None },
             },
             parent,
@@ -519,15 +516,13 @@ mod tests {
                     .collect(),
             );
 
-            let sealed = Header {
+            let header = Header {
                 withdrawals_root: Some(proofs::calculate_withdrawals_root(&withdrawals)),
                 ..Default::default()
-            }
+            };
-            .seal_slow();
-            let (header, seal) = sealed.into_parts();
 
             SealedBlock {
-                header: SealedHeader::new(header, seal),
+                header: SealedHeader::seal(header),
                 body: BlockBody { withdrawals: Some(withdrawals), ..Default::default() },
             }
         };
@@ -558,16 +553,14 @@ mod tests {
         // create a tx with 10 blobs
         let transaction = mock_blob_tx(1, 10);
 
-        let sealed = Header {
+        let header = Header {
             base_fee_per_gas: Some(1337),
             withdrawals_root: Some(proofs::calculate_withdrawals_root(&[])),
             blob_gas_used: Some(1),
             transactions_root: proofs::calculate_transaction_root(&[transaction.clone()]),
             ..Default::default()
-        }
+        };
-        .seal_slow();
+        let header = SealedHeader::seal(header);
-        let (header, seal) = sealed.into_parts();
-        let header = SealedHeader::new(header, seal);
 
         let body = BlockBody {
             transactions: vec![transaction],

crates/engine/tree/src/backfill.rs

@@ -230,7 +230,7 @@ impl<N: ProviderNodeTypes> PipelineState<N> {
 mod tests {
     use super::*;
     use crate::test_utils::{insert_headers_into_client, TestPipelineBuilder};
-    use alloy_primitives::{BlockNumber, Sealable, B256};
+    use alloy_primitives::{BlockNumber, B256};
     use assert_matches::assert_matches;
     use futures::poll;
     use reth_chainspec::{ChainSpecBuilder, MAINNET};
@@ -267,14 +267,12 @@ mod tests {
 
             let pipeline_sync = PipelineSync::new(pipeline, Box::<TokioTaskExecutor>::default());
             let client = TestFullBlockClient::default();
-            let sealed = Header {
+            let header = Header {
                 base_fee_per_gas: Some(7),
                 gas_limit: chain_spec.max_gas_limit,
                 ..Default::default()
-            }
+            };
-            .seal_slow();
+            let header = SealedHeader::seal(header);
-            let (header, seal) = sealed.into_parts();
-            let header = SealedHeader::new(header, seal);
             insert_headers_into_client(&client, header, 0..total_blocks);
 
             let tip = client.highest_block().expect("there should be blocks here").hash();

crates/engine/tree/src/download.rs

@@ -309,7 +309,6 @@ impl BlockDownloader for NoopBlockDownloader {
 mod tests {
     use super::*;
     use crate::test_utils::insert_headers_into_client;
-    use alloy_primitives::Sealable;
     use assert_matches::assert_matches;
     use reth_beacon_consensus::EthBeaconConsensus;
     use reth_chainspec::{ChainSpecBuilder, MAINNET};
@@ -333,14 +332,12 @@ mod tests {
             );
 
             let client = TestFullBlockClient::default();
-            let sealed = Header {
+            let header = Header {
                 base_fee_per_gas: Some(7),
                 gas_limit: chain_spec.max_gas_limit,
                 ..Default::default()
-            }
+            };
-            .seal_slow();
+            let header = SealedHeader::seal(header);
-            let (header, seal) = sealed.into_parts();
-            let header = SealedHeader::new(header, seal);
 
             insert_headers_into_client(&client, header, 0..total_blocks);
             let consensus = Arc::new(EthBeaconConsensus::new(chain_spec));

crates/engine/tree/src/test_utils.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::{Sealable, B256};
+use alloy_primitives::B256;
 use reth_chainspec::ChainSpec;
 use reth_network_p2p::test_utils::TestFullBlockClient;
 use reth_primitives::{BlockBody, SealedHeader};
@@ -76,9 +76,7 @@ pub fn insert_headers_into_client(
         header.parent_hash = hash;
         header.number += 1;
         header.timestamp += 1;
-        let sealed = header.seal_slow();
+        sealed_header = SealedHeader::seal(header);
-        let (header, seal) = sealed.into_parts();
-        sealed_header = SealedHeader::new(header, seal);
         client.insert(sealed_header.clone(), body.clone());
     }
 }

crates/engine/tree/src/tree/mod.rs

@@ -2597,7 +2597,7 @@ pub enum AdvancePersistenceError {
 mod tests {
     use super::*;
     use crate::persistence::PersistenceAction;
-    use alloy_primitives::{Bytes, Sealable};
+    use alloy_primitives::Bytes;
     use alloy_rlp::Decodable;
     use alloy_rpc_types_engine::{CancunPayloadFields, ExecutionPayloadSidecar};
     use assert_matches::assert_matches;
@@ -2709,9 +2709,8 @@ mod tests {
 
             let (from_tree_tx, from_tree_rx) = unbounded_channel();
 
-            let sealed = chain_spec.genesis_header().clone().seal_slow();
+            let header = chain_spec.genesis_header().clone();
-            let (header, seal) = sealed.into_parts();
+            let header = SealedHeader::seal(header);
-            let header = SealedHeader::new(header, seal);
             let engine_api_tree_state = EngineApiTreeState::new(10, 10, header.num_hash());
             let canonical_in_memory_state = CanonicalInMemoryState::with_head(header, None, None);
 

crates/ethereum/consensus/src/lib.rs

@@ -236,7 +236,7 @@ impl<ChainSpec: Send + Sync + EthChainSpec + EthereumHardforks + Debug> Consensu
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_primitives::{Sealable, B256};
+    use alloy_primitives::B256;
     use reth_chainspec::{ChainSpec, ChainSpecBuilder};
     use reth_primitives::proofs;
 
@@ -321,16 +321,14 @@ mod tests {
         // that the header is valid
         let chain_spec = Arc::new(ChainSpecBuilder::mainnet().shanghai_activated().build());
 
-        let sealed = Header {
+        let header = Header {
             base_fee_per_gas: Some(1337),
             withdrawals_root: Some(proofs::calculate_withdrawals_root(&[])),
             ..Default::default()
-        }
+        };
-        .seal_slow();
-        let (header, seal) = sealed.into_parts();
 
         assert_eq!(
-            EthBeaconConsensus::new(chain_spec).validate_header(&SealedHeader::new(header, seal)),
+            EthBeaconConsensus::new(chain_spec).validate_header(&SealedHeader::seal(header,)),
             Ok(())
         );
     }

crates/net/downloaders/src/file_client.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, io, path::Path};
 
 use alloy_eips::BlockHashOrNumber;
-use alloy_primitives::{BlockHash, BlockNumber, Sealable, B256};
+use alloy_primitives::{BlockHash, BlockNumber, B256};
 use futures::Future;
 use itertools::Either;
 use reth_network_p2p::{
@@ -114,11 +114,7 @@ impl FileClient {
     /// Clones and returns the highest header of this client has or `None` if empty. Seals header
     /// before returning.
     pub fn tip_header(&self) -> Option<SealedHeader> {
-        self.headers.get(&self.max_block()?).map(|h| {
+        self.headers.get(&self.max_block()?).map(|h| SealedHeader::seal(h.clone()))
-            let sealed = h.clone().seal_slow();
-            let (header, seal) = sealed.into_parts();
-            SealedHeader::new(header, seal)
-        })
     }
 
     /// Returns true if all blocks are canonical (no gaps)

crates/net/downloaders/src/headers/reverse_headers.rs

@@ -4,7 +4,7 @@ use super::task::TaskDownloader;
 use crate::metrics::HeaderDownloaderMetrics;
 use alloy_consensus::BlockHeader;
 use alloy_eips::BlockHashOrNumber;
-use alloy_primitives::{BlockNumber, Sealable, B256};
+use alloy_primitives::{BlockNumber, B256};
 use futures::{stream::Stream, FutureExt};
 use futures_util::{stream::FuturesUnordered, StreamExt};
 use rayon::prelude::*;
@@ -250,15 +250,7 @@ where
     ) -> Result<(), ReverseHeadersDownloaderError<H::Header>> {
         let mut validated = Vec::with_capacity(headers.len());
 
-        let sealed_headers = headers
+        let sealed_headers = headers.into_par_iter().map(SealedHeader::seal).collect::<Vec<_>>();
-            .into_par_iter()
-            .map(|h| {
-                let sealed = h.seal_slow();
-                let (header, seal) = sealed.into_parts();
-
-                SealedHeader::new(header, seal)
-            })
-            .collect::<Vec<_>>();
         for parent in sealed_headers {
             // Validate that the header is the parent header of the last validated header.
             if let Some(validated_header) =
@@ -384,9 +376,8 @@ where
                     .into())
                 }
 
-                let sealed_target = headers.swap_remove(0).seal_slow();
+                let header = headers.swap_remove(0);
-                let (header, seal) = sealed_target.into_parts();
+                let target = SealedHeader::seal(header);
-                let target = SealedHeader::new(header, seal);
 
                 match sync_target {
                     SyncTargetBlock::Hash(hash) | SyncTargetBlock::HashAndNumber { hash, .. } => {

crates/net/downloaders/src/headers/test_utils.rs

@@ -2,7 +2,6 @@
 
 #![allow(dead_code)]
 
-use alloy_primitives::Sealable;
 use reth_primitives::SealedHeader;
 
 /// Returns a new [`SealedHeader`] that's the child header of the given `parent`.
@@ -10,7 +9,5 @@ pub(crate) fn child_header(parent: &SealedHeader) -> SealedHeader {
     let mut child = parent.as_ref().clone();
     child.number += 1;
     child.parent_hash = parent.hash_slow();
-    let sealed = child.seal_slow();
+    SealedHeader::seal(child)
-    let (header, seal) = sealed.into_parts();
-    SealedHeader::new(header, seal)
 }

crates/net/p2p/src/full_block.rs

@@ -199,15 +199,8 @@ where
                 ResponseResult::Header(res) => {
                     match res {
                         Ok(maybe_header) => {
-                            let (peer, maybe_header) = maybe_header
+                            let (peer, maybe_header) =
-                                .map(|h| {
+                                maybe_header.map(|h| h.map(SealedHeader::seal)).split();
-                                    h.map(|h| {
-                                        let sealed = h.seal_slow();
-                                        let (header, seal) = sealed.into_parts();
-                                        SealedHeader::new(header, seal)
-                                    })
-                                })
-                                .split();
                             if let Some(header) = maybe_header {
                                 if header.hash() == this.hash {
                                     this.header = Some(header);
@@ -457,17 +450,8 @@ where
     }
 
     fn on_headers_response(&mut self, headers: WithPeerId<Vec<Client::Header>>) {
-        let (peer, mut headers_falling) = headers
+        let (peer, mut headers_falling) =
-            .map(|h| {
+            headers.map(|h| h.into_iter().map(SealedHeader::seal).collect::<Vec<_>>()).split();
-                h.into_iter()
-                    .map(|h| {
-                        let sealed = h.seal_slow();
-                        let (header, seal) = sealed.into_parts();
-                        SealedHeader::new(header, seal)
-                    })
-                    .collect::<Vec<_>>()
-            })
-            .split();
 
         // fill in the response if it's the correct length
         if headers_falling.len() == self.count as usize {
@@ -707,9 +691,7 @@ mod tests {
             header.parent_hash = hash;
             header.number += 1;
 
-            let sealed = header.seal_slow();
+            sealed_header = SealedHeader::seal(header);
-            let (header, seal) = sealed.into_parts();
-            sealed_header = SealedHeader::new(header, seal);
 
             client.insert(sealed_header.clone(), body.clone());
         }

crates/net/p2p/src/test_utils/headers.rs

@@ -10,7 +10,6 @@ use crate::{
     },
     priority::Priority,
 };
-use alloy_primitives::Sealable;
 use futures::{Future, FutureExt, Stream, StreamExt};
 use reth_consensus::{test_utils::TestConsensus, Consensus};
 use reth_eth_wire_types::HeadersDirection;
@@ -160,16 +159,8 @@ impl Stream for TestDownload {
             match ready!(this.get_or_init_fut().poll_unpin(cx)) {
                 Ok(resp) => {
                     // Skip head and seal headers
-                    let mut headers = resp
+                    let mut headers =
-                        .1
+                        resp.1.into_iter().skip(1).map(SealedHeader::seal).collect::<Vec<_>>();
-                        .into_iter()
-                        .skip(1)
-                        .map(|header| {
-                            let sealed = header.seal_slow();
-                            let (header, seal) = sealed.into_parts();
-                            SealedHeader::new(header, seal)
-                        })
-                        .collect::<Vec<_>>();
                     headers.sort_unstable_by_key(|h| h.number);
                     headers.into_iter().for_each(|h| this.buffer.push(h));
                     this.done = true;

crates/node/core/src/utils.rs

@@ -3,7 +3,6 @@
 
 use alloy_consensus::BlockHeader;
 use alloy_eips::BlockHashOrNumber;
-use alloy_primitives::Sealable;
 use alloy_rpc_types_engine::{JwtError, JwtSecret};
 use eyre::Result;
 use reth_consensus::Consensus;
@@ -44,13 +43,12 @@ where
 {
     let (peer_id, response) = client.get_header_with_priority(id, Priority::High).await?.split();
 
-    let Some(sealed_header) = response.map(|block| block.seal_slow()) else {
+    let Some(header) = response else {
         client.report_bad_message(peer_id);
         eyre::bail!("Invalid number of headers received. Expected: 1. Received: 0")
     };
 
-    let (header, seal) = sealed_header.into_parts();
+    let header = SealedHeader::seal(header);
-    let header = SealedHeader::new(header, seal);
 
     let valid = match id {
         BlockHashOrNumber::Hash(hash) => header.hash() == hash,

crates/primitives-traits/src/header/sealed.rs

@@ -156,9 +156,7 @@ impl<'a> arbitrary::Arbitrary<'a> for SealedHeader {
     fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
         let header = Header::arbitrary(u)?;
 
-        let sealed = header.seal_slow();
+        Ok(Self::seal(header))
-        let (header, seal) = sealed.into_parts();
-        Ok(Self::new(header, seal))
     }
 }
 

crates/primitives/src/block.rs

@@ -1,7 +1,7 @@
 use crate::{GotExpected, Header, SealedHeader, TransactionSigned, TransactionSignedEcRecovered};
 use alloc::vec::Vec;
 use alloy_eips::{eip2718::Encodable2718, eip4895::Withdrawals};
-use alloy_primitives::{Address, Bytes, Sealable, B256};
+use alloy_primitives::{Address, Bytes, B256};
 use alloy_rlp::{Decodable, Encodable, RlpDecodable, RlpEncodable};
 use derive_more::{Deref, DerefMut};
 #[cfg(any(test, feature = "arbitrary"))]
@@ -25,9 +25,7 @@ pub struct Block {
 impl Block {
     /// Calculate the header hash and seal the block so that it can't be changed.
     pub fn seal_slow(self) -> SealedBlock {
-        let sealed = self.header.seal_slow();
+        SealedBlock { header: SealedHeader::seal(self.header), body: self.body }
-        let (header, seal) = sealed.into_parts();
-        SealedBlock { header: SealedHeader::new(header, seal), body: self.body }
     }
 
     /// Seal the block with a known hash.

crates/rpc/rpc-engine-api/tests/it/payload.rs

@@ -1,7 +1,7 @@
 //! Some payload tests
 
 use alloy_eips::eip4895::Withdrawals;
-use alloy_primitives::{Bytes, Sealable, U256};
+use alloy_primitives::{Bytes, U256};
 use alloy_rlp::{Decodable, Error as RlpError};
 use alloy_rpc_types_engine::{
     ExecutionPayload, ExecutionPayloadBodyV1, ExecutionPayloadSidecar, ExecutionPayloadV1,
@@ -24,10 +24,8 @@ fn transform_block<F: FnOnce(Block) -> Block>(src: SealedBlock, f: F) -> Executi
     transformed.header.transactions_root =
         proofs::calculate_transaction_root(&transformed.body.transactions);
     transformed.header.ommers_hash = proofs::calculate_ommers_root(&transformed.body.ommers);
-    let sealed = transformed.header.seal_slow();
-    let (header, seal) = sealed.into_parts();
     block_to_payload(SealedBlock {
-        header: SealedHeader::new(header, seal),
+        header: SealedHeader::seal(transformed.header),
         body: transformed.body,
     })
 }

crates/stages/stages/benches/setup/mod.rs

@@ -1,5 +1,5 @@
 #![allow(unreachable_pub)]
-use alloy_primitives::{Address, Sealable, B256, U256};
+use alloy_primitives::{Address, B256, U256};
 use itertools::concat;
 use reth_db::{tables, test_utils::TempDatabase, Database, DatabaseEnv};
 use reth_db_api::{
@@ -147,9 +147,7 @@ pub(crate) fn txs_testdata(num_blocks: u64) -> TestStageDB {
         let cloned_second = second_block.clone();
         let mut updated_header = cloned_second.header.unseal();
         updated_header.state_root = root;
-        let sealed = updated_header.seal_slow();
+        *second_block = SealedBlock { header: SealedHeader::seal(updated_header), ..cloned_second };
-        let (header, seal) = sealed.into_parts();
-        *second_block = SealedBlock { header: SealedHeader::new(header, seal), ..cloned_second };
 
         let offset = transitions.len() as u64;
 
@@ -182,9 +180,7 @@ pub(crate) fn txs_testdata(num_blocks: u64) -> TestStageDB {
         let cloned_last = last_block.clone();
         let mut updated_header = cloned_last.header.unseal();
         updated_header.state_root = root;
-        let sealed = updated_header.seal_slow();
+        *last_block = SealedBlock { header: SealedHeader::seal(updated_header), ..cloned_last };
-        let (header, seal) = sealed.into_parts();
-        *last_block = SealedBlock { header: SealedHeader::new(header, seal), ..cloned_last };
 
         db.insert_blocks(blocks.iter(), StorageKind::Static).unwrap();
 

crates/stages/stages/src/stages/execution.rs

@@ -1,5 +1,5 @@
 use crate::stages::MERKLE_STAGE_DEFAULT_CLEAN_THRESHOLD;
-use alloy_primitives::{BlockNumber, Sealable};
+use alloy_primitives::BlockNumber;
 use num_traits::Zero;
 use reth_config::config::ExecutionConfig;
 use reth_db::{static_file::HeaderMask, tables};
@@ -276,11 +276,8 @@ where
             let execute_start = Instant::now();
 
             self.metrics.metered_one((&block, td).into(), |input| {
-                let sealed = block.header.clone().seal_slow();
-                let (header, seal) = sealed.into_parts();
-
                 executor.execute_and_verify_one(input).map_err(|error| StageError::Block {
-                    block: Box::new(SealedHeader::new(header, seal)),
+                    block: Box::new(SealedHeader::seal(block.header.clone())),
                     error: BlockErrorKind::Execution(error),
                 })
             })?;

crates/stages/stages/src/stages/headers.rs

@@ -392,7 +392,7 @@ mod tests {
     use crate::test_utils::{
         stage_test_suite, ExecuteStageTestRunner, StageTestRunner, UnwindStageTestRunner,
     };
-    use alloy_primitives::{Sealable, B256};
+    use alloy_primitives::B256;
     use assert_matches::assert_matches;
     use reth_execution_types::ExecutionOutcome;
     use reth_primitives::{BlockBody, SealedBlock, SealedBlockWithSenders};
@@ -509,9 +509,7 @@ mod tests {
                             // validate the header
                             let header = provider.header_by_number(block_num)?;
                             assert!(header.is_some());
-                            let sealed = header.unwrap().seal_slow();
+                            let header = SealedHeader::seal(header.unwrap());
-                            let (header, seal) = sealed.into_parts();
-                            let header = SealedHeader::new(header, seal);
                             assert_eq!(header.hash(), hash);
 
                             // validate the header total difficulty

crates/stages/stages/src/stages/merkle.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::{BlockNumber, Sealable, B256};
+use alloy_primitives::{BlockNumber, B256};
 use reth_codecs::Compact;
 use reth_consensus::ConsensusError;
 use reth_db::tables;
@@ -276,10 +276,7 @@ where
         // Reset the checkpoint
         self.save_execution_checkpoint(provider, None)?;
 
-        let sealed = target_block.seal_slow();
+        validate_state_root(trie_root, SealedHeader::seal(target_block), to_block)?;
-        let (header, seal) = sealed.into_parts();
-
-        validate_state_root(trie_root, SealedHeader::new(header, seal), to_block)?;
 
         Ok(ExecOutput {
             checkpoint: StageCheckpoint::new(to_block)
@@ -332,10 +329,7 @@ where
                 .header_by_number(input.unwind_to)?
                 .ok_or_else(|| ProviderError::HeaderNotFound(input.unwind_to.into()))?;
 
-            let sealed = target.seal_slow();
+            validate_state_root(block_root, SealedHeader::seal(target), input.unwind_to)?;
-            let (header, seal) = sealed.into_parts();
-
-            validate_state_root(block_root, SealedHeader::new(header, seal), input.unwind_to)?;
 
             // Validation passed, apply unwind changes to the database.
             provider.write_trie_updates(&updates)?;
@@ -538,9 +532,7 @@ mod tests {
                     .into_iter()
                     .map(|(address, account)| (address, (account, std::iter::empty()))),
             );
-            let sealed = header.seal_slow();
+            let sealed_head = SealedBlock { header: SealedHeader::seal(header), body };
-            let (header, seal) = sealed.into_parts();
-            let sealed_head = SealedBlock { header: SealedHeader::new(header, seal), body };
 
             let head_hash = sealed_head.hash();
             let mut blocks = vec![sealed_head];

crates/storage/provider/src/providers/consistent.rs

@@ -10,7 +10,7 @@ use alloy_eips::{
     eip4895::{Withdrawal, Withdrawals},
     BlockHashOrNumber, BlockId, BlockNumHash, BlockNumberOrTag, HashOrNumber,
 };
-use alloy_primitives::{Address, BlockHash, BlockNumber, Sealable, TxHash, TxNumber, B256, U256};
+use alloy_primitives::{Address, BlockHash, BlockNumber, TxHash, TxNumber, B256, U256};
 use reth_chain_state::{BlockState, CanonicalInMemoryState, MemoryOverlayStateProviderRef};
 use reth_chainspec::{ChainInfo, EthereumHardforks};
 use reth_db::models::BlockNumberAddress;
@@ -1324,34 +1324,20 @@ impl<N: ProviderNodeTypes> BlockReaderIdExt for ConsistentProvider<N> {
                 Ok(self.canonical_in_memory_state.get_finalized_header())
             }
             BlockNumberOrTag::Safe => Ok(self.canonical_in_memory_state.get_safe_header()),
-            BlockNumberOrTag::Earliest => self.header_by_number(0)?.map_or_else(
+            BlockNumberOrTag::Earliest => self
-                || Ok(None),
+                .header_by_number(0)?
-                |h| {
+                .map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h)))),
-                    let sealed = h.seal_slow();
-                    let (header, seal) = sealed.into_parts();
-                    Ok(Some(SealedHeader::new(header, seal)))
-                },
-            ),
             BlockNumberOrTag::Pending => Ok(self.canonical_in_memory_state.pending_sealed_header()),
-            BlockNumberOrTag::Number(num) => self.header_by_number(num)?.map_or_else(
+            BlockNumberOrTag::Number(num) => self
-                || Ok(None),
+                .header_by_number(num)?
-                |h| {
+                .map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h)))),
-                    let sealed = h.seal_slow();
-                    let (header, seal) = sealed.into_parts();
-                    Ok(Some(SealedHeader::new(header, seal)))
-                },
-            ),
         }
     }
 
     fn sealed_header_by_id(&self, id: BlockId) -> ProviderResult<Option<SealedHeader>> {
         Ok(match id {
             BlockId::Number(num) => self.sealed_header_by_number_or_tag(num)?,
-            BlockId::Hash(hash) => self.header(&hash.block_hash)?.map(|h| {
+            BlockId::Hash(hash) => self.header(&hash.block_hash)?.map(SealedHeader::seal),
-                let sealed = h.seal_slow();
-                let (header, seal) = sealed.into_parts();
-                SealedHeader::new(header, seal)
-            }),
         })
     }
 

crates/storage/provider/src/providers/mod.rs

@@ -11,7 +11,7 @@ use alloy_eips::{
     eip4895::{Withdrawal, Withdrawals},
     BlockHashOrNumber, BlockId, BlockNumHash, BlockNumberOrTag,
 };
-use alloy_primitives::{Address, BlockHash, BlockNumber, Sealable, TxHash, TxNumber, B256, U256};
+use alloy_primitives::{Address, BlockHash, BlockNumber, TxHash, TxNumber, B256, U256};
 use reth_blockchain_tree_api::{
     error::{CanonicalError, InsertBlockError},
     BlockValidationKind, BlockchainTreeEngine, BlockchainTreeViewer, CanonicalOutcome,
@@ -847,34 +847,20 @@ where
             BlockNumberOrTag::Latest => Ok(Some(self.chain_info.get_canonical_head())),
             BlockNumberOrTag::Finalized => Ok(self.chain_info.get_finalized_header()),
             BlockNumberOrTag::Safe => Ok(self.chain_info.get_safe_header()),
-            BlockNumberOrTag::Earliest => self.header_by_number(0)?.map_or_else(
+            BlockNumberOrTag::Earliest => self
-                || Ok(None),
+                .header_by_number(0)?
-                |h| {
+                .map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h)))),
-                    let sealed = h.seal_slow();
-                    let (header, seal) = sealed.into_parts();
-                    Ok(Some(SealedHeader::new(header, seal)))
-                },
-            ),
             BlockNumberOrTag::Pending => Ok(self.tree.pending_header()),
-            BlockNumberOrTag::Number(num) => self.header_by_number(num)?.map_or_else(
+            BlockNumberOrTag::Number(num) => self
-                || Ok(None),
+                .header_by_number(num)?
-                |h| {
+                .map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h)))),
-                    let sealed = h.seal_slow();
-                    let (header, seal) = sealed.into_parts();
-                    Ok(Some(SealedHeader::new(header, seal)))
-                },
-            ),
         }
     }
 
     fn sealed_header_by_id(&self, id: BlockId) -> ProviderResult<Option<SealedHeader>> {
         Ok(match id {
             BlockId::Number(num) => self.sealed_header_by_number_or_tag(num)?,
-            BlockId::Hash(hash) => self.header(&hash.block_hash)?.map(|h| {
+            BlockId::Hash(hash) => self.header(&hash.block_hash)?.map(SealedHeader::seal),
-                let sealed = h.seal_slow();
-                let (header, seal) = sealed.into_parts();
-                SealedHeader::new(header, seal)
-            }),
         })
     }
 

crates/storage/provider/src/test_utils/blocks.rs

@@ -2,8 +2,7 @@
 use crate::{DBProvider, DatabaseProviderRW, ExecutionOutcome};
 use alloy_consensus::{TxLegacy, EMPTY_OMMER_ROOT_HASH};
 use alloy_primitives::{
-    b256, hex_literal::hex, map::HashMap, Address, BlockNumber, Bytes, Log, Sealable, TxKind, B256,
+    b256, hex_literal::hex, map::HashMap, Address, BlockNumber, Bytes, Log, TxKind, B256, U256,
-    U256,
 };
 
 use alloy_eips::eip4895::{Withdrawal, Withdrawals};
@@ -233,9 +232,7 @@ fn block1(number: BlockNumber) -> (SealedBlockWithSenders, ExecutionOutcome) {
     header.number = number;
     header.state_root = state_root;
     header.parent_hash = B256::ZERO;
-    let sealed = header.seal_slow();
+    block.header = SealedHeader::seal(header);
-    let (header, seal) = sealed.into_parts();
-    block.header = SealedHeader::new(header, seal);
 
     (SealedBlockWithSenders { block, senders: vec![Address::new([0x30; 20])] }, execution_outcome)
 }
@@ -299,9 +296,7 @@ fn block2(
     header.state_root = state_root;
     // parent_hash points to block1 hash
     header.parent_hash = parent_hash;
-    let sealed = header.seal_slow();
+    block.header = SealedHeader::seal(header);
-    let (header, seal) = sealed.into_parts();
-    block.header = SealedHeader::new(header, seal);
 
     (SealedBlockWithSenders { block, senders: vec![Address::new([0x31; 20])] }, execution_outcome)
 }
@@ -365,9 +360,7 @@ fn block3(
     header.state_root = state_root;
     // parent_hash points to block1 hash
     header.parent_hash = parent_hash;
-    let sealed = header.seal_slow();
+    block.header = SealedHeader::seal(header);
-    let (header, seal) = sealed.into_parts();
-    block.header = SealedHeader::new(header, seal);
 
     (SealedBlockWithSenders { block, senders: vec![Address::new([0x31; 20])] }, execution_outcome)
 }
@@ -456,9 +449,7 @@ fn block4(
     header.state_root = state_root;
     // parent_hash points to block1 hash
     header.parent_hash = parent_hash;
-    let sealed = header.seal_slow();
+    block.header = SealedHeader::seal(header);
-    let (header, seal) = sealed.into_parts();
-    block.header = SealedHeader::new(header, seal);
 
     (SealedBlockWithSenders { block, senders: vec![Address::new([0x31; 20])] }, execution_outcome)
 }
@@ -544,9 +535,7 @@ fn block5(
     header.state_root = state_root;
     // parent_hash points to block1 hash
     header.parent_hash = parent_hash;
-    let sealed = header.seal_slow();
+    block.header = SealedHeader::seal(header);
-    let (header, seal) = sealed.into_parts();
-    block.header = SealedHeader::new(header, seal);
 
     (SealedBlockWithSenders { block, senders: vec![Address::new([0x31; 20])] }, execution_outcome)
 }

crates/storage/provider/src/test_utils/mock.rs

@@ -13,8 +13,7 @@ use alloy_eips::{
 use alloy_primitives::{
     keccak256,
     map::{HashMap, HashSet},
-    Address, BlockHash, BlockNumber, Bytes, Sealable, StorageKey, StorageValue, TxHash, TxNumber,
+    Address, BlockHash, BlockNumber, Bytes, StorageKey, StorageValue, TxHash, TxNumber, B256, U256,
-    B256, U256,
 };
 use parking_lot::Mutex;
 use reth_chainspec::{ChainInfo, ChainSpec};
@@ -218,11 +217,7 @@ impl HeaderProvider for MockEthProvider {
     }
 
     fn sealed_header(&self, number: BlockNumber) -> ProviderResult<Option<SealedHeader>> {
-        Ok(self.header_by_number(number)?.map(|h| {
+        Ok(self.header_by_number(number)?.map(SealedHeader::seal))
-            let sealed = h.seal_slow();
-            let (header, seal) = sealed.into_parts();
-            SealedHeader::new(header, seal)
-        }))
     }
 
     fn sealed_headers_while(
@@ -233,11 +228,7 @@ impl HeaderProvider for MockEthProvider {
         Ok(self
             .headers_range(range)?
             .into_iter()
-            .map(|h| {
+            .map(SealedHeader::seal)
-                let sealed = h.seal_slow();
-                let (header, seal) = sealed.into_parts();
-                SealedHeader::new(header, seal)
-            })
             .take_while(|h| predicate(h))
             .collect())
     }
@@ -566,14 +557,7 @@ impl BlockReaderIdExt for MockEthProvider {
     }
 
     fn sealed_header_by_id(&self, id: BlockId) -> ProviderResult<Option<SealedHeader>> {
-        self.header_by_id(id)?.map_or_else(
+        self.header_by_id(id)?.map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h))))
-            || Ok(None),
-            |h| {
-                let sealed = h.seal_slow();
-                let (header, seal) = sealed.into_parts();
-                Ok(Some(SealedHeader::new(header, seal)))
-            },
-        )
     }
 
     fn header_by_id(&self, id: BlockId) -> ProviderResult<Option<Header>> {

crates/storage/storage-api/src/block.rs

@@ -3,7 +3,7 @@ use crate::{
     TransactionsProvider, WithdrawalsProvider,
 };
 use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumberOrTag};
-use alloy_primitives::{BlockNumber, Sealable, B256};
+use alloy_primitives::{BlockNumber, B256};
 use reth_db_models::StoredBlockBodyIndices;
 use reth_primitives::{
     Block, BlockWithSenders, Header, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
@@ -243,14 +243,7 @@ pub trait BlockReaderIdExt: BlockReader + ReceiptProviderIdExt {
     ) -> ProviderResult<Option<SealedHeader>> {
         self.convert_block_number(id)?
             .map_or_else(|| Ok(None), |num| self.header_by_hash_or_number(num.into()))?
-            .map_or_else(
+            .map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h))))
-                || Ok(None),
-                |h| {
-                    let sealed = h.seal_slow();
-                    let (header, seal) = sealed.into_parts();
-                    Ok(Some(SealedHeader::new(header, seal)))
-                },
-            )
     }
 
     /// Returns the sealed header with the matching `BlockId` from the database.

crates/transaction-pool/src/maintain.rs

@@ -8,7 +8,7 @@ use crate::{
     BlockInfo, PoolTransaction,
 };
 use alloy_eips::BlockNumberOrTag;
-use alloy_primitives::{Address, BlockHash, BlockNumber, Sealable};
+use alloy_primitives::{Address, BlockHash, BlockNumber};
 use futures_util::{
     future::{BoxFuture, Fuse, FusedFuture},
     FutureExt, Stream, StreamExt,
@@ -106,9 +106,7 @@ pub async fn maintain_transaction_pool<Client, P, St, Tasks>(
     let MaintainPoolConfig { max_update_depth, max_reload_accounts, .. } = config;
     // ensure the pool points to latest state
     if let Ok(Some(latest)) = client.header_by_number_or_tag(BlockNumberOrTag::Latest) {
-        let sealed = latest.seal_slow();
+        let latest = SealedHeader::seal(latest);
-        let (header, seal) = sealed.into_parts();
-        let latest = SealedHeader::new(header, seal);
         let chain_spec = client.chain_spec();
         let info = BlockInfo {
             block_gas_limit: latest.gas_limit,

examples/db-access/src/main.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::{Address, Sealable, B256};
+use alloy_primitives::{Address, B256};
 use alloy_rpc_types_eth::{Filter, FilteredParams};
 use reth_chainspec::ChainSpecBuilder;
 use reth_db::{open_db_read_only, DatabaseEnv};
@@ -63,9 +63,7 @@ fn header_provider_example<T: HeaderProvider>(provider: T, number: u64) -> eyre:
 
     // We can convert a header to a sealed header which contains the hash w/o needing to re-compute
     // it every time.
-    let sealed = header.seal_slow();
+    let sealed_header = SealedHeader::seal(header);
-    let (header, seal) = sealed.into_parts();
-    let sealed_header = SealedHeader::new(header, seal);
 
     // Can also query the header by hash!
     let header_by_hash =

testing/testing-utils/src/generators.rs

@@ -2,7 +2,7 @@
 
 use alloy_consensus::{Transaction as _, TxLegacy};
 use alloy_eips::eip4895::{Withdrawal, Withdrawals};
-use alloy_primitives::{Address, BlockNumber, Bytes, Sealable, TxKind, B256, U256};
+use alloy_primitives::{Address, BlockNumber, Bytes, TxKind, B256, U256};
 pub use rand::Rng;
 use rand::{
     distributions::uniform::SampleRange, rngs::StdRng, seq::SliceRandom, thread_rng, SeedableRng,
@@ -106,9 +106,7 @@ pub fn random_header<R: Rng>(rng: &mut R, number: u64, parent: Option<B256>) ->
         parent_hash: parent.unwrap_or_default(),
         ..Default::default()
     };
-    let sealed = header.seal_slow();
+    SealedHeader::seal(header)
-    let (header, seal) = sealed.into_parts();
-    SealedHeader::new(header, seal)
 }
 
 /// Generates a random legacy [Transaction].
@@ -203,7 +201,7 @@ pub fn random_block<R: Rng>(rng: &mut R, number: u64, block_params: BlockParams)
     });
     let withdrawals_root = withdrawals.as_ref().map(|w| proofs::calculate_withdrawals_root(w));
 
-    let sealed = Header {
+    let header = Header {
         parent_hash: block_params.parent.unwrap_or_default(),
         number,
         gas_used: total_gas,
@@ -215,13 +213,10 @@ pub fn random_block<R: Rng>(rng: &mut R, number: u64, block_params: BlockParams)
         requests_hash: None,
         withdrawals_root,
         ..Default::default()
-    }
+    };
-    .seal_slow();
-
-    let (header, seal) = sealed.into_parts();
 
     SealedBlock {
-        header: SealedHeader::new(header, seal),
+        header: SealedHeader::seal(header),
         body: BlockBody { transactions, ommers, withdrawals: withdrawals.map(Withdrawals::new) },
     }
 }