refactor(storage): use connector-specific errors, remove Config variants

Creates dedicated error types for connector initialization:
- MdbxConnectorError in cold-mdbx crate
- SqlConnectorError in cold-sql crate

Removes Config(String) variants from MdbxError and SqlColdError, which
were only used for from_env() methods. The new connector error types
are more specific and properly handle missing environment variables.

ConfigError now uses From implementations to convert from connector
errors, simplifying error handling in the builder.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: prestwich

crates/cold-mdbx/src/connector.rs

@@ -8,6 +8,22 @@ use signet_hot::HotConnect;
 use signet_hot_mdbx::{DatabaseArguments, DatabaseEnv, MdbxError};
 use std::path::PathBuf;
 
+/// Errors that can occur when initializing MDBX connectors.
+#[derive(Debug, thiserror::Error)]
+pub enum MdbxConnectorError {
+    /// Missing environment variable.
+    #[error("missing environment variable: {0}")]
+    MissingEnvVar(&'static str),
+
+    /// Hot storage initialization failed.
+    #[error("hot storage initialization failed: {0}")]
+    HotInit(#[from] MdbxError),
+
+    /// Cold storage initialization failed.
+    #[error("cold storage initialization failed: {0}")]
+    ColdInit(#[from] MdbxColdError),
+}
+
 /// Connector for MDBX storage (both hot and cold).
 ///
 /// This unified connector can open MDBX databases for both hot and cold storage.
@@ -65,15 +81,14 @@ impl MdbxConnector {
     /// # Example
     ///
     /// ```ignore
-    /// use signet_hot_mdbx::MdbxConnector;
+    /// use signet_cold_mdbx::MdbxConnector;
     ///
     /// let hot = MdbxConnector::from_env("SIGNET_HOT_PATH")?;
     /// let cold = MdbxConnector::from_env("SIGNET_COLD_PATH")?;
     /// ```
-    pub fn from_env(env_var: &str) -> Result<Self, MdbxError> {
-        let path: PathBuf = std::env::var(env_var)
-            .map_err(|_| MdbxError::Config(format!("missing environment variable: {env_var}")))?
-            .into();
+    pub fn from_env(env_var: &'static str) -> Result<Self, MdbxConnectorError> {
+        let path: PathBuf =
+            std::env::var(env_var).map_err(|_| MdbxConnectorError::MissingEnvVar(env_var))?.into();
         Ok(Self::new(path))
     }
 }

crates/cold-mdbx/src/lib.rs

@@ -47,6 +47,6 @@ mod backend;
 pub use backend::MdbxColdBackend;
 
 mod connector;
-pub use connector::MdbxConnector;
+pub use connector::{MdbxConnector, MdbxConnectorError};
 
 pub use signet_hot_mdbx::{DatabaseArguments, DatabaseEnvKind};

crates/cold-sql/src/connector.rs

@@ -3,6 +3,18 @@
 use crate::{SqlColdBackend, SqlColdError};
 use signet_cold::ColdConnect;
 
+/// Errors that can occur when initializing SQL connectors.
+#[derive(Debug, thiserror::Error)]
+pub enum SqlConnectorError {
+    /// Missing environment variable.
+    #[error("missing environment variable: {0}")]
+    MissingEnvVar(&'static str),
+
+    /// Cold storage initialization failed.
+    #[error("cold storage initialization failed: {0}")]
+    ColdInit(#[from] SqlColdError),
+}
+
 /// Connector for SQL cold storage (PostgreSQL or SQLite).
 ///
 /// Automatically detects the database type from the URL:
@@ -53,10 +65,8 @@ impl SqlConnector {
     ///
     /// let cold = SqlConnector::from_env("SIGNET_COLD_SQL_URL")?;
     /// ```
-    pub fn from_env(env_var: &str) -> Result<Self, SqlColdError> {
-        let url = std::env::var(env_var).map_err(|_| {
-            SqlColdError::Config(format!("missing environment variable: {env_var}"))
-        })?;
+    pub fn from_env(env_var: &'static str) -> Result<Self, SqlConnectorError> {
+        let url = std::env::var(env_var).map_err(|_| SqlConnectorError::MissingEnvVar(env_var))?;
         Ok(Self::new(url))
     }
 }

crates/cold-sql/src/error.rs

@@ -10,10 +10,6 @@ pub enum SqlColdError {
     /// A data conversion error occurred.
     #[error("conversion error: {0}")]
     Convert(String),
-
-    /// Configuration error.
-    #[error("configuration error: {0}")]
-    Config(String),
 }
 
 impl From<SqlColdError> for signet_cold::ColdStorageError {

crates/cold-sql/src/lib.rs

@@ -50,7 +50,7 @@ pub use backend::SqlColdBackend;
 #[cfg(any(feature = "sqlite", feature = "postgres"))]
 mod connector;
 #[cfg(any(feature = "sqlite", feature = "postgres"))]
-pub use connector::SqlConnector;
+pub use connector::{SqlConnector, SqlConnectorError};
 
 /// Backward-compatible alias for [`SqlColdBackend`] when using SQLite.
 #[cfg(feature = "sqlite")]

crates/hot-mdbx/src/error.rs

@@ -55,10 +55,6 @@ pub enum MdbxError {
     /// Deser.
     #[error(transparent)]
     Deser(#[from] DeserError),
-
-    /// Configuration error.
-    #[error("configuration error: {0}")]
-    Config(String),
 }
 
 impl trevm::revm::database::DBErrorMarker for MdbxError {}

crates/storage/src/builder.rs

@@ -123,26 +123,21 @@ impl StorageBuilder<MdbxConnector, EnvColdConnector> {
     /// Exactly one cold backend must be specified.
     pub fn from_env() -> Result<Self, ConfigError> {
         // Hot connector from environment (always MDBX)
-        let hot_connector = MdbxConnector::from_env(ENV_HOT_PATH)
-            .map_err(|e| ConfigError::ConnectorError { connector: "hot", error: e.to_string() })?;
+        let hot_connector = MdbxConnector::from_env(ENV_HOT_PATH)?;
 
         // Determine cold backend from environment
         let has_mdbx = env::var(ENV_COLD_PATH).is_ok();
         let has_sql = env::var(ENV_COLD_SQL_URL).is_ok();
 
         let cold_connector = match (has_mdbx, has_sql) {
             (true, false) => {
-                let mdbx = MdbxConnector::from_env(ENV_COLD_PATH).map_err(|e| {
-                    ConfigError::ConnectorError { connector: "cold MDBX", error: e.to_string() }
-                })?;
+                let mdbx = MdbxConnector::from_env(ENV_COLD_PATH)?;
                 Either::left(mdbx)
             }
             (false, true) => {
                 #[cfg(any(feature = "postgres", feature = "sqlite"))]
                 {
-                    let sql = SqlConnector::from_env(ENV_COLD_SQL_URL).map_err(|e| {
-                        ConfigError::ConnectorError { connector: "cold SQL", error: e.to_string() }
-                    })?;
+                    let sql = SqlConnector::from_env(ENV_COLD_SQL_URL)?;
                     Either::right(sql)
                 }
                 #[cfg(not(any(feature = "postgres", feature = "sqlite")))]

crates/storage/src/config.rs

@@ -13,8 +13,12 @@
 //!
 //! Exactly one of `SIGNET_COLD_PATH` or `SIGNET_COLD_SQL_URL` must be set.
 
+use signet_cold_mdbx::MdbxConnectorError;
 use thiserror::Error;
 
+#[cfg(any(feature = "postgres", feature = "sqlite"))]
+use signet_cold_sql::SqlConnectorError;
+
 /// Environment variable name for hot storage path.
 pub const ENV_HOT_PATH: &str = "SIGNET_HOT_PATH";
 
@@ -48,12 +52,12 @@ pub enum ConfigError {
         env_var: &'static str,
     },
 
-    /// Connector initialization error.
-    #[error("{connector} connector error: {error}")]
-    ConnectorError {
-        /// The connector type (e.g., "hot", "cold MDBX", "cold SQL").
-        connector: &'static str,
-        /// The underlying error message.
-        error: String,
-    },
+    /// MDBX connector error.
+    #[error("MDBX connector error: {0}")]
+    MdbxConnector(#[from] MdbxConnectorError),
+
+    /// SQL connector error.
+    #[cfg(any(feature = "postgres", feature = "sqlite"))]
+    #[error("SQL connector error: {0}")]
+    SqlConnector(#[from] SqlConnectorError),
 }