chore: use BlockWithParent for StageError (#13198)

crates/stages/api/Cargo.toml

@@ -23,7 +23,9 @@ reth-errors.workspace = true
 reth-stages-types.workspace = true
 reth-static-file-types.workspace = true
 
+# alloy
 alloy-primitives.workspace = true
+alloy-eips.workspace = true
 
 # metrics
 reth-metrics.workspace = true

crates/stages/api/src/error.rs

@@ -1,8 +1,8 @@
 use crate::PipelineEvent;
+use alloy_eips::eip1898::BlockWithParent;
 use reth_consensus::ConsensusError;
 use reth_errors::{BlockExecutionError, DatabaseError, RethError};
 use reth_network_p2p::error::DownloadError;
-use reth_primitives_traits::SealedHeader;
 use reth_provider::ProviderError;
 use reth_prune::{PruneSegment, PruneSegmentError, PrunerError};
 use reth_static_file_types::StaticFileSegment;
@@ -34,10 +34,10 @@ impl BlockErrorKind {
 #[derive(Error, Debug)]
 pub enum StageError {
     /// The stage encountered an error related to a block.
-    #[error("stage encountered an error in block #{number}: {error}", number = block.number)]
+    #[error("stage encountered an error in block #{number}: {error}", number = block.block.number)]
     Block {
         /// The block that caused the error.
-        block: Box<SealedHeader>,
+        block: Box<BlockWithParent>,
         /// The specific error type, either consensus or execution error.
         #[source]
         error: BlockErrorKind,
@@ -48,16 +48,16 @@ pub enum StageError {
         "stage encountered inconsistent chain: \
          downloaded header #{header_number} ({header_hash}) is detached from \
          local head #{head_number} ({head_hash}): {error}",
-        header_number = header.number,
-        header_hash = header.hash(),
-        head_number = local_head.number,
-        head_hash = local_head.hash(),
+        header_number = header.block.number,
+        header_hash = header.block.hash,
+        head_number = local_head.block.number,
+        head_hash = local_head.block.hash,
     )]
     DetachedHead {
         /// The local head we attempted to attach to.
-        local_head: Box<SealedHeader>,
+        local_head: Box<BlockWithParent>,
         /// The header we attempted to attach.
-        header: Box<SealedHeader>,
+        header: Box<BlockWithParent>,
         /// The error that occurred when attempting to attach the header.
         #[source]
         error: Box<ConsensusError>,
@@ -92,10 +92,10 @@ pub enum StageError {
     #[error("invalid download response: {0}")]
     Download(#[from] DownloadError),
     /// Database is ahead of static file data.
-    #[error("missing static file data for block number: {number}", number = block.number)]
+    #[error("missing static file data for block number: {number}", number = block.block.number)]
     MissingStaticFileData {
         /// Starting block with  missing data.
-        block: Box<SealedHeader>,
+        block: Box<BlockWithParent>,
         /// Static File segment
         segment: StaticFileSegment,
     },

crates/stages/api/src/pipeline/ctrl.rs

@@ -1,5 +1,5 @@
+use alloy_eips::eip1898::BlockWithParent;
 use alloy_primitives::BlockNumber;
-use reth_primitives_traits::SealedHeader;
 
 /// Determines the control flow during pipeline execution.
 ///
@@ -11,7 +11,7 @@ pub enum ControlFlow {
         /// The block to unwind to.
         target: BlockNumber,
         /// The block that caused the unwind.
-        bad_block: Box<SealedHeader>,
+        bad_block: Box<BlockWithParent>,
     },
     /// The pipeline made progress.
     Continue {

crates/stages/api/src/pipeline/mod.rs

@@ -223,7 +223,7 @@ impl<N: ProviderNodeTypes> Pipeline<N> {
                 }
                 ControlFlow::Continue { block_number } => self.progress.update(block_number),
                 ControlFlow::Unwind { target, bad_block } => {
-                    self.unwind(target, Some(bad_block.number))?;
+                    self.unwind(target, Some(bad_block.block.number))?;
                     return Ok(ControlFlow::Unwind { target, bad_block })
                 }
             }
@@ -505,7 +505,7 @@ fn on_stage_error<N: ProviderNodeTypes>(
 
         // We unwind because of a detached head.
         let unwind_to =
-            local_head.number.saturating_sub(BEACON_CONSENSUS_REORG_UNWIND_DEPTH).max(1);
+            local_head.block.number.saturating_sub(BEACON_CONSENSUS_REORG_UNWIND_DEPTH).max(1);
         Ok(Some(ControlFlow::Unwind { target: unwind_to, bad_block: local_head }))
     } else if let StageError::Block { block, error } = err {
         match error {
@@ -513,7 +513,7 @@ fn on_stage_error<N: ProviderNodeTypes>(
                 error!(
                     target: "sync::pipeline",
                     stage = %stage_id,
-                    bad_block = %block.number,
+                    bad_block = %block.block.number,
                     "Stage encountered a validation error: {validation_error}"
                 );
 
@@ -542,7 +542,7 @@ fn on_stage_error<N: ProviderNodeTypes>(
                 error!(
                     target: "sync::pipeline",
                     stage = %stage_id,
-                    bad_block = %block.number,
+                    bad_block = %block.block.number,
                     "Stage encountered an execution error: {execution_error}"
                 );
 
@@ -560,12 +560,12 @@ fn on_stage_error<N: ProviderNodeTypes>(
         error!(
             target: "sync::pipeline",
             stage = %stage_id,
-            bad_block = %block.number,
+            bad_block = %block.block.number,
             segment = %segment,
             "Stage is missing static file data."
         );
 
-        Ok(Some(ControlFlow::Unwind { target: block.number - 1, bad_block: block }))
+        Ok(Some(ControlFlow::Unwind { target: block.block.number - 1, bad_block: block }))
     } else if err.is_fatal() {
         error!(target: "sync::pipeline", stage = %stage_id, "Stage encountered a fatal error: {err}");
         Err(err.into())
@@ -603,7 +603,7 @@ mod tests {
     use reth_errors::ProviderError;
     use reth_provider::test_utils::{create_test_provider_factory, MockNodeTypesWithDB};
     use reth_prune::PruneModes;
-    use reth_testing_utils::{generators, generators::random_header};
+    use reth_testing_utils::generators::{self, random_block_with_parent};
     use tokio_stream::StreamExt;
 
     #[test]
@@ -975,7 +975,7 @@ mod tests {
             .add_stage(
                 TestStage::new(StageId::Other("B"))
                     .add_exec(Err(StageError::Block {
-                        block: Box::new(random_header(
+                        block: Box::new(random_block_with_parent(
                             &mut generators::rng(),
                             5,
                             Default::default(),

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

@@ -1,5 +1,6 @@
 use crate::stages::MERKLE_STAGE_DEFAULT_CLEAN_THRESHOLD;
 use alloy_consensus::{BlockHeader, Header};
+use alloy_eips::{eip1898::BlockWithParent, NumHash};
 use alloy_primitives::BlockNumber;
 use num_traits::Zero;
 use reth_config::config::ExecutionConfig;
@@ -11,7 +12,7 @@ use reth_evm::{
 };
 use reth_execution_types::Chain;
 use reth_exex::{ExExManagerHandle, ExExNotification, ExExNotificationSource};
-use reth_primitives::{SealedHeader, StaticFileSegment};
+use reth_primitives::StaticFileSegment;
 use reth_primitives_traits::{format_gas_throughput, Block, BlockBody, NodePrimitives};
 use reth_provider::{
     providers::{StaticFileProvider, StaticFileWriter},
@@ -359,9 +360,15 @@ where
             let execute_start = Instant::now();
 
             self.metrics.metered_one((&block, td).into(), |input| {
-                executor.execute_and_verify_one(input).map_err(|error| StageError::Block {
-                    block: Box::new(SealedHeader::seal(block.header().clone())),
-                    error: BlockErrorKind::Execution(error),
+                executor.execute_and_verify_one(input).map_err(|error| {
+                    let header = block.header();
+                    StageError::Block {
+                        block: Box::new(BlockWithParent::new(
+                            header.parent_hash(),
+                            NumHash::new(header.number(), header.hash_slow()),
+                        )),
+                        error: BlockErrorKind::Execution(error),
+                    }
                 })
             })?;
 

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

@@ -1,4 +1,5 @@
 use alloy_consensus::BlockHeader;
+use alloy_eips::{eip1898::BlockWithParent, NumHash};
 use alloy_primitives::{BlockHash, BlockNumber, Bytes, B256};
 use futures_util::StreamExt;
 use reth_config::config::EtlConfig;
@@ -143,7 +144,10 @@ where
             // Header validation
             self.consensus.validate_header_with_total_difficulty(&header, td).map_err(|error| {
                 StageError::Block {
-                    block: Box::new(SealedHeader::new(header.clone(), header_hash)),
+                    block: Box::new(BlockWithParent::new(
+                        header.parent_hash,
+                        NumHash::new(header.number, header_hash),
+                    )),
                     error: BlockErrorKind::Validation(error),
                 }
             })?;
@@ -272,7 +276,11 @@ where
                 }
                 Some(Err(HeadersDownloaderError::DetachedHead { local_head, header, error })) => {
                     error!(target: "sync::stages::headers", %error, "Cannot attach header to head");
-                    return Poll::Ready(Err(StageError::DetachedHead { local_head, header, error }))
+                    return Poll::Ready(Err(StageError::DetachedHead {
+                        local_head: Box::new(local_head.block_with_parent()),
+                        header: Box::new(header.block_with_parent()),
+                        error,
+                    }))
                 }
                 None => return Poll::Ready(Err(StageError::ChannelClosed)),
             }

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

@@ -357,7 +357,7 @@ fn validate_state_root(
             error: BlockErrorKind::Validation(ConsensusError::BodyStateRootDiff(
                 GotExpected { got, expected: expected.state_root }.into(),
             )),
-            block: Box::new(expected),
+            block: Box::new(expected.block_with_parent()),
         })
     }
 }

crates/stages/stages/src/stages/sender_recovery.rs

@@ -192,7 +192,7 @@ where
                                 })?;
 
                             Err(StageError::Block {
-                                block: Box::new(sealed_header),
+                                block: Box::new(sealed_header.block_with_parent()),
                                 error: BlockErrorKind::Validation(
                                     ConsensusError::TransactionSignerRecoveryError,
                                 ),

crates/stages/stages/src/stages/utils.rs

@@ -279,5 +279,8 @@ where
 
     let missing_block = Box::new(provider.sealed_header(last_block + 1)?.unwrap_or_default());
 
-    Ok(StageError::MissingStaticFileData { block: missing_block, segment })
+    Ok(StageError::MissingStaticFileData {
+        block: Box::new(missing_block.block_with_parent()),
+        segment,
+    })
 }