fix(storage): desugar async fn in ColdConnect trait to specify Send bound

Addresses async-fn-in-trait clippy lint by explicitly desugaring async
fn to return impl Future + Send. This makes the Send bound explicit
and allows callers to know the future can be sent across threads.

Changes:
- Desugar ColdConnect::connect to return impl Future + Send
- Add #[allow(clippy::manual_async_fn)] to MDBX and EitherCold impls
- Fix redundant closures in error mapping
- Add Debug derive to StorageBuilder
- Add serial_test to workspace for test isolation

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

Author: prestwich

Cargo.toml

@@ -66,6 +66,7 @@ parking_lot = "0.12.5"
 rand = "0.9.2"
 rayon = "1.10"
 serde = { version = "1.0.217", features = ["derive"] }
+serial_test = "3.3"
 tempfile = "3.20.0"
 thiserror = "2.0.18"
 tokio = { version = "1.45.0", features = ["full"] }

crates/cold-mdbx/src/connector.rs

@@ -106,9 +106,11 @@ impl ColdConnect for MdbxConnector {
     type Cold = MdbxColdBackend;
     type Error = MdbxColdError;
 
-    async fn connect(&self) -> Result<Self::Cold, Self::Error> {
+    #[allow(clippy::manual_async_fn)]
+    fn connect(&self) -> impl std::future::Future<Output = Result<Self::Cold, Self::Error>> + Send {
         // MDBX open is sync, but wrapped in async for trait consistency
         // Opens read-write and creates tables
-        MdbxColdBackend::open_rw(&self.path)
+        let path = self.path.clone();
+        async move { MdbxColdBackend::open_rw(&path) }
     }
 }

crates/cold-sql/src/connector.rs

@@ -76,7 +76,8 @@ impl ColdConnect for SqlConnector {
     type Cold = SqlColdBackend;
     type Error = SqlColdError;
 
-    async fn connect(&self) -> Result<Self::Cold, Self::Error> {
-        SqlColdBackend::connect(&self.url).await
+    fn connect(&self) -> impl std::future::Future<Output = Result<Self::Cold, Self::Error>> + Send {
+        let url = self.url.clone();
+        async move { SqlColdBackend::connect(&url).await }
     }
 }

crates/cold/src/connect.rs

@@ -17,5 +17,5 @@ pub trait ColdConnect {
     ///
     /// Async to support backends that require async initialization
     /// (like SQL connection pools).
-    async fn connect(&self) -> Result<Self::Cold, Self::Error>;
+    fn connect(&self) -> impl std::future::Future<Output = Result<Self::Cold, Self::Error>> + Send;
 }

crates/storage/Cargo.toml

@@ -28,6 +28,7 @@ thiserror.workspace = true
 tokio-util.workspace = true
 
 [dev-dependencies]
+serial_test.workspace = true
 signet-storage = { path = ".", features = ["test-utils"] }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 tokio-util.workspace = true

crates/storage/src/builder.rs

@@ -39,7 +39,7 @@ type EnvColdConnector = Either<MdbxConnector, ()>;
 ///     .build()
 ///     .await?;
 /// ```
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct StorageBuilder<H = (), C = ()> {
     hot_connector: H,
     cold_connector: C,
@@ -163,8 +163,10 @@ impl StorageBuilder<MdbxConnector, EnvColdConnector> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serial_test::serial;
 
     #[test]
+    #[serial]
     fn from_env_missing_hot_path() {
         // SAFETY: Test environment
         unsafe {
@@ -174,6 +176,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn from_env_missing_cold_backend() {
         // SAFETY: Test environment
         unsafe {
@@ -186,6 +189,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn from_env_ambiguous_cold_backend() {
         // SAFETY: Test environment
         unsafe {
@@ -198,6 +202,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn from_env_mdbx_cold() {
         // SAFETY: Test environment
         unsafe {

crates/storage/src/either.rs

@@ -71,6 +71,7 @@ macro_rules! dispatch_async {
 }
 
 // Implement ColdStorage for EitherCold by dispatching to inner type
+#[allow(clippy::manual_async_fn)]
 impl ColdStorage for EitherCold {
     fn get_header(
         &self,
@@ -181,15 +182,18 @@ impl ColdConnect for Either<MdbxConnector, SqlConnector> {
     type Cold = EitherCold;
     type Error = crate::StorageError;
 
-    async fn connect(&self) -> Result<Self::Cold, Self::Error> {
-        match self {
-            Either::Left(mdbx) => {
-                let backend = mdbx.connect().await.map_err(|e| crate::StorageError::MdbxCold(e))?;
-                Ok(EitherCold::Mdbx(backend))
-            }
-            Either::Right(sql) => {
-                let backend = sql.connect().await.map_err(|e| crate::StorageError::SqlCold(e))?;
-                Ok(EitherCold::Sql(backend))
+    fn connect(&self) -> impl std::future::Future<Output = Result<Self::Cold, Self::Error>> + Send {
+        let self_clone = self.clone();
+        async move {
+            match self_clone {
+                Either::Left(mdbx) => {
+                    let backend = mdbx.connect().await.map_err(crate::StorageError::MdbxCold)?;
+                    Ok(EitherCold::Mdbx(backend))
+                }
+                Either::Right(sql) => {
+                    let backend = sql.connect().await.map_err(crate::StorageError::SqlCold)?;
+                    Ok(EitherCold::Sql(backend))
+                }
             }
         }
     }
@@ -201,12 +205,13 @@ impl ColdConnect for Either<MdbxConnector, ()> {
     type Cold = MdbxColdBackend;
     type Error = crate::StorageError;
 
-    async fn connect(&self) -> Result<Self::Cold, Self::Error> {
-        match self {
-            Either::Left(mdbx) => {
-                mdbx.connect().await.map_err(|e| crate::StorageError::MdbxCold(e))
+    fn connect(&self) -> impl std::future::Future<Output = Result<Self::Cold, Self::Error>> + Send {
+        let self_clone = self.clone();
+        async move {
+            match self_clone {
+                Either::Left(mdbx) => mdbx.connect().await.map_err(crate::StorageError::MdbxCold),
+                Either::Right(()) => unreachable!("SQL not enabled"),
             }
-            Either::Right(()) => unreachable!("SQL not enabled"),
         }
     }
 }