refactor(trie): return OpProofsStorageError from execute_and_store_block_updates

crates/optimism/trie/src/error.rs

@@ -2,6 +2,8 @@
 
 use alloy_primitives::B256;
 use reth_db::DatabaseError;
+use reth_execution_errors::BlockExecutionError;
+use reth_provider::ProviderError;
 use reth_trie::Nibbles;
 use std::sync::Arc;
 use thiserror::Error;
@@ -82,6 +84,12 @@ pub enum OpProofsStorageError {
     /// Error occurred while trying to acquire a lock.
     #[error("failed lock attempt")]
     TryLockError,
+    /// Error occurred during block execution.
+    #[error(transparent)]
+    ExecutionError(Arc<BlockExecutionError>),
+    /// Error occurred while interacting with the provider.
+    #[error(transparent)]
+    ProviderError(Arc<ProviderError>),
 }
 
 impl From<TryLockError> for OpProofsStorageError {
@@ -90,6 +98,18 @@ impl From<TryLockError> for OpProofsStorageError {
     }
 }
 
+impl From<BlockExecutionError> for OpProofsStorageError {
+    fn from(error: BlockExecutionError) -> Self {
+        Self::ExecutionError(Arc::new(error))
+    }
+}
+
+impl From<ProviderError> for OpProofsStorageError {
+    fn from(error: ProviderError) -> Self {
+        Self::ProviderError(Arc::new(error))
+    }
+}
+
 impl From<OpProofsStorageError> for DatabaseError {
     fn from(error: OpProofsStorageError) -> Self {
         match error {

crates/optimism/trie/src/live.rs

@@ -40,7 +40,7 @@ where
     pub async fn execute_and_store_block_updates(
         &self,
         block: &RecoveredBlock<BlockTy<Evm::Primitives>>,
-    ) -> eyre::Result<()> {
+    ) -> Result<(), OpProofsStorageError> {
         let mut operation_durations = OperationDurations::default();
 
         let start = Instant::now();
@@ -49,21 +49,20 @@ where
             self.storage.get_earliest_block_number().await?,
             self.storage.get_latest_block_number().await?,
         ) else {
-            return Err(OpProofsStorageError::NoBlocksFound.into());
+            return Err(OpProofsStorageError::NoBlocksFound);
         };
 
         let parent_block_number = block.number() - 1;
         if parent_block_number < earliest {
-            return Err(OpProofsStorageError::UnknownParent.into());
+            return Err(OpProofsStorageError::UnknownParent);
         }
 
         if parent_block_number > latest {
             return Err(OpProofsStorageError::MissingParentBlock {
                 block_number: block.number(),
                 parent_block_number,
                 latest_block_number: latest,
-            }
-            .into());
+            });
         }
 
         let block_ref =
@@ -80,8 +79,7 @@ where
         let db = StateProviderDatabase::new(&state_provider);
         let block_executor = self.evm_config.batch_executor(db);
 
-        let execution_result =
-            block_executor.execute(&(*block).clone()).map_err(|err| eyre::eyre!(err))?;
+        let execution_result = block_executor.execute(&(*block).clone())?;
 
         operation_durations.execution_duration_seconds = start.elapsed();
 
@@ -97,8 +95,7 @@ where
                 block_number: block.number(),
                 current_state_hash: state_root,
                 expected_state_hash: block.state_root(),
-            }
-            .into());
+            });
         }
 
         let update_result = self

crates/optimism/trie/tests/live.rs

@@ -361,10 +361,7 @@ async fn test_execute_and_store_block_updates_missing_parent_block() {
     // EXPECT: MissingParentBlock
     let err = collector.execute_and_store_block_updates(&incorrect_block).await.unwrap_err();
 
-    assert!(matches!(
-        err.downcast_ref::<OpProofsStorageError>().unwrap(),
-        OpProofsStorageError::MissingParentBlock { .. }
-    ));
+    assert!(matches!(err, OpProofsStorageError::MissingParentBlock { .. }));
 }
 
 #[tokio::test]
@@ -425,10 +422,7 @@ async fn test_execute_and_store_block_updates_state_root_mismatch() {
     // EXPECT: StateRootMismatch
     let err = collector.execute_and_store_block_updates(&block).await.unwrap_err();
 
-    assert!(matches!(
-        err.downcast_ref::<OpProofsStorageError>(),
-        Some(OpProofsStorageError::StateRootMismatch { .. })
-    ));
+    assert!(matches!(err, OpProofsStorageError::StateRootMismatch { .. }));
 }
 
 /// Test with multiple blocks before and after backfill