chore: propagate inner error in ef tests (#16970)

testing/ef-tests/src/cases/blockchain_test.rs

@@ -108,7 +108,7 @@ impl BlockchainTestCase {
             }
 
             // A block processing failure occurred.
-            Err(Error::BlockProcessingFailed { block_number }) => match expectation {
+            err @ Err(Error::BlockProcessingFailed { block_number, .. }) => match expectation {
                 // It happened on exactly the block we were told to fail on
                 Some((expected, _)) if block_number == expected => Ok(()),
 
@@ -122,7 +122,7 @@ impl BlockchainTestCase {
                 ))),
 
                 // No failure expected at all - bubble up original error.
-                None => Err(Error::BlockProcessingFailed { block_number }),
+                None => err,
             },
 
             // Non‑processing error – forward as‑is.
@@ -199,15 +199,15 @@ fn run_case(case: &BlockchainTest) -> Result<(), Error> {
 
     provider
         .insert_block(genesis_block.clone(), StorageLocation::Database)
-        .map_err(|_| Error::BlockProcessingFailed { block_number: 0 })?;
+        .map_err(|err| Error::block_failed(0, err))?;
 
     let genesis_state = case.pre.clone().into_genesis_state();
     insert_genesis_state(&provider, genesis_state.iter())
-        .map_err(|_| Error::BlockProcessingFailed { block_number: 0 })?;
+        .map_err(|err| Error::block_failed(0, err))?;
     insert_genesis_hashes(&provider, genesis_state.iter())
-        .map_err(|_| Error::BlockProcessingFailed { block_number: 0 })?;
+        .map_err(|err| Error::block_failed(0, err))?;
     insert_genesis_history(&provider, genesis_state.iter())
-        .map_err(|_| Error::BlockProcessingFailed { block_number: 0 })?;
+        .map_err(|err| Error::block_failed(0, err))?;
 
     // Decode blocks
     let blocks = decode_blocks(&case.blocks)?;
@@ -223,11 +223,11 @@ fn run_case(case: &BlockchainTest) -> Result<(), Error> {
         // Insert the block into the database
         provider
             .insert_block(block.clone(), StorageLocation::Database)
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+            .map_err(|err| Error::block_failed(block_number, err))?;
 
         // Consensus checks before block execution
         pre_execution_checks(chain_spec.clone(), &parent, block)
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+            .map_err(|err| Error::block_failed(block_number, err))?;
 
         let mut witness_record = ExecutionWitnessRecord::default();
 
@@ -240,11 +240,11 @@ fn run_case(case: &BlockchainTest) -> Result<(), Error> {
             .execute_with_state_closure(&(*block).clone(), |statedb: &State<_>| {
                 witness_record.record_executed_state(statedb);
             })
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+            .map_err(|err| Error::block_failed(block_number, err))?;
 
         // Consensus checks after block execution
         validate_block_post_execution(block, &chain_spec, &output.receipts, &output.requests)
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+            .map_err(|err| Error::block_failed(block_number, err))?;
 
         // Generate the stateless witness
         // TODO: Most of this code is copy-pasted from debug_executionWitness
@@ -278,9 +278,12 @@ fn run_case(case: &BlockchainTest) -> Result<(), Error> {
             HashedPostState::from_bundle_state::<KeccakKeyHasher>(output.state.state());
         let (computed_state_root, _) =
             StateRoot::overlay_root_with_updates(provider.tx_ref(), hashed_state.clone())
-                .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+                .map_err(|err| Error::block_failed(block_number, err))?;
         if computed_state_root != block.state_root {
-            return Err(Error::BlockProcessingFailed { block_number })
+            return Err(Error::block_failed(
+                block_number,
+                Error::Assertion("state root mismatch".to_string()),
+            ))
         }
 
         // Commit the post state/state diff to the database
@@ -290,14 +293,14 @@ fn run_case(case: &BlockchainTest) -> Result<(), Error> {
                 OriginalValuesKnown::Yes,
                 StorageLocation::Database,
             )
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+            .map_err(|err| Error::block_failed(block_number, err))?;
 
         provider
             .write_hashed_state(&hashed_state.into_sorted())
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+            .map_err(|err| Error::block_failed(block_number, err))?;
         provider
             .update_history_indices(block.number..=block.number)
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+            .map_err(|err| Error::block_failed(block_number, err))?;
 
         // Since there were no errors, update the parent block
         parent = block.clone()
@@ -341,12 +344,10 @@ fn decode_blocks(
         let block_number = (block_index + 1) as u64;
 
         let decoded = SealedBlock::<Block>::decode(&mut block.rlp.as_ref())
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+            .map_err(|err| Error::block_failed(block_number, err))?;
 
-        let recovered_block = decoded
-            .clone()
-            .try_recover()
-            .map_err(|_| Error::BlockProcessingFailed { block_number })?;
+        let recovered_block =
+            decoded.clone().try_recover().map_err(|err| Error::block_failed(block_number, err))?;
 
         blocks.push(recovered_block);
     }

testing/ef-tests/src/result.rs

@@ -23,10 +23,13 @@ pub enum Error {
     /// Block processing failed
     /// Note: This includes but is not limited to execution.
     /// For example, the header number could be incorrect.
-    #[error("block {block_number} failed to process")]
+    #[error("block {block_number} failed to process: {err}")]
     BlockProcessingFailed {
         /// The block number for the block that failed
         block_number: u64,
+        /// The specific error
+        #[source]
+        err: Box<dyn std::error::Error + Send + Sync>,
     },
     /// An IO error occurred
     #[error("an error occurred interacting with the file system at {path}: {error}")]
@@ -63,6 +66,16 @@ pub enum Error {
     ConsensusError(#[from] reth_consensus::ConsensusError),
 }
 
+impl Error {
+    /// Create a new [`Error::BlockProcessingFailed`] error.
+    pub fn block_failed(
+        block_number: u64,
+        err: impl std::error::Error + Send + Sync + 'static,
+    ) -> Self {
+        Self::BlockProcessingFailed { block_number, err: Box::new(err) }
+    }
+}
+
 /// The result of running a test.
 #[derive(Debug)]
 pub struct CaseResult {