Remove unused wallet traits (#1574)

* fix: remove unused wallet traits

* refactor: move Acquired to the Mint where it is used

crates/cdk-common/src/database/mint/mod.rs

@@ -1,13 +1,13 @@
 //! CDK Database
 
 use std::collections::HashMap;
+use std::ops::{Deref, DerefMut};
 
 use async_trait::async_trait;
 use cashu::quote_id::QuoteId;
 use cashu::Amount;
 
 use super::{DbTransactionFinalizer, Error};
-use crate::database::Acquired;
 use crate::mint::{
     self, MeltQuote, MintKeySetInfo, MintQuote as MintMintQuote, Operation, ProofsWithState,
 };
@@ -32,6 +32,76 @@ pub use super::kvstore::{
     KVSTORE_NAMESPACE_KEY_ALPHABET, KVSTORE_NAMESPACE_KEY_MAX_LEN,
 };
 
+/// A wrapper indicating that a resource has been acquired with a database lock.
+///
+/// This type is returned by database operations that lock rows for update
+/// (e.g., `SELECT ... FOR UPDATE`). It serves as a compile-time marker that
+/// the wrapped resource was properly locked before being returned, ensuring
+/// that subsequent modifications are safe from race conditions.
+///
+/// # Usage
+///
+/// When you need to modify a database record, first acquire it using a locking
+/// query method. The returned `Acquired<T>` guarantees the row is locked for
+/// the duration of the transaction.
+///
+/// ```ignore
+/// // Acquire a quote with a row lock
+/// let mut quote: Acquired<MintQuote> = tx.get_mint_quote_for_update(&quote_id).await?;
+///
+/// // Safely modify the quote (row is locked)
+/// quote.state = QuoteState::Paid;
+///
+/// // Persist the changes
+/// tx.update_mint_quote(&mut quote).await?;
+/// ```
+///
+/// # Deref Behavior
+///
+/// `Acquired<T>` implements `Deref` and `DerefMut`, allowing transparent access
+/// to the inner value's methods and fields.
+#[derive(Debug)]
+pub struct Acquired<T> {
+    inner: T,
+}
+
+impl<T> From<T> for Acquired<T> {
+    /// Wraps a value to indicate it has been acquired with a lock.
+    ///
+    /// This is typically called by database layer implementations after
+    /// executing a locking query.
+    fn from(value: T) -> Self {
+        Acquired { inner: value }
+    }
+}
+
+impl<T> Acquired<T> {
+    /// Consumes the wrapper and returns the inner resource.
+    ///
+    /// Use this when you need to take ownership of the inner value,
+    /// for example when passing it to a function that doesn't accept
+    /// `Acquired<T>`.
+    pub fn inner(self) -> T {
+        self.inner
+    }
+}
+
+impl<T> Deref for Acquired<T> {
+    type Target = T;
+
+    /// Returns a reference to the inner resource.
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for Acquired<T> {
+    /// Returns a mutable reference to the inner resource.
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
 /// Information about a melt request stored in the database
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MeltRequestInfo {

crates/cdk-common/src/database/mod.rs

@@ -7,8 +7,6 @@ pub mod mint;
 #[cfg(feature = "wallet")]
 pub mod wallet;
 
-use std::ops::{Deref, DerefMut};
-
 // Re-export shared KVStore types at the top level for both mint and wallet
 pub use kvstore::{
     validate_kvstore_params, validate_kvstore_string, KVStore, KVStoreDatabase, KVStoreTransaction,
@@ -32,94 +30,6 @@ pub use mint::{DynMintAuthDatabase, MintAuthDatabase, MintAuthTransaction};
 #[cfg(feature = "wallet")]
 pub use wallet::Database as WalletDatabase;
 
-/// A wrapper indicating that a resource has been acquired with a database lock.
-///
-/// This type is returned by database operations that lock rows for update
-/// (e.g., `SELECT ... FOR UPDATE`). It serves as a compile-time marker that
-/// the wrapped resource was properly locked before being returned, ensuring
-/// that subsequent modifications are safe from race conditions.
-///
-/// # Usage
-///
-/// When you need to modify a database record, first acquire it using a locking
-/// query method. The returned `Acquired<T>` guarantees the row is locked for
-/// the duration of the transaction.
-///
-/// ```ignore
-/// // Acquire a quote with a row lock
-/// let mut quote: Acquired<MintQuote> = tx.get_mint_quote_for_update(&quote_id).await?;
-///
-/// // Safely modify the quote (row is locked)
-/// quote.state = QuoteState::Paid;
-///
-/// // Persist the changes
-/// tx.update_mint_quote(&mut quote).await?;
-/// ```
-///
-/// # Deref Behavior
-///
-/// `Acquired<T>` implements `Deref` and `DerefMut`, allowing transparent access
-/// to the inner value's methods and fields.
-#[derive(Debug)]
-pub struct Acquired<T> {
-    inner: T,
-}
-
-impl<T> From<T> for Acquired<T> {
-    /// Wraps a value to indicate it has been acquired with a lock.
-    ///
-    /// This is typically called by database layer implementations after
-    /// executing a locking query.
-    fn from(value: T) -> Self {
-        Acquired { inner: value }
-    }
-}
-
-impl<T> Acquired<T> {
-    /// Consumes the wrapper and returns the inner resource.
-    ///
-    /// Use this when you need to take ownership of the inner value,
-    /// for example when passing it to a function that doesn't accept
-    /// `Acquired<T>`.
-    pub fn inner(self) -> T {
-        self.inner
-    }
-}
-
-impl<T> Deref for Acquired<T> {
-    type Target = T;
-
-    /// Returns a reference to the inner resource.
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<T> DerefMut for Acquired<T> {
-    /// Returns a mutable reference to the inner resource.
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-
-/// Type alias for dynamic Wallet Database
-#[cfg(feature = "wallet")]
-pub type DynWalletDatabase = std::sync::Arc<dyn WalletDatabase<Error> + Send + Sync>;
-
-// Wallet-specific KVStore type aliases
-/// Wallet Key-Value Store trait object
-#[cfg(feature = "wallet")]
-pub type WalletKVStore = dyn KVStore<Err = Error> + Send + Sync;
-/// Arc-wrapped wallet KV store for shared ownership
-#[cfg(feature = "wallet")]
-pub type DynWalletKVStore = std::sync::Arc<WalletKVStore>;
-/// Wallet Key-Value Store Database trait object
-#[cfg(feature = "wallet")]
-pub type WalletKVStoreDatabase = dyn KVStoreDatabase<Err = Error> + Send + Sync;
-/// Wallet Key-Value Store Transaction trait object
-#[cfg(feature = "wallet")]
-pub type WalletKVStoreTransaction = dyn KVStoreTransaction<Error> + Send + Sync;
-
 /// Data conversion error
 #[derive(thiserror::Error, Debug)]
 pub enum ConversionError {

crates/cdk-common/src/database/wallet/mod.rs

@@ -8,7 +8,6 @@ use cashu::KeySet;
 
 use super::Error;
 use crate::common::ProofInfo;
-use crate::database::KVStoreDatabase;
 use crate::mint_url::MintUrl;
 use crate::nuts::{
     CurrencyUnit, Id, KeySetInfo, Keys, MintInfo, PublicKey, SpendingConditions, State,
@@ -23,7 +22,7 @@ pub mod test;
 /// Wallet Database trait
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait Database<Err>: KVStoreDatabase<Err = Err> + Debug
+pub trait Database<Err>: Debug
 where
     Err: Into<Error> + From<Error>,
 {
@@ -152,6 +151,21 @@ where
 
     // KV Store write methods (non-transactional)
 
+    /// Read a value from the key-value store
+    async fn kv_read(
+        &self,
+        primary_namespace: &str,
+        secondary_namespace: &str,
+        key: &str,
+    ) -> Result<Option<Vec<u8>>, Err>;
+
+    /// List keys in a namespace
+    async fn kv_list(
+        &self,
+        primary_namespace: &str,
+        secondary_namespace: &str,
+    ) -> Result<Vec<String>, Err>;
+
     /// Write a value to the key-value store
     async fn kv_write(
         &self,

crates/cdk-ffi/src/database.rs

@@ -3,9 +3,7 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use cdk_common::database::{
-    KVStoreDatabase as CdkKVStoreDatabase, WalletDatabase as CdkWalletDatabase,
-};
+use cdk_common::database::WalletDatabase as CdkWalletDatabase;
 use cdk_sql_common::pool::DatabasePool;
 use cdk_sql_common::SQLWalletDatabase;
 
@@ -209,15 +207,13 @@ impl std::fmt::Debug for WalletDatabaseBridge {
 }
 
 #[async_trait::async_trait]
-impl cdk_common::database::KVStoreDatabase for WalletDatabaseBridge {
-    type Err = cdk::cdk_database::Error;
-
+impl CdkWalletDatabase<cdk::cdk_database::Error> for WalletDatabaseBridge {
     async fn kv_read(
         &self,
         primary_namespace: &str,
         secondary_namespace: &str,
         key: &str,
-    ) -> Result<Option<Vec<u8>>, Self::Err> {
+    ) -> Result<Option<Vec<u8>>, cdk::cdk_database::Error> {
         self.ffi_db
             .kv_read(
                 primary_namespace.to_string(),
@@ -232,7 +228,7 @@ impl cdk_common::database::KVStoreDatabase for WalletDatabaseBridge {
         &self,
         primary_namespace: &str,
         secondary_namespace: &str,
-    ) -> Result<Vec<String>, Self::Err> {
+    ) -> Result<Vec<String>, cdk::cdk_database::Error> {
         self.ffi_db
             .kv_list(
                 primary_namespace.to_string(),
@@ -241,10 +237,7 @@ impl cdk_common::database::KVStoreDatabase for WalletDatabaseBridge {
             .await
             .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
-}
 
-#[async_trait::async_trait]
-impl CdkWalletDatabase<cdk::cdk_database::Error> for WalletDatabaseBridge {
     // Mint Management
     async fn get_mint(
         &self,
@@ -343,7 +336,9 @@ impl CdkWalletDatabase<cdk::cdk_database::Error> for WalletDatabaseBridge {
             .collect::<Result<Vec<_>, _>>()?)
     }
 
-    async fn get_unissued_mint_quotes(&self) -> Result<Vec<cdk::wallet::MintQuote>, Self::Err> {
+    async fn get_unissued_mint_quotes(
+        &self,
+    ) -> Result<Vec<cdk::wallet::MintQuote>, cdk::cdk_database::Error> {
         let result = self
             .ffi_db
             .get_unissued_mint_quotes()

crates/cdk-redb/src/wallet/mod.rs

@@ -8,7 +8,7 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use cdk_common::common::ProofInfo;
-use cdk_common::database::{validate_kvstore_params, KVStoreDatabase, WalletDatabase};
+use cdk_common::database::{validate_kvstore_params, WalletDatabase};
 use cdk_common::mint_url::MintUrl;
 use cdk_common::nut00::KnownMethod;
 use cdk_common::util::unix_time;
@@ -312,7 +312,7 @@ impl WalletDatabase<database::Error> for WalletRedbDatabase {
             .collect())
     }
 
-    async fn get_unissued_mint_quotes(&self) -> Result<Vec<MintQuote>, Self::Err> {
+    async fn get_unissued_mint_quotes(&self) -> Result<Vec<MintQuote>, database::Error> {
         let read_txn = self.db.begin_read().map_err(Into::<Error>::into)?;
         let table = read_txn
             .open_table(MINT_QUOTES_TABLE)
@@ -945,7 +945,58 @@ impl WalletDatabase<database::Error> for WalletRedbDatabase {
         Ok(())
     }
 
-    // KV Store write methods (non-transactional)
+    // KV Store methods
+
+    #[instrument(skip(self))]
+    async fn kv_read(
+        &self,
+        primary_namespace: &str,
+        secondary_namespace: &str,
+        key: &str,
+    ) -> Result<Option<Vec<u8>>, database::Error> {
+        // Validate parameters according to KV store requirements
+        validate_kvstore_params(primary_namespace, secondary_namespace, Some(key))?;
+
+        let read_txn = self.db.begin_read().map_err(Error::from)?;
+        let table = read_txn.open_table(KV_STORE_TABLE).map_err(Error::from)?;
+
+        let result = table
+            .get((primary_namespace, secondary_namespace, key))
+            .map_err(Error::from)?
+            .map(|v| v.value().to_vec());
+
+        Ok(result)
+    }
+
+    #[instrument(skip(self))]
+    async fn kv_list(
+        &self,
+        primary_namespace: &str,
+        secondary_namespace: &str,
+    ) -> Result<Vec<String>, database::Error> {
+        // Validate parameters according to KV store requirements
+        validate_kvstore_params(primary_namespace, secondary_namespace, None)?;
+
+        let read_txn = self.db.begin_read().map_err(Error::from)?;
+        let table = read_txn.open_table(KV_STORE_TABLE).map_err(Error::from)?;
+
+        let start = (primary_namespace, secondary_namespace, "");
+        let iter = table.range(start..).map_err(Error::from)?;
+
+        let mut keys = Vec::new();
+
+        for item in iter {
+            let (key, _) = item.map_err(Error::from)?;
+            let (p, s, k) = key.value();
+            if p == primary_namespace && s == secondary_namespace {
+                keys.push(k.to_string());
+            } else {
+                break;
+            }
+        }
+
+        Ok(keys)
+    }
 
     #[instrument(skip(self, value))]
     async fn kv_write(
@@ -993,58 +1044,6 @@ impl WalletDatabase<database::Error> for WalletRedbDatabase {
     }
 }
 
-#[async_trait]
-impl KVStoreDatabase for WalletRedbDatabase {
-    type Err = database::Error;
-
-    #[instrument(skip_all)]
-    async fn kv_read(
-        &self,
-        primary_namespace: &str,
-        secondary_namespace: &str,
-        key: &str,
-    ) -> Result<Option<Vec<u8>>, Self::Err> {
-        // Validate parameters according to KV store requirements
-        validate_kvstore_params(primary_namespace, secondary_namespace, Some(key))?;
-
-        let read_txn = self.db.begin_read().map_err(Error::from)?;
-        let table = read_txn.open_table(KV_STORE_TABLE).map_err(Error::from)?;
-
-        let result = table
-            .get((primary_namespace, secondary_namespace, key))
-            .map_err(Error::from)?
-            .map(|v| v.value().to_vec());
-
-        Ok(result)
-    }
-
-    #[instrument(skip_all)]
-    async fn kv_list(
-        &self,
-        primary_namespace: &str,
-        secondary_namespace: &str,
-    ) -> Result<Vec<String>, Self::Err> {
-        validate_kvstore_params(primary_namespace, secondary_namespace, None)?;
-
-        let read_txn = self.db.begin_read().map_err(Error::from)?;
-        let table = read_txn.open_table(KV_STORE_TABLE).map_err(Error::from)?;
-
-        let mut keys = Vec::new();
-        let start = (primary_namespace, secondary_namespace, "");
-
-        for result in table.range(start..).map_err(Error::from)? {
-            let (key_tuple, _) = result.map_err(Error::from)?;
-            let (primary_from_db, secondary_from_db, k) = key_tuple.value();
-            if primary_from_db != primary_namespace || secondary_from_db != secondary_namespace {
-                break;
-            }
-            keys.push(k.to_string());
-        }
-
-        Ok(keys)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use std::path::PathBuf;

crates/cdk-sql-common/src/mint/proofs.rs

@@ -4,7 +4,8 @@ use std::collections::HashMap;
 use std::str::FromStr;
 
 use async_trait::async_trait;
-use cdk_common::database::{self, Acquired, Error, MintProofsDatabase};
+use cdk_common::database::mint::Acquired;
+use cdk_common::database::{self, Error, MintProofsDatabase};
 use cdk_common::mint::{Operation, ProofsWithState};
 use cdk_common::nut00::ProofsMethods;
 use cdk_common::quote_id::QuoteId;

crates/cdk-sql-common/src/mint/quotes.rs

@@ -3,9 +3,9 @@
 use std::str::FromStr;
 
 use async_trait::async_trait;
-use cdk_common::database::mint::LockedMeltQuotes;
+use cdk_common::database::mint::{Acquired, LockedMeltQuotes};
 use cdk_common::database::{
-    self, Acquired, ConversionError, Error, MintQuotesDatabase, MintQuotesTransaction,
+    self, ConversionError, Error, MintQuotesDatabase, MintQuotesTransaction,
 };
 use cdk_common::mint::{
     self, IncomingPayment, Issuance, MeltPaymentRequest, MeltQuote, MintQuote, Operation,

crates/cdk-sql-common/src/wallet/mod.rs

@@ -500,7 +500,7 @@ where
     }
 
     #[instrument(skip(self))]
-    async fn get_unissued_mint_quotes(&self) -> Result<Vec<MintQuote>, Self::Err> {
+    async fn get_unissued_mint_quotes(&self) -> Result<Vec<MintQuote>, database::Error> {
         let conn = self.pool.get().map_err(|e| Error::Database(Box::new(e)))?;
         Ok(query(
             r#"
@@ -1283,6 +1283,23 @@ where
 
     // KV Store write methods (non-transactional)
 
+    async fn kv_read(
+        &self,
+        primary_namespace: &str,
+        secondary_namespace: &str,
+        key: &str,
+    ) -> Result<Option<Vec<u8>>, database::Error> {
+        crate::keyvalue::kv_read(&self.pool, primary_namespace, secondary_namespace, key).await
+    }
+
+    async fn kv_list(
+        &self,
+        primary_namespace: &str,
+        secondary_namespace: &str,
+    ) -> Result<Vec<String>, database::Error> {
+        crate::keyvalue::kv_list(&self.pool, primary_namespace, secondary_namespace).await
+    }
+
     async fn kv_write(
         &self,
         primary_namespace: &str,
@@ -1555,30 +1572,3 @@ fn sql_row_to_transaction(row: Vec<Column>) -> Result<Transaction, Error> {
             .map_err(Error::from)?,
     })
 }
-
-// KVStore implementations for wallet
-
-#[async_trait]
-impl<RM> database::KVStoreDatabase for SQLWalletDatabase<RM>
-where
-    RM: DatabasePool + 'static,
-{
-    type Err = Error;
-
-    async fn kv_read(
-        &self,
-        primary_namespace: &str,
-        secondary_namespace: &str,
-        key: &str,
-    ) -> Result<Option<Vec<u8>>, Error> {
-        crate::keyvalue::kv_read(&self.pool, primary_namespace, secondary_namespace, key).await
-    }
-
-    async fn kv_list(
-        &self,
-        primary_namespace: &str,
-        secondary_namespace: &str,
-    ) -> Result<Vec<String>, Error> {
-        crate::keyvalue::kv_list(&self.pool, primary_namespace, secondary_namespace).await
-    }
-}

crates/cdk/src/mint/issue/mod.rs

@@ -1,4 +1,4 @@
-use cdk_common::database::Acquired;
+use cdk_common::database::mint::Acquired;
 use cdk_common::mint::{MintQuote, Operation};
 use cdk_common::nut00::KnownMethod;
 use cdk_common::payment::{

crates/cdk/src/mint/melt/shared.rs

@@ -6,7 +6,8 @@
 //!
 //! The functions here ensure consistency between these two code paths.
 
-use cdk_common::database::{self, Acquired, DynMintDatabase};
+use cdk_common::database::mint::Acquired;
+use cdk_common::database::{self, DynMintDatabase};
 use cdk_common::nuts::{BlindSignature, BlindedMessage, MeltQuoteState, State};
 use cdk_common::{Amount, CurrencyUnit, Error, PublicKey, QuoteId};
 use cdk_signatory::signatory::SignatoryKeySet;

crates/cdk/src/mint/mod.rs

@@ -6,9 +6,10 @@ use std::time::Duration;
 
 use arc_swap::ArcSwap;
 use cdk_common::common::{PaymentProcessorKey, QuoteTTL};
+use cdk_common::database::mint::Acquired;
 #[cfg(feature = "auth")]
 use cdk_common::database::DynMintAuthDatabase;
-use cdk_common::database::{self, Acquired, DynMintDatabase};
+use cdk_common::database::{self, DynMintDatabase};
 use cdk_common::nuts::{BlindSignature, BlindedMessage, CurrencyUnit, Id};
 use cdk_common::payment::{DynMintPayment, WaitPaymentResponse};
 pub use cdk_common::quote_id::QuoteId;

crates/cdk/src/mint/proofs.rs

@@ -1,4 +1,5 @@
-use cdk_common::database::{Acquired, DynMintTransaction};
+use cdk_common::database::mint::Acquired;
+use cdk_common::database::DynMintTransaction;
 use cdk_common::mint::ProofsWithState;
 use cdk_common::state::{self, check_state_transition};
 use cdk_common::{Error, State};