Remove cashu ffi (#1102)

* feat: remove cdk-common and cashu from cdk-ffi

crates/cdk-ffi/Cargo.toml

@@ -12,15 +12,13 @@ name = "cdk_ffi"
 
 [features]
 default = ["auth", "bip353"]
-auth = ["cdk/auth", "cdk-common/auth", "cashu/auth"]
+auth = ["cdk/auth"]
 bip353 = ["cdk/bip353"]
 
 [dependencies]
 async-trait = { workspace = true }
 bip39 = { workspace = true }
-cashu = { workspace = true }
 cdk = { workspace = true, default-features = false, features = ["wallet"] }
-cdk-common = { workspace = true }
 cdk-sqlite = { workspace = true }
 ctor = "0.2"
 futures = { workspace = true }

crates/cdk-ffi/src/database.rs

@@ -3,7 +3,7 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use cdk_common::database::WalletDatabase as CdkWalletDatabase;
+use cdk::cdk_database::WalletDatabase as CdkWalletDatabase;
 use cdk_sqlite::wallet::WalletSqliteDatabase as CdkWalletSqliteDatabase;
 
 use crate::error::FfiError;
@@ -161,13 +161,13 @@ impl std::fmt::Debug for WalletDatabaseBridge {
 
 #[async_trait::async_trait]
 impl CdkWalletDatabase for WalletDatabaseBridge {
-    type Err = cdk_common::database::Error;
+    type Err = cdk::cdk_database::Error;
 
     // Mint Management
     async fn add_mint(
         &self,
-        mint_url: cdk_common::mint_url::MintUrl,
-        mint_info: Option<cdk_common::nuts::MintInfo>,
+        mint_url: cdk::mint_url::MintUrl,
+        mint_info: Option<cdk::nuts::MintInfo>,
     ) -> Result<(), Self::Err> {
         let ffi_mint_url = mint_url.into();
         let ffi_mint_info = mint_info.map(Into::into);
@@ -175,45 +175,44 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
         self.ffi_db
             .add_mint(ffi_mint_url, ffi_mint_info)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
-    async fn remove_mint(&self, mint_url: cdk_common::mint_url::MintUrl) -> Result<(), Self::Err> {
+    async fn remove_mint(&self, mint_url: cdk::mint_url::MintUrl) -> Result<(), Self::Err> {
         let ffi_mint_url = mint_url.into();
         self.ffi_db
             .remove_mint(ffi_mint_url)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     async fn get_mint(
         &self,
-        mint_url: cdk_common::mint_url::MintUrl,
-    ) -> Result<Option<cdk_common::nuts::MintInfo>, Self::Err> {
+        mint_url: cdk::mint_url::MintUrl,
+    ) -> Result<Option<cdk::nuts::MintInfo>, Self::Err> {
         let ffi_mint_url = mint_url.into();
         let result = self
             .ffi_db
             .get_mint(ffi_mint_url)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
         Ok(result.map(Into::into))
     }
 
     async fn get_mints(
         &self,
-    ) -> Result<HashMap<cdk_common::mint_url::MintUrl, Option<cdk_common::nuts::MintInfo>>, Self::Err>
-    {
+    ) -> Result<HashMap<cdk::mint_url::MintUrl, Option<cdk::nuts::MintInfo>>, Self::Err> {
         let result = self
             .ffi_db
             .get_mints()
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
 
         let mut cdk_result = HashMap::new();
         for (ffi_mint_url, mint_info_opt) in result {
-            let cdk_url = ffi_mint_url.try_into().map_err(|e: FfiError| {
-                cdk_common::database::Error::Database(e.to_string().into())
-            })?;
+            let cdk_url = ffi_mint_url
+                .try_into()
+                .map_err(|e: FfiError| cdk::cdk_database::Error::Database(e.to_string().into()))?;
             cdk_result.insert(cdk_url, mint_info_opt.map(Into::into));
         }
         Ok(cdk_result)
@@ -221,22 +220,22 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
 
     async fn update_mint_url(
         &self,
-        old_mint_url: cdk_common::mint_url::MintUrl,
-        new_mint_url: cdk_common::mint_url::MintUrl,
+        old_mint_url: cdk::mint_url::MintUrl,
+        new_mint_url: cdk::mint_url::MintUrl,
     ) -> Result<(), Self::Err> {
         let ffi_old_mint_url = old_mint_url.into();
         let ffi_new_mint_url = new_mint_url.into();
         self.ffi_db
             .update_mint_url(ffi_old_mint_url, ffi_new_mint_url)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     // Keyset Management
     async fn add_mint_keysets(
         &self,
-        mint_url: cdk_common::mint_url::MintUrl,
-        keysets: Vec<cdk_common::nuts::KeySetInfo>,
+        mint_url: cdk::mint_url::MintUrl,
+        keysets: Vec<cdk::nuts::KeySetInfo>,
     ) -> Result<(), Self::Err> {
         let ffi_mint_url = mint_url.into();
         let ffi_keysets: Vec<KeySetInfo> = keysets.into_iter().map(Into::into).collect();
@@ -244,74 +243,72 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
         self.ffi_db
             .add_mint_keysets(ffi_mint_url, ffi_keysets)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     async fn get_mint_keysets(
         &self,
-        mint_url: cdk_common::mint_url::MintUrl,
-    ) -> Result<Option<Vec<cdk_common::nuts::KeySetInfo>>, Self::Err> {
+        mint_url: cdk::mint_url::MintUrl,
+    ) -> Result<Option<Vec<cdk::nuts::KeySetInfo>>, Self::Err> {
         let ffi_mint_url = mint_url.into();
         let result = self
             .ffi_db
             .get_mint_keysets(ffi_mint_url)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
         Ok(result.map(|keysets| keysets.into_iter().map(Into::into).collect()))
     }
 
     async fn get_keyset_by_id(
         &self,
-        keyset_id: &cdk_common::nuts::Id,
-    ) -> Result<Option<cdk_common::nuts::KeySetInfo>, Self::Err> {
+        keyset_id: &cdk::nuts::Id,
+    ) -> Result<Option<cdk::nuts::KeySetInfo>, Self::Err> {
         let ffi_id = (*keyset_id).into();
         let result = self
             .ffi_db
             .get_keyset_by_id(ffi_id)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
         Ok(result.map(Into::into))
     }
 
     // Mint Quote Management
-    async fn add_mint_quote(&self, quote: cdk_common::wallet::MintQuote) -> Result<(), Self::Err> {
+    async fn add_mint_quote(&self, quote: cdk::wallet::MintQuote) -> Result<(), Self::Err> {
         let ffi_quote = quote.into();
         self.ffi_db
             .add_mint_quote(ffi_quote)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     async fn get_mint_quote(
         &self,
         quote_id: &str,
-    ) -> Result<Option<cdk_common::wallet::MintQuote>, Self::Err> {
+    ) -> Result<Option<cdk::wallet::MintQuote>, Self::Err> {
         let result = self
             .ffi_db
             .get_mint_quote(quote_id.to_string())
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
         Ok(result
             .map(|q| {
-                q.try_into().map_err(|e: FfiError| {
-                    cdk_common::database::Error::Database(e.to_string().into())
-                })
+                q.try_into()
+                    .map_err(|e: FfiError| cdk::cdk_database::Error::Database(e.to_string().into()))
             })
             .transpose()?)
     }
 
-    async fn get_mint_quotes(&self) -> Result<Vec<cdk_common::wallet::MintQuote>, Self::Err> {
+    async fn get_mint_quotes(&self) -> Result<Vec<cdk::wallet::MintQuote>, Self::Err> {
         let result = self
             .ffi_db
             .get_mint_quotes()
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
         Ok(result
             .into_iter()
             .map(|q| {
-                q.try_into().map_err(|e: FfiError| {
-                    cdk_common::database::Error::Database(e.to_string().into())
-                })
+                q.try_into()
+                    .map_err(|e: FfiError| cdk::cdk_database::Error::Database(e.to_string().into()))
             })
             .collect::<Result<Vec<_>, _>>()?)
     }
@@ -320,48 +317,46 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
         self.ffi_db
             .remove_mint_quote(quote_id.to_string())
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     // Melt Quote Management
-    async fn add_melt_quote(&self, quote: cdk_common::wallet::MeltQuote) -> Result<(), Self::Err> {
+    async fn add_melt_quote(&self, quote: cdk::wallet::MeltQuote) -> Result<(), Self::Err> {
         let ffi_quote = quote.into();
         self.ffi_db
             .add_melt_quote(ffi_quote)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     async fn get_melt_quote(
         &self,
         quote_id: &str,
-    ) -> Result<Option<cdk_common::wallet::MeltQuote>, Self::Err> {
+    ) -> Result<Option<cdk::wallet::MeltQuote>, Self::Err> {
         let result = self
             .ffi_db
             .get_melt_quote(quote_id.to_string())
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
         Ok(result
             .map(|q| {
-                q.try_into().map_err(|e: FfiError| {
-                    cdk_common::database::Error::Database(e.to_string().into())
-                })
+                q.try_into()
+                    .map_err(|e: FfiError| cdk::cdk_database::Error::Database(e.to_string().into()))
             })
             .transpose()?)
     }
 
-    async fn get_melt_quotes(&self) -> Result<Vec<cdk_common::wallet::MeltQuote>, Self::Err> {
+    async fn get_melt_quotes(&self) -> Result<Vec<cdk::wallet::MeltQuote>, Self::Err> {
         let result = self
             .ffi_db
             .get_melt_quotes()
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
         Ok(result
             .into_iter()
             .map(|q| {
-                q.try_into().map_err(|e: FfiError| {
-                    cdk_common::database::Error::Database(e.to_string().into())
-                })
+                q.try_into()
+                    .map_err(|e: FfiError| cdk::cdk_database::Error::Database(e.to_string().into()))
             })
             .collect::<Result<Vec<_>, _>>()?)
     }
@@ -370,52 +365,49 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
         self.ffi_db
             .remove_melt_quote(quote_id.to_string())
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     // Keys Management
-    async fn add_keys(&self, keyset: cashu::KeySet) -> Result<(), Self::Err> {
+    async fn add_keys(&self, keyset: cdk::nuts::KeySet) -> Result<(), Self::Err> {
         let ffi_keyset: KeySet = keyset.into();
         self.ffi_db
             .add_keys(ffi_keyset)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
-    async fn get_keys(
-        &self,
-        id: &cdk_common::nuts::Id,
-    ) -> Result<Option<cdk_common::nuts::Keys>, Self::Err> {
+    async fn get_keys(&self, id: &cdk::nuts::Id) -> Result<Option<cdk::nuts::Keys>, Self::Err> {
         let ffi_id: Id = (*id).into();
         let result = self
             .ffi_db
             .get_keys(ffi_id)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
 
         // Convert FFI Keys back to CDK Keys using TryFrom
         result
             .map(|ffi_keys| {
-                ffi_keys.try_into().map_err(|e: FfiError| {
-                    cdk_common::database::Error::Database(e.to_string().into())
-                })
+                ffi_keys
+                    .try_into()
+                    .map_err(|e: FfiError| cdk::cdk_database::Error::Database(e.to_string().into()))
             })
             .transpose()
     }
 
-    async fn remove_keys(&self, id: &cdk_common::nuts::Id) -> Result<(), Self::Err> {
+    async fn remove_keys(&self, id: &cdk::nuts::Id) -> Result<(), Self::Err> {
         let ffi_id = (*id).into();
         self.ffi_db
             .remove_keys(ffi_id)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     // Proof Management
     async fn update_proofs(
         &self,
-        added: Vec<cdk_common::common::ProofInfo>,
-        removed_ys: Vec<cdk_common::nuts::PublicKey>,
+        added: Vec<cdk::types::ProofInfo>,
+        removed_ys: Vec<cdk::nuts::PublicKey>,
     ) -> Result<(), Self::Err> {
         let ffi_added: Vec<ProofInfo> = added.into_iter().map(Into::into).collect();
         let ffi_removed_ys: Vec<PublicKey> = removed_ys.into_iter().map(Into::into).collect();
@@ -423,16 +415,16 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
         self.ffi_db
             .update_proofs(ffi_added, ffi_removed_ys)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     async fn get_proofs(
         &self,
-        mint_url: Option<cdk_common::mint_url::MintUrl>,
-        unit: Option<cdk_common::nuts::CurrencyUnit>,
-        state: Option<Vec<cdk_common::nuts::State>>,
-        spending_conditions: Option<Vec<cdk_common::nuts::SpendingConditions>>,
-    ) -> Result<Vec<cdk_common::common::ProofInfo>, Self::Err> {
+        mint_url: Option<cdk::mint_url::MintUrl>,
+        unit: Option<cdk::nuts::CurrencyUnit>,
+        state: Option<Vec<cdk::nuts::State>>,
+        spending_conditions: Option<Vec<cdk::nuts::SpendingConditions>>,
+    ) -> Result<Vec<cdk::types::ProofInfo>, Self::Err> {
         let ffi_mint_url = mint_url.map(Into::into);
         let ffi_unit = unit.map(Into::into);
         let ffi_state = state.map(|s| s.into_iter().map(Into::into).collect());
@@ -443,41 +435,40 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
             .ffi_db
             .get_proofs(ffi_mint_url, ffi_unit, ffi_state, ffi_spending_conditions)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
 
         // Convert back to CDK ProofInfo
-        let cdk_result: Result<Vec<cdk_common::common::ProofInfo>, cdk_common::database::Error> =
-            result
-                .into_iter()
-                .map(|info| {
-                    Ok(cdk_common::common::ProofInfo {
-                        proof: info.proof.inner.clone(),
-                        y: info.y.try_into().map_err(|e: FfiError| {
-                            cdk_common::database::Error::Database(e.to_string().into())
-                        })?,
-                        mint_url: info.mint_url.try_into().map_err(|e: FfiError| {
-                            cdk_common::database::Error::Database(e.to_string().into())
+        let cdk_result: Result<Vec<cdk::types::ProofInfo>, cdk::cdk_database::Error> = result
+            .into_iter()
+            .map(|info| {
+                Ok(cdk::types::ProofInfo {
+                    proof: info.proof.inner.clone(),
+                    y: info.y.try_into().map_err(|e: FfiError| {
+                        cdk::cdk_database::Error::Database(e.to_string().into())
+                    })?,
+                    mint_url: info.mint_url.try_into().map_err(|e: FfiError| {
+                        cdk::cdk_database::Error::Database(e.to_string().into())
+                    })?,
+                    state: info.state.into(),
+                    spending_condition: info
+                        .spending_condition
+                        .map(|sc| sc.try_into())
+                        .transpose()
+                        .map_err(|e: FfiError| {
+                            cdk::cdk_database::Error::Database(e.to_string().into())
                         })?,
-                        state: info.state.into(),
-                        spending_condition: info
-                            .spending_condition
-                            .map(|sc| sc.try_into())
-                            .transpose()
-                            .map_err(|e: FfiError| {
-                                cdk_common::database::Error::Database(e.to_string().into())
-                            })?,
-                        unit: info.unit.into(),
-                    })
+                    unit: info.unit.into(),
                 })
-                .collect();
+            })
+            .collect();
 
         cdk_result
     }
 
     async fn update_proofs_state(
         &self,
-        ys: Vec<cdk_common::nuts::PublicKey>,
-        state: cdk_common::nuts::State,
+        ys: Vec<cdk::nuts::PublicKey>,
+        state: cdk::nuts::State,
     ) -> Result<(), Self::Err> {
         let ffi_ys: Vec<PublicKey> = ys.into_iter().map(Into::into).collect();
         let ffi_state = state.into();
@@ -485,57 +476,57 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
         self.ffi_db
             .update_proofs_state(ffi_ys, ffi_state)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     // Keyset Counter Management
     async fn increment_keyset_counter(
         &self,
-        keyset_id: &cdk_common::nuts::Id,
+        keyset_id: &cdk::nuts::Id,
         count: u32,
     ) -> Result<u32, Self::Err> {
         let ffi_id = (*keyset_id).into();
         self.ffi_db
             .increment_keyset_counter(ffi_id, count)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     // Transaction Management
     async fn add_transaction(
         &self,
-        transaction: cdk_common::wallet::Transaction,
+        transaction: cdk::wallet::types::Transaction,
     ) -> Result<(), Self::Err> {
         let ffi_transaction = transaction.into();
         self.ffi_db
             .add_transaction(ffi_transaction)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     async fn get_transaction(
         &self,
-        transaction_id: cdk_common::wallet::TransactionId,
-    ) -> Result<Option<cdk_common::wallet::Transaction>, Self::Err> {
+        transaction_id: cdk::wallet::types::TransactionId,
+    ) -> Result<Option<cdk::wallet::types::Transaction>, Self::Err> {
         let ffi_id = transaction_id.into();
         let result = self
             .ffi_db
             .get_transaction(ffi_id)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
 
         result
             .map(|tx| tx.try_into())
             .transpose()
-            .map_err(|e: FfiError| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e: FfiError| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     async fn list_transactions(
         &self,
-        mint_url: Option<cdk_common::mint_url::MintUrl>,
-        direction: Option<cdk_common::wallet::TransactionDirection>,
-        unit: Option<cdk_common::nuts::CurrencyUnit>,
-    ) -> Result<Vec<cdk_common::wallet::Transaction>, Self::Err> {
+        mint_url: Option<cdk::mint_url::MintUrl>,
+        direction: Option<cdk::wallet::types::TransactionDirection>,
+        unit: Option<cdk::nuts::CurrencyUnit>,
+    ) -> Result<Vec<cdk::wallet::types::Transaction>, Self::Err> {
         let ffi_mint_url = mint_url.map(Into::into);
         let ffi_direction = direction.map(Into::into);
         let ffi_unit = unit.map(Into::into);
@@ -544,24 +535,24 @@ impl CdkWalletDatabase for WalletDatabaseBridge {
             .ffi_db
             .list_transactions(ffi_mint_url, ffi_direction, ffi_unit)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))?;
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))?;
 
         result
             .into_iter()
             .map(|tx| tx.try_into())
             .collect::<Result<Vec<_>, FfiError>>()
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 
     async fn remove_transaction(
         &self,
-        transaction_id: cdk_common::wallet::TransactionId,
+        transaction_id: cdk::wallet::types::TransactionId,
     ) -> Result<(), Self::Err> {
         let ffi_id = transaction_id.into();
         self.ffi_db
             .remove_transaction(ffi_id)
             .await
-            .map_err(|e| cdk_common::database::Error::Database(e.to_string().into()))
+            .map_err(|e| cdk::cdk_database::Error::Database(e.to_string().into()))
     }
 }
 
@@ -690,8 +681,7 @@ impl WalletDatabase for WalletSqliteDatabase {
         keysets: Vec<KeySetInfo>,
     ) -> Result<(), FfiError> {
         let cdk_mint_url = mint_url.try_into()?;
-        let cdk_keysets: Vec<cdk_common::nuts::KeySetInfo> =
-            keysets.into_iter().map(Into::into).collect();
+        let cdk_keysets: Vec<cdk::nuts::KeySetInfo> = keysets.into_iter().map(Into::into).collect();
         self.inner
             .add_mint_keysets(cdk_mint_url, cdk_keysets)
             .await
@@ -791,10 +781,10 @@ impl WalletDatabase for WalletSqliteDatabase {
 
     // Keys Management
     async fn add_keys(&self, keyset: KeySet) -> Result<(), FfiError> {
-        // Convert FFI KeySet to cashu::KeySet
-        let cashu_keyset: cashu::KeySet = keyset.try_into()?;
+        // Convert FFI KeySet to cdk::nuts::KeySet
+        let cdk_keyset: cdk::nuts::KeySet = keyset.try_into()?;
         self.inner
-            .add_keys(cashu_keyset)
+            .add_keys(cdk_keyset)
             .await
             .map_err(|e| FfiError::Database { msg: e.to_string() })
     }
@@ -824,10 +814,10 @@ impl WalletDatabase for WalletSqliteDatabase {
         removed_ys: Vec<PublicKey>,
     ) -> Result<(), FfiError> {
         // Convert FFI types to CDK types
-        let cdk_added: Result<Vec<cdk_common::common::ProofInfo>, FfiError> = added
+        let cdk_added: Result<Vec<cdk::types::ProofInfo>, FfiError> = added
             .into_iter()
             .map(|info| {
-                Ok::<cdk_common::common::ProofInfo, FfiError>(cdk_common::common::ProofInfo {
+                Ok::<cdk::types::ProofInfo, FfiError>(cdk::types::ProofInfo {
                     proof: info.proof.inner.clone(),
                     y: info.y.try_into()?,
                     mint_url: info.mint_url.try_into()?,
@@ -842,7 +832,7 @@ impl WalletDatabase for WalletSqliteDatabase {
             .collect();
         let cdk_added = cdk_added?;
 
-        let cdk_removed_ys: Result<Vec<cdk_common::nuts::PublicKey>, FfiError> =
+        let cdk_removed_ys: Result<Vec<cdk::nuts::PublicKey>, FfiError> =
             removed_ys.into_iter().map(|pk| pk.try_into()).collect();
         let cdk_removed_ys = cdk_removed_ys?;
 
@@ -862,7 +852,7 @@ impl WalletDatabase for WalletSqliteDatabase {
         let cdk_mint_url = mint_url.map(|u| u.try_into()).transpose()?;
         let cdk_unit = unit.map(Into::into);
         let cdk_state = state.map(|s| s.into_iter().map(Into::into).collect());
-        let cdk_spending_conditions: Option<Vec<cdk_common::nuts::SpendingConditions>> =
+        let cdk_spending_conditions: Option<Vec<cdk::nuts::SpendingConditions>> =
             spending_conditions
                 .map(|sc| {
                     sc.into_iter()
@@ -885,7 +875,7 @@ impl WalletDatabase for WalletSqliteDatabase {
         ys: Vec<PublicKey>,
         state: ProofState,
     ) -> Result<(), FfiError> {
-        let cdk_ys: Result<Vec<cdk_common::nuts::PublicKey>, FfiError> =
+        let cdk_ys: Result<Vec<cdk::nuts::PublicKey>, FfiError> =
             ys.into_iter().map(|pk| pk.try_into()).collect();
         let cdk_ys = cdk_ys?;
         let cdk_state = state.into();
@@ -908,7 +898,7 @@ impl WalletDatabase for WalletSqliteDatabase {
     // Transaction Management
     async fn add_transaction(&self, transaction: Transaction) -> Result<(), FfiError> {
         // Convert FFI Transaction to CDK Transaction using TryFrom
-        let cdk_transaction: cdk_common::wallet::Transaction = transaction.try_into()?;
+        let cdk_transaction: cdk::wallet::types::Transaction = transaction.try_into()?;
 
         self.inner
             .add_transaction(cdk_transaction)
@@ -960,6 +950,6 @@ impl WalletDatabase for WalletSqliteDatabase {
 /// Helper function to create a CDK database from the FFI trait
 pub fn create_cdk_database_from_ffi(
     ffi_db: Arc<dyn WalletDatabase>,
-) -> Arc<dyn CdkWalletDatabase<Err = cdk_common::database::Error> + Send + Sync> {
+) -> Arc<dyn CdkWalletDatabase<Err = cdk::cdk_database::Error> + Send + Sync> {
     Arc::new(WalletDatabaseBridge::new(ffi_db))
 }

crates/cdk-ffi/src/error.rs

@@ -107,8 +107,8 @@ impl From<cdk::amount::Error> for FfiError {
     }
 }
 
-impl From<cdk_common::nut00::Error> for FfiError {
-    fn from(err: cdk_common::nut00::Error) -> Self {
+impl From<cdk::nuts::nut00::Error> for FfiError {
+    fn from(err: cdk::nuts::nut00::Error) -> Self {
         FfiError::Generic {
             msg: err.to_string(),
         }

crates/cdk-ffi/src/types.rs

@@ -5,8 +5,8 @@ use std::str::FromStr;
 use std::sync::Mutex;
 
 use cdk::nuts::{CurrencyUnit as CdkCurrencyUnit, State as CdkState};
+use cdk::pub_sub::SubId;
 use cdk::Amount as CdkAmount;
-use cdk_common::pub_sub::SubId;
 use serde::{Deserialize, Serialize};
 
 use crate::error::FfiError;
@@ -388,34 +388,32 @@ pub enum SendKind {
     OfflineTolerance { tolerance: Amount },
 }
 
-impl From<SendKind> for cdk_common::wallet::SendKind {
+impl From<SendKind> for cdk::wallet::SendKind {
     fn from(kind: SendKind) -> Self {
         match kind {
-            SendKind::OnlineExact => cdk_common::wallet::SendKind::OnlineExact,
+            SendKind::OnlineExact => cdk::wallet::SendKind::OnlineExact,
             SendKind::OnlineTolerance { tolerance } => {
-                cdk_common::wallet::SendKind::OnlineTolerance(tolerance.into())
+                cdk::wallet::SendKind::OnlineTolerance(tolerance.into())
             }
-            SendKind::OfflineExact => cdk_common::wallet::SendKind::OfflineExact,
+            SendKind::OfflineExact => cdk::wallet::SendKind::OfflineExact,
             SendKind::OfflineTolerance { tolerance } => {
-                cdk_common::wallet::SendKind::OfflineTolerance(tolerance.into())
+                cdk::wallet::SendKind::OfflineTolerance(tolerance.into())
             }
         }
     }
 }
 
-impl From<cdk_common::wallet::SendKind> for SendKind {
-    fn from(kind: cdk_common::wallet::SendKind) -> Self {
+impl From<cdk::wallet::SendKind> for SendKind {
+    fn from(kind: cdk::wallet::SendKind) -> Self {
         match kind {
-            cdk_common::wallet::SendKind::OnlineExact => SendKind::OnlineExact,
-            cdk_common::wallet::SendKind::OnlineTolerance(tolerance) => SendKind::OnlineTolerance {
+            cdk::wallet::SendKind::OnlineExact => SendKind::OnlineExact,
+            cdk::wallet::SendKind::OnlineTolerance(tolerance) => SendKind::OnlineTolerance {
+                tolerance: tolerance.into(),
+            },
+            cdk::wallet::SendKind::OfflineExact => SendKind::OfflineExact,
+            cdk::wallet::SendKind::OfflineTolerance(tolerance) => SendKind::OfflineTolerance {
                 tolerance: tolerance.into(),
             },
-            cdk_common::wallet::SendKind::OfflineExact => SendKind::OfflineExact,
-            cdk_common::wallet::SendKind::OfflineTolerance(tolerance) => {
-                SendKind::OfflineTolerance {
-                    tolerance: tolerance.into(),
-                }
-            }
         }
     }
 }
@@ -1299,8 +1297,8 @@ pub struct Melted {
 
 // MeltQuoteState is just an alias for nut05::QuoteState, so we don't need a separate implementation
 
-impl From<cdk_common::common::Melted> for Melted {
-    fn from(melted: cdk_common::common::Melted) -> Self {
+impl From<cdk::types::Melted> for Melted {
+    fn from(melted: cdk::types::Melted) -> Self {
         Self {
             state: melted.state.into(),
             preimage: melted.preimage,
@@ -1588,7 +1586,7 @@ impl From<cdk::nuts::MintInfo> for MintInfo {
     }
 }
 
-impl From<MintInfo> for cdk_common::nuts::MintInfo {
+impl From<MintInfo> for cdk::nuts::MintInfo {
     fn from(info: MintInfo) -> Self {
         Self {
             name: info.name,
@@ -1599,7 +1597,7 @@ impl From<MintInfo> for cdk_common::nuts::MintInfo {
             contact: info
                 .contact
                 .map(|contacts| contacts.into_iter().map(Into::into).collect()),
-            nuts: cdk_common::nuts::Nuts::default(), // Simplified conversion
+            nuts: cdk::nuts::Nuts::default(), // Simplified conversion
             icon_url: info.icon_url,
             urls: info.urls,
             motd: info.motd,
@@ -1856,8 +1854,8 @@ pub struct Transaction {
     pub quote_id: Option<String>,
 }
 
-impl From<cdk_common::wallet::Transaction> for Transaction {
-    fn from(tx: cdk_common::wallet::Transaction) -> Self {
+impl From<cdk::wallet::types::Transaction> for Transaction {
+    fn from(tx: cdk::wallet::types::Transaction) -> Self {
         Self {
             id: tx.id().into(),
             mint_url: tx.mint_url.into(),
@@ -1875,11 +1873,11 @@ impl From<cdk_common::wallet::Transaction> for Transaction {
 }
 
 /// Convert FFI Transaction to CDK Transaction
-impl TryFrom<Transaction> for cdk_common::wallet::Transaction {
+impl TryFrom<Transaction> for cdk::wallet::types::Transaction {
     type Error = FfiError;
 
     fn try_from(tx: Transaction) -> Result<Self, Self::Error> {
-        let cdk_ys: Result<Vec<cdk_common::nuts::PublicKey>, _> =
+        let cdk_ys: Result<Vec<cdk::nuts::PublicKey>, _> =
             tx.ys.into_iter().map(|pk| pk.try_into()).collect();
         let cdk_ys = cdk_ys?;
 
@@ -1926,20 +1924,20 @@ pub enum TransactionDirection {
     Outgoing,
 }
 
-impl From<cdk_common::wallet::TransactionDirection> for TransactionDirection {
-    fn from(direction: cdk_common::wallet::TransactionDirection) -> Self {
+impl From<cdk::wallet::types::TransactionDirection> for TransactionDirection {
+    fn from(direction: cdk::wallet::types::TransactionDirection) -> Self {
         match direction {
-            cdk_common::wallet::TransactionDirection::Incoming => TransactionDirection::Incoming,
-            cdk_common::wallet::TransactionDirection::Outgoing => TransactionDirection::Outgoing,
+            cdk::wallet::types::TransactionDirection::Incoming => TransactionDirection::Incoming,
+            cdk::wallet::types::TransactionDirection::Outgoing => TransactionDirection::Outgoing,
         }
     }
 }
 
-impl From<TransactionDirection> for cdk_common::wallet::TransactionDirection {
+impl From<TransactionDirection> for cdk::wallet::types::TransactionDirection {
     fn from(direction: TransactionDirection) -> Self {
         match direction {
-            TransactionDirection::Incoming => cdk_common::wallet::TransactionDirection::Incoming,
-            TransactionDirection::Outgoing => cdk_common::wallet::TransactionDirection::Outgoing,
+            TransactionDirection::Incoming => cdk::wallet::types::TransactionDirection::Incoming,
+            TransactionDirection::Outgoing => cdk::wallet::types::TransactionDirection::Outgoing,
         }
     }
 }
@@ -1975,26 +1973,26 @@ impl TransactionId {
     /// Create from proofs
     pub fn from_proofs(proofs: &Proofs) -> Result<Self, FfiError> {
         let cdk_proofs: Vec<cdk::nuts::Proof> = proofs.iter().map(|p| p.inner.clone()).collect();
-        let id = cdk_common::wallet::TransactionId::from_proofs(cdk_proofs)?;
+        let id = cdk::wallet::types::TransactionId::from_proofs(cdk_proofs)?;
         Ok(Self {
             hex: id.to_string(),
         })
     }
 }
 
-impl From<cdk_common::wallet::TransactionId> for TransactionId {
-    fn from(id: cdk_common::wallet::TransactionId) -> Self {
+impl From<cdk::wallet::types::TransactionId> for TransactionId {
+    fn from(id: cdk::wallet::types::TransactionId) -> Self {
         Self {
             hex: id.to_string(),
         }
     }
 }
 
-impl TryFrom<TransactionId> for cdk_common::wallet::TransactionId {
+impl TryFrom<TransactionId> for cdk::wallet::types::TransactionId {
     type Error = FfiError;
 
     fn try_from(id: TransactionId) -> Result<Self, Self::Error> {
-        cdk_common::wallet::TransactionId::from_hex(&id.hex)
+        cdk::wallet::types::TransactionId::from_hex(&id.hex)
             .map_err(|e| FfiError::InvalidHex { msg: e.to_string() })
     }
 }
@@ -2014,8 +2012,8 @@ pub struct AuthProof {
 }
 
 #[cfg(feature = "auth")]
-impl From<cdk_common::AuthProof> for AuthProof {
-    fn from(auth_proof: cdk_common::AuthProof) -> Self {
+impl From<cdk::nuts::AuthProof> for AuthProof {
+    fn from(auth_proof: cdk::nuts::AuthProof) -> Self {
         Self {
             keyset_id: auth_proof.keyset_id.to_string(),
             secret: auth_proof.secret.to_string(),
@@ -2029,20 +2027,20 @@ impl From<cdk_common::AuthProof> for AuthProof {
 }
 
 #[cfg(feature = "auth")]
-impl TryFrom<AuthProof> for cdk_common::AuthProof {
+impl TryFrom<AuthProof> for cdk::nuts::AuthProof {
     type Error = FfiError;
 
     fn try_from(auth_proof: AuthProof) -> Result<Self, Self::Error> {
         use std::str::FromStr;
         Ok(Self {
-            keyset_id: cdk_common::Id::from_str(&auth_proof.keyset_id)
+            keyset_id: cdk::nuts::Id::from_str(&auth_proof.keyset_id)
                 .map_err(|e| FfiError::Serialization { msg: e.to_string() })?,
             secret: {
                 use std::str::FromStr;
-                cdk_common::secret::Secret::from_str(&auth_proof.secret)
+                cdk::secret::Secret::from_str(&auth_proof.secret)
                     .map_err(|e| FfiError::Serialization { msg: e.to_string() })?
             },
-            c: cdk_common::PublicKey::from_str(&auth_proof.c)
+            c: cdk::nuts::PublicKey::from_str(&auth_proof.c)
                 .map_err(|e| FfiError::InvalidCryptographicKey { msg: e.to_string() })?,
             dleq: None, // FFI doesn't expose DLEQ proofs for simplicity
         })
@@ -2150,7 +2148,7 @@ pub struct SubscribeParams {
     pub id: Option<String>,
 }
 
-impl From<SubscribeParams> for cdk_common::subscription::Params {
+impl From<SubscribeParams> for cdk::nuts::nut17::Params<cdk::pub_sub::SubId> {
     fn from(params: SubscribeParams) -> Self {
         let sub_id = params
             .id
@@ -2329,8 +2327,8 @@ pub struct KeySetInfo {
     pub input_fee_ppk: u64,
 }
 
-impl From<cdk_common::nuts::KeySetInfo> for KeySetInfo {
-    fn from(keyset: cdk_common::nuts::KeySetInfo) -> Self {
+impl From<cdk::nuts::KeySetInfo> for KeySetInfo {
+    fn from(keyset: cdk::nuts::KeySetInfo) -> Self {
         Self {
             id: keyset.id.to_string(),
             unit: keyset.unit.into(),
@@ -2340,17 +2338,11 @@ impl From<cdk_common::nuts::KeySetInfo> for KeySetInfo {
     }
 }
 
-impl From<KeySetInfo> for cdk_common::nuts::KeySetInfo {
+impl From<KeySetInfo> for cdk::nuts::KeySetInfo {
     fn from(keyset: KeySetInfo) -> Self {
         use std::str::FromStr;
         Self {
-            id: cdk_common::nuts::Id::from_str(&keyset.id).unwrap_or_else(|_| {
-                // Create a dummy keyset for empty mint keys
-                use std::collections::BTreeMap;
-                let empty_map = BTreeMap::new();
-                let empty_keys = cdk_common::nut01::MintKeys::new(empty_map);
-                cdk_common::nuts::Id::from(&empty_keys)
-            }),
+            id: cdk::nuts::Id::from_str(&keyset.id).unwrap(),
             unit: keyset.unit.into(),
             active: keyset.active,
             final_expiry: None,
@@ -2386,15 +2378,15 @@ pub struct PublicKey {
     pub hex: String,
 }
 
-impl From<cdk_common::nuts::PublicKey> for PublicKey {
-    fn from(key: cdk_common::nuts::PublicKey) -> Self {
+impl From<cdk::nuts::PublicKey> for PublicKey {
+    fn from(key: cdk::nuts::PublicKey) -> Self {
         Self {
             hex: key.to_string(),
         }
     }
 }
 
-impl TryFrom<PublicKey> for cdk_common::nuts::PublicKey {
+impl TryFrom<PublicKey> for cdk::nuts::PublicKey {
     type Error = FfiError;
 
     fn try_from(key: PublicKey) -> Result<Self, Self::Error> {
@@ -2417,8 +2409,8 @@ pub struct Keys {
     pub keys: HashMap<u64, String>,
 }
 
-impl From<cdk_common::nuts::Keys> for Keys {
-    fn from(keys: cdk_common::nuts::Keys) -> Self {
+impl From<cdk::nuts::Keys> for Keys {
+    fn from(keys: cdk::nuts::Keys) -> Self {
         // Keys doesn't have id and unit - we'll need to get these from context
         // For now, use placeholder values
         Self {
@@ -2433,7 +2425,7 @@ impl From<cdk_common::nuts::Keys> for Keys {
     }
 }
 
-impl TryFrom<Keys> for cdk_common::nuts::Keys {
+impl TryFrom<Keys> for cdk::nuts::Keys {
     type Error = FfiError;
 
     fn try_from(keys: Keys) -> Result<Self, Self::Error> {
@@ -2443,13 +2435,13 @@ impl TryFrom<Keys> for cdk_common::nuts::Keys {
         // Convert the HashMap to BTreeMap with proper types
         let mut keys_map = BTreeMap::new();
         for (amount_u64, pubkey_hex) in keys.keys {
-            let amount = cashu::Amount::from(amount_u64);
-            let pubkey = cashu::PublicKey::from_str(&pubkey_hex)
+            let amount = cdk::Amount::from(amount_u64);
+            let pubkey = cdk::nuts::PublicKey::from_str(&pubkey_hex)
                 .map_err(|e| FfiError::InvalidCryptographicKey { msg: e.to_string() })?;
             keys_map.insert(amount, pubkey);
         }
 
-        Ok(cdk_common::nuts::Keys::new(keys_map))
+        Ok(cdk::nuts::Keys::new(keys_map))
     }
 }
 
@@ -2485,8 +2477,8 @@ pub struct KeySet {
     pub final_expiry: Option<u64>,
 }
 
-impl From<cashu::KeySet> for KeySet {
-    fn from(keyset: cashu::KeySet) -> Self {
+impl From<cdk::nuts::KeySet> for KeySet {
+    fn from(keyset: cdk::nuts::KeySet) -> Self {
         Self {
             id: keyset.id.to_string(),
             unit: keyset.unit.into(),
@@ -2501,7 +2493,7 @@ impl From<cashu::KeySet> for KeySet {
     }
 }
 
-impl TryFrom<KeySet> for cashu::KeySet {
+impl TryFrom<KeySet> for cdk::nuts::KeySet {
     type Error = FfiError;
 
     fn try_from(keyset: KeySet) -> Result<Self, Self::Error> {
@@ -2509,23 +2501,23 @@ impl TryFrom<KeySet> for cashu::KeySet {
         use std::str::FromStr;
 
         // Convert id
-        let id = cashu::Id::from_str(&keyset.id)
+        let id = cdk::nuts::Id::from_str(&keyset.id)
             .map_err(|e| FfiError::Serialization { msg: e.to_string() })?;
 
         // Convert unit
-        let unit: cashu::CurrencyUnit = keyset.unit.into();
+        let unit: cdk::nuts::CurrencyUnit = keyset.unit.into();
 
         // Convert keys
         let mut keys_map = BTreeMap::new();
         for (amount_u64, pubkey_hex) in keyset.keys {
-            let amount = cashu::Amount::from(amount_u64);
-            let pubkey = cashu::PublicKey::from_str(&pubkey_hex)
+            let amount = cdk::Amount::from(amount_u64);
+            let pubkey = cdk::nuts::PublicKey::from_str(&pubkey_hex)
                 .map_err(|e| FfiError::InvalidCryptographicKey { msg: e.to_string() })?;
             keys_map.insert(amount, pubkey);
         }
-        let keys = cashu::Keys::new(keys_map);
+        let keys = cdk::nuts::Keys::new(keys_map);
 
-        Ok(cashu::KeySet {
+        Ok(cdk::nuts::KeySet {
             id,
             unit,
             keys,
@@ -2570,8 +2562,8 @@ pub struct ProofInfo {
     pub unit: CurrencyUnit,
 }
 
-impl From<cdk_common::common::ProofInfo> for ProofInfo {
-    fn from(info: cdk_common::common::ProofInfo) -> Self {
+impl From<cdk::types::ProofInfo> for ProofInfo {
+    fn from(info: cdk::types::ProofInfo) -> Self {
         Self {
             proof: std::sync::Arc::new(info.proof.into()),
             y: info.y.into(),
@@ -2586,15 +2578,15 @@ impl From<cdk_common::common::ProofInfo> for ProofInfo {
 /// Decode ProofInfo from JSON string
 #[uniffi::export]
 pub fn decode_proof_info(json: String) -> Result<ProofInfo, FfiError> {
-    let info: cdk_common::common::ProofInfo = serde_json::from_str(&json)?;
+    let info: cdk::types::ProofInfo = serde_json::from_str(&json)?;
     Ok(info.into())
 }
 
 /// Encode ProofInfo to JSON string
 #[uniffi::export]
 pub fn encode_proof_info(info: ProofInfo) -> Result<String, FfiError> {
-    // Convert to cdk_common::common::ProofInfo for serialization
-    let cdk_info = cdk_common::common::ProofInfo {
+    // Convert to cdk::types::ProofInfo for serialization
+    let cdk_info = cdk::types::ProofInfo {
         proof: info.proof.inner.clone(),
         y: info.y.try_into()?,
         mint_url: info.mint_url.try_into()?,
@@ -2614,23 +2606,17 @@ pub struct Id {
     pub hex: String,
 }
 
-impl From<cdk_common::nuts::Id> for Id {
-    fn from(id: cdk_common::nuts::Id) -> Self {
+impl From<cdk::nuts::Id> for Id {
+    fn from(id: cdk::nuts::Id) -> Self {
         Self {
             hex: id.to_string(),
         }
     }
 }
 
-impl From<Id> for cdk_common::nuts::Id {
+impl From<Id> for cdk::nuts::Id {
     fn from(id: Id) -> Self {
         use std::str::FromStr;
-        Self::from_str(&id.hex).unwrap_or_else(|_| {
-            // Create a dummy keyset for empty mint keys
-            use std::collections::BTreeMap;
-            let empty_map = BTreeMap::new();
-            let empty_keys = cdk_common::nut01::MintKeys::new(empty_map);
-            cdk_common::nuts::Id::from(&empty_keys)
-        })
+        Self::from_str(&id.hex).unwrap()
     }
 }

crates/cdk-ffi/src/wallet.rs

@@ -348,7 +348,7 @@ impl Wallet {
         &self,
         params: SubscribeParams,
     ) -> Result<std::sync::Arc<ActiveSubscription>, FfiError> {
-        let cdk_params: cdk_common::subscription::Params = params.clone().into();
+        let cdk_params: cdk::nuts::nut17::Params<cdk::pub_sub::SubId> = params.clone().into();
         let sub_id = cdk_params.id.to_string();
         let active_sub = self.inner.subscribe(cdk_params).await;
         Ok(std::sync::Arc::new(ActiveSubscription::new(