DatabaseError -> BackendError

Author: klkvr

src/cache.rs

@@ -99,17 +99,17 @@ impl BlockchainDb {
     }
 
     /// Returns the Env related metadata
-    pub fn meta(&self) -> &Arc<RwLock<BlockchainDbMeta>> {
+    pub const fn meta(&self) -> &Arc<RwLock<BlockchainDbMeta>> {
         &self.meta
     }
 
     /// Returns the inner cache
-    pub fn cache(&self) -> &Arc<JsonBlockCacheDB> {
+    pub const fn cache(&self) -> &Arc<JsonBlockCacheDB> {
         &self.cache
     }
 
     /// Returns the underlying storage
-    pub fn db(&self) -> &Arc<MemDb> {
+    pub const fn db(&self) -> &Arc<MemDb> {
         &self.db
     }
 }
@@ -364,17 +364,17 @@ impl JsonBlockCacheDB {
     }
 
     /// Returns the [MemDb] it holds access to
-    pub fn db(&self) -> &Arc<MemDb> {
+    pub const fn db(&self) -> &Arc<MemDb> {
         &self.data.data
     }
 
     /// Metadata stored alongside the data
-    pub fn meta(&self) -> &Arc<RwLock<BlockchainDbMeta>> {
+    pub const fn meta(&self) -> &Arc<RwLock<BlockchainDbMeta>> {
         &self.data.meta
     }
 
     /// Returns `true` if this is a transient cache and nothing will be flushed
-    pub fn is_transient(&self) -> bool {
+    pub const fn is_transient(&self) -> bool {
         self.cache_path.is_none()
     }
 

src/error.rs

@@ -1,7 +1,6 @@
 use alloy_primitives::{Address, B256, U256};
 use alloy_rpc_types::BlockId;
 use futures::channel::mpsc::{SendError, TrySendError};
-use revm::primitives::EVMError;
 use std::{
     convert::Infallible,
     sync::{mpsc::RecvError, Arc},
@@ -14,12 +13,6 @@ pub type DatabaseResult<T> = Result<T, DatabaseError>;
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum DatabaseError {
-    #[error("{0}")]
-    Message(String),
-    #[error("cheatcodes are not enabled for {0}; see `vm.allowCheatcodes(address)`")]
-    NoCheats(Address),
-    #[error("failed to fetch account info for {0}")]
-    MissingAccount(Address),
     #[error("missing bytecode for code hash {0}")]
     MissingCode(B256),
     #[error(transparent)]
@@ -38,30 +31,9 @@ pub enum DatabaseError {
     BlockNotFound(BlockId),
     #[error("failed to get transaction {0}: {1}")]
     GetTransaction(B256, Arc<eyre::Error>),
-    #[error("transaction {0} not found")]
-    TransactionNotFound(B256),
-    #[error(
-        "CREATE2 Deployer (0x4e59b44847b379578588920ca78fbf26c0b4956c) not present on this chain.\n\
-         For a production environment, you can deploy it using the pre-signed transaction from \
-         https://github.com/Arachnid/deterministic-deployment-proxy.\n\
-         For a test environment, you can use `etch` to place the required bytecode at that address."
-    )]
-    MissingCreate2Deployer,
-    #[error("{0}")]
-    Other(String),
 }
 
 impl DatabaseError {
-    /// Create a new error with a message
-    pub fn msg(msg: impl Into<String>) -> Self {
-        Self::Message(msg.into())
-    }
-
-    /// Create a new error with a message
-    pub fn display(msg: impl std::fmt::Display) -> Self {
-        Self::Message(msg.to_string())
-    }
-
     fn get_rpc_error(&self) -> Option<&eyre::Error> {
         match self {
             Self::GetAccount(_, err) => Some(err),
@@ -70,16 +42,7 @@ impl DatabaseError {
             Self::GetFullBlock(_, err) => Some(err),
             Self::GetTransaction(_, err) => Some(err),
             // Enumerate explicitly to make sure errors are updated if a new one is added.
-            Self::NoCheats(_)
-            | Self::MissingAccount(_)
-            | Self::MissingCode(_)
-            | Self::Recv(_)
-            | Self::Send(_)
-            | Self::Message(_)
-            | Self::BlockNotFound(_)
-            | Self::TransactionNotFound(_)
-            | Self::MissingCreate2Deployer => None,
-            Self::Other(_) => None,
+            Self::MissingCode(_) | Self::Recv(_) | Self::Send(_) | Self::BlockNotFound(_) => None,
         }
     }
 
@@ -94,12 +57,6 @@ impl DatabaseError {
     }
 }
 
-impl From<tokio::task::JoinError> for DatabaseError {
-    fn from(value: tokio::task::JoinError) -> Self {
-        Self::display(value)
-    }
-}
-
 impl<T> From<TrySendError<T>> for DatabaseError {
     fn from(value: TrySendError<T>) -> Self {
         value.into_send_error().into()
@@ -111,13 +68,3 @@ impl From<Infallible> for DatabaseError {
         match value {}
     }
 }
-
-// Note: this is mostly necessary to use some revm internals that return an [EVMError]
-impl From<EVMError<Self>> for DatabaseError {
-    fn from(err: EVMError<Self>) -> Self {
-        match err {
-            EVMError::Database(err) => err,
-            err => Self::Other(err.to_string()),
-        }
-    }
-}