refactor!: streamline OpBlockExecutionError error type to replace a hard-coded BlockExecutionError

bin/reth/src/commands/debug_cmd/execution.rs

@@ -68,7 +68,7 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>> Command<C> {
         provider_factory: ProviderFactory<N>,
         task_executor: &TaskExecutor,
         static_file_producer: StaticFileProducer<ProviderFactory<N>>,
-    ) -> eyre::Result<Pipeline<N>>
+    ) -> eyre::Result<Pipeline<N, E>>
     where
         N: ProviderNodeTypes<ChainSpec = C::ChainSpec, Primitives = EthPrimitives> + CliNodeTypes,
         Client: EthBlockClient + 'static,

crates/cli/commands/src/import.rs

@@ -166,7 +166,7 @@ pub fn build_import_pipeline<N, C, E>(
     static_file_producer: StaticFileProducer<ProviderFactory<N>>,
     disable_exec: bool,
     executor: E,
-) -> eyre::Result<(Pipeline<N>, impl Stream<Item = NodeEvent<N::Primitives>>)>
+) -> eyre::Result<(Pipeline<N, E>, impl Stream<Item = NodeEvent<N::Primitives>>)>
 where
     N: ProviderNodeTypes + CliNodeTypes,
     C: Consensus<BlockTy<N>, Error = ConsensusError> + 'static,

crates/cli/commands/src/stage/unwind.rs

@@ -108,7 +108,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> Command<C>
         self,
         config: Config,
         provider_factory: ProviderFactory<N>,
-    ) -> Result<Pipeline<N>, eyre::Error> {
+    ) -> Result<Pipeline<N, E>, eyre::Error> {
         let stage_conf = &config.stages;
         let prune_modes = config.prune.clone().map(|prune| prune.segments).unwrap_or_default();
 

crates/engine/service/src/service.rs

@@ -79,7 +79,7 @@ where
         chain_spec: Arc<N::ChainSpec>,
         client: Client,
         incoming_requests: EngineMessageStream<N::Engine>,
-        pipeline: Pipeline<N>,
+        pipeline: Pipeline<N, E>,
         pipeline_task_spawner: Box<dyn TaskSpawner>,
         provider: ProviderFactory<N>,
         blockchain_db: BlockchainProvider<N>,

crates/engine/tree/src/backfill.rs

@@ -8,6 +8,7 @@
 //! These modes are mutually exclusive and the node can only be in one mode at a time.
 
 use futures::FutureExt;
+use reth_errors::GenericBlockExecutionError;
 use reth_provider::providers::ProviderNodeTypes;
 use reth_stages_api::{ControlFlow, Pipeline, PipelineError, PipelineTarget, PipelineWithResult};
 use reth_tasks::TaskSpawner;
@@ -90,7 +91,7 @@ pub struct PipelineSync<N: ProviderNodeTypes> {
 
 impl<N: ProviderNodeTypes> PipelineSync<N> {
     /// Create a new instance.
-    pub fn new(pipeline: Pipeline<N>, pipeline_task_spawner: Box<dyn TaskSpawner>) -> Self {
+    pub fn new(pipeline: Pipeline<N, E>, pipeline_task_spawner: Box<dyn TaskSpawner>) -> Self {
         Self {
             pipeline_task_spawner,
             pipeline_state: PipelineState::Idle(Some(pipeline)),
@@ -212,11 +213,11 @@ impl<N: ProviderNodeTypes> BackfillSync for PipelineSync<N> {
 /// blockchain tree any messages that would result in database writes, since it would result in a
 /// deadlock.
 #[derive(Debug)]
-enum PipelineState<N: ProviderNodeTypes> {
+enum PipelineState<N: ProviderNodeTypes, E: GenericBlockExecutionError> {
     /// Pipeline is idle.
-    Idle(Option<Pipeline<N>>),
+    Idle(Option<Pipeline<N, E>>),
     /// Pipeline is running and waiting for a response
-    Running(oneshot::Receiver<PipelineWithResult<N>>),
+    Running(oneshot::Receiver<PipelineWithResult<N, E>>),
 }
 
 impl<N: ProviderNodeTypes> PipelineState<N> {

crates/errors/src/lib.rs

@@ -16,7 +16,9 @@ mod error;
 pub use error::{RethError, RethResult};
 
 pub use reth_consensus::ConsensusError;
-pub use reth_execution_errors::{BlockExecutionError, BlockValidationError};
+pub use reth_execution_errors::{
+    BlockExecutionError, BlockValidationError, GenericBlockExecutionError,
+};
 pub use reth_storage_errors::{
     db::DatabaseError,
     provider::{ProviderError, ProviderResult},

crates/ethereum/evm/src/execute.rs

@@ -69,6 +69,8 @@ where
             Transaction = reth_primitives::TransactionSigned,
         >,
 {
+    type Error = BlockExecutionError;
+
     type Primitives = EthPrimitives;
 
     type Strategy<DB: Database<Error: Into<ProviderError> + Display>> =

crates/evm/execution-errors/src/lib.rs

@@ -17,6 +17,7 @@ use alloc::{
 };
 use alloy_eips::BlockNumHash;
 use alloy_primitives::B256;
+use core::fmt::Display;
 use reth_consensus::ConsensusError;
 use reth_prune_types::PruneSegmentError;
 use reth_storage_errors::provider::ProviderError;
@@ -134,6 +135,21 @@ pub enum BlockExecutionError {
     Internal(#[from] InternalBlockExecutionError),
 }
 
+/// Generic block execution error.
+pub trait GenericBlockExecutionError:
+    Display + Sync + Send + std::fmt::Debug + 'static + From<ConsensusError> + From<BlockExecutionError>
+{
+    /// Returns `true` if the error is a state root error.
+    fn is_state_root_error(&self) -> bool;
+}
+
+impl GenericBlockExecutionError for BlockExecutionError {
+    /// Returns `true` if the error is a state root error.
+    fn is_state_root_error(&self) -> bool {
+        matches!(self, Self::Validation(BlockValidationError::StateRoot(_)))
+    }
+}
+
 impl BlockExecutionError {
     /// Create a new [`BlockExecutionError::Internal`] variant, containing a
     /// [`InternalBlockExecutionError::Other`] error.
@@ -157,11 +173,6 @@ impl BlockExecutionError {
             _ => None,
         }
     }
-
-    /// Returns `true` if the error is a state root error.
-    pub const fn is_state_root_error(&self) -> bool {
-        matches!(self, Self::Validation(BlockValidationError::StateRoot(_)))
-    }
 }
 
 impl From<ProviderError> for BlockExecutionError {

crates/evm/src/either.rs

@@ -19,10 +19,12 @@ use revm::State;
 impl<A, B> BlockExecutorProvider for Either<A, B>
 where
     A: BlockExecutorProvider,
-    B: BlockExecutorProvider<Primitives = A::Primitives>,
+    B: BlockExecutorProvider<Primitives = A::Primitives, Error = A::Error>,
 {
     type Primitives = A::Primitives;
 
+    type Error = A::Error;
+
     type Executor<DB: Database<Error: Into<ProviderError> + Display>> =
         Either<A::Executor<DB>, B::Executor<DB>>;
 

crates/evm/src/execute.rs

@@ -1,6 +1,7 @@
 //! Traits for execution.
 
 use alloy_consensus::BlockHeader;
+use reth_execution_errors::GenericBlockExecutionError;
 // Re-export execution types
 pub use reth_execution_errors::{
     BlockExecutionError, BlockValidationError, InternalBlockExecutionError,
@@ -80,7 +81,7 @@ pub trait BatchExecutor<DB> {
     /// The output type for the executor.
     type Output;
     /// The error type returned by the executor.
-    type Error;
+    type Error: GenericBlockExecutionError;
 
     /// Executes the next block in the batch, verifies the output and updates the state internally.
     fn execute_and_verify_one(&mut self, input: Self::Input<'_>) -> Result<(), Self::Error>;
@@ -137,6 +138,9 @@ pub trait BlockExecutorProvider: Send + Sync + Clone + Unpin + 'static {
     /// Receipt type.
     type Primitives: NodePrimitives;
 
+    /// The error type returned by the executor.
+    type Error: GenericBlockExecutionError;
+
     /// An executor that can execute a single block given a database.
     ///
     /// # Verification
@@ -152,15 +156,15 @@ pub trait BlockExecutorProvider: Send + Sync + Clone + Unpin + 'static {
         DB,
         Input<'a> = &'a RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>,
         Output = BlockExecutionOutput<<Self::Primitives as NodePrimitives>::Receipt>,
-        Error = BlockExecutionError,
+        Error = Self::Error,
     >;
 
     /// An executor that can execute a batch of blocks given a database.
     type BatchExecutor<DB: Database<Error: Into<ProviderError> + Display>>: for<'a> BatchExecutor<
         DB,
         Input<'a> = &'a RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>,
         Output = ExecutionOutcome<<Self::Primitives as NodePrimitives>::Receipt>,
-        Error = BlockExecutionError,
+        Error = Self::Error,
     >;
 
     /// Creates a new executor for single block execution.
@@ -197,7 +201,7 @@ pub trait BlockExecutionStrategy {
     type Primitives: NodePrimitives;
 
     /// The error type returned by this strategy's methods.
-    type Error: From<ProviderError> + core::error::Error;
+    type Error: GenericBlockExecutionError;
 
     /// Initialize the strategy with the given transaction environment overrides.
     fn init(&mut self, _tx_env_overrides: Box<dyn TxEnvOverrides>) {}
@@ -249,14 +253,17 @@ pub trait BlockExecutionStrategy {
 
 /// A strategy factory that can create block execution strategies.
 pub trait BlockExecutionStrategyFactory: Send + Sync + Clone + Unpin + 'static {
+    /// The error type returned by this strategy's methods.
+    type Error: GenericBlockExecutionError;
+
     /// Primitive types used by the strategy.
     type Primitives: NodePrimitives;
 
     /// Associated strategy type.
     type Strategy<DB: Database<Error: Into<ProviderError> + Display>>: BlockExecutionStrategy<
         DB = DB,
         Primitives = Self::Primitives,
-        Error = BlockExecutionError,
+        Error = Self::Error,
     >;
 
     /// Creates a strategy using the give database.
@@ -291,6 +298,8 @@ impl<F> BlockExecutorProvider for BasicBlockExecutorProvider<F>
 where
     F: BlockExecutionStrategyFactory,
 {
+    type Error = F::Error;
+
     type Primitives = F::Primitives;
 
     type Executor<DB: Database<Error: Into<ProviderError> + Display>> =
@@ -421,12 +430,12 @@ where
 
 impl<S, DB> BatchExecutor<DB> for BasicBatchExecutor<S>
 where
-    S: BlockExecutionStrategy<DB = DB, Error = BlockExecutionError>,
+    S: BlockExecutionStrategy<DB = DB>,
     DB: Database<Error: Into<ProviderError> + Display>,
 {
     type Input<'a> = &'a RecoveredBlock<<S::Primitives as NodePrimitives>::Block>;
     type Output = ExecutionOutcome<<S::Primitives as NodePrimitives>::Receipt>;
-    type Error = BlockExecutionError;
+    type Error = S::Error;
 
     fn execute_and_verify_one(&mut self, block: Self::Input<'_>) -> Result<(), Self::Error> {
         if self.batch_record.first_block().is_none() {
@@ -525,6 +534,7 @@ mod tests {
     struct TestExecutorProvider;
 
     impl BlockExecutorProvider for TestExecutorProvider {
+        type Error = BlockExecutionError;
         type Primitives = EthPrimitives;
         type Executor<DB: Database<Error: Into<ProviderError> + Display>> = TestExecutor<DB>;
         type BatchExecutor<DB: Database<Error: Into<ProviderError> + Display>> = TestExecutor<DB>;
@@ -623,6 +633,7 @@ mod tests {
     }
 
     impl BlockExecutionStrategyFactory for TestExecutorStrategyFactory {
+        type Error = BlockExecutionError;
         type Primitives = EthPrimitives;
         type Strategy<DB: Database<Error: Into<ProviderError> + Display>> =
             TestExecutorStrategy<DB, TestEvmConfig>;

crates/evm/src/metrics.rs

@@ -145,6 +145,7 @@ mod tests {
     use super::*;
     use alloy_eips::eip7685::Requests;
     use metrics_util::debugging::{DebugValue, DebuggingRecorder, Snapshotter};
+    use reth_execution_errors::BlockExecutionError;
     use revm::db::BundleState;
     use revm_primitives::{
         Account, AccountInfo, AccountStatus, EvmState, EvmStorage, EvmStorageSlot, B256, U256,
@@ -162,7 +163,7 @@ mod tests {
         where
             Self: 'a;
         type Output = BlockExecutionOutput<()>;
-        type Error = std::convert::Infallible;
+        type Error = BlockExecutionError;
 
         fn execute(self, _input: Self::Input<'_>) -> Result<Self::Output, Self::Error> {
             Ok(BlockExecutionOutput {

crates/evm/src/noop.rs

@@ -25,6 +25,8 @@ pub struct NoopBlockExecutorProvider<P>(core::marker::PhantomData<P>);
 impl<P: NodePrimitives> BlockExecutorProvider for NoopBlockExecutorProvider<P> {
     type Primitives = P;
 
+    type Error = BlockExecutionError;
+
     type Executor<DB: Database<Error: Into<ProviderError> + Display>> = Self;
 
     type BatchExecutor<DB: Database<Error: Into<ProviderError> + Display>> = Self;

crates/evm/src/test_utils.rs

@@ -35,6 +35,8 @@ impl MockExecutorProvider {
 impl BlockExecutorProvider for MockExecutorProvider {
     type Primitives = EthPrimitives;
 
+    type Error = BlockExecutionError;
+
     type Executor<DB: Database<Error: Into<ProviderError> + Display>> = Self;
 
     type BatchExecutor<DB: Database<Error: Into<ProviderError> + Display>> = Self;

crates/exex/exex/src/backfill/job.rs

@@ -39,7 +39,10 @@ pub struct BackfillJob<E, P> {
 
 impl<E, P> Iterator for BackfillJob<E, P>
 where
-    E: BlockExecutorProvider<Primitives: NodePrimitives<Block = P::Block>>,
+    E: BlockExecutorProvider<
+        Primitives: NodePrimitives<Block = P::Block>,
+        Error = BlockExecutionError,
+    >,
     P: HeaderProvider + BlockReader<Transaction: SignedTransaction> + StateProviderFactory,
 {
     type Item = BackfillJobResult<Chain<E::Primitives>>;
@@ -55,7 +58,10 @@ where
 
 impl<E, P> BackfillJob<E, P>
 where
-    E: BlockExecutorProvider<Primitives: NodePrimitives<Block = P::Block>>,
+    E: BlockExecutorProvider<
+        Primitives: NodePrimitives<Block = P::Block>,
+        Error = BlockExecutionError,
+    >,
     P: BlockReader<Transaction: SignedTransaction> + HeaderProvider + StateProviderFactory,
 {
     /// Converts the backfill job into a single block backfill job.
@@ -161,7 +167,10 @@ pub struct SingleBlockBackfillJob<E, P> {
 
 impl<E, P> Iterator for SingleBlockBackfillJob<E, P>
 where
-    E: BlockExecutorProvider<Primitives: NodePrimitives<Block = P::Block>>,
+    E: BlockExecutorProvider<
+        Primitives: NodePrimitives<Block = P::Block>,
+        Error = BlockExecutionError,
+    >,
     P: HeaderProvider + BlockReader + StateProviderFactory,
 {
     type Item = BackfillJobResult<(
@@ -176,7 +185,10 @@ where
 
 impl<E, P> SingleBlockBackfillJob<E, P>
 where
-    E: BlockExecutorProvider<Primitives: NodePrimitives<Block = P::Block>>,
+    E: BlockExecutorProvider<
+        Primitives: NodePrimitives<Block = P::Block>,
+        Error = BlockExecutionError,
+    >,
     P: HeaderProvider + BlockReader + StateProviderFactory,
 {
     /// Converts the single block backfill job into a stream.

crates/exex/exex/src/backfill/stream.rs

@@ -114,7 +114,11 @@ where
 
 impl<E, P> Stream for StreamBackfillJob<E, P, SingleBlockStreamItem<E::Primitives>>
 where
-    E: BlockExecutorProvider<Primitives: NodePrimitives<Block = P::Block>> + Clone + 'static,
+    E: BlockExecutorProvider<
+            Primitives: NodePrimitives<Block = P::Block>,
+            Error = BlockExecutionError,
+        > + Clone
+        + 'static,
     P: BlockReader + StateProviderFactory + Clone + Unpin + 'static,
 {
     type Item = BackfillJobResult<SingleBlockStreamItem<E::Primitives>>;
@@ -147,7 +151,11 @@ where
 
 impl<E, P> Stream for StreamBackfillJob<E, P, BatchBlockStreamItem<E::Primitives>>
 where
-    E: BlockExecutorProvider<Primitives: NodePrimitives<Block = P::Block>> + Clone + 'static,
+    E: BlockExecutorProvider<
+            Primitives: NodePrimitives<Block = P::Block>,
+            Error = BlockExecutionError,
+        > + Clone
+        + 'static,
     P: BlockReader + StateProviderFactory + Clone + Unpin + 'static,
 {
     type Item = BackfillJobResult<BatchBlockStreamItem<E::Primitives>>;