chore(errors): manually implement errors instead of using thiserror

Author: Evalir

Cargo.toml

@@ -36,7 +36,6 @@ revm = { version = "14.0.3", default-features = false, features = ["std"] }
 
 zenith-types = "0.9"
 
-thiserror = "1.0"
 alloy-rlp = "0.3"
 
 [dev-dependencies]

src/driver/alloy.rs

@@ -12,49 +12,83 @@ use alloy::{
 };
 use alloy_primitives::{bytes::Buf, keccak256, Address, Bytes, TxKind, U256};
 use revm::primitives::{EVMError, ExecutionResult, MAX_BLOB_GAS_PER_BLOCK};
-use thiserror::Error;
 
 /// Possible errors that can occur while driving a bundle.
-#[derive(Error)]
 pub enum BundleError<Db: revm::Database> {
     /// The block number of the bundle does not match the block number of the revm block configuration.
-    #[error("revm block number must match the bundle block number")]
     BlockNumberMismatch,
     /// The timestamp of the bundle is out of range.
-    #[error("timestamp out of range")]
     TimestampOutOfRange,
     /// The bundle was reverted (or halted).
-    #[error("bundle reverted")]
     BundleReverted,
     /// The bundle has no transactions
-    #[error("bundle has no transactions")]
     BundleEmpty,
     /// Too many blob transactions
-    #[error("max blob gas limit exceeded")]
     Eip4844BlobGasExceeded,
     /// An unsupported transaction type was encountered.
-    #[error("unsupported transaction type")]
     UnsupportedTransactionType,
     /// An error occurred while decoding a transaction contained in the bundle.
-    #[error("transaction decoding error")]
-    TransactionDecodingError(#[from] alloy::eips::eip2718::Eip2718Error),
-    /// An error ocurred while recovering the sender of a transaction
-    #[error("transaction sender recovery error")]
-    TransactionSenderRecoveryError(#[from] alloy_primitives::SignatureError),
+    TransactionDecodingError(alloy::eips::eip2718::Eip2718Error),
+    /// An error occurred while recovering the sender of a transaction.
+    TransactionSenderRecoveryError(alloy_primitives::SignatureError),
     /// An error occurred while running the EVM.
-    #[error("internal EVM Error")]
     EVMError {
         /// The error that occurred while running the EVM.
         inner: EVMError<Db::Error>,
     },
 }
 
+// Manually implementing the Display trait for formatting the errors
+impl<Db: revm::Database> core::fmt::Display for BundleError<Db> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::BlockNumberMismatch => {
+                write!(f, "revm block number must match the bundle block number")
+            }
+            Self::TimestampOutOfRange => write!(f, "timestamp out of range"),
+            Self::BundleReverted => write!(f, "bundle reverted"),
+            Self::BundleEmpty => write!(f, "bundle has no transactions"),
+            Self::Eip4844BlobGasExceeded => write!(f, "max blob gas limit exceeded"),
+            Self::UnsupportedTransactionType => write!(f, "unsupported transaction type"),
+            Self::TransactionDecodingError(_) => write!(f, "transaction decoding error"),
+            Self::TransactionSenderRecoveryError(_) => {
+                write!(f, "transaction sender recovery error")
+            }
+            Self::EVMError { inner: _ } => write!(f, "internal EVM Error"),
+        }
+    }
+}
+
+// Manually implement From for TransactionDecodingError (formerly #[from])
+impl<Db: revm::Database> From<alloy::eips::eip2718::Eip2718Error> for BundleError<Db> {
+    fn from(err: alloy::eips::eip2718::Eip2718Error) -> Self {
+        Self::TransactionDecodingError(err)
+    }
+}
+
+// Manually implement From for TransactionSenderRecoveryError (formerly #[from])
+impl<Db: revm::Database> From<alloy_primitives::SignatureError> for BundleError<Db> {
+    fn from(err: alloy_primitives::SignatureError) -> Self {
+        Self::TransactionSenderRecoveryError(err)
+    }
+}
+
 impl<Db: revm::Database> From<EVMError<Db::Error>> for BundleError<Db> {
     fn from(inner: EVMError<Db::Error>) -> Self {
         Self::EVMError { inner }
     }
 }
 
+impl<Db: revm::Database> core::error::Error for BundleError<Db> {
+    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
+        match self {
+            Self::TransactionDecodingError(err) => Some(err),
+            Self::TransactionSenderRecoveryError(err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
 impl<Db: revm::Database> core::fmt::Debug for BundleError<Db> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {

src/journal/coder.rs

@@ -44,11 +44,48 @@ const ACCOUNT_INFO_BYTES: usize = 8 + 32 + 32;
 const INFO_OUTCOME_MIN_BYTES: usize = 1 + ACCOUNT_INFO_BYTES;
 const ACCT_DIFF_MIN_BYTES: usize = 4 + INFO_OUTCOME_MIN_BYTES;
 
+// /// Error decoding journal types.
+// #[derive(thiserror::Error, Debug, Copy, Clone, PartialEq, Eq)]
+// pub enum JournalDecodeError {
+//     /// The buffer does not contain enough data to decode the type.
+//     #[error("buffer overrun while decoding {ty_name}. Expected {expected} bytes, but only {remaining} bytes remain")]
+//     Overrun {
+//         /// The name of the type being decoded.
+//         ty_name: &'static str,
+//         /// The number of bytes required to decode the type.
+//         expected: usize,
+//         /// The number of bytes remaining in the buffer.
+//         remaining: usize,
+//     },
+
+//     /// Invalid tag while decoding a type.
+//     #[error("invalid tag while decoding {ty_name}. Expected a tag in range 0..={max_expected}, got {tag}")]
+//     InvalidTag {
+//         /// The name of the type being decoded.
+//         ty_name: &'static str,
+//         /// The tag that was decoded.
+//         tag: u8,
+//         /// The maximum expected tag value.
+//         max_expected: u8,
+//     },
+
+//     /// Storage slot is unchanged, journal should not contain unchanged slots.
+//     #[error("storage slot is unchanged. Unchanged items should never be in the journal")]
+//     UnchangedStorage,
+
+//     /// Error decoding an EOF bytecode.
+//     #[error("error decoding EOF bytecode: {0}")]
+//     EofDecode(#[from] EofDecodeError),
+
+//     /// Error decoding an EIP-7702 bytecode.
+//     #[error("error decoding EIP-7702 bytecode: {0}")]
+//     Eip7702Decode(#[from] Eip7702DecodeError),
+// }
+
 /// Error decoding journal types.
-#[derive(thiserror::Error, Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum JournalDecodeError {
     /// The buffer does not contain enough data to decode the type.
-    #[error("buffer overrun while decoding {ty_name}. Expected {expected} bytes, but only {remaining} bytes remain")]
     Overrun {
         /// The name of the type being decoded.
         ty_name: &'static str,
@@ -59,7 +96,6 @@ pub enum JournalDecodeError {
     },
 
     /// Invalid tag while decoding a type.
-    #[error("invalid tag while decoding {ty_name}. Expected a tag in range 0..={max_expected}, got {tag}")]
     InvalidTag {
         /// The name of the type being decoded.
         ty_name: &'static str,
@@ -70,16 +106,50 @@ pub enum JournalDecodeError {
     },
 
     /// Storage slot is unchanged, journal should not contain unchanged slots.
-    #[error("storage slot is unchanged. Unchanged items should never be in the journal")]
     UnchangedStorage,
 
     /// Error decoding an EOF bytecode.
-    #[error("error decoding EOF bytecode: {0}")]
-    EofDecode(#[from] EofDecodeError),
+    EofDecode(EofDecodeError),
 
     /// Error decoding an EIP-7702 bytecode.
-    #[error("error decoding EIP-7702 bytecode: {0}")]
-    Eip7702Decode(#[from] Eip7702DecodeError),
+    Eip7702Decode(Eip7702DecodeError),
+}
+
+impl core::fmt::Display for JournalDecodeError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Overrun { ty_name, expected, remaining } => {
+                write!(f, "buffer overrun while decoding {ty_name}. Expected {expected} bytes, but only {remaining} bytes remain")
+            }
+            Self::InvalidTag { ty_name, tag, max_expected } => {
+                write!(f, "invalid tag while decoding {ty_name}. Expected a tag in range 0..={max_expected}, got {tag}")
+            }
+            Self::UnchangedStorage => {
+                write!(
+                    f,
+                    "storage slot is unchanged. Unchanged items should never be in the journal"
+                )
+            }
+            Self::EofDecode(e) => {
+                write!(f, "error decoding EOF bytecode: {e}")
+            }
+            Self::Eip7702Decode(e) => {
+                write!(f, "error decoding EIP-7702 bytecode: {e}")
+            }
+        }
+    }
+}
+
+impl From<EofDecodeError> for JournalDecodeError {
+    fn from(err: EofDecodeError) -> Self {
+        Self::EofDecode(err)
+    }
+}
+
+impl From<Eip7702DecodeError> for JournalDecodeError {
+    fn from(err: Eip7702DecodeError) -> Self {
+        Self::Eip7702Decode(err)
+    }
 }
 
 macro_rules! check_len {