Remove lifetime parameter from database transaction trait

Simplify database transaction API by removing the lifetime parameter from
DatabaseTransaction trait and related types. This change:

- Changes DynWalletDatabaseTransaction from Box<dyn DatabaseTransaction<'a, E>>
  to Box<dyn DatabaseTransaction<E>>
- Updates begin_db_transaction to return owned transaction objects without
  lifetime constraints
- Refactors FFI database traits to separate read and write operations:
  - WalletDatabaseFfi: read-only operations + begin_db_transaction
  - WalletDatabaseTransactionFfi: write operations + commit/rollback
- Updates commit/rollback to consume Arc<Self> instead of &self, enforcing
  single-use semantics
- Simplifies transaction handling in wallet operations across all database
  implementations (SQLite, PostgreSQL, redb)

This refactoring reduces complexity by eliminating lifetime annotations while
maintaining the same transactional guarantees through interior mutability and
Arc-based ownership

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

@@ -17,15 +17,14 @@ use crate::wallet::{
 };
 
 /// Easy to use Dynamic Database type alias
-pub type DynWalletDatabaseTransaction<'a> =
-    Box<dyn DatabaseTransaction<'a, super::Error> + Sync + Send + 'a>;
+pub type DynWalletDatabaseTransaction = Box<dyn DatabaseTransaction<super::Error> + Sync + Send>;
 
 /// Database transaction
 ///
 /// This trait encapsulates all the changes to be done in the wallet
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait DatabaseTransaction<'a, Error>: DbTransactionFinalizer<Err = Error> {
+pub trait DatabaseTransaction<Error>: DbTransactionFinalizer<Err = Error> {
     /// Add Mint to storage
     async fn add_mint(
         &mut self,
@@ -118,9 +117,9 @@ pub trait Database: Debug {
     type Err: Into<Error> + From<Error>;
 
     /// Begins a DB transaction
-    async fn begin_db_transaction<'a>(
-        &'a self,
-    ) -> Result<Box<dyn DatabaseTransaction<'a, Self::Err> + Send + Sync + 'a>, Self::Err>;
+    async fn begin_db_transaction(
+        &self,
+    ) -> Result<Box<dyn DatabaseTransaction<Self::Err> + Send + Sync>, Self::Err>;
 
     /// Get mint from storage
     async fn get_mint(&self, mint_url: MintUrl) -> Result<Option<MintInfo>, Self::Err>;

crates/cdk-ffi/src/multi_mint_wallet.rs

@@ -23,12 +23,12 @@ pub struct MultiMintWallet {
 
 #[uniffi::export(async_runtime = "tokio")]
 impl MultiMintWallet {
-    /// Create a new MultiMintWallet from mnemonic using WalletDatabase trait
+    /// Create a new MultiMintWallet from mnemonic using WalletDatabaseFfi trait
     #[uniffi::constructor]
     pub fn new(
         unit: CurrencyUnit,
         mnemonic: String,
-        db: Arc<dyn crate::database::WalletDatabase>,
+        db: crate::database::WalletDatabaseType,
     ) -> Result<Self, FfiError> {
         // Parse mnemonic and generate seed without passphrase
         let m = Mnemonic::parse(&mnemonic)
@@ -36,7 +36,7 @@ impl MultiMintWallet {
         let seed = m.to_seed_normalized("");
 
         // Convert the FFI database trait to a CDK database implementation
-        let localstore = crate::database::create_cdk_database_from_ffi(db);
+        let localstore = crate::database::create_cdk_database_from_ffi(db.as_trait());
 
         let wallet = match tokio::runtime::Handle::try_current() {
             Ok(handle) => tokio::task::block_in_place(|| {
@@ -66,7 +66,7 @@ impl MultiMintWallet {
     pub fn new_with_proxy(
         unit: CurrencyUnit,
         mnemonic: String,
-        db: Arc<dyn crate::database::WalletDatabase>,
+        db: crate::database::WalletDatabaseType,
         proxy_url: String,
     ) -> Result<Self, FfiError> {
         // Parse mnemonic and generate seed without passphrase
@@ -75,7 +75,7 @@ impl MultiMintWallet {
         let seed = m.to_seed_normalized("");
 
         // Convert the FFI database trait to a CDK database implementation
-        let localstore = crate::database::create_cdk_database_from_ffi(db);
+        let localstore = crate::database::create_cdk_database_from_ffi(db.as_trait());
 
         // Parse proxy URL
         let proxy_url =

crates/cdk-ffi/src/postgres.rs

@@ -5,9 +5,9 @@ use std::sync::Arc;
 use cdk_postgres::PgConnectionPool;
 
 use crate::{
-    CurrencyUnit, FfiError, FfiWalletSQLDatabase, Id, KeySet, KeySetInfo, Keys, MeltQuote,
-    MintInfo, MintQuote, MintUrl, ProofInfo, ProofState, PublicKey, SpendingConditions,
-    Transaction, TransactionDirection, TransactionId, WalletDatabase,
+    CurrencyUnit, FfiError, FfiWalletSQLDatabase, Id, KeySetInfo, Keys, MeltQuote, MintInfo,
+    MintQuote, MintUrl, ProofInfo, ProofState, SpendingConditions, Transaction,
+    TransactionDirection, TransactionId, WalletDatabaseFfi,
 };
 
 #[derive(uniffi::Object)]
@@ -57,78 +57,25 @@ impl WalletPostgresDatabase {
             inner: FfiWalletSQLDatabase::new(inner),
         }))
     }
-
-    fn clone_as_trait(&self) -> Arc<dyn WalletDatabase> {
-        // Safety: UniFFI objects are reference counted and Send+Sync via Arc
-        let obj: Arc<dyn WalletDatabase> = Arc::new(WalletPostgresDatabase {
-            inner: self.inner.clone(),
-        });
-        obj
-    }
 }
 
 #[uniffi::export(async_runtime = "tokio")]
 #[async_trait::async_trait]
-impl WalletDatabase for WalletPostgresDatabase {
-    /// Begins a DB transaction
-    async fn begin(&self) -> Result<(), FfiError> {
-        self.inner.begin().await
-    }
-
-    /// Begins a DB transaction
-    async fn commit(&self) -> Result<(), FfiError> {
-        self.inner.commit().await
-    }
-
-    async fn rollback(&self) -> Result<(), FfiError> {
-        self.inner.rollback().await
-    }
-
-    // Mint Management
-    /// Add Mint to storage
-    async fn add_mint(
+impl WalletDatabaseFfi for WalletPostgresDatabase {
+    async fn begin_db_transaction(
         &self,
-        mint_url: MintUrl,
-        mint_info: Option<MintInfo>,
-    ) -> Result<(), FfiError> {
-        self.inner.add_mint(mint_url, mint_info).await
-    }
-
-    /// Remove Mint from storage
-    async fn remove_mint(&self, mint_url: MintUrl) -> Result<(), FfiError> {
-        self.inner.remove_mint(mint_url).await
+    ) -> Result<Arc<dyn crate::database::WalletDatabaseTransactionFfi>, FfiError> {
+        self.inner.begin_db_transaction().await
     }
 
-    /// Get mint from storage
     async fn get_mint(&self, mint_url: MintUrl) -> Result<Option<MintInfo>, FfiError> {
         self.inner.get_mint(mint_url).await
     }
 
-    /// Get all mints from storage
     async fn get_mints(&self) -> Result<HashMap<MintUrl, Option<MintInfo>>, FfiError> {
         self.inner.get_mints().await
     }
 
-    /// Update mint url
-    async fn update_mint_url(
-        &self,
-        old_mint_url: MintUrl,
-        new_mint_url: MintUrl,
-    ) -> Result<(), FfiError> {
-        self.inner.update_mint_url(old_mint_url, new_mint_url).await
-    }
-
-    // Keyset Management
-    /// Add mint keyset to storage
-    async fn add_mint_keysets(
-        &self,
-        mint_url: MintUrl,
-        keysets: Vec<KeySetInfo>,
-    ) -> Result<(), FfiError> {
-        self.inner.add_mint_keysets(mint_url, keysets).await
-    }
-
-    /// Get mint keysets for mint url
     async fn get_mint_keysets(
         &self,
         mint_url: MintUrl,
@@ -136,80 +83,30 @@ impl WalletDatabase for WalletPostgresDatabase {
         self.inner.get_mint_keysets(mint_url).await
     }
 
-    /// Get mint keyset by id
     async fn get_keyset_by_id(&self, keyset_id: Id) -> Result<Option<KeySetInfo>, FfiError> {
         self.inner.get_keyset_by_id(keyset_id).await
     }
 
-    // Mint Quote Management
-    /// Add mint quote to storage
-    async fn add_mint_quote(&self, quote: MintQuote) -> Result<(), FfiError> {
-        self.inner.add_mint_quote(quote).await
-    }
-
-    /// Get mint quote from storage
     async fn get_mint_quote(&self, quote_id: String) -> Result<Option<MintQuote>, FfiError> {
         self.inner.get_mint_quote(quote_id).await
     }
 
-    /// Get mint quotes from storage
     async fn get_mint_quotes(&self) -> Result<Vec<MintQuote>, FfiError> {
         self.inner.get_mint_quotes().await
     }
 
-    /// Remove mint quote from storage
-    async fn remove_mint_quote(&self, quote_id: String) -> Result<(), FfiError> {
-        self.inner.remove_mint_quote(quote_id).await
-    }
-
-    // Melt Quote Management
-    /// Add melt quote to storage
-    async fn add_melt_quote(&self, quote: MeltQuote) -> Result<(), FfiError> {
-        self.inner.add_melt_quote(quote).await
-    }
-
-    /// Get melt quote from storage
     async fn get_melt_quote(&self, quote_id: String) -> Result<Option<MeltQuote>, FfiError> {
         self.inner.get_melt_quote(quote_id).await
     }
 
-    /// Get melt quotes from storage
     async fn get_melt_quotes(&self) -> Result<Vec<MeltQuote>, FfiError> {
         self.inner.get_melt_quotes().await
     }
 
-    /// Remove melt quote from storage
-    async fn remove_melt_quote(&self, quote_id: String) -> Result<(), FfiError> {
-        self.inner.remove_melt_quote(quote_id).await
-    }
-
-    // Keys Management
-    /// Add Keys to storage
-    async fn add_keys(&self, keyset: KeySet) -> Result<(), FfiError> {
-        self.inner.add_keys(keyset).await
-    }
-
-    /// Get Keys from storage
     async fn get_keys(&self, id: Id) -> Result<Option<Keys>, FfiError> {
         self.inner.get_keys(id).await
     }
 
-    /// Remove Keys from storage
-    async fn remove_keys(&self, id: Id) -> Result<(), FfiError> {
-        self.inner.remove_keys(id).await
-    }
-
-    // Proof Management
-    /// Update the proofs in storage by adding new proofs or removing proofs by their Y value
-    async fn update_proofs(
-        &self,
-        added: Vec<ProofInfo>,
-        removed_ys: Vec<PublicKey>,
-    ) -> Result<(), FfiError> {
-        self.inner.update_proofs(added, removed_ys).await
-    }
-
-    /// Get proofs from storage
     async fn get_proofs(
         &self,
         mint_url: Option<MintUrl>,
@@ -222,7 +119,6 @@ impl WalletDatabase for WalletPostgresDatabase {
             .await
     }
 
-    /// Get balance efficiently using SQL aggregation
     async fn get_balance(
         &self,
         mint_url: Option<MintUrl>,
@@ -232,28 +128,6 @@ impl WalletDatabase for WalletPostgresDatabase {
         self.inner.get_balance(mint_url, unit, state).await
     }
 
-    /// Update proofs state in storage
-    async fn update_proofs_state(
-        &self,
-        ys: Vec<PublicKey>,
-        state: ProofState,
-    ) -> Result<(), FfiError> {
-        self.inner.update_proofs_state(ys, state).await
-    }
-
-    // Keyset Counter Management
-    /// Increment Keyset counter
-    async fn increment_keyset_counter(&self, keyset_id: Id, count: u32) -> Result<u32, FfiError> {
-        self.inner.increment_keyset_counter(keyset_id, count).await
-    }
-
-    // Transaction Management
-    /// Add transaction to storage
-    async fn add_transaction(&self, transaction: Transaction) -> Result<(), FfiError> {
-        self.inner.add_transaction(transaction).await
-    }
-
-    /// Get transaction from storage
     async fn get_transaction(
         &self,
         transaction_id: TransactionId,
@@ -261,7 +135,6 @@ impl WalletDatabase for WalletPostgresDatabase {
         self.inner.get_transaction(transaction_id).await
     }
 
-    /// List transactions from storage
     async fn list_transactions(
         &self,
         mint_url: Option<MintUrl>,
@@ -272,9 +145,4 @@ impl WalletDatabase for WalletPostgresDatabase {
             .list_transactions(mint_url, direction, unit)
             .await
     }
-
-    /// Remove transaction from storage
-    async fn remove_transaction(&self, transaction_id: TransactionId) -> Result<(), FfiError> {
-        self.inner.remove_transaction(transaction_id).await
-    }
 }

crates/cdk-ffi/src/sqlite.rs

@@ -5,12 +5,12 @@ use cdk_sqlite::wallet::WalletSqliteDatabase as CdkWalletSqliteDatabase;
 use cdk_sqlite::SqliteConnectionManager;
 
 use crate::{
-    CurrencyUnit, FfiError, FfiWalletSQLDatabase, Id, KeySet, KeySetInfo, Keys, MeltQuote,
-    MintInfo, MintQuote, MintUrl, ProofInfo, ProofState, PublicKey, SpendingConditions,
-    Transaction, TransactionDirection, TransactionId, WalletDatabase,
+    CurrencyUnit, FfiError, FfiWalletSQLDatabase, Id, KeySetInfo, Keys, MeltQuote, MintInfo,
+    MintQuote, MintUrl, ProofInfo, ProofState, SpendingConditions, Transaction,
+    TransactionDirection, TransactionId, WalletDatabaseFfi,
 };
 
-/// FFI-compatible WalletSqliteDatabase implementation that implements the WalletDatabase trait
+/// FFI-compatible WalletSqliteDatabase implementation that implements the WalletDatabaseFfi trait
 #[derive(uniffi::Object)]
 pub struct WalletSqliteDatabase {
     inner: Arc<FfiWalletSQLDatabase<SqliteConnectionManager>>,
@@ -66,66 +66,21 @@ impl WalletSqliteDatabase {
 
 #[uniffi::export(async_runtime = "tokio")]
 #[async_trait::async_trait]
-impl WalletDatabase for WalletSqliteDatabase {
-    /// Begins a DB transaction
-    async fn begin(&self) -> Result<(), FfiError> {
-        self.inner.begin().await
-    }
-
-    /// Begins a DB transaction
-    async fn commit(&self) -> Result<(), FfiError> {
-        self.inner.commit().await
-    }
-
-    async fn rollback(&self) -> Result<(), FfiError> {
-        self.inner.rollback().await
-    }
-
-    // Mint Management
-    /// Add Mint to storage
-    async fn add_mint(
+impl WalletDatabaseFfi for WalletSqliteDatabase {
+    async fn begin_db_transaction(
         &self,
-        mint_url: MintUrl,
-        mint_info: Option<MintInfo>,
-    ) -> Result<(), FfiError> {
-        self.inner.add_mint(mint_url, mint_info).await
+    ) -> Result<Arc<dyn crate::database::WalletDatabaseTransactionFfi>, FfiError> {
+        self.inner.begin_db_transaction().await
     }
 
-    /// Remove Mint from storage
-    async fn remove_mint(&self, mint_url: MintUrl) -> Result<(), FfiError> {
-        self.inner.remove_mint(mint_url).await
-    }
-
-    /// Get mint from storage
     async fn get_mint(&self, mint_url: MintUrl) -> Result<Option<MintInfo>, FfiError> {
         self.inner.get_mint(mint_url).await
     }
 
-    /// Get all mints from storage
     async fn get_mints(&self) -> Result<HashMap<MintUrl, Option<MintInfo>>, FfiError> {
         self.inner.get_mints().await
     }
 
-    /// Update mint url
-    async fn update_mint_url(
-        &self,
-        old_mint_url: MintUrl,
-        new_mint_url: MintUrl,
-    ) -> Result<(), FfiError> {
-        self.inner.update_mint_url(old_mint_url, new_mint_url).await
-    }
-
-    // Keyset Management
-    /// Add mint keyset to storage
-    async fn add_mint_keysets(
-        &self,
-        mint_url: MintUrl,
-        keysets: Vec<KeySetInfo>,
-    ) -> Result<(), FfiError> {
-        self.inner.add_mint_keysets(mint_url, keysets).await
-    }
-
-    /// Get mint keysets for mint url
     async fn get_mint_keysets(
         &self,
         mint_url: MintUrl,
@@ -133,80 +88,30 @@ impl WalletDatabase for WalletSqliteDatabase {
         self.inner.get_mint_keysets(mint_url).await
     }
 
-    /// Get mint keyset by id
     async fn get_keyset_by_id(&self, keyset_id: Id) -> Result<Option<KeySetInfo>, FfiError> {
         self.inner.get_keyset_by_id(keyset_id).await
     }
 
-    // Mint Quote Management
-    /// Add mint quote to storage
-    async fn add_mint_quote(&self, quote: MintQuote) -> Result<(), FfiError> {
-        self.inner.add_mint_quote(quote).await
-    }
-
-    /// Get mint quote from storage
     async fn get_mint_quote(&self, quote_id: String) -> Result<Option<MintQuote>, FfiError> {
         self.inner.get_mint_quote(quote_id).await
     }
 
-    /// Get mint quotes from storage
     async fn get_mint_quotes(&self) -> Result<Vec<MintQuote>, FfiError> {
         self.inner.get_mint_quotes().await
     }
 
-    /// Remove mint quote from storage
-    async fn remove_mint_quote(&self, quote_id: String) -> Result<(), FfiError> {
-        self.inner.remove_mint_quote(quote_id).await
-    }
-
-    // Melt Quote Management
-    /// Add melt quote to storage
-    async fn add_melt_quote(&self, quote: MeltQuote) -> Result<(), FfiError> {
-        self.inner.add_melt_quote(quote).await
-    }
-
-    /// Get melt quote from storage
     async fn get_melt_quote(&self, quote_id: String) -> Result<Option<MeltQuote>, FfiError> {
         self.inner.get_melt_quote(quote_id).await
     }
 
-    /// Get melt quotes from storage
     async fn get_melt_quotes(&self) -> Result<Vec<MeltQuote>, FfiError> {
         self.inner.get_melt_quotes().await
     }
 
-    /// Remove melt quote from storage
-    async fn remove_melt_quote(&self, quote_id: String) -> Result<(), FfiError> {
-        self.inner.remove_melt_quote(quote_id).await
-    }
-
-    // Keys Management
-    /// Add Keys to storage
-    async fn add_keys(&self, keyset: KeySet) -> Result<(), FfiError> {
-        self.inner.add_keys(keyset).await
-    }
-
-    /// Get Keys from storage
     async fn get_keys(&self, id: Id) -> Result<Option<Keys>, FfiError> {
         self.inner.get_keys(id).await
     }
 
-    /// Remove Keys from storage
-    async fn remove_keys(&self, id: Id) -> Result<(), FfiError> {
-        self.inner.remove_keys(id).await
-    }
-
-    // Proof Management
-    /// Update the proofs in storage by adding new proofs or removing proofs by their Y value
-    async fn update_proofs(
-        &self,
-        added: Vec<ProofInfo>,
-        removed_ys: Vec<PublicKey>,
-    ) -> Result<(), FfiError> {
-        self.inner.update_proofs(added, removed_ys).await
-    }
-
-    /// Get proofs from storage
     async fn get_proofs(
         &self,
         mint_url: Option<MintUrl>,
@@ -219,7 +124,6 @@ impl WalletDatabase for WalletSqliteDatabase {
             .await
     }
 
-    /// Get balance efficiently using SQL aggregation
     async fn get_balance(
         &self,
         mint_url: Option<MintUrl>,
@@ -229,28 +133,6 @@ impl WalletDatabase for WalletSqliteDatabase {
         self.inner.get_balance(mint_url, unit, state).await
     }
 
-    /// Update proofs state in storage
-    async fn update_proofs_state(
-        &self,
-        ys: Vec<PublicKey>,
-        state: ProofState,
-    ) -> Result<(), FfiError> {
-        self.inner.update_proofs_state(ys, state).await
-    }
-
-    // Keyset Counter Management
-    /// Increment Keyset counter
-    async fn increment_keyset_counter(&self, keyset_id: Id, count: u32) -> Result<u32, FfiError> {
-        self.inner.increment_keyset_counter(keyset_id, count).await
-    }
-
-    // Transaction Management
-    /// Add transaction to storage
-    async fn add_transaction(&self, transaction: Transaction) -> Result<(), FfiError> {
-        self.inner.add_transaction(transaction).await
-    }
-
-    /// Get transaction from storage
     async fn get_transaction(
         &self,
         transaction_id: TransactionId,
@@ -258,7 +140,6 @@ impl WalletDatabase for WalletSqliteDatabase {
         self.inner.get_transaction(transaction_id).await
     }
 
-    /// List transactions from storage
     async fn list_transactions(
         &self,
         mint_url: Option<MintUrl>,
@@ -269,9 +150,4 @@ impl WalletDatabase for WalletSqliteDatabase {
             .list_transactions(mint_url, direction, unit)
             .await
     }
-
-    /// Remove transaction from storage
-    async fn remove_transaction(&self, transaction_id: TransactionId) -> Result<(), FfiError> {
-        self.inner.remove_transaction(transaction_id).await
-    }
 }

crates/cdk-ffi/src/wallet.rs

@@ -25,13 +25,13 @@ impl Wallet {
 
 #[uniffi::export(async_runtime = "tokio")]
 impl Wallet {
-    /// Create a new Wallet from mnemonic using WalletDatabase trait
+    /// Create a new Wallet from mnemonic using WalletDatabaseFfi trait
     #[uniffi::constructor]
     pub fn new(
         mint_url: String,
         unit: CurrencyUnit,
         mnemonic: String,
-        db: Arc<dyn crate::database::WalletDatabase>,
+        db: crate::database::WalletDatabaseType,
         config: WalletConfig,
     ) -> Result<Self, FfiError> {
         // Parse mnemonic and generate seed without passphrase
@@ -40,7 +40,7 @@ impl Wallet {
         let seed = m.to_seed_normalized("");
 
         // Convert the FFI database trait to a CDK database implementation
-        let localstore = crate::database::create_cdk_database_from_ffi(db);
+        let localstore = crate::database::create_cdk_database_from_ffi(db.as_trait());
 
         let wallet =
             CdkWalletBuilder::new()

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

@@ -470,10 +470,10 @@ impl WalletDatabase for WalletRedbDatabase {
         Ok(transactions)
     }
 
-    async fn begin_db_transaction<'a>(
-        &'a self,
+    async fn begin_db_transaction(
+        &self,
     ) -> Result<
-        Box<dyn cdk_common::database::WalletDatabaseTransaction<'a, Self::Err> + Send + Sync + 'a>,
+        Box<dyn cdk_common::database::WalletDatabaseTransaction<Self::Err> + Send + Sync>,
         Self::Err,
     > {
         let write_txn = self.db.begin_write().map_err(Error::from)?;
@@ -482,9 +482,7 @@ impl WalletDatabase for WalletRedbDatabase {
 }
 
 #[async_trait]
-impl<'a> cdk_common::database::WalletDatabaseTransaction<'a, database::Error>
-    for RedbWalletTransaction
-{
+impl cdk_common::database::WalletDatabaseTransaction<database::Error> for RedbWalletTransaction {
     #[instrument(skip(self), fields(keyset_id = %keyset_id))]
     async fn get_keyset_by_id(
         &mut self,

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

@@ -52,7 +52,7 @@ where
 }
 
 #[async_trait]
-impl<'a, RM> WalletDatabaseTransaction<'a, Error> for SQLWalletTransaction<RM>
+impl<RM> WalletDatabaseTransaction<Error> for SQLWalletTransaction<RM>
 where
     RM: DatabasePool + 'static,
 {
@@ -888,10 +888,9 @@ where
 {
     type Err = database::Error;
 
-    async fn begin_db_transaction<'a>(
-        &'a self,
-    ) -> Result<Box<dyn WalletDatabaseTransaction<'a, Self::Err> + Send + Sync + 'a>, Self::Err>
-    {
+    async fn begin_db_transaction(
+        &self,
+    ) -> Result<Box<dyn WalletDatabaseTransaction<Self::Err> + Send + Sync>, Self::Err> {
         Ok(Box::new(SQLWalletTransaction {
             inner: ConnectionWithTransaction::new(
                 self.pool.get().map_err(|e| Error::Database(Box::new(e)))?,

crates/cdk/src/wallet/melt/mod.rs

@@ -49,7 +49,7 @@ impl Wallet {
 
     pub(crate) async fn add_transaction_for_pending_melt(
         &self,
-        tx: &mut DynWalletDatabaseTransaction<'_>,
+        tx: &mut DynWalletDatabaseTransaction,
         quote: &MeltQuote,
         response: &MeltQuoteBolt11Response<String>,
     ) -> Result<(), Error> {

crates/cdk/src/wallet/mod.rs

@@ -371,7 +371,7 @@ impl Wallet {
     #[instrument(skip(self, tx))]
     pub(crate) async fn amounts_needed_for_state_target(
         &self,
-        tx: &mut DynWalletDatabaseTransaction<'_>,
+        tx: &mut DynWalletDatabaseTransaction,
         fee_and_amounts: &FeeAndAmounts,
     ) -> Result<Vec<Amount>, Error> {
         let unspent_proofs = self
@@ -409,7 +409,7 @@ impl Wallet {
     #[instrument(skip(self, tx))]
     async fn determine_split_target_values(
         &self,
-        tx: &mut DynWalletDatabaseTransaction<'_>,
+        tx: &mut DynWalletDatabaseTransaction,
         change_amount: Amount,
         fee_and_amounts: &FeeAndAmounts,
     ) -> Result<SplitTarget, Error> {

crates/cdk/src/wallet/proofs.rs

@@ -47,7 +47,7 @@ impl Wallet {
     /// Get this wallet's [Proofs] that match the args
     pub async fn get_proofs_with(
         &self,
-        tx: Option<&mut DynWalletDatabaseTransaction<'_>>,
+        tx: Option<&mut DynWalletDatabaseTransaction>,
         state: Option<Vec<State>>,
         spending_conditions: Option<Vec<SpendingConditions>>,
     ) -> Result<Proofs, Error> {

crates/cdk/src/wallet/swap.rs

@@ -199,7 +199,7 @@ impl Wallet {
     #[allow(clippy::too_many_arguments)]
     pub async fn create_swap(
         &self,
-        mut tx: DynWalletDatabaseTransaction<'_>,
+        mut tx: DynWalletDatabaseTransaction,
         active_keyset_id: Id,
         fee_and_amounts: &FeeAndAmounts,
         amount: Option<Amount>,