From bc7994b51521d96cc50d71b9158f371c3ea72aa4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Thu, 30 Jun 2022 18:44:40 +0800
Subject: [PATCH 01/16] Change `TxParams` for multi-descriptor context

Store policy paths in a map with ExtendedDescriptor as key. This way we
can re-use the TxParams struct in multi-descriptor/multi-wallet
contexts.
---
 src/testutils/blockchain_tests.rs |  4 ++--
 src/wallet/mod.rs                 | 33 ++++++++++++++-----------------
 src/wallet/tx_builder.rs          | 25 ++++++++++++-----------
 3 files changed, 30 insertions(+), 32 deletions(-)

diff --git a/src/testutils/blockchain_tests.rs b/src/testutils/blockchain_tests.rs
index 7c08699c6..3084a7e06 100644
--- a/src/testutils/blockchain_tests.rs
+++ b/src/testutils/blockchain_tests.rs
@@ -1328,8 +1328,8 @@ macro_rules! bdk_blockchain_tests {
                 let tx = {
                     let mut builder = wallet.build_tx();
                     builder.add_recipient(test_client.get_node_address(None).script_pubkey(), 25_000)
-                        .policy_path(ext_path, KeychainKind::External)
-                        .policy_path(int_path, KeychainKind::Internal);
+                        .policy_path(ext_path, wallet.get_descriptor_for_keychain(KeychainKind::External))
+                        .policy_path(int_path, wallet.get_descriptor_for_keychain(KeychainKind::Internal));
                     let (mut psbt, _details) = builder.finish().unwrap();
                     wallet.sign(&mut psbt, Default::default()).unwrap();
                     psbt.extract_tx()
diff --git a/src/wallet/mod.rs b/src/wallet/mod.rs
index 9231c3b74..bbd2809e6 100644
--- a/src/wallet/mod.rs
+++ b/src/wallet/mod.rs
@@ -572,39 +572,36 @@ where
             })
             .transpose()?;
 
+        let external_policy_path = params.descriptor_policy_paths.get(&self.descriptor);
+        let internal_policy_path = self
+            .change_descriptor
+            .as_ref()
+            .and_then(|desc| params.descriptor_policy_paths.get(desc));
+
         // The policy allows spending external outputs, but it requires a policy path that hasn't been
         // provided
         if params.change_policy != tx_builder::ChangeSpendPolicy::OnlyChange
             && external_policy.requires_path()
-            && params.external_policy_path.is_none()
+            && external_policy_path.is_none()
         {
-            return Err(Error::SpendingPolicyRequired(KeychainKind::External));
+            return Err(Error::SpendingPolicyRequired(KeychainKind::External)); // TODO: Error should be of descriptor
         };
         // Same for the internal_policy path, if present
         if let Some(internal_policy) = &internal_policy {
             if params.change_policy != tx_builder::ChangeSpendPolicy::ChangeForbidden
                 && internal_policy.requires_path()
-                && params.internal_policy_path.is_none()
+                && internal_policy_path.is_none()
             {
                 return Err(Error::SpendingPolicyRequired(KeychainKind::Internal));
             };
         }
 
-        let external_requirements = external_policy.get_condition(
-            params
-                .external_policy_path
-                .as_ref()
-                .unwrap_or(&BTreeMap::new()),
-        )?;
+        let external_requirements =
+            external_policy.get_condition(external_policy_path.unwrap_or(&BTreeMap::new()))?;
         let internal_requirements = internal_policy
             .map(|policy| {
                 Ok::<_, Error>(
-                    policy.get_condition(
-                        params
-                            .internal_policy_path
-                            .as_ref()
-                            .unwrap_or(&BTreeMap::new()),
-                    )?,
+                    policy.get_condition(internal_policy_path.unwrap_or(&BTreeMap::new()))?,
                 )
             })
             .transpose()?;
@@ -2738,7 +2735,7 @@ pub(crate) mod test {
         let mut builder = wallet.build_tx();
         builder
             .add_recipient(addr.script_pubkey(), 30_000)
-            .policy_path(path, KeychainKind::External);
+            .policy_path(path, &wallet.descriptor);
         let (psbt, _) = builder.finish().unwrap();
 
         assert_eq!(psbt.unsigned_tx.input[0].sequence, 0xFFFFFFFF);
@@ -2757,7 +2754,7 @@ pub(crate) mod test {
         let mut builder = wallet.build_tx();
         builder
             .add_recipient(addr.script_pubkey(), 30_000)
-            .policy_path(path, KeychainKind::External);
+            .policy_path(path, &wallet.descriptor);
         let (psbt, _) = builder.finish().unwrap();
 
         assert_eq!(psbt.unsigned_tx.input[0].sequence, 144);
@@ -4546,7 +4543,7 @@ pub(crate) mod test {
         let mut builder = wallet.build_tx();
         builder
             .add_recipient(addr.script_pubkey(), 25_000)
-            .policy_path(path, KeychainKind::External);
+            .policy_path(path, &wallet.descriptor);
         let (psbt, _) = builder.finish().unwrap();
 
         assert_eq!(
diff --git a/src/wallet/tx_builder.rs b/src/wallet/tx_builder.rs
index 0fee8aa9e..43045463b 100644
--- a/src/wallet/tx_builder.rs
+++ b/src/wallet/tx_builder.rs
@@ -47,6 +47,7 @@ use bitcoin::{OutPoint, Script, Transaction};
 use miniscript::descriptor::DescriptorTrait;
 
 use super::coin_selection::{CoinSelectionAlgorithm, DefaultCoinSelectionAlgorithm};
+use crate::descriptor::ExtendedDescriptor;
 use crate::{database::BatchDatabase, Error, Utxo, Wallet};
 use crate::{
     types::{FeeRate, KeychainKind, LocalUtxo, WeightedUtxo},
@@ -119,7 +120,7 @@ impl TxBuilderContext for BumpFee {}
 #[derive(Debug)]
 pub struct TxBuilder<'a, D, Cs, Ctx> {
     pub(crate) wallet: &'a Wallet<D>,
-    pub(crate) params: TxParams,
+    pub(crate) params: TxParams<'a>,
     pub(crate) coin_selection: Cs,
     pub(crate) phantom: PhantomData<Ctx>,
 }
@@ -127,13 +128,13 @@ pub struct TxBuilder<'a, D, Cs, Ctx> {
 /// The parameters for transaction creation sans coin selection algorithm.
 //TODO: TxParams should eventually be exposed publicly.
 #[derive(Default, Debug, Clone)]
-pub(crate) struct TxParams {
+pub(crate) struct TxParams<'a> {
     pub(crate) recipients: Vec<(Script, u64)>,
     pub(crate) drain_wallet: bool,
     pub(crate) drain_to: Option<Script>,
     pub(crate) fee_policy: Option<FeePolicy>,
-    pub(crate) internal_policy_path: Option<BTreeMap<String, Vec<usize>>>,
-    pub(crate) external_policy_path: Option<BTreeMap<String, Vec<usize>>>,
+    pub(crate) descriptor_policy_paths:
+        BTreeMap<&'a ExtendedDescriptor, BTreeMap<String, Vec<usize>>>,
     pub(crate) utxos: Vec<WeightedUtxo>,
     pub(crate) unspendable: HashSet<OutPoint>,
     pub(crate) manually_selected_only: bool,
@@ -250,21 +251,21 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     /// let builder = wallet
     ///     .build_tx()
     ///     .add_recipient(to_address.script_pubkey(), 50_000)
-    ///     .policy_path(path, KeychainKind::External);
+    ///     .policy_path(
+    ///         path,
+    ///         wallet.get_descriptor_for_keychain(KeychainKind::External),
+    ///     );
     ///
     /// # Ok::<(), bdk::Error>(())
     /// ```
     pub fn policy_path(
         &mut self,
         policy_path: BTreeMap<String, Vec<usize>>,
-        keychain: KeychainKind,
+        descriptor: &'a ExtendedDescriptor,
     ) -> &mut Self {
-        let to_update = match keychain {
-            KeychainKind::Internal => &mut self.params.internal_policy_path,
-            KeychainKind::External => &mut self.params.external_policy_path,
-        };
-
-        *to_update = Some(policy_path);
+        self.params
+            .descriptor_policy_paths
+            .insert(descriptor, policy_path);
         self
     }
 

From ea622b452b9956000210465e1701661e1a550318 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Fri, 1 Jul 2022 00:58:05 +0800
Subject: [PATCH 02/16] Modify `Error::SpendingPolicyRequired`

Use `ExtendedDescriptor` instead of `Keychain`
---
 src/error.rs      |  4 ++--
 src/wallet/mod.rs | 15 +++++++++++----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/error.rs b/src/error.rs
index 15ec5713d..f1976474a 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -73,8 +73,8 @@ pub enum Error {
     Key(crate::keys::KeyError),
     /// Descriptor checksum mismatch
     ChecksumMismatch,
-    /// Spending policy is not compatible with this [`KeychainKind`](crate::types::KeychainKind)
-    SpendingPolicyRequired(crate::types::KeychainKind),
+    /// Spending policy is not compatible with this [`ExtendedDescriptor`](crate::descriptor::ExtendedDescriptor)
+    SpendingPolicyRequired(Box<crate::descriptor::ExtendedDescriptor>),
     /// Error while extracting and manipulating policies
     InvalidPolicyPathError(crate::descriptor::policy::PolicyError),
     /// Signing error
diff --git a/src/wallet/mod.rs b/src/wallet/mod.rs
index bbd2809e6..7bdeee90b 100644
--- a/src/wallet/mod.rs
+++ b/src/wallet/mod.rs
@@ -584,7 +584,9 @@ where
             && external_policy.requires_path()
             && external_policy_path.is_none()
         {
-            return Err(Error::SpendingPolicyRequired(KeychainKind::External)); // TODO: Error should be of descriptor
+            return Err(Error::SpendingPolicyRequired(Box::new(
+                self.descriptor.clone(),
+            )));
         };
         // Same for the internal_policy path, if present
         if let Some(internal_policy) = &internal_policy {
@@ -592,7 +594,9 @@ where
                 && internal_policy.requires_path()
                 && internal_policy_path.is_none()
             {
-                return Err(Error::SpendingPolicyRequired(KeychainKind::Internal));
+                return Err(Error::SpendingPolicyRequired(Box::new(
+                    self.change_descriptor.as_ref().unwrap().clone(),
+                )));
             };
         }
 
@@ -2712,14 +2716,17 @@ pub(crate) mod test {
     }
 
     #[test]
-    #[should_panic(expected = "SpendingPolicyRequired(External)")]
     fn test_create_tx_policy_path_required() {
         let (wallet, _, _) = get_funded_wallet(get_test_a_or_b_plus_csv());
 
         let addr = Address::from_str("2N1Ffz3WaNzbeLFBb51xyFMHYSEUXcbiSoX").unwrap();
         let mut builder = wallet.build_tx();
         builder.add_recipient(addr.script_pubkey(), 30_000);
-        builder.finish().unwrap();
+
+        match builder.finish().unwrap_err() {
+            Error::SpendingPolicyRequired(desc) => assert_eq!(desc.as_ref(), &wallet.descriptor),
+            err => panic!("unexpected error type: {}", err),
+        };
     }
 
     #[test]

From 82f3b953b568192d3b0ed4a9deeff7054929381e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Wed, 29 Jun 2022 17:02:23 +0800
Subject: [PATCH 03/16] .gitignore for vscode

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 4dc9a2ff9..5df2148e8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,6 @@ Cargo.lock
 
 *.swp
 .idea
+
+# IDE
+/.vscode

From 9df2586d9819cb81e094608a656f8caba8234dd8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Sat, 9 Jul 2022 13:08:55 +0800
Subject: [PATCH 04/16] WIP: Decouple `TxBuilder` from `Wallet`.

This is a WIP.

Explanation for my approach (will be / is) provided in the PR's
description box.
---
 src/database/memory.rs             |   9 +-
 src/wallet/coin_selection.rs       | 280 +++++++++----
 src/wallet/mod.rs                  | 650 ++++++++++++++++++++---------
 src/wallet/signer.rs               |   1 +
 src/wallet/spendable_collection.rs | 329 +++++++++++++++
 src/wallet/tx_builder.rs           | 117 +++++-
 6 files changed, 1073 insertions(+), 313 deletions(-)
 create mode 100644 src/wallet/spendable_collection.rs

diff --git a/src/database/memory.rs b/src/database/memory.rs
index 7d806eb4a..7c6cd76b8 100644
--- a/src/database/memory.rs
+++ b/src/database/memory.rs
@@ -555,6 +555,7 @@ macro_rules! doctest_wallet {
         use $crate::bitcoin::Network;
         use $crate::database::MemoryDatabase;
         use $crate::testutils;
+
         let descriptor = "wpkh(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW)";
         let descriptors = testutils!(@descriptors (descriptor) (descriptor));
 
@@ -567,13 +568,17 @@ macro_rules! doctest_wallet {
             Some(100),
         );
 
-        $crate::Wallet::new(
+        let wallet = $crate::Wallet::new(
             &descriptors.0,
             descriptors.1.as_ref(),
             Network::Regtest,
             db
         )
-        .unwrap()
+        .unwrap();
+
+        wallet.ensure_addresses_cached(10).unwrap();
+
+        wallet
     }}
 }
 
diff --git a/src/wallet/coin_selection.rs b/src/wallet/coin_selection.rs
index 7b4a48334..a9b3101fd 100644
--- a/src/wallet/coin_selection.rs
+++ b/src/wallet/coin_selection.rs
@@ -26,15 +26,14 @@
 //! ```
 //! # use std::str::FromStr;
 //! # use bitcoin::*;
-//! # use bdk::wallet::{self, coin_selection::*};
-//! # use bdk::database::Database;
+//! # use bdk::wallet::{self, coin_selection::*, spendable_collection::*};
 //! # use bdk::*;
 //! # const TXIN_BASE_WEIGHT: usize = (32 + 4 + 4 + 1) * 4;
 //! #[derive(Debug)]
 //! struct AlwaysSpendEverything;
 //!
-//! impl<D: Database> CoinSelectionAlgorithm<D> for AlwaysSpendEverything {
-//!     fn coin_select(
+//! impl CoinSelectionAlgorithm for AlwaysSpendEverything {
+//!     fn coin_select<D: SpendableCollection>(
 //!         &self,
 //!         database: &D,
 //!         required_utxos: Vec<WeightedUtxo>,
@@ -89,7 +88,7 @@
 //! ```
 
 use crate::types::FeeRate;
-use crate::{database::Database, WeightedUtxo};
+use crate::WeightedUtxo;
 use crate::{error::Error, Utxo};
 
 use rand::seq::SliceRandom;
@@ -100,6 +99,8 @@ use rand::{rngs::StdRng, SeedableRng};
 use std::collections::HashMap;
 use std::convert::TryInto;
 
+use super::spendable_collection::SpendableCollection;
+
 /// Default coin selection algorithm used by [`TxBuilder`](super::tx_builder::TxBuilder) if not
 /// overridden
 #[cfg(not(test))]
@@ -144,7 +145,7 @@ impl CoinSelectionResult {
 /// selection algorithm when it creates transactions.
 ///
 /// For an example see [this module](crate::wallet::coin_selection)'s documentation.
-pub trait CoinSelectionAlgorithm<D: Database>: std::fmt::Debug {
+pub trait CoinSelectionAlgorithm: std::fmt::Debug {
     /// Perform the coin selection
     ///
     /// - `database`: a reference to the wallet's database that can be used to lookup additional
@@ -157,9 +158,9 @@ pub trait CoinSelectionAlgorithm<D: Database>: std::fmt::Debug {
     /// - `amount_needed`: the amount in satoshi to select
     /// - `fee_amount`: the amount of fees in satoshi already accumulated from adding outputs and
     ///                 the transaction's header
-    fn coin_select(
+    fn coin_select<Sc: SpendableCollection>(
         &self,
-        database: &D,
+        database: &Sc,
         required_utxos: Vec<WeightedUtxo>,
         optional_utxos: Vec<WeightedUtxo>,
         fee_rate: FeeRate,
@@ -175,8 +176,8 @@ pub trait CoinSelectionAlgorithm<D: Database>: std::fmt::Debug {
 #[derive(Debug, Default, Clone, Copy)]
 pub struct LargestFirstCoinSelection;
 
-impl<D: Database> CoinSelectionAlgorithm<D> for LargestFirstCoinSelection {
-    fn coin_select(
+impl CoinSelectionAlgorithm for LargestFirstCoinSelection {
+    fn coin_select<D: SpendableCollection>(
         &self,
         _database: &D,
         required_utxos: Vec<WeightedUtxo>,
@@ -213,8 +214,8 @@ impl<D: Database> CoinSelectionAlgorithm<D> for LargestFirstCoinSelection {
 #[derive(Debug, Default, Clone, Copy)]
 pub struct OldestFirstCoinSelection;
 
-impl<D: Database> CoinSelectionAlgorithm<D> for OldestFirstCoinSelection {
-    fn coin_select(
+impl CoinSelectionAlgorithm for OldestFirstCoinSelection {
+    fn coin_select<D: SpendableCollection>(
         &self,
         database: &D,
         required_utxos: Vec<WeightedUtxo>,
@@ -233,10 +234,13 @@ impl<D: Database> CoinSelectionAlgorithm<D> for OldestFirstCoinSelection {
                     if bh_acc.contains_key(&txid) {
                         Ok(bh_acc)
                     } else {
-                        database.get_tx(&txid, false).map(|details| {
-                            bh_acc.insert(
-                                txid,
-                                details.and_then(|d| d.confirmation_time.map(|ct| ct.height)),
+                        database.get_tx(&txid).map(|details| {
+                            let conf_time =
+                                details.and_then(|(_, bt_opt)| bt_opt.map(|bt| bt.height));
+                            bh_acc.insert(txid, conf_time);
+                            println!(
+                                "OldestFirstCoinSelection: insert({}, {:?})",
+                                txid, conf_time
                             );
                             bh_acc
                         })
@@ -357,8 +361,8 @@ impl BranchAndBoundCoinSelection {
 
 const BNB_TOTAL_TRIES: usize = 100_000;
 
-impl<D: Database> CoinSelectionAlgorithm<D> for BranchAndBoundCoinSelection {
-    fn coin_select(
+impl CoinSelectionAlgorithm for BranchAndBoundCoinSelection {
+    fn coin_select<D: SpendableCollection>(
         &self,
         _database: &D,
         required_utxos: Vec<WeightedUtxo>,
@@ -603,13 +607,17 @@ impl BranchAndBoundCoinSelection {
 
 #[cfg(test)]
 mod test {
+    use std::cell::RefCell;
     use std::str::FromStr;
 
-    use bitcoin::{OutPoint, Script, TxOut};
+    use bitcoin::{Network, OutPoint, Script, Transaction, TxOut, Txid};
 
     use super::*;
-    use crate::database::{BatchOperations, MemoryDatabase};
+    use crate::database::{BatchOperations, Database, MemoryDatabase};
+    use crate::descriptor::{ExtendedDescriptor, IntoWalletDescriptor};
     use crate::types::*;
+    use crate::wallet::spendable_collection::SpendableDatabase;
+    use crate::wallet::utils::SecpCtx;
     use crate::wallet::Vbytes;
 
     use rand::rngs::StdRng;
@@ -620,6 +628,29 @@ mod test {
 
     const FEE_AMOUNT: u64 = 50;
 
+    // static DESCRIPTOR: ExtendedDescriptor =
+    //     "wsh(pk(cRYhyJQzA92kLQUtJZbVVQrBoQwSm4WT23sanTXYrKoUMjX8ph1Z))"
+    //         .into_wallet_descriptor(&SecpCtx::new(), Network::Regtest)
+    //         .unwrap()
+    //         .0;
+    fn new_desc() -> ExtendedDescriptor {
+        "wsh(pk(cRYhyJQzA92kLQUtJZbVVQrBoQwSm4WT23sanTXYrKoUMjX8ph1Z))"
+            .into_wallet_descriptor(&SecpCtx::new(), Network::Regtest)
+            .unwrap()
+            .0
+    }
+
+    fn new_db() -> RefCell<MemoryDatabase> {
+        RefCell::new(MemoryDatabase::new())
+    }
+
+    fn new_collection<'a>(
+        desc: &'a ExtendedDescriptor,
+        db: &'a RefCell<MemoryDatabase>,
+    ) -> SpendableDatabase<'a, MemoryDatabase> {
+        SpendableDatabase::new(desc, None, Network::Regtest, db, Vec::new())
+    }
+
     fn utxo(value: u64, index: u32) -> WeightedUtxo {
         assert!(index < 10);
         let outpoint = OutPoint::from_str(&format!(
@@ -649,21 +680,52 @@ mod test {
         ]
     }
 
+    // creates a tx with given utxo as single output.
+    // updates utxo to contain correct txid in outpoint.
+    fn tx(utxo: &mut WeightedUtxo, lock_time: u32) -> (Transaction, Txid) {
+        let local = match &mut utxo.utxo {
+            Utxo::Local(local) => local,
+            _ => panic!(),
+        };
+        let tx = Transaction {
+            version: 2,
+            lock_time,
+            input: Vec::new(),
+            output: vec![local.txout.clone()],
+        };
+        let txid = tx.txid();
+        local.outpoint.txid = txid;
+        (tx, txid)
+    }
+
     fn setup_database_and_get_oldest_first_test_utxos<D: Database>(
         database: &mut D,
     ) -> Vec<WeightedUtxo> {
         // ensure utxos are from different tx
-        let utxo1 = utxo(120_000, 1);
-        let utxo2 = utxo(80_000, 2);
-        let utxo3 = utxo(300_000, 3);
+        let mut utxo1 = utxo(120_000, 1);
+        let mut utxo2 = utxo(80_000, 2);
+        let mut utxo3 = utxo(300_000, 3);
+
+        // let tx = |utxo: &WeightedUtxo, index: u32| {
+        //     let local = match &utxo.utxo {
+        //         Utxo::Local(local) => local,
+        //         _ => panic!(),
+        //     };
+        //     Transaction{ version: 2, lock_time: index, input: Vec::new(), output: vec![local.txout.clone()] }
+        // };
+
+        let (tx1, txid1) = tx(&mut utxo1, 1);
+        let (tx2, txid2) = tx(&mut utxo2, 2);
+        let (tx3, txid3) = tx(&mut utxo3, 3);
 
         // add tx to DB so utxos are sorted by blocktime asc
         // utxos will be selected by the following order
         // utxo1(blockheight 1) -> utxo2(blockheight 2), utxo3 (blockheight 3)
         // timestamp are all set as the same to ensure that only block height is used in sorting
         let utxo1_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo1.utxo.outpoint().txid,
+            transaction: Some(tx1),
+            txid: txid1,
+            // txid: utxo1.utxo.outpoint().txid,
             received: 1,
             sent: 0,
             fee: None,
@@ -674,8 +736,9 @@ mod test {
         };
 
         let utxo2_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo2.utxo.outpoint().txid,
+            transaction: Some(tx2),
+            txid: txid2,
+            // txid: utxo2.utxo.outpoint().txid,
             received: 1,
             sent: 0,
             fee: None,
@@ -686,8 +749,9 @@ mod test {
         };
 
         let utxo3_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo3.utxo.outpoint().txid,
+            transaction: Some(tx3),
+            txid: txid3,
+            // txid: utxo3.utxo.outpoint().txid,
             received: 1,
             sent: 0,
             fee: None,
@@ -757,11 +821,13 @@ mod test {
     #[test]
     fn test_largest_first_coin_selection_success() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         let result = LargestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 utxos,
                 vec![],
                 FeeRate::from_sat_per_vb(1.0),
@@ -778,11 +844,13 @@ mod test {
     #[test]
     fn test_largest_first_coin_selection_use_all() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         let result = LargestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 utxos,
                 vec![],
                 FeeRate::from_sat_per_vb(1.0),
@@ -799,11 +867,13 @@ mod test {
     #[test]
     fn test_largest_first_coin_selection_use_only_necessary() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         let result = LargestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -821,11 +891,13 @@ mod test {
     #[should_panic(expected = "InsufficientFunds")]
     fn test_largest_first_coin_selection_insufficient_funds() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         LargestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -839,11 +911,13 @@ mod test {
     #[should_panic(expected = "InsufficientFunds")]
     fn test_largest_first_coin_selection_insufficient_funds_high_fees() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         LargestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1000.0),
@@ -855,12 +929,14 @@ mod test {
 
     #[test]
     fn test_oldest_first_coin_selection_success() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
+        let utxos = { setup_database_and_get_oldest_first_test_utxos(&mut *db.borrow_mut()) };
 
         let result = OldestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -877,19 +953,29 @@ mod test {
     #[test]
     fn test_oldest_first_coin_selection_utxo_not_in_db_will_be_selected_last() {
         // ensure utxos are from different tx
-        let utxo1 = utxo(120_000, 1);
-        let utxo2 = utxo(80_000, 2);
-        let utxo3 = utxo(300_000, 3);
+        let mut utxo1 = utxo(120_000, 1);
+        let mut utxo2 = utxo(80_000, 2);
+        let mut utxo3 = utxo(300_000, 3);
+
+        let (tx1, txid1) = tx(&mut utxo1, 1);
+        let (tx2, txid2) = tx(&mut utxo2, 2);
+        let _ = tx(&mut utxo3, 3);
+
+        // let txid1 = tx1.txid();
+        // let txid2 = tx2.txid();
 
-        let mut database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         // add tx to DB so utxos are sorted by blocktime asc
         // utxos will be selected by the following order
         // utxo1(blockheight 1) -> utxo2(blockheight 2), utxo3 (not exist in DB)
         // timestamp are all set as the same to ensure that only block height is used in sorting
         let utxo1_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo1.utxo.outpoint().txid,
+            transaction: Some(tx1),
+            txid: txid1,
+            // txid: utxo1.utxo.outpoint().txid,
             received: 1,
             sent: 0,
             fee: None,
@@ -900,8 +986,9 @@ mod test {
         };
 
         let utxo2_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo2.utxo.outpoint().txid,
+            transaction: Some(tx2),
+            txid: txid2,
+            // txid: utxo2.utxo.outpoint().txid,
             received: 1,
             sent: 0,
             fee: None,
@@ -911,12 +998,15 @@ mod test {
             }),
         };
 
-        database.set_tx(&utxo1_tx_details).unwrap();
-        database.set_tx(&utxo2_tx_details).unwrap();
+        {
+            let db = &mut *db.borrow_mut();
+            db.set_tx(&utxo1_tx_details).unwrap();
+            db.set_tx(&utxo2_tx_details).unwrap();
+        }
 
         let result = OldestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 vec![utxo3, utxo1, utxo2],
                 FeeRate::from_sat_per_vb(1.0),
@@ -932,12 +1022,17 @@ mod test {
 
     #[test]
     fn test_oldest_first_coin_selection_use_all() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
+        let utxos = {
+            // let database: &mut MemoryDatabase = cache.borrow_mut();
+            setup_database_and_get_oldest_first_test_utxos(&mut *db.borrow_mut())
+        };
 
         let result = OldestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 utxos,
                 vec![],
                 FeeRate::from_sat_per_vb(1.0),
@@ -953,12 +1048,14 @@ mod test {
 
     #[test]
     fn test_oldest_first_coin_selection_use_only_necessary() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
+        let utxos = { setup_database_and_get_oldest_first_test_utxos(&mut *db.borrow_mut()) };
 
         let result = OldestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -975,12 +1072,14 @@ mod test {
     #[test]
     #[should_panic(expected = "InsufficientFunds")]
     fn test_oldest_first_coin_selection_insufficient_funds() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
+        let utxos = { setup_database_and_get_oldest_first_test_utxos(&mut *db.borrow_mut()) };
 
         OldestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -993,15 +1092,17 @@ mod test {
     #[test]
     #[should_panic(expected = "InsufficientFunds")]
     fn test_oldest_first_coin_selection_insufficient_funds_high_fees() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
+        let utxos = { setup_database_and_get_oldest_first_test_utxos(&mut *db.borrow_mut()) };
 
         let amount_needed: u64 =
             utxos.iter().map(|wu| wu.utxo.txout().value).sum::<u64>() - (FEE_AMOUNT + 50);
 
         OldestFirstCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1000.0),
@@ -1017,11 +1118,13 @@ mod test {
         // select three outputs
         let utxos = generate_same_value_utxos(100_000, 20);
 
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         let result = BranchAndBoundCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -1038,11 +1141,13 @@ mod test {
     #[test]
     fn test_bnb_coin_selection_required_are_enough() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         let result = BranchAndBoundCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 utxos.clone(),
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -1059,11 +1164,13 @@ mod test {
     #[test]
     fn test_bnb_coin_selection_optional_are_enough() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         let result = BranchAndBoundCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -1080,7 +1187,9 @@ mod test {
     #[test]
     fn test_bnb_coin_selection_required_not_enough() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         let required = vec![utxos[0].clone()];
         let mut optional = utxos[1..].to_vec();
@@ -1094,7 +1203,7 @@ mod test {
 
         let result = BranchAndBoundCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 required,
                 optional,
                 FeeRate::from_sat_per_vb(1.0),
@@ -1112,11 +1221,13 @@ mod test {
     #[should_panic(expected = "InsufficientFunds")]
     fn test_bnb_coin_selection_insufficient_funds() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         BranchAndBoundCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -1130,11 +1241,13 @@ mod test {
     #[should_panic(expected = "InsufficientFunds")]
     fn test_bnb_coin_selection_insufficient_funds_high_fees() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         BranchAndBoundCoinSelection::default()
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1000.0),
@@ -1147,11 +1260,12 @@ mod test {
     #[test]
     fn test_bnb_coin_selection_check_fee_rate() {
         let utxos = get_test_utxos();
-        let database = MemoryDatabase::default();
-
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
         let result = BranchAndBoundCoinSelection::new(0)
             .coin_select(
-                &database,
+                &cache,
                 vec![],
                 utxos,
                 FeeRate::from_sat_per_vb(1.0),
@@ -1171,14 +1285,16 @@ mod test {
     fn test_bnb_coin_selection_exact_match() {
         let seed = [0; 32];
         let mut rng: StdRng = SeedableRng::from_seed(seed);
-        let database = MemoryDatabase::default();
+        let desc = new_desc();
+        let db = new_db();
+        let cache = new_collection(&desc, &db);
 
         for _i in 0..200 {
             let mut optional_utxos = generate_random_utxos(&mut rng, 16);
             let target_amount = sum_random_utxos(&mut rng, &mut optional_utxos);
             let result = BranchAndBoundCoinSelection::new(0)
                 .coin_select(
-                    &database,
+                    &cache,
                     vec![],
                     optional_utxos,
                     FeeRate::from_sat_per_vb(0.0),
diff --git a/src/wallet/mod.rs b/src/wallet/mod.rs
index 7bdeee90b..10d2cd3ef 100644
--- a/src/wallet/mod.rs
+++ b/src/wallet/mod.rs
@@ -41,6 +41,9 @@ pub mod address_validator;
 pub mod coin_selection;
 pub mod export;
 pub mod signer;
+
+/// Spendable collection
+pub mod spendable_collection;
 pub mod time;
 pub mod tx_builder;
 pub(crate) mod utils;
@@ -73,6 +76,8 @@ use crate::signer::SignerError;
 use crate::testutils;
 use crate::types::*;
 
+pub use self::spendable_collection::{SpendableCollection, SpendableDatabase};
+
 const CACHE_ADDR_BATCH_SIZE: u32 = 100;
 const COINBASE_MATURITY: u32 = 100;
 
@@ -245,12 +250,38 @@ where
 
     // Return a newly derived address for the specified `keychain`.
     fn get_new_address(&self, keychain: KeychainKind) -> Result<AddressInfo, Error> {
-        let incremented_index = self.fetch_and_increment_index(keychain)?;
+        let (descriptor, _) = self._get_descriptor_for_keychain(keychain);
 
-        let address_result = self
-            .get_descriptor_for_keychain(keychain)
-            .as_derived(incremented_index, &self.secp)
-            .address(self.network);
+        Self::_get_new_address(
+            &self.database,
+            &self.secp,
+            self.address_validators.clone(),
+            descriptor,
+            keychain,
+            self.network,
+        )
+    }
+
+    /// TODO @evanlinjin: Move out of [`Wallet`].
+    pub(crate) fn _get_new_address(
+        database: &RefCell<D>,
+        secp: &SecpCtx,
+        address_validators: Vec<Arc<dyn AddressValidator>>,
+        descriptor: &ExtendedDescriptor,
+        keychain: KeychainKind,
+        network: Network,
+    ) -> Result<AddressInfo, Error> {
+        let incremented_index = Self::_fetch_and_increment_index(
+            database,
+            secp,
+            address_validators,
+            descriptor,
+            keychain,
+        )?;
+
+        let address_result = descriptor
+            .as_derived(incremented_index, secp)
+            .address(network);
 
         address_result
             .map(|address| AddressInfo {
@@ -517,6 +548,24 @@ where
         &self.address_validators
     }
 
+    fn as_spendable_collection(&self) -> SpendableDatabase<D> {
+        SpendableDatabase::new(
+            &self.descriptor,
+            self.change_descriptor.as_ref(),
+            self.network,
+            &self.database,
+            self.address_validators.clone(),
+        )
+    }
+
+    /// Returns 0 when not synced
+    fn get_current_known_block_height(&self) -> Result<u32, Error> {
+        self.database().get_sync_time().map(|opt| match opt {
+            Some(sync_time) => sync_time.block_time.height,
+            None => 0_u32,
+        })
+    }
+
     /// Start building a transaction.
     ///
     /// This returns a blank [`TxBuilder`] from which you can specify the parameters for the transaction.
@@ -543,75 +592,78 @@ where
     /// ```
     ///
     /// [`TxBuilder`]: crate::TxBuilder
-    pub fn build_tx(&self) -> TxBuilder<'_, D, DefaultCoinSelectionAlgorithm, CreateTx> {
+    pub fn build_tx(
+        &self,
+    ) -> TxBuilder<'_, D, SpendableDatabase<D>, DefaultCoinSelectionAlgorithm, CreateTx> {
+        // Get default block height to set as nLockTime (we try to prevent fee sniping).
+        // However, if we do not know the block height, we default to 0.
+        let default_block_height = self.get_current_known_block_height().unwrap_or(0_u32);
+
         TxBuilder {
-            wallet: self,
+            spendable_collection: self.as_spendable_collection(),
             params: TxParams::default(),
+            default_block_height,
             coin_selection: DefaultCoinSelectionAlgorithm::default(),
+            signers: &self.signers,
+            secp: self.secp.clone(),
             phantom: core::marker::PhantomData,
+            phantom_database: core::marker::PhantomData,
         }
     }
 
-    pub(crate) fn create_tx<Cs: coin_selection::CoinSelectionAlgorithm<D>>(
-        &self,
+    /// TODO @evanlinjin: Move this out of [`Wallet`].
+    /// Is `fallback_block_height` in the right place?
+    pub(crate) fn _create_tx<'a, Sc, Cs>(
+        spendable_collection: &'a Sc,
         coin_selection: Cs,
         params: TxParams,
-    ) -> Result<(psbt::PartiallySignedTransaction, TransactionDetails), Error> {
-        let external_policy = self
-            .descriptor
-            .extract_policy(&self.signers, BuildSatisfaction::None, &self.secp)?
-            .unwrap();
-        let internal_policy = self
-            .change_descriptor
-            .as_ref()
-            .map(|desc| {
-                Ok::<_, Error>(
-                    desc.extract_policy(&self.change_signers, BuildSatisfaction::None, &self.secp)?
-                        .unwrap(),
-                )
-            })
-            .transpose()?;
-
-        let external_policy_path = params.descriptor_policy_paths.get(&self.descriptor);
-        let internal_policy_path = self
-            .change_descriptor
-            .as_ref()
-            .and_then(|desc| params.descriptor_policy_paths.get(desc));
+        fallback_block_height: u32,
+        signers: &SignersContainer,
+        secp: &SecpCtx,
+    ) -> Result<(psbt::PartiallySignedTransaction, TransactionDetails), Error>
+    where
+        Sc: SpendableCollection,
+        Cs: coin_selection::CoinSelectionAlgorithm,
+    {
+        let conditions = spendable_collection
+            .iter_descriptors()?
+            .map(|(desc, keychain)| {
+                let policy = desc
+                    .extract_policy(signers, BuildSatisfaction::None, secp)?
+                    .unwrap();
+                let policy_path = params.descriptor_policy_paths.get(&desc);
+
+                // are we permitted to spend inputs?
+                let is_permitted = match keychain {
+                    KeychainKind::External => {
+                        params.change_policy != tx_builder::ChangeSpendPolicy::OnlyChange
+                    }
+                    KeychainKind::Internal => {
+                        params.change_policy != tx_builder::ChangeSpendPolicy::ChangeForbidden
+                    }
+                };
 
-        // The policy allows spending external outputs, but it requires a policy path that hasn't been
-        // provided
-        if params.change_policy != tx_builder::ChangeSpendPolicy::OnlyChange
-            && external_policy.requires_path()
-            && external_policy_path.is_none()
-        {
-            return Err(Error::SpendingPolicyRequired(Box::new(
-                self.descriptor.clone(),
-            )));
-        };
-        // Same for the internal_policy path, if present
-        if let Some(internal_policy) = &internal_policy {
-            if params.change_policy != tx_builder::ChangeSpendPolicy::ChangeForbidden
-                && internal_policy.requires_path()
-                && internal_policy_path.is_none()
-            {
-                return Err(Error::SpendingPolicyRequired(Box::new(
-                    self.change_descriptor.as_ref().unwrap().clone(),
-                )));
-            };
-        }
+                // if permitted, ensure policy path requirements are satisfied
+                if is_permitted && policy.requires_path() && policy_path.is_none() {
+                    Err(Error::SpendingPolicyRequired(Box::new(desc.clone())))
+                } else {
+                    policy
+                        .get_condition(policy_path.unwrap_or(&BTreeMap::new()))
+                        .map_err(Error::InvalidPolicyPathError)
+                }
+            });
 
-        let external_requirements =
-            external_policy.get_condition(external_policy_path.unwrap_or(&BTreeMap::new()))?;
-        let internal_requirements = internal_policy
-            .map(|policy| {
-                Ok::<_, Error>(
-                    policy.get_condition(internal_policy_path.unwrap_or(&BTreeMap::new()))?,
-                )
+        let requirements = conditions
+            .reduce(|acc_res, cond_res| match (acc_res, cond_res) {
+                (Ok(acc), Ok(cond)) => acc.merge(&cond).map_err(Error::InvalidPolicyPathError),
+                (Err(err), _) => Err(err),
+                (_, Err(err)) => Err(err),
             })
-            .transpose()?;
+            .transpose()?
+            // TODO @evanlinjin: Figure out an appropriate error when there are no descriptors in
+            // the spendable collection.
+            .ok_or_else(|| Error::Generic("No descriptors in spendable collection".to_string()))?;
 
-        let requirements =
-            external_requirements.merge(&internal_requirements.unwrap_or_default())?;
         debug!("Policy requirements: {:?}", requirements);
 
         let version = match params.version {
@@ -632,10 +684,7 @@ where
         // We use a match here instead of a map_or_else as it's way more readable :)
         let current_height = match params.current_height {
             // If they didn't tell us the current height, we assume it's the latest sync height.
-            None => self
-                .database()
-                .get_sync_time()?
-                .map(|sync_time| sync_time.block_time.height),
+            None => Some(fallback_block_height),
             h => h,
         };
 
@@ -745,7 +794,7 @@ where
                 return Err(Error::OutputBelowDustLimit(index));
             }
 
-            if self.is_mine(script_pubkey)? {
+            if spendable_collection.is_mine(script_pubkey)? {
                 received += value;
             }
 
@@ -753,6 +802,7 @@ where
                 script_pubkey: script_pubkey.clone(),
                 value,
             };
+
             fee_amount += fee_rate.fee_vb(serialize(&new_out).len());
 
             tx.output.push(new_out);
@@ -760,26 +810,35 @@ where
             outgoing += value;
         }
 
-        if params.change_policy != tx_builder::ChangeSpendPolicy::ChangeAllowed
-            && self.change_descriptor.is_none()
-        {
-            return Err(Error::Generic(
-                "The `change_policy` can be set only if the wallet has a change_descriptor".into(),
-            ));
+        // If policy is to only use internal inputs, we need to ensure we have internal descriptors
+        // @evanlinjin: This logic has been changed, see Discord:
+        // https://discord.com/channels/753336465005608961/753367451319926827/995475330531868782
+        if params.change_policy == tx_builder::ChangeSpendPolicy::OnlyChange {
+            let has_internal = spendable_collection
+                .iter_descriptors()?
+                .any(|(_, kc)| kc == KeychainKind::Internal);
+
+            if !has_internal {
+                return Err(Error::Generic(
+                    "The `change_policy` can be set only if the wallet has a change_descriptor"
+                        .into(),
+                ));
+            }
         }
 
-        let (required_utxos, optional_utxos) = self.preselect_utxos(
+        let (required_utxos, optional_utxos) = Self::_preselect_utxos(
+            spendable_collection,
             params.change_policy,
             &params.unspendable,
             params.utxos.clone(),
             params.drain_wallet,
             params.manually_selected_only,
-            params.bumping_fee.is_some(), // we mandate confirmed transactions if we're bumping the fee
+            params.bumping_fee.is_some(), /* we mandate confirmed transactions if we're bumping the fee */
             current_height,
         )?;
 
         let coin_selection = coin_selection.coin_select(
-            self.database.borrow().deref(),
+            spendable_collection,
             required_utxos,
             optional_utxos,
             fee_rate,
@@ -803,8 +862,9 @@ where
         let mut drain_output = {
             let script_pubkey = match params.drain_to {
                 Some(ref drain_recipient) => drain_recipient.clone(),
-                None => self
-                    .get_internal_address(AddressIndex::New)?
+                #[allow(deprecated)]
+                None => spendable_collection
+                    .new_auto_address()?
                     .address
                     .script_pubkey(),
             };
@@ -843,7 +903,7 @@ where
             fee_amount += drain_val;
         } else {
             drain_output.value = drain_val;
-            if self.is_mine(&drain_output.script_pubkey)? {
+            if spendable_collection.is_mine(&drain_output.script_pubkey)? {
                 received += drain_val;
             }
             tx.output.push(drain_output);
@@ -854,7 +914,13 @@ where
 
         let txid = tx.txid();
         let sent = coin_selection.local_selected_amount();
-        let psbt = self.complete_transaction(tx, coin_selection.selected, params)?;
+        let psbt = Self::_complete_transaction(
+            spendable_collection,
+            tx,
+            coin_selection.selected,
+            params,
+            secp,
+        )?;
 
         let transaction_details = TransactionDetails {
             transaction: None,
@@ -911,7 +977,8 @@ where
     pub fn build_fee_bump(
         &self,
         txid: Txid,
-    ) -> Result<TxBuilder<'_, D, DefaultCoinSelectionAlgorithm, BumpFee>, Error> {
+    ) -> Result<TxBuilder<'_, D, SpendableDatabase<D>, DefaultCoinSelectionAlgorithm, BumpFee>, Error>
+    {
         let mut details = match self.database.borrow().get_tx(&txid, true)? {
             None => return Err(Error::TransactionNotFound),
             Some(tx) if tx.transaction.is_none() => return Err(Error::TransactionNotFound),
@@ -936,6 +1003,10 @@ where
                     .get_previous_output(&txin.previous_output)?
                     .ok_or(Error::UnknownUtxo)?;
 
+                // TODO @evanlinjin: Remove requirement of &self -> TxbuilderCache
+                //  Option(root_desc, child_index) <- txout.script_pubkey
+                //      Some => (root_desc.max_satisfaction_weight(), keychain_kind(root_desc))
+                //      None => (ser_len(txin.script_sig) * 4 + ser_len(txin.witness), external_keychain)
                 let (weight, keychain) = match self
                     .database
                     .borrow()
@@ -974,7 +1045,11 @@ where
         if tx.output.len() > 1 {
             let mut change_index = None;
             for (index, txout) in tx.output.iter().enumerate() {
+                // TODO @evanlinjin:
+                // if has_explicit_change_descriptor() => change_type = External
+                // else                                => change_type = Internal
                 let (_, change_type) = self._get_descriptor_for_keychain(KeychainKind::Internal);
+
                 match self
                     .database
                     .borrow()
@@ -1007,10 +1082,14 @@ where
         };
 
         Ok(TxBuilder {
-            wallet: self,
+            spendable_collection: self.as_spendable_collection(),
             params,
             coin_selection: DefaultCoinSelectionAlgorithm::default(),
             phantom: core::marker::PhantomData,
+            phantom_database: core::marker::PhantomData,
+            default_block_height: 0, // TODO
+            signers: &self.signers,
+            secp: self.secp.clone(),
         })
     }
 
@@ -1131,6 +1210,7 @@ where
         psbt: &mut psbt::PartiallySignedTransaction,
         sign_options: SignOptions,
     ) -> Result<bool, Error> {
+        // NOTE @evanlinjin: this is only used in `.sign`
         let tx = &psbt.unsigned_tx;
         let mut finished = true;
 
@@ -1256,27 +1336,49 @@ where
 
     fn fetch_and_increment_index(&self, keychain: KeychainKind) -> Result<u32, Error> {
         let (descriptor, keychain) = self._get_descriptor_for_keychain(keychain);
+        Self::_fetch_and_increment_index(
+            &self.database,
+            &self.secp,
+            self.address_validators.clone(),
+            descriptor,
+            keychain,
+        )
+    }
+
+    // TODO @evanlinjin: Move out of [`Wallet`].
+    fn _fetch_and_increment_index(
+        database: &RefCell<D>,
+        secp: &SecpCtx,
+        address_validators: Vec<Arc<dyn AddressValidator>>,
+        descriptor: &ExtendedDescriptor,
+        keychain: KeychainKind,
+    ) -> Result<u32, Error> {
         let index = match descriptor.is_deriveable() {
             false => 0,
-            true => self.database.borrow_mut().increment_last_index(keychain)?,
+            true => database.borrow_mut().increment_last_index(keychain)?,
         };
 
-        if self
-            .database
+        if database
             .borrow()
             .get_script_pubkey_from_path(keychain, index)?
             .is_none()
         {
-            self.cache_addresses(keychain, index, CACHE_ADDR_BATCH_SIZE)?;
+            Self::_cache_addresses(
+                database,
+                secp,
+                descriptor,
+                keychain,
+                index,
+                CACHE_ADDR_BATCH_SIZE,
+            )?;
         }
 
-        let derived_descriptor = descriptor.as_derived(index, &self.secp);
+        let derived_descriptor = descriptor.as_derived(index, secp);
 
-        let hd_keypaths = derived_descriptor.get_hd_keypaths(&self.secp);
+        let hd_keypaths = derived_descriptor.get_hd_keypaths(secp);
         let script = derived_descriptor.script_pubkey();
 
-        for validator in &self.address_validators {
-            #[allow(deprecated)]
+        for validator in address_validators {
             validator.validate(keychain, &hd_keypaths, &script)?;
         }
 
@@ -1302,13 +1404,27 @@ where
         Ok(())
     }
 
-    fn cache_addresses(
-        &self,
+    fn cache_addresses(&self, keychain: KeychainKind, from: u32, count: u32) -> Result<(), Error> {
+        let (descriptor, keychain) = self._get_descriptor_for_keychain(keychain);
+        Self::_cache_addresses(
+            &self.database,
+            &self.secp,
+            descriptor,
+            keychain,
+            from,
+            count,
+        )
+    }
+
+    /// TODO @evanlinjin: Move out of [`Wallet`].
+    fn _cache_addresses(
+        database: &RefCell<D>,
+        secp: &SecpCtx,
+        descriptor: &ExtendedDescriptor,
         keychain: KeychainKind,
         from: u32,
         mut count: u32,
     ) -> Result<(), Error> {
-        let (descriptor, keychain) = self._get_descriptor_for_keychain(keychain);
         if !descriptor.is_deriveable() {
             if from > 0 {
                 return Ok(());
@@ -1317,12 +1433,12 @@ where
             count = 1;
         }
 
-        let mut address_batch = self.database.borrow().begin_batch();
+        let mut address_batch = database.borrow().begin_batch();
 
         let start_time = time::Instant::new();
         for i in from..(from + count) {
             address_batch.set_script_pubkey(
-                &descriptor.as_derived(i, &self.secp).script_pubkey(),
+                &descriptor.as_derived(i, secp).script_pubkey(),
                 keychain,
                 i,
             )?;
@@ -1335,33 +1451,18 @@ where
             start_time.elapsed().as_millis()
         );
 
-        self.database.borrow_mut().commit_batch(address_batch)?;
+        database.borrow_mut().commit_batch(address_batch)?;
 
         Ok(())
     }
 
-    fn get_available_utxos(&self) -> Result<Vec<(LocalUtxo, usize)>, Error> {
-        Ok(self
-            .list_unspent()?
-            .into_iter()
-            .map(|utxo| {
-                let keychain = utxo.keychain;
-                (
-                    utxo,
-                    self.get_descriptor_for_keychain(keychain)
-                        .max_satisfaction_weight()
-                        .unwrap(),
-                )
-            })
-            .collect())
-    }
-
     /// Given the options returns the list of utxos that must be used to form the
     /// transaction and any further that may be used if needed.
+    /// TODO @evanlinjin: Move out of [`Wallet`].
     #[allow(clippy::type_complexity)]
     #[allow(clippy::too_many_arguments)]
-    fn preselect_utxos(
-        &self,
+    fn _preselect_utxos<Sc>(
+        spendable_collection: &Sc,
         change_policy: tx_builder::ChangeSpendPolicy,
         unspendable: &HashSet<OutPoint>,
         manually_selected: Vec<WeightedUtxo>,
@@ -1369,48 +1470,50 @@ where
         manual_only: bool,
         must_only_use_confirmed_tx: bool,
         current_height: Option<u32>,
-    ) -> Result<(Vec<WeightedUtxo>, Vec<WeightedUtxo>), Error> {
-        //    must_spend <- manually selected utxos
-        //    may_spend  <- all other available utxos
-        let mut may_spend = self.get_available_utxos()?;
-
-        may_spend.retain(|may_spend| {
-            !manually_selected
-                .iter()
-                .any(|manually_selected| manually_selected.utxo.outpoint() == may_spend.0.outpoint)
-        });
-        let mut must_spend = manually_selected;
-
+    ) -> Result<(Vec<WeightedUtxo>, Vec<WeightedUtxo>), Error>
+    where
+        Sc: SpendableCollection,
+    {
         // NOTE: we are intentionally ignoring `unspendable` here. i.e manual
         // selection overrides unspendable.
         if manual_only {
-            return Ok((must_spend, vec![]));
+            return Ok((manually_selected, vec![]));
         }
 
-        let database = self.database.borrow();
+        //    must_spend <- manually selected utxos
+        //    may_spend  <- all other available utxos
+        let mut may_spend = spendable_collection
+            .iter_utxos()?
+            .filter(|(utxo, _)| {
+                let is_manually_selected = manually_selected
+                    .iter()
+                    .any(|selected_utxo| selected_utxo.utxo.outpoint() == utxo.outpoint);
+
+                !is_manually_selected
+            })
+            .collect::<Vec<_>>();
+
+        let mut must_spend = manually_selected;
+
         let satisfies_confirmed = may_spend
             .iter()
             .map(|u| {
-                database
-                    .get_tx(&u.0.outpoint.txid, true)
+                spendable_collection
+                    .get_tx(&u.0.outpoint.txid)
                     .map(|tx| match tx {
                         // We don't have the tx in the db for some reason,
                         // so we can't know for sure if it's mature or not.
                         // We prefer not to spend it.
                         None => false,
-                        Some(tx) => {
+                        Some((tx, block_time)) => {
                             // Whether the UTXO is mature and, if needed, confirmed
                             let mut spendable = true;
-                            if must_only_use_confirmed_tx && tx.confirmation_time.is_none() {
+                            if must_only_use_confirmed_tx && block_time.is_none() {
                                 return false;
                             }
-                            if tx
-                                .transaction
-                                .expect("We specifically ask for the transaction above")
-                                .is_coin_base()
-                            {
+                            if tx.is_coin_base() {
                                 if let Some(current_height) = current_height {
-                                    match &tx.confirmation_time {
+                                    match &block_time {
                                         Some(t) => {
                                             // https://github.com/bitcoin/bitcoin/blob/c5e67be03bb06a5d7885c55db1f016fbf2333fe3/src/validation.cpp#L373-L375
                                             spendable &= (current_height.saturating_sub(t.height))
@@ -1450,26 +1553,37 @@ where
         Ok((must_spend, may_spend))
     }
 
-    fn complete_transaction(
-        &self,
+    /// TODO @evanlinjin: Move out of [`Wallet`].
+    fn _complete_transaction<'a, Sc>(
+        spendable_collection: &'a Sc,
         tx: Transaction,
         selected: Vec<Utxo>,
         params: TxParams,
-    ) -> Result<psbt::PartiallySignedTransaction, Error> {
+        secp: &SecpCtx,
+    ) -> Result<psbt::PartiallySignedTransaction, Error>
+    where
+        Sc: SpendableCollection,
+    {
         let mut psbt = psbt::PartiallySignedTransaction::from_unsigned_tx(tx)?;
 
         if params.add_global_xpubs {
-            let mut all_xpubs = self.descriptor.get_extended_keys()?;
-            if let Some(change_descriptor) = &self.change_descriptor {
-                all_xpubs.extend(change_descriptor.get_extended_keys()?);
-            }
+            let all_xpubs = spendable_collection
+                .iter_descriptors()?
+                .try_fold(Vec::new(), |mut xpubs, (desc, _)| {
+                    xpubs.append(&mut desc.get_extended_keys()?);
+                    Ok(xpubs)
+                })
+                .map_err(Error::Descriptor)?;
+
+            // let mut all_xpubs = self.descriptor.get_extended_keys()?;
+            // if let Some(change_descriptor) = &self.change_descriptor {
+            //     all_xpubs.extend(change_descriptor.get_extended_keys()?);
+            // }
 
             for xpub in all_xpubs {
                 let origin = match xpub.origin {
                     Some(origin) => origin,
-                    None if xpub.xkey.depth == 0 => {
-                        (xpub.root_fingerprint(&self.secp), vec![].into())
-                    }
+                    None if xpub.xkey.depth == 0 => (xpub.root_fingerprint(secp), vec![].into()),
                     _ => return Err(Error::MissingKeyOrigin(xpub.xkey.to_string())),
                 };
 
@@ -1491,8 +1605,16 @@ where
 
             match utxo {
                 Utxo::Local(utxo) => {
+                    let psbt_input_res = Self::_get_psbt_input(
+                        spendable_collection,
+                        secp,
+                        utxo,
+                        params.sighash,
+                        params.only_witness_utxo,
+                    );
                     *psbt_input =
-                        match self.get_psbt_input(utxo, params.sighash, params.only_witness_utxo) {
+                        // match self.get_psbt_input(utxo, params.sighash, params.only_witness_utxo) {
+                        match psbt_input_res {
                             Ok(psbt_input) => psbt_input,
                             Err(e) => match e {
                                 Error::UnknownUtxo => psbt::Input {
@@ -1527,18 +1649,23 @@ where
         }
 
         // probably redundant but it doesn't hurt...
-        self.add_input_hd_keypaths(&mut psbt)?;
+        // self.add_input_hd_keypaths(&mut psbt)?;
+        Self::_add_input_hd_keypaths(spendable_collection, secp, &mut psbt)?;
 
         // add metadata for the outputs
         for (psbt_output, tx_output) in psbt.outputs.iter_mut().zip(psbt.unsigned_tx.output.iter())
         {
-            if let Some((keychain, child)) = self
-                .database
-                .borrow()
-                .get_path_from_script_pubkey(&tx_output.script_pubkey)?
-            {
-                let (desc, _) = self._get_descriptor_for_keychain(keychain);
-                let derived_descriptor = desc.as_derived(child, &self.secp);
+            // TODO @evanlinjin
+            let path_opt =
+                spendable_collection.get_path_of_script_pubkey(&tx_output.script_pubkey)?;
+            // if let Some((keychain, child)) = self
+            //     .database
+            //     .borrow()
+            //     .get_path_from_script_pubkey(&tx_output.script_pubkey)?
+            // {
+            if let Some((desc, child)) = path_opt {
+                // let (desc, _) = self._get_descriptor_for_keychain(keychain);
+                let derived_descriptor = desc.as_derived(child, secp);
 
                 if let miniscript::Descriptor::Tr(tr) = &derived_descriptor {
                     let tap_tree = if tr.taptree().is_some() {
@@ -1559,12 +1686,12 @@ where
                     psbt_output.tap_tree = tap_tree;
                     psbt_output
                         .tap_key_origins
-                        .append(&mut derived_descriptor.get_tap_key_origins(&self.secp));
+                        .append(&mut derived_descriptor.get_tap_key_origins(secp));
                     psbt_output.tap_internal_key = Some(tr.internal_key().to_x_only_pubkey());
                 } else {
                     psbt_output
                         .bip32_derivation
-                        .append(&mut derived_descriptor.get_hd_keypaths(&self.secp));
+                        .append(&mut derived_descriptor.get_hd_keypaths(secp));
                 }
                 if params.include_output_redeem_witness_script {
                     psbt_output.witness_script = derived_descriptor.psbt_witness_script();
@@ -1582,25 +1709,47 @@ where
         utxo: LocalUtxo,
         sighash_type: Option<psbt::PsbtSighashType>,
         only_witness_utxo: bool,
+    ) -> Result<psbt::Input, Error> {
+        let spendable_collection = self.as_spendable_collection();
+        Self::_get_psbt_input(
+            &spendable_collection,
+            &self.secp,
+            utxo,
+            sighash_type,
+            only_witness_utxo,
+        )
+    }
+
+    /// TODO @evanlinjin: Move out of [`Wallet`].
+    /// * Should this method be renamed to `make_psbt_input`?
+    fn _get_psbt_input<Sc: SpendableCollection>(
+        spendable_collection: &Sc,
+        secp: &SecpCtx,
+        utxo: LocalUtxo,
+        sighash_type: Option<psbt::PsbtSighashType>,
+        only_witness_utxo: bool,
     ) -> Result<psbt::Input, Error> {
         // Try to find the prev_script in our db to figure out if this is internal or external,
         // and the derivation index
-        let (keychain, child) = self
-            .database
-            .borrow()
-            .get_path_from_script_pubkey(&utxo.txout.script_pubkey)?
+        let (desc, child) = spendable_collection
+            .get_path_of_script_pubkey(&utxo.txout.script_pubkey)?
             .ok_or(Error::UnknownUtxo)?;
+        // let (keychain, child) = self
+        //     .database
+        //     .borrow()
+        //     .get_path_from_script_pubkey(&utxo.txout.script_pubkey)?
+        //     .ok_or(Error::UnknownUtxo)?;
 
         let mut psbt_input = psbt::Input {
             sighash_type,
             ..psbt::Input::default()
         };
 
-        let desc = self.get_descriptor_for_keychain(keychain);
-        let derived_descriptor = desc.as_derived(child, &self.secp);
+        // let desc = self.get_descriptor_for_keychain(keychain);
+        let derived_descriptor = desc.as_derived(child, secp);
 
         if let miniscript::Descriptor::Tr(tr) = &derived_descriptor {
-            psbt_input.tap_key_origins = derived_descriptor.get_tap_key_origins(&self.secp);
+            psbt_input.tap_key_origins = derived_descriptor.get_tap_key_origins(secp);
             psbt_input.tap_internal_key = Some(tr.internal_key().to_x_only_pubkey());
 
             let spend_info = tr.spend_info();
@@ -1615,14 +1764,16 @@ where
                 })
                 .collect();
         } else {
-            psbt_input.bip32_derivation = derived_descriptor.get_hd_keypaths(&self.secp);
+            psbt_input.bip32_derivation = derived_descriptor.get_hd_keypaths(secp);
         }
 
         psbt_input.redeem_script = derived_descriptor.psbt_redeem_script();
         psbt_input.witness_script = derived_descriptor.psbt_witness_script();
 
         let prev_output = utxo.outpoint;
-        if let Some(prev_tx) = self.database.borrow().get_raw_tx(&prev_output.txid)? {
+        let prev_tx_opt = spendable_collection.get_tx(&prev_output.txid)?;
+        // if let Some(prev_tx) = self.database.borrow().get_raw_tx(&prev_output.txid)? {
+        if let Some((prev_tx, _)) = prev_tx_opt {
             if desc.is_witness() || desc.is_taproot() {
                 psbt_input.witness_utxo = Some(prev_tx.output[prev_output.vout as usize].clone());
             }
@@ -1637,39 +1788,92 @@ where
         &self,
         psbt: &mut psbt::PartiallySignedTransaction,
     ) -> Result<(), Error> {
-        let mut input_utxos = Vec::with_capacity(psbt.inputs.len());
-        for n in 0..psbt.inputs.len() {
-            input_utxos.push(psbt.get_utxo_for(n).clone());
-        }
+        let spendable_collection = self.as_spendable_collection();
+        Self::_add_input_hd_keypaths(&spendable_collection, &self.secp, psbt)
+    }
 
-        // try to add hd_keypaths if we've already seen the output
-        for (psbt_input, out) in psbt.inputs.iter_mut().zip(input_utxos.iter()) {
-            if let Some(out) = out {
-                if let Some((keychain, child)) = self
-                    .database
-                    .borrow()
-                    .get_path_from_script_pubkey(&out.script_pubkey)?
-                {
-                    debug!("Found descriptor {:?}/{}", keychain, child);
-
-                    // merge hd_keypaths or tap_key_origins
-                    let desc = self.get_descriptor_for_keychain(keychain);
-                    if desc.is_taproot() {
-                        let mut tap_key_origins = desc
-                            .as_derived(child, &self.secp)
-                            .get_tap_key_origins(&self.secp);
-                        psbt_input.tap_key_origins.append(&mut tap_key_origins);
-                    } else {
-                        let mut hd_keypaths = desc
-                            .as_derived(child, &self.secp)
-                            .get_hd_keypaths(&self.secp);
-                        psbt_input.bip32_derivation.append(&mut hd_keypaths);
-                    }
+    /// TODO @evanlinjin: Move out of [`Wallet`].
+    fn _add_input_hd_keypaths<'a, Sc>(
+        spendable_collection: &'a Sc,
+        secp: &SecpCtx,
+        psbt: &mut psbt::PartiallySignedTransaction,
+    ) -> Result<(), Error>
+    where
+        Sc: SpendableCollection,
+    {
+        let input_utxos = (0..psbt.inputs.len())
+            .map(|i| psbt.get_utxo_for(i))
+            .collect::<Vec<_>>();
+
+        psbt.inputs
+            .iter_mut()
+            .zip(input_utxos.iter())
+            .try_for_each(|(psbt_input, input_utxo)| {
+                // obtain previous output's script pubkey (if any)
+                let prev_script_pubkey = match input_utxo {
+                    Some(input_utxo) => &input_utxo.script_pubkey,
+                    None => return Ok(()),
+                };
+
+                // obtain parent descriptor + child index of script_pubkey (if any)
+                let (parent_desc, child) =
+                    match spendable_collection.get_path_of_script_pubkey(prev_script_pubkey)? {
+                        Some(path) => path,
+                        None => return Ok(()),
+                    };
+
+                debug!("Found descriptor {} /{}", parent_desc, child);
+
+                // merge hd_keypaths or tap_keys_origins
+                if parent_desc.is_taproot() {
+                    let tap_key_origins = &mut parent_desc
+                        .as_derived(child, secp)
+                        .get_tap_key_origins(secp);
+                    psbt_input.tap_key_origins.append(tap_key_origins);
+                } else {
+                    let hd_keypaths =
+                        &mut parent_desc.as_derived(child, secp).get_hd_keypaths(secp);
+                    psbt_input.bip32_derivation.append(hd_keypaths);
                 }
-            }
-        }
 
-        Ok(())
+                Ok(())
+            })
+
+        // let mut input_utxos = Vec::with_capacity(psbt.inputs.len());
+        // for n in 0..psbt.inputs.len() {
+        //     input_utxos.push(psbt.get_utxo_for(n).clone());
+        // }
+
+        // // try to add hd_keypaths if we've already seen the output
+        // // @evanlinjin: Just some notes for myself:
+        // //  * out: psbt input (UTXO)
+        // for (psbt_input, out) in psbt.inputs.iter_mut().zip(input_utxos.iter()) {
+        //     if let Some(out) = out {
+        //         if let Some((keychain, child)) = self
+        //             .database
+        //             .borrow()
+        //             .get_path_from_script_pubkey(&out.script_pubkey)?
+        //         {
+        //             debug!("Found descriptor {:?}/{}", keychain, child);
+
+        //             // merge hd_keypaths or tap_key_origins
+        //             let desc = self.get_descriptor_for_keychain(keychain);
+        //             if desc.is_taproot() {
+        //                 let mut tap_key_origins = desc
+        //                     .as_derived(child, &self.secp)
+        //                     .get_tap_key_origins(&self.secp);
+        //                 psbt_input.tap_key_origins.append(&mut tap_key_origins);
+        //             } else {
+        //                 let mut hd_keypaths = desc
+        //                     .as_derived(child, &self.secp)
+        //                     .get_hd_keypaths(&self.secp);
+        //                 psbt_input.bip32_derivation.append(&mut hd_keypaths);
+        //             }
+        //         }
+        //     }
+        // }
+
+        // Ok(())
     }
 
     /// Return an immutable reference to the internal database
@@ -1805,6 +2009,7 @@ pub(crate) mod test {
 
     use crate::database::Database;
     use crate::types::KeychainKind;
+    use crate::wallet::spendable_collection::SpendableCollectionInner;
 
     use super::*;
     use crate::signer::{SignOptions, SignerError};
@@ -2079,8 +2284,10 @@ pub(crate) mod test {
     fn test_create_tx_fee_sniping_locktime_last_sync() {
         let (wallet, _, _) = get_funded_wallet(get_test_wpkh());
         let addr = wallet.get_address(New).unwrap();
-        let mut builder = wallet.build_tx();
-        builder.add_recipient(addr.script_pubkey(), 25_000);
+
+        // @evanlinjin: Setting sync time has been moved to before the `wallet.build_tx()` call.
+        // This is because the "fallback nLockTime" is now determined in the `wallet.build_tx()`
+        // step (moved from the `builder.finish()` step).
         let sync_time = SyncTime {
             block_time: BlockTime {
                 height: 25,
@@ -2092,6 +2299,22 @@ pub(crate) mod test {
             .borrow_mut()
             .set_sync_time(sync_time.clone())
             .unwrap();
+
+        let mut builder = wallet.build_tx();
+        builder.add_recipient(addr.script_pubkey(), 25_000);
+
+        // let sync_time = SyncTime {
+        //     block_time: BlockTime {
+        //         height: 25,
+        //         timestamp: 0,
+        //     },
+        // };
+        // wallet
+        //     .database
+        //     .borrow_mut()
+        //     .set_sync_time(sync_time.clone())
+        //     .unwrap();
+
         let (psbt, _) = builder.finish().unwrap();
 
         // If there's no current_height we're left with using the last sync height
@@ -2249,7 +2472,7 @@ pub(crate) mod test {
         let mut builder = wallet.build_tx();
         builder
             .add_recipient(addr.script_pubkey(), 25_000)
-            .do_not_spend_change();
+            .only_spend_change();
         builder.finish().unwrap();
     }
 
@@ -2299,9 +2522,10 @@ pub(crate) mod test {
         let (wallet, _, _) = get_funded_wallet(get_test_wpkh());
         let addr = wallet.get_address(New).unwrap();
         let utxos: Vec<_> = wallet
-            .get_available_utxos()
+            .as_spendable_collection()
+            .iter_utxos()
             .unwrap()
-            .into_iter()
+            // .into_iter()
             .map(|(u, _)| u.outpoint)
             .collect();
         let mut builder = wallet.build_tx();
@@ -2941,11 +3165,18 @@ pub(crate) mod test {
             .max_satisfaction_weight()
             .unwrap();
 
-        let mut builder = wallet1.build_tx();
-        builder.add_recipient(addr.script_pubkey(), 60_000);
+        let make_builder = || {
+            let mut builder = wallet1.build_tx();
+            builder.add_recipient(addr.script_pubkey(), 60_000);
+            builder
+        };
+
+        // let mut builder = wallet1.build_tx();
+        // builder.add_recipient(addr.script_pubkey(), 60_000);
 
         {
-            let mut builder = builder.clone();
+            // let mut builder = builder.clone();
+            let mut builder = make_builder();
             let psbt_input = psbt::Input {
                 witness_utxo: Some(utxo2.txout.clone()),
                 ..Default::default()
@@ -2960,7 +3191,7 @@ pub(crate) mod test {
         }
 
         {
-            let mut builder = builder.clone();
+            let mut builder = make_builder();
             let psbt_input = psbt::Input {
                 witness_utxo: Some(utxo2.txout.clone()),
                 ..Default::default()
@@ -2976,7 +3207,8 @@ pub(crate) mod test {
         }
 
         {
-            let mut builder = builder.clone();
+            // let mut builder = builder.clone();
+            let mut builder = make_builder();
             let tx2 = wallet2
                 .database
                 .borrow()
@@ -4895,6 +5127,10 @@ pub(crate) mod test {
         )
         .unwrap();
 
+        wallet
+            .cache_addresses(KeychainKind::External, 0, 5)
+            .unwrap();
+
         let confirmation_time = 5;
 
         crate::populate_test_db!(
diff --git a/src/wallet/signer.rs b/src/wallet/signer.rs
index cb190bf93..b1d8e4e5f 100644
--- a/src/wallet/signer.rs
+++ b/src/wallet/signer.rs
@@ -303,6 +303,7 @@ impl InputSigner for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
             .tap_key_origins
             .iter()
             .map(|(pk, (_, keysource))| (SinglePubKey::XOnly(*pk), keysource));
+
         let (public_key, full_path) = match psbt.inputs[input_index]
             .bip32_derivation
             .iter()
diff --git a/src/wallet/spendable_collection.rs b/src/wallet/spendable_collection.rs
new file mode 100644
index 000000000..9cfaaba27
--- /dev/null
+++ b/src/wallet/spendable_collection.rs
@@ -0,0 +1,329 @@
+///! SpendableCollection
+///
+/// This module defines the [`SpendableCollection`] trait.
+use std::{cell::RefCell, sync::Arc};
+
+use bitcoin::{Network, OutPoint, Script, Transaction, TxOut, Txid};
+use miniscript::DescriptorTrait;
+
+use crate::{
+    address_validator::AddressValidator,
+    database::{BatchDatabase, DatabaseUtils},
+    descriptor::{AsDerived, ExtendedDescriptor},
+    BlockTime, Error, KeychainKind, LocalUtxo, Wallet,
+};
+
+use super::{utils::SecpCtx, AddressInfo};
+
+/// Contains the "required" methods of [`SpendableCollection`], where all other methods could be
+/// deried from (albiet probably not in an optimised manner).
+pub trait SpendableCollectionInner {
+    /// Iterates though descriptors with associated keychain kind.
+    type DescIter: Iterator<Item = (ExtendedDescriptor, KeychainKind)> + ExactSizeIterator;
+
+    /// Iterates through UTXOs with associated weight.
+    type UtxoIter: Iterator<Item = (LocalUtxo, usize)>;
+
+    /// Returns an iterator that ranges through all owned descriptors.
+    fn iter_descriptors(&self) -> Result<Self::DescIter, Error>;
+
+    /// Obtains owned UTXOs alongside their satisfaction weights.
+    ///     Warning: It is possible that the returned list contains a UTXO currently used as an
+    ///     unconfirmed tx input.
+    fn iter_utxos(&self) -> Result<Self::UtxoIter, Error>;
+
+    /// Obtains transaction (and details) of given txid.
+    ///
+    /// Internally, we should include atleast all transactions containing owned and spendable UTXOs
+    /// of the given descriptors (internal and external).
+    /// However, having extra and unnecessary transactions should not hurt (TODO @evanlinjin:
+    /// confirm this).
+    ///
+    /// TODO @evanlinjin: Maybe this should be in it's own trait?
+    fn get_tx(&self, txid: &Txid) -> Result<Option<(Transaction, Option<BlockTime>)>, Error>;
+
+    /// Returns a fresh/unused address derived from given descriptor. This is currently used for
+    /// obtaining a change/drain address.
+    #[deprecated(note = "Change selection should be in it's separate step")]
+    fn new_address(&self, desc: &ExtendedDescriptor) -> Result<AddressInfo, Error>;
+}
+
+/// Represents a collection of owned and spendable `UTXO`s, `ExtendedDescriptor`s and associated
+/// `Transaction`s.
+pub trait SpendableCollection: SpendableCollectionInner {
+    /// Obtains parent [`ExtendedDescriptor`] and child index of the provided `ScriptPubKey`.
+    /// Note that if the script is not owned, None shoud be returned.
+    fn get_path_of_script_pubkey(
+        &self,
+        script: &Script,
+    ) -> Result<Option<(ExtendedDescriptor, u32)>, Error> {
+        let descriptors = self
+            .iter_descriptors()?
+            .map(|(desc, _)| desc)
+            .collect::<Vec<_>>();
+
+        let secp = SecpCtx::new();
+
+        for index in 0..2100_u32 {
+            for desc in &descriptors {
+                let derived_script = desc.as_derived(index, &secp).script_pubkey();
+                if script == &derived_script {
+                    return Ok(Some((desc.clone(), index)));
+                }
+            }
+        }
+
+        Ok(None)
+    }
+
+    /// Obtain a local UTXO given the provided outpoint.
+    /// The default implementation is very inefficient and should be overloaded.
+    fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<LocalUtxo>, Error> {
+        Ok(self.iter_utxos()?.find_map(|(utxo, _)| {
+            if &utxo.outpoint == outpoint {
+                Some(utxo)
+            } else {
+                None
+            }
+        }))
+    }
+
+    /// Returns whether given script is owned by us, or not.
+    fn is_mine(&self, script: &Script) -> Result<bool, Error> {
+        self.get_path_of_script_pubkey(script)
+            .map(|path| path.is_some())
+    }
+
+    /// Obtains a new change address without a descriptor provided explicitly
+    #[deprecated]
+    fn new_auto_address(&self) -> Result<AddressInfo, Error> {
+        let (mut internal, mut external): (Vec<_>, Vec<_>) = self
+            .iter_descriptors()?
+            .partition(|(_, kc)| kc == &KeychainKind::Internal);
+
+        internal.append(&mut external);
+
+        let (desc, _) = internal.iter().chain(external.iter()).next().unwrap();
+
+        #[allow(deprecated)]
+        self.new_address(desc)
+    }
+}
+
+/// Addons to [`SpendableCollection`] to allow for usage with fee-bump logic.
+///
+/// TODO @evanlinjin: decouple fee-bump logic from Wallet.
+pub trait FeeBumpCollection: SpendableCollection {
+    /// Previous output may be from a confirmed transaction.
+    fn get_previous_output(&self, outpoint: &OutPoint) -> Result<Option<TxOut>, Error>;
+}
+
+/// Implements [`SpendableCollection`] with one external descriptor and an optional internal descriptor.
+// #[derive(Clone)]
+pub struct SpendableDatabase<'a, D> {
+    descriptor: &'a ExtendedDescriptor,
+    change_descriptor: Option<&'a ExtendedDescriptor>,
+    network: Network,
+    secp: SecpCtx,
+
+    pub(crate) db: &'a RefCell<D>,
+    pub(crate) address_validators: Vec<Arc<dyn AddressValidator>>,
+}
+
+impl<'a, D: BatchDatabase> Clone for SpendableDatabase<'a, D> {
+    fn clone(&self) -> Self {
+        Self {
+            descriptor: self.descriptor,
+            change_descriptor: self.change_descriptor,
+            network: self.network,
+            secp: self.secp.clone(),
+            db: self.db,
+            address_validators: self.address_validators.clone(),
+        }
+    }
+}
+
+/// [`SpendableCollection`] `::DescIter` implementation for [`SpendableDatabase`].
+pub struct DatabaseDescIter<'a, D>(SpendableDatabase<'a, D>, usize);
+
+impl<'a, D> Iterator for DatabaseDescIter<'a, D> {
+    type Item = (ExtendedDescriptor, KeychainKind);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.1 += 1;
+
+        match self.1 {
+            1 => Some((self.0.descriptor.clone(), KeychainKind::External)),
+            2 => self
+                .0
+                .change_descriptor
+                .map(|change_desc| (change_desc.clone(), KeychainKind::Internal)),
+            _ => None,
+        }
+    }
+}
+
+impl<'a, D> ExactSizeIterator for DatabaseDescIter<'a, D> {
+    fn len(&self) -> usize {
+        let start_count = if self.0.change_descriptor.is_some() {
+            2
+        } else {
+            1
+        };
+        start_count - self.1
+    }
+}
+
+impl<'a, D: BatchDatabase> SpendableDatabase<'a, D> {
+    /// Creates a new [`SpendableDatabase`].
+    pub fn new(
+        descriptor: &'a ExtendedDescriptor,
+        change_descriptor: Option<&'a ExtendedDescriptor>,
+        network: Network,
+        db: &'a RefCell<D>,
+        address_validators: Vec<Arc<dyn AddressValidator>>,
+    ) -> Self {
+        let secp = SecpCtx::new();
+        Self {
+            descriptor,
+            change_descriptor,
+            network,
+            secp,
+            db,
+            address_validators,
+        }
+    }
+}
+
+impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D> {
+    type DescIter = DatabaseDescIter<'a, D>;
+
+    type UtxoIter = std::vec::IntoIter<(LocalUtxo, usize)>;
+
+    fn iter_descriptors(&self) -> Result<Self::DescIter, Error> {
+        Ok(DatabaseDescIter::<'_>(self.clone(), 0))
+    }
+
+    /// TODO @evanlinjin:
+    /// With the old implementation, we can call `get_descriptor_from_keychain` to obtain the
+    /// parent descriptor without relying on a "cache" of relationships between `ScriptPubKey`s
+    /// and "paths".
+    /// However, we cannot continue to use this approach since we need to generalize everything
+    /// to support multiple descriptors.
+    /// A possible solution would be to replace usage of [`KeychainKind`] with
+    /// `(KeychainKind, u32)`, so descriptors are referenced with an additional index.
+    ///
+    /// For now, we need to ensure the aforementioned relationship is sufficiently cached to
+    /// avoid "missing" available UTXOs.
+    fn iter_utxos(&self) -> Result<Self::UtxoIter, Error> {
+        #[allow(clippy::needless_collect)]
+        let utxos = self
+            .db
+            .borrow()
+            .iter_utxos()?
+            .into_iter()
+            .filter(|utxo| !utxo.is_spent)
+            .filter_map(|utxo| {
+                let (parent_desc, _) = self
+                    // @evanlinjin: Will panic with default implementation on timeout.
+                    .get_path_of_script_pubkey(&utxo.txout.script_pubkey)
+                    .unwrap()?;
+                let weight = parent_desc.max_satisfaction_weight().unwrap();
+                Some((utxo, weight))
+            })
+            .collect::<Vec<_>>();
+
+        Ok(utxos.into_iter())
+    }
+
+    fn get_tx(&self, txid: &Txid) -> Result<Option<(Transaction, Option<BlockTime>)>, Error> {
+        Ok(self.db.borrow().get_tx(txid, true)?.map(|tx_details| {
+            (
+                tx_details.transaction.unwrap(),
+                tx_details.confirmation_time,
+            )
+        }))
+    }
+
+    fn new_address(&self, desc: &ExtendedDescriptor) -> Result<AddressInfo, Error> {
+        let keychain = if desc == self.descriptor {
+            KeychainKind::External
+        } else if self.change_descriptor == Some(desc) {
+            KeychainKind::Internal
+        } else {
+            return Err(Error::Generic("descriptor does not exist".to_string()));
+        };
+
+        Wallet::_get_new_address(
+            self.db,
+            &self.secp,
+            self.address_validators.clone(),
+            desc,
+            keychain,
+            self.network,
+        )
+    }
+}
+
+impl<'a, D: BatchDatabase> SpendableCollection for SpendableDatabase<'a, D> {
+    fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<LocalUtxo>, Error> {
+        self.db.borrow().get_utxo(outpoint)
+    }
+
+    fn get_path_of_script_pubkey(
+        &self,
+        script: &Script,
+    ) -> Result<Option<(ExtendedDescriptor, u32)>, Error> {
+        let cached_res =
+            self.db
+                .borrow()
+                .get_path_from_script_pubkey(script)?
+                .map(|(keychain, child_ind)| {
+                    let desc = match keychain {
+                        KeychainKind::External => self.descriptor,
+                        KeychainKind::Internal => self.change_descriptor.unwrap(),
+                    };
+
+                    (desc.clone(), child_ind)
+                });
+
+        if cached_res.is_some() {
+            return Ok(cached_res);
+        }
+
+        // // try brute-force method...
+        let last_ext = self
+            .db
+            .borrow()
+            .get_last_index(KeychainKind::External)?
+            .unwrap_or(0_u32);
+        let last_int = self
+            .db
+            .borrow()
+            .get_last_index(KeychainKind::Internal)?
+            .unwrap_or(0_u32);
+        let start = std::cmp::min(last_ext, last_int);
+
+        let descriptors = self
+            .iter_descriptors()?
+            .map(|(desc, _)| desc)
+            .collect::<Vec<_>>();
+
+        let secp = SecpCtx::new();
+
+        for index in start..start + 2100_u32 {
+            for desc in &descriptors {
+                let derived_script = desc.as_derived(index, &secp).script_pubkey();
+                if script == &derived_script {
+                    return Ok(Some((desc.clone(), index)));
+                }
+            }
+        }
+
+        Ok(None)
+    }
+
+    fn is_mine(&self, script: &Script) -> Result<bool, Error> {
+        self.db.borrow().is_mine(script)
+    }
+}
diff --git a/src/wallet/tx_builder.rs b/src/wallet/tx_builder.rs
index 43045463b..242d673d5 100644
--- a/src/wallet/tx_builder.rs
+++ b/src/wallet/tx_builder.rs
@@ -47,8 +47,12 @@ use bitcoin::{OutPoint, Script, Transaction};
 use miniscript::descriptor::DescriptorTrait;
 
 use super::coin_selection::{CoinSelectionAlgorithm, DefaultCoinSelectionAlgorithm};
+use super::spendable_collection::SpendableCollection;
+use super::utils::SecpCtx;
 use crate::descriptor::ExtendedDescriptor;
-use crate::{database::BatchDatabase, Error, Utxo, Wallet};
+use crate::signer::SignersContainer;
+use crate::Wallet;
+use crate::{database::BatchDatabase, Error, Utxo};
 use crate::{
     types::{FeeRate, KeychainKind, LocalUtxo, WeightedUtxo},
     TransactionDetails,
@@ -118,11 +122,18 @@ impl TxBuilderContext for BumpFee {}
 /// [`finish`]: Self::finish
 /// [`coin_selection`]: Self::coin_selection
 #[derive(Debug)]
-pub struct TxBuilder<'a, D, Cs, Ctx> {
-    pub(crate) wallet: &'a Wallet<D>,
+pub struct TxBuilder<'a, D, Sc, Cs, Ctx> {
+    pub(crate) spendable_collection: Sc,
     pub(crate) params: TxParams<'a>,
+    pub(crate) default_block_height: u32,
     pub(crate) coin_selection: Cs,
+    pub(crate) signers: &'a SignersContainer,
+    pub(crate) secp: SecpCtx,
     pub(crate) phantom: PhantomData<Ctx>,
+
+    /// TODO @evanlinjin: We can remove the generic type parameter `D` once we actually
+    /// move the various methods out of [`Wallet`].
+    pub(crate) phantom_database: PhantomData<D>,
 }
 
 /// The parameters for transaction creation sans coin selection algorithm.
@@ -143,7 +154,7 @@ pub(crate) struct TxParams<'a> {
     pub(crate) locktime: Option<u32>,
     pub(crate) rbf: Option<RbfValue>,
     pub(crate) version: Option<Version>,
-    pub(crate) change_policy: ChangeSpendPolicy,
+    pub(crate) change_policy: ChangeSpendPolicy, // when selecting prev_outputs
     pub(crate) only_witness_utxo: bool,
     pub(crate) add_global_xpubs: bool,
     pub(crate) include_output_redeem_witness_script: bool,
@@ -169,20 +180,47 @@ impl std::default::Default for FeePolicy {
     }
 }
 
-impl<'a, Cs: Clone, Ctx, D> Clone for TxBuilder<'a, D, Cs, Ctx> {
+impl<'a, D, Sc: Clone, Cs: Clone, Ctx> Clone for TxBuilder<'a, D, Sc, Cs, Ctx> {
     fn clone(&self) -> Self {
         TxBuilder {
-            wallet: self.wallet,
+            spendable_collection: self.spendable_collection.clone(),
             params: self.params.clone(),
             coin_selection: self.coin_selection.clone(),
+            default_block_height: self.default_block_height,
             phantom: PhantomData,
+            phantom_database: self.phantom_database,
+            signers: self.signers,
+            secp: self.secp.clone(),
+        }
+    }
+}
+
+impl<'a, D: BatchDatabase, Sc: SpendableCollection, Ctx: TxBuilderContext>
+    TxBuilder<'a, D, Sc, DefaultCoinSelectionAlgorithm, Ctx>
+{
+    /// Creates a new [`TxBuilder`]
+    pub fn new(spendables: Sc, signers: &'a SignersContainer, fallback_block_height: u32) -> Self {
+        Self {
+            spendable_collection: spendables,
+            params: TxParams::default(),
+            coin_selection: DefaultCoinSelectionAlgorithm::default(),
+            signers,
+            default_block_height: fallback_block_height,
+            secp: SecpCtx::new(),
+            phantom: core::marker::PhantomData,
+            phantom_database: core::marker::PhantomData,
         }
     }
 }
 
 // methods supported by both contexts, for any CoinSelectionAlgorithm
-impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
-    TxBuilder<'a, D, Cs, Ctx>
+impl<
+        'a,
+        D: BatchDatabase,
+        Sc: SpendableCollection,
+        Cs: CoinSelectionAlgorithm,
+        Ctx: TxBuilderContext,
+    > TxBuilder<'a, D, Sc, Cs, Ctx>
 {
     /// Set a custom fee rate
     pub fn fee_rate(&mut self, fee_rate: FeeRate) -> &mut Self {
@@ -278,16 +316,32 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     pub fn add_utxos(&mut self, outpoints: &[OutPoint]) -> Result<&mut Self, Error> {
         let utxos = outpoints
             .iter()
-            .map(|outpoint| self.wallet.get_utxo(*outpoint)?.ok_or(Error::UnknownUtxo))
+            .map(|outpoint| {
+                self.spendable_collection
+                    .get_utxo(outpoint)?
+                    .ok_or(Error::UnknownUtxo)
+            })
             .collect::<Result<Vec<_>, _>>()?;
 
-        for utxo in utxos {
-            let descriptor = self.wallet.get_descriptor_for_keychain(utxo.keychain);
-            let satisfaction_weight = descriptor.max_satisfaction_weight().unwrap();
-            self.params.utxos.push(WeightedUtxo {
-                satisfaction_weight,
-                utxo: Utxo::Local(utxo),
-            });
+        let weighted_utxos = utxos
+            .into_iter()
+            .map(|utxo| {
+                self.spendable_collection
+                    .get_path_of_script_pubkey(&utxo.txout.script_pubkey)?
+                    .map(|(desc, _)| {
+                        let utxo = Utxo::Local(utxo);
+                        let satisfaction_weight = desc.max_satisfaction_weight().unwrap();
+                        WeightedUtxo {
+                            utxo,
+                            satisfaction_weight,
+                        }
+                    })
+                    .ok_or(Error::UnknownUtxo)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        for weighted_utxo in weighted_utxos {
+            self.params.utxos.push(weighted_utxo);
         }
 
         Ok(self)
@@ -505,15 +559,19 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     /// Overrides the [`DefaultCoinSelectionAlgorithm`](super::coin_selection::DefaultCoinSelectionAlgorithm).
     ///
     /// Note that this function consumes the builder and returns it so it is usually best to put this as the first call on the builder.
-    pub fn coin_selection<P: CoinSelectionAlgorithm<D>>(
+    pub fn coin_selection<P: CoinSelectionAlgorithm>(
         self,
         coin_selection: P,
-    ) -> TxBuilder<'a, D, P, Ctx> {
+    ) -> TxBuilder<'a, D, Sc, P, Ctx> {
         TxBuilder {
-            wallet: self.wallet,
+            spendable_collection: self.spendable_collection,
             params: self.params,
             coin_selection,
+            default_block_height: self.default_block_height,
             phantom: PhantomData,
+            phantom_database: self.phantom_database,
+            signers: self.signers,
+            secp: self.secp,
         }
     }
 
@@ -523,7 +581,18 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     ///
     /// [`BIP174`]: https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
     pub fn finish(self) -> Result<(Psbt, TransactionDetails), Error> {
-        self.wallet.create_tx(self.coin_selection, self.params)
+        // self.cache.create_tx(self.coin_selection, self.params)
+
+        // TODO @evalinjin: Get rid of the D. #NoPunIntended
+        Wallet::<D>::_create_tx(
+            &self.spendable_collection,
+            self.coin_selection,
+            self.params,
+            self.default_block_height,
+            self.signers,
+            &self.secp,
+        )
+        // todo!()
     }
 
     /// Enable signaling RBF
@@ -563,7 +632,9 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     }
 }
 
-impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>> TxBuilder<'a, D, Cs, CreateTx> {
+impl<'a, D: BatchDatabase, Sc: SpendableCollection, Cs: CoinSelectionAlgorithm>
+    TxBuilder<'a, D, Sc, Cs, CreateTx>
+{
     /// Replace the recipients already added with a new list
     pub fn set_recipients(&mut self, recipients: Vec<(Script, u64)>) -> &mut Self {
         self.params.recipients = recipients;
@@ -634,7 +705,9 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>> TxBuilder<'a, D, Cs, C
 }
 
 // methods supported only by bump_fee
-impl<'a, D: BatchDatabase> TxBuilder<'a, D, DefaultCoinSelectionAlgorithm, BumpFee> {
+impl<'a, D: BatchDatabase, Sc: SpendableCollection>
+    TxBuilder<'a, D, Sc, DefaultCoinSelectionAlgorithm, BumpFee>
+{
     /// Explicitly tells the wallet that it is allowed to reduce the amount of the output matching this
     /// `script_pubkey` in order to bump the transaction fee. Without specifying this the wallet
     /// will attempt to find a change output to shrink instead.

From 721562301304bfc494ab0c4eb44ee6606059e51e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Wed, 13 Jul 2022 10:27:45 +0800
Subject: [PATCH 05/16] WIP: Decoupled signing logic

---
 src/wallet/coin_selection.rs       |   2 +-
 src/wallet/mod.rs                  | 204 ++++++++++++++---------------
 src/wallet/spendable_collection.rs |  25 ++++
 src/wallet/tx_builder.rs           |   3 -
 4 files changed, 124 insertions(+), 110 deletions(-)

diff --git a/src/wallet/coin_selection.rs b/src/wallet/coin_selection.rs
index a9b3101fd..16f6dde10 100644
--- a/src/wallet/coin_selection.rs
+++ b/src/wallet/coin_selection.rs
@@ -648,7 +648,7 @@ mod test {
         desc: &'a ExtendedDescriptor,
         db: &'a RefCell<MemoryDatabase>,
     ) -> SpendableDatabase<'a, MemoryDatabase> {
-        SpendableDatabase::new(desc, None, Network::Regtest, db, Vec::new())
+        SpendableDatabase::new(desc, None, Network::Regtest, db, Vec::new(), Vec::new())
     }
 
     fn utxo(value: u64, index: u32) -> WeightedUtxo {
diff --git a/src/wallet/mod.rs b/src/wallet/mod.rs
index 10d2cd3ef..9ff957d11 100644
--- a/src/wallet/mod.rs
+++ b/src/wallet/mod.rs
@@ -66,9 +66,8 @@ use crate::database::{AnyDatabase, BatchDatabase, BatchOperations, DatabaseUtils
 use crate::descriptor::derived::AsDerived;
 use crate::descriptor::policy::BuildSatisfaction;
 use crate::descriptor::{
-    get_checksum, into_wallet_descriptor_checked, DerivedDescriptor, DerivedDescriptorMeta,
-    DescriptorMeta, DescriptorScripts, ExtendedDescriptor, ExtractPolicy, IntoWalletDescriptor,
-    Policy, XKeyUtils,
+    get_checksum, into_wallet_descriptor_checked, DerivedDescriptorMeta, DescriptorMeta,
+    DescriptorScripts, ExtendedDescriptor, ExtractPolicy, IntoWalletDescriptor, Policy, XKeyUtils,
 };
 use crate::error::Error;
 use crate::psbt::PsbtUtils;
@@ -549,11 +548,14 @@ where
     }
 
     fn as_spendable_collection(&self) -> SpendableDatabase<D> {
+        let signers = vec![Arc::clone(&self.signers), Arc::clone(&self.change_signers)];
+
         SpendableDatabase::new(
             &self.descriptor,
             self.change_descriptor.as_ref(),
             self.network,
             &self.database,
+            signers,
             self.address_validators.clone(),
         )
     }
@@ -1123,9 +1125,33 @@ where
         &self,
         psbt: &mut psbt::PartiallySignedTransaction,
         sign_options: SignOptions,
+    ) -> Result<bool, Error> {
+        let spendable_collection = self.as_spendable_collection();
+
+        let fallback_block_height = self
+            .database()
+            .get_sync_time()?
+            .map(|sync_time| sync_time.block_time.height);
+
+        Self::_sign(
+            &spendable_collection,
+            fallback_block_height,
+            &self.secp,
+            psbt,
+            sign_options,
+        )
+    }
+
+    pub(crate) fn _sign<Sc: SpendableCollection>(
+        spendable_collection: &Sc,
+        fallback_block_height: Option<u32>,
+        secp: &SecpCtx,
+        psbt: &mut psbt::PartiallySignedTransaction,
+        sign_options: SignOptions,
     ) -> Result<bool, Error> {
         // this helps us doing our job later
-        self.add_input_hd_keypaths(psbt)?;
+        Self::_add_input_hd_keypaths(spendable_collection, secp, psbt)?;
+        // self.add_input_hd_keypaths(psbt)?;
 
         // If we aren't allowed to use `witness_utxo`, ensure that every input (except p2tr and finalized ones)
         // has the `non_witness_utxo`
@@ -1153,18 +1179,29 @@ where
             return Err(Error::Signer(signer::SignerError::NonStandardSighash));
         }
 
-        for signer in self
-            .signers
-            .signers()
-            .iter()
-            .chain(self.change_signers.signers().iter())
-        {
-            signer.sign_transaction(psbt, &self.secp)?;
+        for signer in spendable_collection.iter_signers()? {
+            signer.sign_transaction(psbt, secp)?;
         }
 
+        // for signer in self
+        //     .signers
+        //     .signers()
+        //     .iter()
+        //     .chain(self.change_signers.signers().iter())
+        // {
+        //     signer.sign_transaction(psbt, secp)?;
+        // }
+
         // attempt to finalize
         if sign_options.try_finalize {
-            self.finalize_psbt(psbt, sign_options)
+            Self::_finalize_psbt(
+                spendable_collection,
+                fallback_block_height,
+                secp,
+                psbt,
+                sign_options,
+            )
+            // self.finalize_psbt(psbt, sign_options)
         } else {
             Ok(false)
         }
@@ -1209,6 +1246,29 @@ where
         &self,
         psbt: &mut psbt::PartiallySignedTransaction,
         sign_options: SignOptions,
+    ) -> Result<bool, Error> {
+        let spendable_collection = self.as_spendable_collection();
+
+        let fallback_block_height = self
+            .database()
+            .get_sync_time()?
+            .map(|sync_time| sync_time.block_time.height);
+
+        Self::_finalize_psbt(
+            &spendable_collection,
+            fallback_block_height,
+            &self.secp,
+            psbt,
+            sign_options,
+        )
+    }
+
+    pub(crate) fn _finalize_psbt<Sc: SpendableCollection>(
+        spendable_collection: &Sc,
+        fallback_block_height: Option<u32>,
+        secp: &SecpCtx,
+        psbt: &mut psbt::PartiallySignedTransaction,
+        sign_options: SignOptions,
     ) -> Result<bool, Error> {
         // NOTE @evanlinjin: this is only used in `.sign`
         let tx = &psbt.unsigned_tx;
@@ -1224,15 +1284,10 @@ where
             }
             // if the height is None in the database it means it's still unconfirmed, so consider
             // that as a very high value
-            let create_height = self
-                .database
-                .borrow()
-                .get_tx(&input.previous_output.txid, false)?
-                .map(|tx| tx.confirmation_time.map(|c| c.height).unwrap_or(u32::MAX));
-            let last_sync_height = self
-                .database()
-                .get_sync_time()?
-                .map(|sync_time| sync_time.block_time.height);
+            let create_height = spendable_collection
+                .get_tx(&input.previous_output.txid)?
+                .map(|(_, bt)| bt.map_or(u32::MAX, |c| c.height));
+            let last_sync_height = fallback_block_height;
             let current_height = sign_options.assume_height.or(last_sync_height);
 
             debug!(
@@ -1246,25 +1301,25 @@ where
             //   is in `src/descriptor/mod.rs`, but it will basically look at `bip32_derivation`,
             //   `redeem_script` and `witness_script` to determine the right derivation
             // - If that also fails, it will try it on the internal descriptor, if present
-            let desc = psbt
+            let derived_desc = psbt
                 .get_utxo_for(n)
-                .map(|txout| self.get_descriptor_for_txout(&txout))
-                .transpose()?
-                .flatten()
-                .or_else(|| {
-                    self.descriptor.derive_from_psbt_input(
-                        psbt_input,
-                        psbt.get_utxo_for(n),
-                        &self.secp,
-                    )
+                .and_then(|txout| {
+                    spendable_collection
+                        .get_path_of_script_pubkey(&txout.script_pubkey)
+                        .expect("spendable collection should not fail")
+                        .map(|(parent_desc, child_ind)| parent_desc.as_derived(child_ind, secp))
                 })
                 .or_else(|| {
-                    self.change_descriptor.as_ref().and_then(|desc| {
-                        desc.derive_from_psbt_input(psbt_input, psbt.get_utxo_for(n), &self.secp)
-                    })
+                    spendable_collection
+                        .iter_descriptors()
+                        .expect("spendable collection should not fail")
+                        .find_map(|(desc, _)| {
+                            let prev_utxo = psbt.get_utxo_for(n);
+                            desc.derive_from_psbt_input(psbt_input, prev_utxo, secp)
+                        })
                 });
 
-            match desc {
+            match derived_desc {
                 Some(desc) => {
                     let mut tmp_input = bitcoin::TxIn::default();
                     match desc.satisfy(
@@ -1322,18 +1377,6 @@ where
         }
     }
 
-    fn get_descriptor_for_txout(
-        &self,
-        txout: &TxOut,
-    ) -> Result<Option<DerivedDescriptor<'_>>, Error> {
-        Ok(self
-            .database
-            .borrow()
-            .get_path_from_script_pubkey(&txout.script_pubkey)?
-            .map(|(keychain, child)| (self.get_descriptor_for_keychain(keychain), child))
-            .map(|(desc, child)| desc.as_derived(child, &self.secp)))
-    }
-
     fn fetch_and_increment_index(&self, keychain: KeychainKind) -> Result<u32, Error> {
         let (descriptor, keychain) = self._get_descriptor_for_keychain(keychain);
         Self::_fetch_and_increment_index(
@@ -1575,11 +1618,6 @@ where
                 })
                 .map_err(Error::Descriptor)?;
 
-            // let mut all_xpubs = self.descriptor.get_extended_keys()?;
-            // if let Some(change_descriptor) = &self.change_descriptor {
-            //     all_xpubs.extend(change_descriptor.get_extended_keys()?);
-            // }
-
             for xpub in all_xpubs {
                 let origin = match xpub.origin {
                     Some(origin) => origin,
@@ -1655,14 +1693,9 @@ where
         // add metadata for the outputs
         for (psbt_output, tx_output) in psbt.outputs.iter_mut().zip(psbt.unsigned_tx.output.iter())
         {
-            // TODO @evanlinjin
             let path_opt =
                 spendable_collection.get_path_of_script_pubkey(&tx_output.script_pubkey)?;
-            // if let Some((keychain, child)) = self
-            //     .database
-            //     .borrow()
-            //     .get_path_from_script_pubkey(&tx_output.script_pubkey)?
-            // {
+
             if let Some((desc, child)) = path_opt {
                 // let (desc, _) = self._get_descriptor_for_keychain(keychain);
                 let derived_descriptor = desc.as_derived(child, secp);
@@ -1734,11 +1767,6 @@ where
         let (desc, child) = spendable_collection
             .get_path_of_script_pubkey(&utxo.txout.script_pubkey)?
             .ok_or(Error::UnknownUtxo)?;
-        // let (keychain, child) = self
-        //     .database
-        //     .borrow()
-        //     .get_path_from_script_pubkey(&utxo.txout.script_pubkey)?
-        //     .ok_or(Error::UnknownUtxo)?;
 
         let mut psbt_input = psbt::Input {
             sighash_type,
@@ -1784,13 +1812,13 @@ where
         Ok(psbt_input)
     }
 
-    fn add_input_hd_keypaths(
-        &self,
-        psbt: &mut psbt::PartiallySignedTransaction,
-    ) -> Result<(), Error> {
-        let spendable_collection = self.as_spendable_collection();
-        Self::_add_input_hd_keypaths(&spendable_collection, &self.secp, psbt)
-    }
+    // fn add_input_hd_keypaths(
+    //     &self,
+    //     psbt: &mut psbt::PartiallySignedTransaction,
+    // ) -> Result<(), Error> {
+    //     let spendable_collection = self.as_spendable_collection();
+    //     Self::_add_input_hd_keypaths(&spendable_collection, &self.secp, psbt)
+    // }
 
     /// TODO @evanlinjin: Move out of [`Wallet`].
     fn _add_input_hd_keypaths<'a, Sc>(
@@ -1838,42 +1866,6 @@ where
 
                 Ok(())
             })
-
-        // let mut input_utxos = Vec::with_capacity(psbt.inputs.len());
-        // for n in 0..psbt.inputs.len() {
-        //     input_utxos.push(psbt.get_utxo_for(n).clone());
-        // }
-
-        // // try to add hd_keypaths if we've already seen the output
-        // // @evanlinjin: Just some notes for myself:
-        // //  * out: psbt input (UTXO)
-        // for (psbt_input, out) in psbt.inputs.iter_mut().zip(input_utxos.iter()) {
-        //     if let Some(out) = out {
-        //         if let Some((keychain, child)) = self
-        //             .database
-        //             .borrow()
-        //             .get_path_from_script_pubkey(&out.script_pubkey)?
-        //         {
-        //             debug!("Found descriptor {:?}/{}", keychain, child);
-
-        //             // merge hd_keypaths or tap_key_origins
-        //             let desc = self.get_descriptor_for_keychain(keychain);
-        //             if desc.is_taproot() {
-        //                 let mut tap_key_origins = desc
-        //                     .as_derived(child, &self.secp)
-        //                     .get_tap_key_origins(&self.secp);
-        //                 psbt_input.tap_key_origins.append(&mut tap_key_origins);
-        //             } else {
-        //                 let mut hd_keypaths = desc
-        //                     .as_derived(child, &self.secp)
-        //                     .get_hd_keypaths(&self.secp);
-        //                 psbt_input.bip32_derivation.append(&mut hd_keypaths);
-        //             }
-        //         }
-        //     }
-        // }
-
-        // Ok(())
     }
 
     /// Return an immutable reference to the internal database
diff --git a/src/wallet/spendable_collection.rs b/src/wallet/spendable_collection.rs
index 9cfaaba27..9a5ddacaf 100644
--- a/src/wallet/spendable_collection.rs
+++ b/src/wallet/spendable_collection.rs
@@ -10,6 +10,7 @@ use crate::{
     address_validator::AddressValidator,
     database::{BatchDatabase, DatabaseUtils},
     descriptor::{AsDerived, ExtendedDescriptor},
+    signer::{SignersContainer, TransactionSigner},
     BlockTime, Error, KeychainKind, LocalUtxo, Wallet,
 };
 
@@ -21,12 +22,18 @@ pub trait SpendableCollectionInner {
     /// Iterates though descriptors with associated keychain kind.
     type DescIter: Iterator<Item = (ExtendedDescriptor, KeychainKind)> + ExactSizeIterator;
 
+    /// Iterates though signers.
+    type SignerIter: Iterator<Item = Arc<dyn TransactionSigner>>;
+
     /// Iterates through UTXOs with associated weight.
     type UtxoIter: Iterator<Item = (LocalUtxo, usize)>;
 
     /// Returns an iterator that ranges through all owned descriptors.
     fn iter_descriptors(&self) -> Result<Self::DescIter, Error>;
 
+    /// Returns an iterator that ranges through all owned signers.
+    fn iter_signers(&self) -> Result<Self::SignerIter, Error>;
+
     /// Obtains owned UTXOs alongside their satisfaction weights.
     ///     Warning: It is possible that the returned list contains a UTXO currently used as an
     ///     unconfirmed tx input.
@@ -127,6 +134,7 @@ pub struct SpendableDatabase<'a, D> {
     secp: SecpCtx,
 
     pub(crate) db: &'a RefCell<D>,
+    pub(crate) signers: Vec<Arc<SignersContainer>>, // [external, internal]
     pub(crate) address_validators: Vec<Arc<dyn AddressValidator>>,
 }
 
@@ -138,6 +146,7 @@ impl<'a, D: BatchDatabase> Clone for SpendableDatabase<'a, D> {
             network: self.network,
             secp: self.secp.clone(),
             db: self.db,
+            signers: self.signers.clone(),
             address_validators: self.address_validators.clone(),
         }
     }
@@ -181,6 +190,7 @@ impl<'a, D: BatchDatabase> SpendableDatabase<'a, D> {
         change_descriptor: Option<&'a ExtendedDescriptor>,
         network: Network,
         db: &'a RefCell<D>,
+        signers: Vec<Arc<SignersContainer>>,
         address_validators: Vec<Arc<dyn AddressValidator>>,
     ) -> Self {
         let secp = SecpCtx::new();
@@ -190,6 +200,7 @@ impl<'a, D: BatchDatabase> SpendableDatabase<'a, D> {
             network,
             secp,
             db,
+            signers,
             address_validators,
         }
     }
@@ -198,12 +209,26 @@ impl<'a, D: BatchDatabase> SpendableDatabase<'a, D> {
 impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D> {
     type DescIter = DatabaseDescIter<'a, D>;
 
+    type SignerIter = std::vec::IntoIter<Arc<dyn TransactionSigner>>;
+
     type UtxoIter = std::vec::IntoIter<(LocalUtxo, usize)>;
 
     fn iter_descriptors(&self) -> Result<Self::DescIter, Error> {
         Ok(DatabaseDescIter::<'_>(self.clone(), 0))
     }
 
+    fn iter_signers(&self) -> Result<Self::SignerIter, Error> {
+        #[allow(clippy::needless_collect)]
+        let signers = self
+            .signers
+            .iter()
+            .flat_map(|cont| cont.signers())
+            .map(Arc::clone)
+            .collect::<Vec<_>>();
+
+        Ok(signers.into_iter())
+    }
+
     /// TODO @evanlinjin:
     /// With the old implementation, we can call `get_descriptor_from_keychain` to obtain the
     /// parent descriptor without relying on a "cache" of relationships between `ScriptPubKey`s
diff --git a/src/wallet/tx_builder.rs b/src/wallet/tx_builder.rs
index 242d673d5..99050bdb5 100644
--- a/src/wallet/tx_builder.rs
+++ b/src/wallet/tx_builder.rs
@@ -581,8 +581,6 @@ impl<
     ///
     /// [`BIP174`]: https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
     pub fn finish(self) -> Result<(Psbt, TransactionDetails), Error> {
-        // self.cache.create_tx(self.coin_selection, self.params)
-
         // TODO @evalinjin: Get rid of the D. #NoPunIntended
         Wallet::<D>::_create_tx(
             &self.spendable_collection,
@@ -592,7 +590,6 @@ impl<
             self.signers,
             &self.secp,
         )
-        // todo!()
     }
 
     /// Enable signaling RBF

From f1d2b9e3d81fe7b5b9d11e602413d77a522c531c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Wed, 13 Jul 2022 10:48:36 +0800
Subject: [PATCH 06/16] WIP: Added TxBuilder::finish_and_sign

---
 src/wallet/tx_builder.rs | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/src/wallet/tx_builder.rs b/src/wallet/tx_builder.rs
index 99050bdb5..d1111c8e6 100644
--- a/src/wallet/tx_builder.rs
+++ b/src/wallet/tx_builder.rs
@@ -51,6 +51,7 @@ use super::spendable_collection::SpendableCollection;
 use super::utils::SecpCtx;
 use crate::descriptor::ExtendedDescriptor;
 use crate::signer::SignersContainer;
+use crate::SignOptions;
 use crate::Wallet;
 use crate::{database::BatchDatabase, Error, Utxo};
 use crate::{
@@ -592,6 +593,31 @@ impl<
         )
     }
 
+    /// Finishes and signs the transaction.
+    pub fn finish_and_sign(self, sign_options: SignOptions) -> Result<SignedResult, Error> {
+        let (mut psbt, details) = Wallet::<D>::_create_tx(
+            &self.spendable_collection,
+            self.coin_selection,
+            self.params,
+            self.default_block_height,
+            self.signers,
+            &self.secp,
+        )?;
+        let is_finalized = Wallet::<D>::_sign(
+            &self.spendable_collection,
+            None,
+            &self.secp,
+            &mut psbt,
+            sign_options,
+        )?;
+
+        Ok(SignedResult {
+            psbt,
+            details,
+            is_finalized,
+        })
+    }
+
     /// Enable signaling RBF
     ///
     /// This will use the default nSequence value of `0xFFFFFFFD`.
@@ -735,6 +761,17 @@ impl<'a, D: BatchDatabase, Sc: SpendableCollection>
     }
 }
 
+/// Represents a signed result
+#[derive(Debug, Clone)]
+pub struct SignedResult {
+    /// The generated (and signed) PSBT
+    pub psbt: Psbt,
+    /// Additional transaction details
+    pub details: TransactionDetails,
+    /// Whether transaction is finalized
+    pub is_finalized: bool,
+}
+
 /// Ordering of the transaction's inputs and outputs
 #[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
 pub enum TxOrdering {

From 66931d284a38d223feb92da59e2fd694ded6e08f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Wed, 13 Jul 2022 17:08:53 +0800
Subject: [PATCH 07/16] WIP: Decouple fee-bump logic

---
 src/wallet/coin_selection.rs       |  12 +-
 src/wallet/mod.rs                  | 265 +++++++++++++----------------
 src/wallet/signer.rs               |   1 -
 src/wallet/spendable_collection.rs | 151 +++++++++-------
 src/wallet/tx_builder.rs           |  35 ++--
 5 files changed, 232 insertions(+), 232 deletions(-)

diff --git a/src/wallet/coin_selection.rs b/src/wallet/coin_selection.rs
index 16f6dde10..1131bff7e 100644
--- a/src/wallet/coin_selection.rs
+++ b/src/wallet/coin_selection.rs
@@ -236,7 +236,7 @@ impl CoinSelectionAlgorithm for OldestFirstCoinSelection {
                     } else {
                         database.get_tx(&txid).map(|details| {
                             let conf_time =
-                                details.and_then(|(_, bt_opt)| bt_opt.map(|bt| bt.height));
+                                details.and_then(|tx| tx.confirmed.map(|conf| conf.height));
                             bh_acc.insert(txid, conf_time);
                             println!(
                                 "OldestFirstCoinSelection: insert({}, {:?})",
@@ -628,11 +628,6 @@ mod test {
 
     const FEE_AMOUNT: u64 = 50;
 
-    // static DESCRIPTOR: ExtendedDescriptor =
-    //     "wsh(pk(cRYhyJQzA92kLQUtJZbVVQrBoQwSm4WT23sanTXYrKoUMjX8ph1Z))"
-    //         .into_wallet_descriptor(&SecpCtx::new(), Network::Regtest)
-    //         .unwrap()
-    //         .0;
     fn new_desc() -> ExtendedDescriptor {
         "wsh(pk(cRYhyJQzA92kLQUtJZbVVQrBoQwSm4WT23sanTXYrKoUMjX8ph1Z))"
             .into_wallet_descriptor(&SecpCtx::new(), Network::Regtest)
@@ -1025,10 +1020,7 @@ mod test {
         let desc = new_desc();
         let db = new_db();
         let cache = new_collection(&desc, &db);
-        let utxos = {
-            // let database: &mut MemoryDatabase = cache.borrow_mut();
-            setup_database_and_get_oldest_first_test_utxos(&mut *db.borrow_mut())
-        };
+        let utxos = { setup_database_and_get_oldest_first_test_utxos(&mut *db.borrow_mut()) };
 
         let result = OldestFirstCoinSelection::default()
             .coin_select(
diff --git a/src/wallet/mod.rs b/src/wallet/mod.rs
index 9ff957d11..85377e95d 100644
--- a/src/wallet/mod.rs
+++ b/src/wallet/mod.rs
@@ -75,6 +75,7 @@ use crate::signer::SignerError;
 use crate::testutils;
 use crate::types::*;
 
+use self::spendable_collection::TransactionItem;
 pub use self::spendable_collection::{SpendableCollection, SpendableDatabase};
 
 const CACHE_ADDR_BATCH_SIZE: u32 = 100;
@@ -599,14 +600,13 @@ where
     ) -> TxBuilder<'_, D, SpendableDatabase<D>, DefaultCoinSelectionAlgorithm, CreateTx> {
         // Get default block height to set as nLockTime (we try to prevent fee sniping).
         // However, if we do not know the block height, we default to 0.
-        let default_block_height = self.get_current_known_block_height().unwrap_or(0_u32);
+        let fallback_height = self.get_current_known_block_height().unwrap_or(0_u32);
 
         TxBuilder {
             spendable_collection: self.as_spendable_collection(),
             params: TxParams::default(),
-            default_block_height,
+            fallback_height,
             coin_selection: DefaultCoinSelectionAlgorithm::default(),
-            signers: &self.signers,
             secp: self.secp.clone(),
             phantom: core::marker::PhantomData,
             phantom_database: core::marker::PhantomData,
@@ -620,40 +620,40 @@ where
         coin_selection: Cs,
         params: TxParams,
         fallback_block_height: u32,
-        signers: &SignersContainer,
         secp: &SecpCtx,
     ) -> Result<(psbt::PartiallySignedTransaction, TransactionDetails), Error>
     where
         Sc: SpendableCollection,
         Cs: coin_selection::CoinSelectionAlgorithm,
     {
-        let conditions = spendable_collection
-            .iter_descriptors()?
-            .map(|(desc, keychain)| {
-                let policy = desc
-                    .extract_policy(signers, BuildSatisfaction::None, secp)?
-                    .unwrap();
-                let policy_path = params.descriptor_policy_paths.get(&desc);
-
-                // are we permitted to spend inputs?
-                let is_permitted = match keychain {
-                    KeychainKind::External => {
-                        params.change_policy != tx_builder::ChangeSpendPolicy::OnlyChange
-                    }
-                    KeychainKind::Internal => {
-                        params.change_policy != tx_builder::ChangeSpendPolicy::ChangeForbidden
-                    }
-                };
+        let conditions = spendable_collection.iter_descriptors()?.map(|item| {
+            let policy = item
+                .descriptor
+                .extract_policy(&item.signers, BuildSatisfaction::None, secp)?
+                .unwrap();
+            let policy_path = params.descriptor_policy_paths.get(&item.descriptor);
 
-                // if permitted, ensure policy path requirements are satisfied
-                if is_permitted && policy.requires_path() && policy_path.is_none() {
-                    Err(Error::SpendingPolicyRequired(Box::new(desc.clone())))
-                } else {
-                    policy
-                        .get_condition(policy_path.unwrap_or(&BTreeMap::new()))
-                        .map_err(Error::InvalidPolicyPathError)
+            // are we permitted to spend inputs?
+            let is_permitted = match item.keychain {
+                KeychainKind::External => {
+                    params.change_policy != tx_builder::ChangeSpendPolicy::OnlyChange
                 }
-            });
+                KeychainKind::Internal => {
+                    params.change_policy != tx_builder::ChangeSpendPolicy::ChangeForbidden
+                }
+            };
+
+            // if permitted, ensure policy path requirements are satisfied
+            if is_permitted && policy.requires_path() && policy_path.is_none() {
+                Err(Error::SpendingPolicyRequired(Box::new(
+                    item.descriptor.clone(),
+                )))
+            } else {
+                policy
+                    .get_condition(policy_path.unwrap_or(&BTreeMap::new()))
+                    .map_err(Error::InvalidPolicyPathError)
+            }
+        });
 
         let requirements = conditions
             .reduce(|acc_res, cond_res| match (acc_res, cond_res) {
@@ -818,7 +818,7 @@ where
         if params.change_policy == tx_builder::ChangeSpendPolicy::OnlyChange {
             let has_internal = spendable_collection
                 .iter_descriptors()?
-                .any(|(_, kc)| kc == KeychainKind::Internal);
+                .any(|item| item.keychain == KeychainKind::Internal);
 
             if !has_internal {
                 return Err(Error::Generic(
@@ -981,46 +981,54 @@ where
         txid: Txid,
     ) -> Result<TxBuilder<'_, D, SpendableDatabase<D>, DefaultCoinSelectionAlgorithm, BumpFee>, Error>
     {
-        let mut details = match self.database.borrow().get_tx(&txid, true)? {
+        let spendable_collection = self.as_spendable_collection();
+        let fallback_height = self.get_current_known_block_height().unwrap_or(0_u32);
+
+        Self::_build_fee_bump(
+            spendable_collection,
+            self.secp.clone(),
+            fallback_height,
+            txid,
+        )
+    }
+
+    pub(crate) fn _build_fee_bump<'a, Sc: SpendableCollection>(
+        spendable_collection: Sc,
+        secp: SecpCtx,
+        fallback_height: u32,
+        txid: Txid,
+    ) -> Result<TxBuilder<'a, D, Sc, DefaultCoinSelectionAlgorithm, BumpFee>, Error> {
+        let (mut tx, tx_fee) = match spendable_collection.get_tx(&txid)? {
             None => return Err(Error::TransactionNotFound),
-            Some(tx) if tx.transaction.is_none() => return Err(Error::TransactionNotFound),
-            Some(tx) if tx.confirmation_time.is_some() => return Err(Error::TransactionConfirmed),
-            Some(tx) => tx,
+            Some(TransactionItem {
+                confirmed: Some(_), ..
+            }) => return Err(Error::TransactionConfirmed),
+            Some(TransactionItem { fees: None, .. }) => return Err(Error::FeeRateUnavailable),
+            Some(tx) => (tx.raw, tx.fees.unwrap()),
         };
-        let mut tx = details.transaction.take().unwrap();
+
+        // let mut tx = details.transaction.take().unwrap();
         if !tx.input.iter().any(|txin| txin.sequence <= 0xFFFFFFFD) {
             return Err(Error::IrreplaceableTransaction);
         }
 
-        let feerate = FeeRate::from_wu(details.fee.ok_or(Error::FeeRateUnavailable)?, tx.weight());
+        let feerate = FeeRate::from_wu(tx_fee, tx.weight());
 
         // remove the inputs from the tx and process them
         let original_txin = tx.input.drain(..).collect::<Vec<_>>();
         let original_utxos = original_txin
             .iter()
             .map(|txin| -> Result<_, Error> {
-                let txout = self
-                    .database
-                    .borrow()
-                    .get_previous_output(&txin.previous_output)?
+                let txout = spendable_collection
+                    .get_output(&txin.previous_output)?
                     .ok_or(Error::UnknownUtxo)?;
 
-                // TODO @evanlinjin: Remove requirement of &self -> TxbuilderCache
-                //  Option(root_desc, child_index) <- txout.script_pubkey
-                //      Some => (root_desc.max_satisfaction_weight(), keychain_kind(root_desc))
-                //      None => (ser_len(txin.script_sig) * 4 + ser_len(txin.witness), external_keychain)
-                let (weight, keychain) = match self
-                    .database
-                    .borrow()
-                    .get_path_from_script_pubkey(&txout.script_pubkey)?
-                {
-                    Some((keychain, _)) => (
-                        self._get_descriptor_for_keychain(keychain)
-                            .0
-                            .max_satisfaction_weight()
-                            .unwrap(),
-                        keychain,
-                    ),
+                let path = spendable_collection.get_path_of_script_pubkey(&txout.script_pubkey)?;
+                let (weight, keychain) = match path {
+                    Some((item, _)) => {
+                        let weight = item.descriptor.max_satisfaction_weight().unwrap();
+                        (weight, item.keychain)
+                    }
                     None => {
                         // estimate the weight based on the scriptsig/witness size present in the
                         // original transaction
@@ -1044,21 +1052,19 @@ where
             })
             .collect::<Result<Vec<_>, _>>()?;
 
+        // Find change index
+        // TODO @evanlinjin: Should we prioritize larger inputs so we have more wriggle room?
         if tx.output.len() > 1 {
             let mut change_index = None;
+
             for (index, txout) in tx.output.iter().enumerate() {
-                // TODO @evanlinjin:
-                // if has_explicit_change_descriptor() => change_type = External
-                // else                                => change_type = Internal
-                let (_, change_type) = self._get_descriptor_for_keychain(KeychainKind::Internal);
-
-                match self
-                    .database
-                    .borrow()
-                    .get_path_from_script_pubkey(&txout.script_pubkey)?
-                {
-                    Some((keychain, _)) if keychain == change_type => change_index = Some(index),
-                    _ => {}
+                let path = spendable_collection.get_path_of_script_pubkey(&txout.script_pubkey)?;
+
+                if let Some((item, _)) = path {
+                    // Prioritize internal inputs
+                    if change_index.is_none() || item.keychain == KeychainKind::Internal {
+                        change_index = Some(index);
+                    }
                 }
             }
 
@@ -1077,21 +1083,20 @@ where
                 .collect(),
             utxos: original_utxos,
             bumping_fee: Some(tx_builder::PreviousFee {
-                absolute: details.fee.ok_or(Error::FeeRateUnavailable)?,
+                absolute: tx_fee,
                 rate: feerate.as_sat_vb(),
             }),
             ..Default::default()
         };
 
         Ok(TxBuilder {
-            spendable_collection: self.as_spendable_collection(),
+            spendable_collection,
             params,
             coin_selection: DefaultCoinSelectionAlgorithm::default(),
             phantom: core::marker::PhantomData,
             phantom_database: core::marker::PhantomData,
-            default_block_height: 0, // TODO
-            signers: &self.signers,
-            secp: self.secp.clone(),
+            fallback_height,
+            secp,
         })
     }
 
@@ -1183,15 +1188,6 @@ where
             signer.sign_transaction(psbt, secp)?;
         }
 
-        // for signer in self
-        //     .signers
-        //     .signers()
-        //     .iter()
-        //     .chain(self.change_signers.signers().iter())
-        // {
-        //     signer.sign_transaction(psbt, secp)?;
-        // }
-
         // attempt to finalize
         if sign_options.try_finalize {
             Self::_finalize_psbt(
@@ -1201,7 +1197,6 @@ where
                 psbt,
                 sign_options,
             )
-            // self.finalize_psbt(psbt, sign_options)
         } else {
             Ok(false)
         }
@@ -1270,7 +1265,6 @@ where
         psbt: &mut psbt::PartiallySignedTransaction,
         sign_options: SignOptions,
     ) -> Result<bool, Error> {
-        // NOTE @evanlinjin: this is only used in `.sign`
         let tx = &psbt.unsigned_tx;
         let mut finished = true;
 
@@ -1286,7 +1280,7 @@ where
             // that as a very high value
             let create_height = spendable_collection
                 .get_tx(&input.previous_output.txid)?
-                .map(|(_, bt)| bt.map_or(u32::MAX, |c| c.height));
+                .map(|tx| tx.confirmed.map_or(u32::MAX, |c| c.height));
             let last_sync_height = fallback_block_height;
             let current_height = sign_options.assume_height.or(last_sync_height);
 
@@ -1307,15 +1301,18 @@ where
                     spendable_collection
                         .get_path_of_script_pubkey(&txout.script_pubkey)
                         .expect("spendable collection should not fail")
-                        .map(|(parent_desc, child_ind)| parent_desc.as_derived(child_ind, secp))
+                        .map(|(parent_item, child_ind)| {
+                            parent_item.descriptor.as_derived(child_ind, secp)
+                        })
                 })
                 .or_else(|| {
                     spendable_collection
                         .iter_descriptors()
                         .expect("spendable collection should not fail")
-                        .find_map(|(desc, _)| {
+                        .find_map(|item| {
                             let prev_utxo = psbt.get_utxo_for(n);
-                            desc.derive_from_psbt_input(psbt_input, prev_utxo, secp)
+                            item.descriptor
+                                .derive_from_psbt_input(psbt_input, prev_utxo, secp)
                         })
                 });
 
@@ -1548,15 +1545,15 @@ where
                         // so we can't know for sure if it's mature or not.
                         // We prefer not to spend it.
                         None => false,
-                        Some((tx, block_time)) => {
+                        Some(tx) => {
                             // Whether the UTXO is mature and, if needed, confirmed
                             let mut spendable = true;
-                            if must_only_use_confirmed_tx && block_time.is_none() {
+                            if must_only_use_confirmed_tx && tx.confirmed.is_none() {
                                 return false;
                             }
-                            if tx.is_coin_base() {
+                            if tx.raw.is_coin_base() {
                                 if let Some(current_height) = current_height {
-                                    match &block_time {
+                                    match &tx.confirmed {
                                         Some(t) => {
                                             // https://github.com/bitcoin/bitcoin/blob/c5e67be03bb06a5d7885c55db1f016fbf2333fe3/src/validation.cpp#L373-L375
                                             spendable &= (current_height.saturating_sub(t.height))
@@ -1612,8 +1609,8 @@ where
         if params.add_global_xpubs {
             let all_xpubs = spendable_collection
                 .iter_descriptors()?
-                .try_fold(Vec::new(), |mut xpubs, (desc, _)| {
-                    xpubs.append(&mut desc.get_extended_keys()?);
+                .try_fold(Vec::new(), |mut xpubs, item| {
+                    xpubs.append(&mut item.descriptor.get_extended_keys()?);
                     Ok(xpubs)
                 })
                 .map_err(Error::Descriptor)?;
@@ -1650,18 +1647,16 @@ where
                         params.sighash,
                         params.only_witness_utxo,
                     );
-                    *psbt_input =
-                        // match self.get_psbt_input(utxo, params.sighash, params.only_witness_utxo) {
-                        match psbt_input_res {
-                            Ok(psbt_input) => psbt_input,
-                            Err(e) => match e {
-                                Error::UnknownUtxo => psbt::Input {
-                                    sighash_type: params.sighash,
-                                    ..psbt::Input::default()
-                                },
-                                _ => return Err(e),
+                    *psbt_input = match psbt_input_res {
+                        Ok(psbt_input) => psbt_input,
+                        Err(e) => match e {
+                            Error::UnknownUtxo => psbt::Input {
+                                sighash_type: params.sighash,
+                                ..psbt::Input::default()
                             },
-                        }
+                            _ => return Err(e),
+                        },
+                    }
                 }
                 Utxo::Foreign {
                     psbt_input: foreign_psbt_input,
@@ -1696,9 +1691,9 @@ where
             let path_opt =
                 spendable_collection.get_path_of_script_pubkey(&tx_output.script_pubkey)?;
 
-            if let Some((desc, child)) = path_opt {
+            if let Some((item, child)) = path_opt {
                 // let (desc, _) = self._get_descriptor_for_keychain(keychain);
-                let derived_descriptor = desc.as_derived(child, secp);
+                let derived_descriptor = item.descriptor.as_derived(child, secp);
 
                 if let miniscript::Descriptor::Tr(tr) = &derived_descriptor {
                     let tap_tree = if tr.taptree().is_some() {
@@ -1764,7 +1759,7 @@ where
     ) -> Result<psbt::Input, Error> {
         // Try to find the prev_script in our db to figure out if this is internal or external,
         // and the derivation index
-        let (desc, child) = spendable_collection
+        let (item, child) = spendable_collection
             .get_path_of_script_pubkey(&utxo.txout.script_pubkey)?
             .ok_or(Error::UnknownUtxo)?;
 
@@ -1773,8 +1768,7 @@ where
             ..psbt::Input::default()
         };
 
-        // let desc = self.get_descriptor_for_keychain(keychain);
-        let derived_descriptor = desc.as_derived(child, secp);
+        let derived_descriptor = item.descriptor.as_derived(child, secp);
 
         if let miniscript::Descriptor::Tr(tr) = &derived_descriptor {
             psbt_input.tap_key_origins = derived_descriptor.get_tap_key_origins(secp);
@@ -1801,25 +1795,20 @@ where
         let prev_output = utxo.outpoint;
         let prev_tx_opt = spendable_collection.get_tx(&prev_output.txid)?;
         // if let Some(prev_tx) = self.database.borrow().get_raw_tx(&prev_output.txid)? {
-        if let Some((prev_tx, _)) = prev_tx_opt {
-            if desc.is_witness() || desc.is_taproot() {
-                psbt_input.witness_utxo = Some(prev_tx.output[prev_output.vout as usize].clone());
+        if let Some(prev_tx) = prev_tx_opt {
+            if item.descriptor.is_witness() || item.descriptor.is_taproot() {
+                psbt_input.witness_utxo =
+                    Some(prev_tx.raw.output[prev_output.vout as usize].clone());
             }
-            if !desc.is_taproot() && (!desc.is_witness() || !only_witness_utxo) {
-                psbt_input.non_witness_utxo = Some(prev_tx);
+            if !item.descriptor.is_taproot()
+                && (!item.descriptor.is_witness() || !only_witness_utxo)
+            {
+                psbt_input.non_witness_utxo = Some(prev_tx.raw);
             }
         }
         Ok(psbt_input)
     }
 
-    // fn add_input_hd_keypaths(
-    //     &self,
-    //     psbt: &mut psbt::PartiallySignedTransaction,
-    // ) -> Result<(), Error> {
-    //     let spendable_collection = self.as_spendable_collection();
-    //     Self::_add_input_hd_keypaths(&spendable_collection, &self.secp, psbt)
-    // }
-
     /// TODO @evanlinjin: Move out of [`Wallet`].
     fn _add_input_hd_keypaths<'a, Sc>(
         spendable_collection: &'a Sc,
@@ -1844,23 +1833,26 @@ where
                 };
 
                 // obtain parent descriptor + child index of script_pubkey (if any)
-                let (parent_desc, child) =
+                let (parent, child) =
                     match spendable_collection.get_path_of_script_pubkey(prev_script_pubkey)? {
                         Some(path) => path,
                         None => return Ok(()),
                     };
 
-                debug!("Found descriptor {} /{}", parent_desc, child);
+                debug!("Found descriptor {} /{}", parent.descriptor, child);
 
                 // merge hd_keypaths or tap_keys_origins
-                if parent_desc.is_taproot() {
-                    let tap_key_origins = &mut parent_desc
+                if parent.descriptor.is_taproot() {
+                    let tap_key_origins = &mut parent
+                        .descriptor
                         .as_derived(child, secp)
                         .get_tap_key_origins(secp);
                     psbt_input.tap_key_origins.append(tap_key_origins);
                 } else {
-                    let hd_keypaths =
-                        &mut parent_desc.as_derived(child, secp).get_hd_keypaths(secp);
+                    let hd_keypaths = &mut parent
+                        .descriptor
+                        .as_derived(child, secp)
+                        .get_hd_keypaths(secp);
                     psbt_input.bip32_derivation.append(hd_keypaths);
                 }
 
@@ -2295,18 +2287,6 @@ pub(crate) mod test {
         let mut builder = wallet.build_tx();
         builder.add_recipient(addr.script_pubkey(), 25_000);
 
-        // let sync_time = SyncTime {
-        //     block_time: BlockTime {
-        //         height: 25,
-        //         timestamp: 0,
-        //     },
-        // };
-        // wallet
-        //     .database
-        //     .borrow_mut()
-        //     .set_sync_time(sync_time.clone())
-        //     .unwrap();
-
         let (psbt, _) = builder.finish().unwrap();
 
         // If there's no current_height we're left with using the last sync height
@@ -3163,9 +3143,6 @@ pub(crate) mod test {
             builder
         };
 
-        // let mut builder = wallet1.build_tx();
-        // builder.add_recipient(addr.script_pubkey(), 60_000);
-
         {
             // let mut builder = builder.clone();
             let mut builder = make_builder();
diff --git a/src/wallet/signer.rs b/src/wallet/signer.rs
index b1d8e4e5f..cb190bf93 100644
--- a/src/wallet/signer.rs
+++ b/src/wallet/signer.rs
@@ -303,7 +303,6 @@ impl InputSigner for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
             .tap_key_origins
             .iter()
             .map(|(pk, (_, keysource))| (SinglePubKey::XOnly(*pk), keysource));
-
         let (public_key, full_path) = match psbt.inputs[input_index]
             .bip32_derivation
             .iter()
diff --git a/src/wallet/spendable_collection.rs b/src/wallet/spendable_collection.rs
index 9a5ddacaf..63c85497f 100644
--- a/src/wallet/spendable_collection.rs
+++ b/src/wallet/spendable_collection.rs
@@ -1,7 +1,7 @@
 ///! SpendableCollection
 ///
 /// This module defines the [`SpendableCollection`] trait.
-use std::{cell::RefCell, sync::Arc};
+use std::{cell::RefCell, collections::HashMap, sync::Arc};
 
 use bitcoin::{Network, OutPoint, Script, Transaction, TxOut, Txid};
 use miniscript::DescriptorTrait;
@@ -16,11 +16,33 @@ use crate::{
 
 use super::{utils::SecpCtx, AddressInfo};
 
+/// Contains a descriptor and associated data
+#[derive(Debug, Clone)]
+pub struct DescriptorItem {
+    /// Wallet descriptor
+    pub descriptor: ExtendedDescriptor,
+    /// Keychain kind of descriptor - external/internal
+    pub keychain: KeychainKind,
+    /// Signers of descriptor
+    pub signers: Arc<SignersContainer>,
+}
+
+/// Contains a transaction and it's associated data
+#[derive(Debug, Clone)]
+pub struct TransactionItem {
+    /// Raw transaction
+    pub raw: Transaction,
+    /// Confirmed time (if any) of the transaction
+    pub confirmed: Option<BlockTime>,
+    /// Fees of the transaction (if avaliable)
+    pub fees: Option<u64>,
+}
+
 /// Contains the "required" methods of [`SpendableCollection`], where all other methods could be
 /// deried from (albiet probably not in an optimised manner).
 pub trait SpendableCollectionInner {
     /// Iterates though descriptors with associated keychain kind.
-    type DescIter: Iterator<Item = (ExtendedDescriptor, KeychainKind)> + ExactSizeIterator;
+    type DescIter: Iterator<Item = DescriptorItem> + ExactSizeIterator;
 
     /// Iterates though signers.
     type SignerIter: Iterator<Item = Arc<dyn TransactionSigner>>;
@@ -47,7 +69,7 @@ pub trait SpendableCollectionInner {
     /// confirm this).
     ///
     /// TODO @evanlinjin: Maybe this should be in it's own trait?
-    fn get_tx(&self, txid: &Txid) -> Result<Option<(Transaction, Option<BlockTime>)>, Error>;
+    fn get_tx(&self, txid: &Txid) -> Result<Option<TransactionItem>, Error>;
 
     /// Returns a fresh/unused address derived from given descriptor. This is currently used for
     /// obtaining a change/drain address.
@@ -63,19 +85,17 @@ pub trait SpendableCollection: SpendableCollectionInner {
     fn get_path_of_script_pubkey(
         &self,
         script: &Script,
-    ) -> Result<Option<(ExtendedDescriptor, u32)>, Error> {
-        let descriptors = self
-            .iter_descriptors()?
-            .map(|(desc, _)| desc)
-            .collect::<Vec<_>>();
+    ) -> Result<Option<(DescriptorItem, u32)>, Error> {
+        let descriptors = self.iter_descriptors()?.collect::<Vec<_>>();
 
         let secp = SecpCtx::new();
 
         for index in 0..2100_u32 {
-            for desc in &descriptors {
+            for item in &descriptors {
+                let desc = item.descriptor.clone();
                 let derived_script = desc.as_derived(index, &secp).script_pubkey();
                 if script == &derived_script {
-                    return Ok(Some((desc.clone(), index)));
+                    return Ok(Some((item.clone(), index)));
                 }
             }
         }
@@ -95,6 +115,21 @@ pub trait SpendableCollection: SpendableCollectionInner {
         }))
     }
 
+    /// Obtain output of the provided outpoint.
+    /// Output may not be owned by us, just be part of a transaction that we are keeping track of.
+    fn get_output(&self, outpoint: &OutPoint) -> Result<Option<TxOut>, Error> {
+        self.get_tx(&outpoint.txid)?.map_or_else(
+            || Err(Error::InvalidOutpoint(*outpoint)),
+            |tx_item| {
+                Ok(tx_item
+                    .raw
+                    .output
+                    .get(outpoint.vout as usize)
+                    .map(Clone::clone))
+            },
+        )
+    }
+
     /// Returns whether given script is owned by us, or not.
     fn is_mine(&self, script: &Script) -> Result<bool, Error> {
         self.get_path_of_script_pubkey(script)
@@ -106,25 +141,17 @@ pub trait SpendableCollection: SpendableCollectionInner {
     fn new_auto_address(&self) -> Result<AddressInfo, Error> {
         let (mut internal, mut external): (Vec<_>, Vec<_>) = self
             .iter_descriptors()?
-            .partition(|(_, kc)| kc == &KeychainKind::Internal);
+            .partition(|item| item.keychain == KeychainKind::Internal);
 
         internal.append(&mut external);
 
-        let (desc, _) = internal.iter().chain(external.iter()).next().unwrap();
+        let item = internal.iter().chain(external.iter()).next().unwrap();
 
         #[allow(deprecated)]
-        self.new_address(desc)
+        self.new_address(&item.descriptor)
     }
 }
 
-/// Addons to [`SpendableCollection`] to allow for usage with fee-bump logic.
-///
-/// TODO @evanlinjin: decouple fee-bump logic from Wallet.
-pub trait FeeBumpCollection: SpendableCollection {
-    /// Previous output may be from a confirmed transaction.
-    fn get_previous_output(&self, outpoint: &OutPoint) -> Result<Option<TxOut>, Error>;
-}
-
 /// Implements [`SpendableCollection`] with one external descriptor and an optional internal descriptor.
 // #[derive(Clone)]
 pub struct SpendableDatabase<'a, D> {
@@ -156,17 +183,22 @@ impl<'a, D: BatchDatabase> Clone for SpendableDatabase<'a, D> {
 pub struct DatabaseDescIter<'a, D>(SpendableDatabase<'a, D>, usize);
 
 impl<'a, D> Iterator for DatabaseDescIter<'a, D> {
-    type Item = (ExtendedDescriptor, KeychainKind);
+    type Item = DescriptorItem;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.1 += 1;
 
         match self.1 {
-            1 => Some((self.0.descriptor.clone(), KeychainKind::External)),
-            2 => self
-                .0
-                .change_descriptor
-                .map(|change_desc| (change_desc.clone(), KeychainKind::Internal)),
+            1 => Some(DescriptorItem {
+                descriptor: self.0.descriptor.clone(),
+                keychain: KeychainKind::External,
+                signers: Arc::clone(&self.0.signers[0]),
+            }),
+            2 => self.0.change_descriptor.map(|change_desc| DescriptorItem {
+                descriptor: change_desc.clone(),
+                keychain: KeychainKind::Internal,
+                signers: Arc::clone(&self.0.signers[1]),
+            }),
             _ => None,
         }
     }
@@ -249,11 +281,11 @@ impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D>
             .into_iter()
             .filter(|utxo| !utxo.is_spent)
             .filter_map(|utxo| {
-                let (parent_desc, _) = self
+                let (item, _) = self
                     // @evanlinjin: Will panic with default implementation on timeout.
                     .get_path_of_script_pubkey(&utxo.txout.script_pubkey)
                     .unwrap()?;
-                let weight = parent_desc.max_satisfaction_weight().unwrap();
+                let weight = item.descriptor.max_satisfaction_weight().unwrap();
                 Some((utxo, weight))
             })
             .collect::<Vec<_>>();
@@ -261,13 +293,16 @@ impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D>
         Ok(utxos.into_iter())
     }
 
-    fn get_tx(&self, txid: &Txid) -> Result<Option<(Transaction, Option<BlockTime>)>, Error> {
-        Ok(self.db.borrow().get_tx(txid, true)?.map(|tx_details| {
-            (
-                tx_details.transaction.unwrap(),
-                tx_details.confirmation_time,
-            )
-        }))
+    fn get_tx(&self, txid: &Txid) -> Result<Option<TransactionItem>, Error> {
+        Ok(self
+            .db
+            .borrow()
+            .get_tx(txid, true)?
+            .map(|details| TransactionItem {
+                raw: details.transaction.unwrap(),
+                confirmed: details.confirmation_time,
+                fees: details.fee,
+            }))
     }
 
     fn new_address(&self, desc: &ExtendedDescriptor) -> Result<AddressInfo, Error> {
@@ -298,7 +333,14 @@ impl<'a, D: BatchDatabase> SpendableCollection for SpendableDatabase<'a, D> {
     fn get_path_of_script_pubkey(
         &self,
         script: &Script,
-    ) -> Result<Option<(ExtendedDescriptor, u32)>, Error> {
+    ) -> Result<Option<(DescriptorItem, u32)>, Error> {
+        // TODO: Add as struct field
+        let desc_map = self
+            .iter_descriptors()?
+            .map(|desc| (desc.descriptor.to_string(), desc))
+            .collect::<HashMap<_, _>>();
+
+        // check internal cache for relation
         let cached_res =
             self.db
                 .borrow()
@@ -308,39 +350,30 @@ impl<'a, D: BatchDatabase> SpendableCollection for SpendableDatabase<'a, D> {
                         KeychainKind::External => self.descriptor,
                         KeychainKind::Internal => self.change_descriptor.unwrap(),
                     };
-
-                    (desc.clone(), child_ind)
+                    let item = desc_map.get(&desc.to_string()).unwrap();
+                    (item.clone(), child_ind)
                 });
 
         if cached_res.is_some() {
             return Ok(cached_res);
         }
 
-        // // try brute-force method...
-        let last_ext = self
-            .db
-            .borrow()
-            .get_last_index(KeychainKind::External)?
-            .unwrap_or(0_u32);
-        let last_int = self
-            .db
-            .borrow()
-            .get_last_index(KeychainKind::Internal)?
-            .unwrap_or(0_u32);
+        // try brute-force method
+        let db = self.db.borrow();
+        let last_ext = db.get_last_index(KeychainKind::External)?.unwrap_or(0_u32);
+        let last_int = db.get_last_index(KeychainKind::Internal)?.unwrap_or(0_u32);
         let start = std::cmp::min(last_ext, last_int);
 
-        let descriptors = self
-            .iter_descriptors()?
-            .map(|(desc, _)| desc)
-            .collect::<Vec<_>>();
-
-        let secp = SecpCtx::new();
+        let descriptors = self.iter_descriptors()?.collect::<Vec<_>>();
 
         for index in start..start + 2100_u32 {
-            for desc in &descriptors {
-                let derived_script = desc.as_derived(index, &secp).script_pubkey();
+            for item in &descriptors {
+                let derived_script = item
+                    .descriptor
+                    .as_derived(index, &self.secp)
+                    .script_pubkey();
                 if script == &derived_script {
-                    return Ok(Some((desc.clone(), index)));
+                    return Ok(Some((item.clone(), index)));
                 }
             }
         }
diff --git a/src/wallet/tx_builder.rs b/src/wallet/tx_builder.rs
index d1111c8e6..5d2f32eab 100644
--- a/src/wallet/tx_builder.rs
+++ b/src/wallet/tx_builder.rs
@@ -42,15 +42,14 @@ use std::default::Default;
 use std::marker::PhantomData;
 
 use bitcoin::util::psbt::{self, PartiallySignedTransaction as Psbt};
+use bitcoin::Txid;
 use bitcoin::{OutPoint, Script, Transaction};
-
-use miniscript::descriptor::DescriptorTrait;
+use miniscript::DescriptorTrait;
 
 use super::coin_selection::{CoinSelectionAlgorithm, DefaultCoinSelectionAlgorithm};
 use super::spendable_collection::SpendableCollection;
 use super::utils::SecpCtx;
 use crate::descriptor::ExtendedDescriptor;
-use crate::signer::SignersContainer;
 use crate::SignOptions;
 use crate::Wallet;
 use crate::{database::BatchDatabase, Error, Utxo};
@@ -126,9 +125,8 @@ impl TxBuilderContext for BumpFee {}
 pub struct TxBuilder<'a, D, Sc, Cs, Ctx> {
     pub(crate) spendable_collection: Sc,
     pub(crate) params: TxParams<'a>,
-    pub(crate) default_block_height: u32,
+    pub(crate) fallback_height: u32,
     pub(crate) coin_selection: Cs,
-    pub(crate) signers: &'a SignersContainer,
     pub(crate) secp: SecpCtx,
     pub(crate) phantom: PhantomData<Ctx>,
 
@@ -187,10 +185,9 @@ impl<'a, D, Sc: Clone, Cs: Clone, Ctx> Clone for TxBuilder<'a, D, Sc, Cs, Ctx> {
             spendable_collection: self.spendable_collection.clone(),
             params: self.params.clone(),
             coin_selection: self.coin_selection.clone(),
-            default_block_height: self.default_block_height,
+            fallback_height: self.fallback_height,
             phantom: PhantomData,
             phantom_database: self.phantom_database,
-            signers: self.signers,
             secp: self.secp.clone(),
         }
     }
@@ -200,13 +197,12 @@ impl<'a, D: BatchDatabase, Sc: SpendableCollection, Ctx: TxBuilderContext>
     TxBuilder<'a, D, Sc, DefaultCoinSelectionAlgorithm, Ctx>
 {
     /// Creates a new [`TxBuilder`]
-    pub fn new(spendables: Sc, signers: &'a SignersContainer, fallback_block_height: u32) -> Self {
+    pub fn new(spendables: Sc, fallback_block_height: u32) -> Self {
         Self {
             spendable_collection: spendables,
             params: TxParams::default(),
             coin_selection: DefaultCoinSelectionAlgorithm::default(),
-            signers,
-            default_block_height: fallback_block_height,
+            fallback_height: fallback_block_height,
             secp: SecpCtx::new(),
             phantom: core::marker::PhantomData,
             phantom_database: core::marker::PhantomData,
@@ -329,9 +325,10 @@ impl<
             .map(|utxo| {
                 self.spendable_collection
                     .get_path_of_script_pubkey(&utxo.txout.script_pubkey)?
-                    .map(|(desc, _)| {
+                    .map(|(item, _)| {
                         let utxo = Utxo::Local(utxo);
-                        let satisfaction_weight = desc.max_satisfaction_weight().unwrap();
+                        let satisfaction_weight =
+                            item.descriptor.max_satisfaction_weight().unwrap();
                         WeightedUtxo {
                             utxo,
                             satisfaction_weight,
@@ -568,10 +565,9 @@ impl<
             spendable_collection: self.spendable_collection,
             params: self.params,
             coin_selection,
-            default_block_height: self.default_block_height,
+            fallback_height: self.fallback_height,
             phantom: PhantomData,
             phantom_database: self.phantom_database,
-            signers: self.signers,
             secp: self.secp,
         }
     }
@@ -587,8 +583,7 @@ impl<
             &self.spendable_collection,
             self.coin_selection,
             self.params,
-            self.default_block_height,
-            self.signers,
+            self.fallback_height,
             &self.secp,
         )
     }
@@ -599,8 +594,7 @@ impl<
             &self.spendable_collection,
             self.coin_selection,
             self.params,
-            self.default_block_height,
-            self.signers,
+            self.fallback_height,
             &self.secp,
         )?;
         let is_finalized = Wallet::<D>::_sign(
@@ -731,6 +725,11 @@ impl<'a, D: BatchDatabase, Sc: SpendableCollection, Cs: CoinSelectionAlgorithm>
 impl<'a, D: BatchDatabase, Sc: SpendableCollection>
     TxBuilder<'a, D, Sc, DefaultCoinSelectionAlgorithm, BumpFee>
 {
+    /// New transaction builder for fee bump.
+    pub fn new_fee_bump(spendables: Sc, txid: Txid, fallback_height: u32) -> Result<Self, Error> {
+        Wallet::<D>::_build_fee_bump(spendables, SecpCtx::new(), fallback_height, txid)
+    }
+
     /// Explicitly tells the wallet that it is allowed to reduce the amount of the output matching this
     /// `script_pubkey` in order to bump the transaction fee. Without specifying this the wallet
     /// will attempt to find a change output to shrink instead.

From aac576d98a3c62bfe862ad76139f3f7ee8afe274 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Thu, 14 Jul 2022 13:59:41 +0800
Subject: [PATCH 08/16] WIP: Change SpendableCollection to use boxed Iterators

---
 src/wallet/spendable_collection.rs | 47 ++++++++++--------------------
 1 file changed, 16 insertions(+), 31 deletions(-)

diff --git a/src/wallet/spendable_collection.rs b/src/wallet/spendable_collection.rs
index 63c85497f..e89ada74d 100644
--- a/src/wallet/spendable_collection.rs
+++ b/src/wallet/spendable_collection.rs
@@ -41,25 +41,18 @@ pub struct TransactionItem {
 /// Contains the "required" methods of [`SpendableCollection`], where all other methods could be
 /// deried from (albiet probably not in an optimised manner).
 pub trait SpendableCollectionInner {
-    /// Iterates though descriptors with associated keychain kind.
-    type DescIter: Iterator<Item = DescriptorItem> + ExactSizeIterator;
-
-    /// Iterates though signers.
-    type SignerIter: Iterator<Item = Arc<dyn TransactionSigner>>;
-
-    /// Iterates through UTXOs with associated weight.
-    type UtxoIter: Iterator<Item = (LocalUtxo, usize)>;
-
     /// Returns an iterator that ranges through all owned descriptors.
-    fn iter_descriptors(&self) -> Result<Self::DescIter, Error>;
+    fn iter_descriptors(&self) -> Result<Box<dyn Iterator<Item = DescriptorItem> + '_>, Error>;
 
     /// Returns an iterator that ranges through all owned signers.
-    fn iter_signers(&self) -> Result<Self::SignerIter, Error>;
+    fn iter_signers(
+        &self,
+    ) -> Result<Box<dyn Iterator<Item = Arc<dyn TransactionSigner>> + '_>, Error>;
 
     /// Obtains owned UTXOs alongside their satisfaction weights.
     ///     Warning: It is possible that the returned list contains a UTXO currently used as an
     ///     unconfirmed tx input.
-    fn iter_utxos(&self) -> Result<Self::UtxoIter, Error>;
+    fn iter_utxos(&self) -> Result<Box<dyn Iterator<Item = (LocalUtxo, usize)> + '_>, Error>;
 
     /// Obtains transaction (and details) of given txid.
     ///
@@ -239,26 +232,20 @@ impl<'a, D: BatchDatabase> SpendableDatabase<'a, D> {
 }
 
 impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D> {
-    type DescIter = DatabaseDescIter<'a, D>;
-
-    type SignerIter = std::vec::IntoIter<Arc<dyn TransactionSigner>>;
-
-    type UtxoIter = std::vec::IntoIter<(LocalUtxo, usize)>;
-
-    fn iter_descriptors(&self) -> Result<Self::DescIter, Error> {
-        Ok(DatabaseDescIter::<'_>(self.clone(), 0))
+    fn iter_descriptors(&self) -> Result<Box<dyn Iterator<Item = DescriptorItem> + '_>, Error> {
+        Ok(Box::new(DatabaseDescIter::<'_>(self.clone(), 0)))
     }
 
-    fn iter_signers(&self) -> Result<Self::SignerIter, Error> {
-        #[allow(clippy::needless_collect)]
+    fn iter_signers(
+        &self,
+    ) -> Result<Box<dyn Iterator<Item = Arc<dyn TransactionSigner>> + '_>, Error> {
         let signers = self
             .signers
             .iter()
             .flat_map(|cont| cont.signers())
-            .map(Arc::clone)
-            .collect::<Vec<_>>();
+            .map(Arc::clone);
 
-        Ok(signers.into_iter())
+        Ok(Box::new(signers))
     }
 
     /// TODO @evanlinjin:
@@ -272,25 +259,23 @@ impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D>
     ///
     /// For now, we need to ensure the aforementioned relationship is sufficiently cached to
     /// avoid "missing" available UTXOs.
-    fn iter_utxos(&self) -> Result<Self::UtxoIter, Error> {
-        #[allow(clippy::needless_collect)]
+    fn iter_utxos(&self) -> Result<Box<dyn Iterator<Item = (LocalUtxo, usize)> + '_>, Error> {
         let utxos = self
             .db
             .borrow()
             .iter_utxos()?
             .into_iter()
             .filter(|utxo| !utxo.is_spent)
-            .filter_map(|utxo| {
+            .filter_map(move |utxo| {
                 let (item, _) = self
                     // @evanlinjin: Will panic with default implementation on timeout.
                     .get_path_of_script_pubkey(&utxo.txout.script_pubkey)
                     .unwrap()?;
                 let weight = item.descriptor.max_satisfaction_weight().unwrap();
                 Some((utxo, weight))
-            })
-            .collect::<Vec<_>>();
+            });
 
-        Ok(utxos.into_iter())
+        Ok(Box::new(utxos))
     }
 
     fn get_tx(&self, txid: &Txid) -> Result<Option<TransactionItem>, Error> {

From e3ca1ce88dd913ec2caddeb7ef48166fab7917a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Thu, 14 Jul 2022 14:48:10 +0800
Subject: [PATCH 09/16] WIP: Rename `SpendableCollection` to `MultiTracker` and
 tweaks.

* Added `MultiTracker::latest_blockheight` method.
* Update documentation to reflect changes.
---
 src/wallet/coin_selection.rs                  |  20 +--
 src/wallet/mod.rs                             | 134 ++++++------------
 ...endable_collection.rs => multi_tracker.rs} |  68 +++++----
 src/wallet/tx_builder.rs                      |  77 ++++------
 4 files changed, 122 insertions(+), 177 deletions(-)
 rename src/wallet/{spendable_collection.rs => multi_tracker.rs} (84%)

diff --git a/src/wallet/coin_selection.rs b/src/wallet/coin_selection.rs
index 1131bff7e..bffc530c1 100644
--- a/src/wallet/coin_selection.rs
+++ b/src/wallet/coin_selection.rs
@@ -26,14 +26,14 @@
 //! ```
 //! # use std::str::FromStr;
 //! # use bitcoin::*;
-//! # use bdk::wallet::{self, coin_selection::*, spendable_collection::*};
+//! # use bdk::wallet::{self, coin_selection::*, multi_tracker::*};
 //! # use bdk::*;
 //! # const TXIN_BASE_WEIGHT: usize = (32 + 4 + 4 + 1) * 4;
 //! #[derive(Debug)]
 //! struct AlwaysSpendEverything;
 //!
 //! impl CoinSelectionAlgorithm for AlwaysSpendEverything {
-//!     fn coin_select<D: SpendableCollection>(
+//!     fn coin_select<D: MultiTracker>(
 //!         &self,
 //!         database: &D,
 //!         required_utxos: Vec<WeightedUtxo>,
@@ -99,7 +99,7 @@ use rand::{rngs::StdRng, SeedableRng};
 use std::collections::HashMap;
 use std::convert::TryInto;
 
-use super::spendable_collection::SpendableCollection;
+use super::multi_tracker::MultiTracker;
 
 /// Default coin selection algorithm used by [`TxBuilder`](super::tx_builder::TxBuilder) if not
 /// overridden
@@ -158,7 +158,7 @@ pub trait CoinSelectionAlgorithm: std::fmt::Debug {
     /// - `amount_needed`: the amount in satoshi to select
     /// - `fee_amount`: the amount of fees in satoshi already accumulated from adding outputs and
     ///                 the transaction's header
-    fn coin_select<Sc: SpendableCollection>(
+    fn coin_select<Sc: MultiTracker>(
         &self,
         database: &Sc,
         required_utxos: Vec<WeightedUtxo>,
@@ -177,7 +177,7 @@ pub trait CoinSelectionAlgorithm: std::fmt::Debug {
 pub struct LargestFirstCoinSelection;
 
 impl CoinSelectionAlgorithm for LargestFirstCoinSelection {
-    fn coin_select<D: SpendableCollection>(
+    fn coin_select<D: MultiTracker>(
         &self,
         _database: &D,
         required_utxos: Vec<WeightedUtxo>,
@@ -215,7 +215,7 @@ impl CoinSelectionAlgorithm for LargestFirstCoinSelection {
 pub struct OldestFirstCoinSelection;
 
 impl CoinSelectionAlgorithm for OldestFirstCoinSelection {
-    fn coin_select<D: SpendableCollection>(
+    fn coin_select<D: MultiTracker>(
         &self,
         database: &D,
         required_utxos: Vec<WeightedUtxo>,
@@ -362,7 +362,7 @@ impl BranchAndBoundCoinSelection {
 const BNB_TOTAL_TRIES: usize = 100_000;
 
 impl CoinSelectionAlgorithm for BranchAndBoundCoinSelection {
-    fn coin_select<D: SpendableCollection>(
+    fn coin_select<D: MultiTracker>(
         &self,
         _database: &D,
         required_utxos: Vec<WeightedUtxo>,
@@ -616,7 +616,7 @@ mod test {
     use crate::database::{BatchOperations, Database, MemoryDatabase};
     use crate::descriptor::{ExtendedDescriptor, IntoWalletDescriptor};
     use crate::types::*;
-    use crate::wallet::spendable_collection::SpendableDatabase;
+    use crate::wallet::multi_tracker::LegacyTracker;
     use crate::wallet::utils::SecpCtx;
     use crate::wallet::Vbytes;
 
@@ -642,8 +642,8 @@ mod test {
     fn new_collection<'a>(
         desc: &'a ExtendedDescriptor,
         db: &'a RefCell<MemoryDatabase>,
-    ) -> SpendableDatabase<'a, MemoryDatabase> {
-        SpendableDatabase::new(desc, None, Network::Regtest, db, Vec::new(), Vec::new())
+    ) -> LegacyTracker<'a, MemoryDatabase> {
+        LegacyTracker::new(desc, None, Network::Regtest, db, Vec::new(), Vec::new())
     }
 
     fn utxo(value: u64, index: u32) -> WeightedUtxo {
diff --git a/src/wallet/mod.rs b/src/wallet/mod.rs
index 85377e95d..76de4e3ad 100644
--- a/src/wallet/mod.rs
+++ b/src/wallet/mod.rs
@@ -43,7 +43,7 @@ pub mod export;
 pub mod signer;
 
 /// Spendable collection
-pub mod spendable_collection;
+pub mod multi_tracker;
 pub mod time;
 pub mod tx_builder;
 pub(crate) mod utils;
@@ -75,8 +75,8 @@ use crate::signer::SignerError;
 use crate::testutils;
 use crate::types::*;
 
-use self::spendable_collection::TransactionItem;
-pub use self::spendable_collection::{SpendableCollection, SpendableDatabase};
+use self::multi_tracker::TransactionItem;
+pub use self::multi_tracker::{LegacyTracker, MultiTracker};
 
 const CACHE_ADDR_BATCH_SIZE: u32 = 100;
 const COINBASE_MATURITY: u32 = 100;
@@ -263,6 +263,7 @@ where
     }
 
     /// TODO @evanlinjin: Move out of [`Wallet`].
+    #[allow(deprecated)]
     pub(crate) fn _get_new_address(
         database: &RefCell<D>,
         secp: &SecpCtx,
@@ -548,10 +549,10 @@ where
         &self.address_validators
     }
 
-    fn as_spendable_collection(&self) -> SpendableDatabase<D> {
+    fn as_multi_tracker(&self) -> LegacyTracker<D> {
         let signers = vec![Arc::clone(&self.signers), Arc::clone(&self.change_signers)];
 
-        SpendableDatabase::new(
+        LegacyTracker::new(
             &self.descriptor,
             self.change_descriptor.as_ref(),
             self.network,
@@ -561,14 +562,6 @@ where
         )
     }
 
-    /// Returns 0 when not synced
-    fn get_current_known_block_height(&self) -> Result<u32, Error> {
-        self.database().get_sync_time().map(|opt| match opt {
-            Some(sync_time) => sync_time.block_time.height,
-            None => 0_u32,
-        })
-    }
-
     /// Start building a transaction.
     ///
     /// This returns a blank [`TxBuilder`] from which you can specify the parameters for the transaction.
@@ -597,19 +590,13 @@ where
     /// [`TxBuilder`]: crate::TxBuilder
     pub fn build_tx(
         &self,
-    ) -> TxBuilder<'_, D, SpendableDatabase<D>, DefaultCoinSelectionAlgorithm, CreateTx> {
-        // Get default block height to set as nLockTime (we try to prevent fee sniping).
-        // However, if we do not know the block height, we default to 0.
-        let fallback_height = self.get_current_known_block_height().unwrap_or(0_u32);
-
+    ) -> TxBuilder<'_, LegacyTracker<D>, DefaultCoinSelectionAlgorithm, CreateTx> {
         TxBuilder {
-            spendable_collection: self.as_spendable_collection(),
+            multi_tracker: self.as_multi_tracker(),
             params: TxParams::default(),
-            fallback_height,
             coin_selection: DefaultCoinSelectionAlgorithm::default(),
             secp: self.secp.clone(),
             phantom: core::marker::PhantomData,
-            phantom_database: core::marker::PhantomData,
         }
     }
 
@@ -619,11 +606,10 @@ where
         spendable_collection: &'a Sc,
         coin_selection: Cs,
         params: TxParams,
-        fallback_block_height: u32,
         secp: &SecpCtx,
     ) -> Result<(psbt::PartiallySignedTransaction, TransactionDetails), Error>
     where
-        Sc: SpendableCollection,
+        Sc: MultiTracker,
         Cs: coin_selection::CoinSelectionAlgorithm,
     {
         let conditions = spendable_collection.iter_descriptors()?.map(|item| {
@@ -686,7 +672,9 @@ where
         // We use a match here instead of a map_or_else as it's way more readable :)
         let current_height = match params.current_height {
             // If they didn't tell us the current height, we assume it's the latest sync height.
-            None => Some(fallback_block_height),
+            None => spendable_collection
+                .latest_blockheight()?
+                .map(|bt| bt.height),
             h => h,
         };
 
@@ -979,26 +967,19 @@ where
     pub fn build_fee_bump(
         &self,
         txid: Txid,
-    ) -> Result<TxBuilder<'_, D, SpendableDatabase<D>, DefaultCoinSelectionAlgorithm, BumpFee>, Error>
+    ) -> Result<TxBuilder<'_, LegacyTracker<D>, DefaultCoinSelectionAlgorithm, BumpFee>, Error>
     {
-        let spendable_collection = self.as_spendable_collection();
-        let fallback_height = self.get_current_known_block_height().unwrap_or(0_u32);
+        let multi_tracker = self.as_multi_tracker();
 
-        Self::_build_fee_bump(
-            spendable_collection,
-            self.secp.clone(),
-            fallback_height,
-            txid,
-        )
+        Self::_build_fee_bump(multi_tracker, self.secp.clone(), txid)
     }
 
-    pub(crate) fn _build_fee_bump<'a, Sc: SpendableCollection>(
-        spendable_collection: Sc,
+    pub(crate) fn _build_fee_bump<'a, Mt: MultiTracker>(
+        multi_tracker: Mt,
         secp: SecpCtx,
-        fallback_height: u32,
         txid: Txid,
-    ) -> Result<TxBuilder<'a, D, Sc, DefaultCoinSelectionAlgorithm, BumpFee>, Error> {
-        let (mut tx, tx_fee) = match spendable_collection.get_tx(&txid)? {
+    ) -> Result<TxBuilder<'a, Mt, DefaultCoinSelectionAlgorithm, BumpFee>, Error> {
+        let (mut tx, tx_fee) = match multi_tracker.get_tx(&txid)? {
             None => return Err(Error::TransactionNotFound),
             Some(TransactionItem {
                 confirmed: Some(_), ..
@@ -1019,11 +1000,11 @@ where
         let original_utxos = original_txin
             .iter()
             .map(|txin| -> Result<_, Error> {
-                let txout = spendable_collection
+                let txout = multi_tracker
                     .get_output(&txin.previous_output)?
                     .ok_or(Error::UnknownUtxo)?;
 
-                let path = spendable_collection.get_path_of_script_pubkey(&txout.script_pubkey)?;
+                let path = multi_tracker.get_path_of_script_pubkey(&txout.script_pubkey)?;
                 let (weight, keychain) = match path {
                     Some((item, _)) => {
                         let weight = item.descriptor.max_satisfaction_weight().unwrap();
@@ -1058,7 +1039,7 @@ where
             let mut change_index = None;
 
             for (index, txout) in tx.output.iter().enumerate() {
-                let path = spendable_collection.get_path_of_script_pubkey(&txout.script_pubkey)?;
+                let path = multi_tracker.get_path_of_script_pubkey(&txout.script_pubkey)?;
 
                 if let Some((item, _)) = path {
                     // Prioritize internal inputs
@@ -1090,12 +1071,10 @@ where
         };
 
         Ok(TxBuilder {
-            spendable_collection,
+            multi_tracker,
             params,
             coin_selection: DefaultCoinSelectionAlgorithm::default(),
             phantom: core::marker::PhantomData,
-            phantom_database: core::marker::PhantomData,
-            fallback_height,
             secp,
         })
     }
@@ -1131,25 +1110,13 @@ where
         psbt: &mut psbt::PartiallySignedTransaction,
         sign_options: SignOptions,
     ) -> Result<bool, Error> {
-        let spendable_collection = self.as_spendable_collection();
+        let spendable_collection = self.as_multi_tracker();
 
-        let fallback_block_height = self
-            .database()
-            .get_sync_time()?
-            .map(|sync_time| sync_time.block_time.height);
-
-        Self::_sign(
-            &spendable_collection,
-            fallback_block_height,
-            &self.secp,
-            psbt,
-            sign_options,
-        )
+        Self::_sign(&spendable_collection, &self.secp, psbt, sign_options)
     }
 
-    pub(crate) fn _sign<Sc: SpendableCollection>(
+    pub(crate) fn _sign<Sc: MultiTracker>(
         spendable_collection: &Sc,
-        fallback_block_height: Option<u32>,
         secp: &SecpCtx,
         psbt: &mut psbt::PartiallySignedTransaction,
         sign_options: SignOptions,
@@ -1190,13 +1157,7 @@ where
 
         // attempt to finalize
         if sign_options.try_finalize {
-            Self::_finalize_psbt(
-                spendable_collection,
-                fallback_block_height,
-                secp,
-                psbt,
-                sign_options,
-            )
+            Self::_finalize_psbt(spendable_collection, secp, psbt, sign_options)
         } else {
             Ok(false)
         }
@@ -1242,25 +1203,13 @@ where
         psbt: &mut psbt::PartiallySignedTransaction,
         sign_options: SignOptions,
     ) -> Result<bool, Error> {
-        let spendable_collection = self.as_spendable_collection();
-
-        let fallback_block_height = self
-            .database()
-            .get_sync_time()?
-            .map(|sync_time| sync_time.block_time.height);
+        let spendable_collection = self.as_multi_tracker();
 
-        Self::_finalize_psbt(
-            &spendable_collection,
-            fallback_block_height,
-            &self.secp,
-            psbt,
-            sign_options,
-        )
+        Self::_finalize_psbt(&spendable_collection, &self.secp, psbt, sign_options)
     }
 
-    pub(crate) fn _finalize_psbt<Sc: SpendableCollection>(
+    pub(crate) fn _finalize_psbt<Sc: MultiTracker>(
         spendable_collection: &Sc,
-        fallback_block_height: Option<u32>,
         secp: &SecpCtx,
         psbt: &mut psbt::PartiallySignedTransaction,
         sign_options: SignOptions,
@@ -1281,7 +1230,9 @@ where
             let create_height = spendable_collection
                 .get_tx(&input.previous_output.txid)?
                 .map(|tx| tx.confirmed.map_or(u32::MAX, |c| c.height));
-            let last_sync_height = fallback_block_height;
+            let last_sync_height = spendable_collection
+                .latest_blockheight()?
+                .map(|bt| bt.height);
             let current_height = sign_options.assume_height.or(last_sync_height);
 
             debug!(
@@ -1386,6 +1337,7 @@ where
     }
 
     // TODO @evanlinjin: Move out of [`Wallet`].
+    #[allow(deprecated)]
     fn _fetch_and_increment_index(
         database: &RefCell<D>,
         secp: &SecpCtx,
@@ -1512,7 +1464,7 @@ where
         current_height: Option<u32>,
     ) -> Result<(Vec<WeightedUtxo>, Vec<WeightedUtxo>), Error>
     where
-        Sc: SpendableCollection,
+        Sc: MultiTracker,
     {
         // NOTE: we are intentionally ignoring `unspendable` here. i.e manual
         // selection overrides unspendable.
@@ -1523,7 +1475,7 @@ where
         //    must_spend <- manually selected utxos
         //    may_spend  <- all other available utxos
         let mut may_spend = spendable_collection
-            .iter_utxos()?
+            .iter_unspent()?
             .filter(|(utxo, _)| {
                 let is_manually_selected = manually_selected
                     .iter()
@@ -1602,7 +1554,7 @@ where
         secp: &SecpCtx,
     ) -> Result<psbt::PartiallySignedTransaction, Error>
     where
-        Sc: SpendableCollection,
+        Sc: MultiTracker,
     {
         let mut psbt = psbt::PartiallySignedTransaction::from_unsigned_tx(tx)?;
 
@@ -1738,7 +1690,7 @@ where
         sighash_type: Option<psbt::PsbtSighashType>,
         only_witness_utxo: bool,
     ) -> Result<psbt::Input, Error> {
-        let spendable_collection = self.as_spendable_collection();
+        let spendable_collection = self.as_multi_tracker();
         Self::_get_psbt_input(
             &spendable_collection,
             &self.secp,
@@ -1750,7 +1702,7 @@ where
 
     /// TODO @evanlinjin: Move out of [`Wallet`].
     /// * Should this method be renamed to `make_psbt_input`?
-    fn _get_psbt_input<Sc: SpendableCollection>(
+    fn _get_psbt_input<Sc: MultiTracker>(
         spendable_collection: &Sc,
         secp: &SecpCtx,
         utxo: LocalUtxo,
@@ -1816,7 +1768,7 @@ where
         psbt: &mut psbt::PartiallySignedTransaction,
     ) -> Result<(), Error>
     where
-        Sc: SpendableCollection,
+        Sc: MultiTracker,
     {
         let input_utxos = (0..psbt.inputs.len())
             .map(|i| psbt.get_utxo_for(i))
@@ -1993,7 +1945,7 @@ pub(crate) mod test {
 
     use crate::database::Database;
     use crate::types::KeychainKind;
-    use crate::wallet::spendable_collection::SpendableCollectionInner;
+    use crate::wallet::multi_tracker::MultiTrackerInner;
 
     use super::*;
     use crate::signer::{SignOptions, SignerError};
@@ -2494,8 +2446,8 @@ pub(crate) mod test {
         let (wallet, _, _) = get_funded_wallet(get_test_wpkh());
         let addr = wallet.get_address(New).unwrap();
         let utxos: Vec<_> = wallet
-            .as_spendable_collection()
-            .iter_utxos()
+            .as_multi_tracker()
+            .iter_unspent()
             .unwrap()
             // .into_iter()
             .map(|(u, _)| u.outpoint)
diff --git a/src/wallet/spendable_collection.rs b/src/wallet/multi_tracker.rs
similarity index 84%
rename from src/wallet/spendable_collection.rs
rename to src/wallet/multi_tracker.rs
index e89ada74d..af0de7602 100644
--- a/src/wallet/spendable_collection.rs
+++ b/src/wallet/multi_tracker.rs
@@ -1,11 +1,12 @@
-///! SpendableCollection
+///! MultiTracker
 ///
-/// This module defines the [`SpendableCollection`] trait.
+/// This module defines the [`MultiTracker`] trait.
 use std::{cell::RefCell, collections::HashMap, sync::Arc};
 
 use bitcoin::{Network, OutPoint, Script, Transaction, TxOut, Txid};
 use miniscript::DescriptorTrait;
 
+#[allow(deprecated)]
 use crate::{
     address_validator::AddressValidator,
     database::{BatchDatabase, DatabaseUtils},
@@ -38,9 +39,12 @@ pub struct TransactionItem {
     pub fees: Option<u64>,
 }
 
-/// Contains the "required" methods of [`SpendableCollection`], where all other methods could be
+/// Contains the "required" methods of [`MultiTracker`], where all other methods could be
 /// deried from (albiet probably not in an optimised manner).
-pub trait SpendableCollectionInner {
+///
+/// TODO @evanlinjin: Should we have an `iter_txout` method as defined in `bdk_core`?
+/// <https://github.com/LLFourn/bdk_core_staging/blob/67d1e5499b0eb1de59f652c433c88942646593b3/bdk_core/src/descriptor_tracker.rs#L873>
+pub trait MultiTrackerInner {
     /// Returns an iterator that ranges through all owned descriptors.
     fn iter_descriptors(&self) -> Result<Box<dyn Iterator<Item = DescriptorItem> + '_>, Error>;
 
@@ -50,20 +54,23 @@ pub trait SpendableCollectionInner {
     ) -> Result<Box<dyn Iterator<Item = Arc<dyn TransactionSigner>> + '_>, Error>;
 
     /// Obtains owned UTXOs alongside their satisfaction weights.
-    ///     Warning: It is possible that the returned list contains a UTXO currently used as an
-    ///     unconfirmed tx input.
-    fn iter_utxos(&self) -> Result<Box<dyn Iterator<Item = (LocalUtxo, usize)> + '_>, Error>;
+    ///
+    /// TODO @evanlinjin: We should have our own structure for Unspents.
+    /// Fields that make sense =>
+    /// * Confirmed height.
+    /// * Descriptor + Child index.
+    /// * Satisfaction weight of scriptPubKey (weight of corresponding scriptSig/witness data).
+    fn iter_unspent(&self) -> Result<Box<dyn Iterator<Item = (LocalUtxo, usize)> + '_>, Error>;
 
     /// Obtains transaction (and details) of given txid.
     ///
     /// Internally, we should include atleast all transactions containing owned and spendable UTXOs
     /// of the given descriptors (internal and external).
-    /// However, having extra and unnecessary transactions should not hurt (TODO @evanlinjin:
-    /// confirm this).
-    ///
-    /// TODO @evanlinjin: Maybe this should be in it's own trait?
     fn get_tx(&self, txid: &Txid) -> Result<Option<TransactionItem>, Error>;
 
+    /// Obtains the latest block height of internal trackers.
+    fn latest_blockheight(&self) -> Result<Option<BlockTime>, Error>;
+
     /// Returns a fresh/unused address derived from given descriptor. This is currently used for
     /// obtaining a change/drain address.
     #[deprecated(note = "Change selection should be in it's separate step")]
@@ -72,7 +79,7 @@ pub trait SpendableCollectionInner {
 
 /// Represents a collection of owned and spendable `UTXO`s, `ExtendedDescriptor`s and associated
 /// `Transaction`s.
-pub trait SpendableCollection: SpendableCollectionInner {
+pub trait MultiTracker: MultiTrackerInner {
     /// Obtains parent [`ExtendedDescriptor`] and child index of the provided `ScriptPubKey`.
     /// Note that if the script is not owned, None shoud be returned.
     fn get_path_of_script_pubkey(
@@ -99,7 +106,7 @@ pub trait SpendableCollection: SpendableCollectionInner {
     /// Obtain a local UTXO given the provided outpoint.
     /// The default implementation is very inefficient and should be overloaded.
     fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<LocalUtxo>, Error> {
-        Ok(self.iter_utxos()?.find_map(|(utxo, _)| {
+        Ok(self.iter_unspent()?.find_map(|(utxo, _)| {
             if &utxo.outpoint == outpoint {
                 Some(utxo)
             } else {
@@ -145,9 +152,9 @@ pub trait SpendableCollection: SpendableCollectionInner {
     }
 }
 
-/// Implements [`SpendableCollection`] with one external descriptor and an optional internal descriptor.
+/// Implements [`MultiTracker`] with one external descriptor and an optional internal descriptor.
 // #[derive(Clone)]
-pub struct SpendableDatabase<'a, D> {
+pub struct LegacyTracker<'a, D> {
     descriptor: &'a ExtendedDescriptor,
     change_descriptor: Option<&'a ExtendedDescriptor>,
     network: Network,
@@ -155,10 +162,11 @@ pub struct SpendableDatabase<'a, D> {
 
     pub(crate) db: &'a RefCell<D>,
     pub(crate) signers: Vec<Arc<SignersContainer>>, // [external, internal]
+    #[allow(deprecated)]
     pub(crate) address_validators: Vec<Arc<dyn AddressValidator>>,
 }
 
-impl<'a, D: BatchDatabase> Clone for SpendableDatabase<'a, D> {
+impl<'a, D: BatchDatabase> Clone for LegacyTracker<'a, D> {
     fn clone(&self) -> Self {
         Self {
             descriptor: self.descriptor,
@@ -172,10 +180,10 @@ impl<'a, D: BatchDatabase> Clone for SpendableDatabase<'a, D> {
     }
 }
 
-/// [`SpendableCollection`] `::DescIter` implementation for [`SpendableDatabase`].
-pub struct DatabaseDescIter<'a, D>(SpendableDatabase<'a, D>, usize);
+/// [`MultiTracker`] descriptor iterator implementation for [`LegacyTracker`].
+pub struct LegacyDescIter<'a, D>(LegacyTracker<'a, D>, usize);
 
-impl<'a, D> Iterator for DatabaseDescIter<'a, D> {
+impl<'a, D> Iterator for LegacyDescIter<'a, D> {
     type Item = DescriptorItem;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -197,7 +205,7 @@ impl<'a, D> Iterator for DatabaseDescIter<'a, D> {
     }
 }
 
-impl<'a, D> ExactSizeIterator for DatabaseDescIter<'a, D> {
+impl<'a, D> ExactSizeIterator for LegacyDescIter<'a, D> {
     fn len(&self) -> usize {
         let start_count = if self.0.change_descriptor.is_some() {
             2
@@ -208,8 +216,9 @@ impl<'a, D> ExactSizeIterator for DatabaseDescIter<'a, D> {
     }
 }
 
-impl<'a, D: BatchDatabase> SpendableDatabase<'a, D> {
-    /// Creates a new [`SpendableDatabase`].
+impl<'a, D: BatchDatabase> LegacyTracker<'a, D> {
+    /// Creates a new [`LegacyTracker`].
+    #[allow(deprecated)]
     pub fn new(
         descriptor: &'a ExtendedDescriptor,
         change_descriptor: Option<&'a ExtendedDescriptor>,
@@ -231,9 +240,9 @@ impl<'a, D: BatchDatabase> SpendableDatabase<'a, D> {
     }
 }
 
-impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D> {
+impl<'a, D: BatchDatabase> MultiTrackerInner for LegacyTracker<'a, D> {
     fn iter_descriptors(&self) -> Result<Box<dyn Iterator<Item = DescriptorItem> + '_>, Error> {
-        Ok(Box::new(DatabaseDescIter::<'_>(self.clone(), 0)))
+        Ok(Box::new(LegacyDescIter::<'_>(self.clone(), 0)))
     }
 
     fn iter_signers(
@@ -259,7 +268,7 @@ impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D>
     ///
     /// For now, we need to ensure the aforementioned relationship is sufficiently cached to
     /// avoid "missing" available UTXOs.
-    fn iter_utxos(&self) -> Result<Box<dyn Iterator<Item = (LocalUtxo, usize)> + '_>, Error> {
+    fn iter_unspent(&self) -> Result<Box<dyn Iterator<Item = (LocalUtxo, usize)> + '_>, Error> {
         let utxos = self
             .db
             .borrow()
@@ -290,6 +299,13 @@ impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D>
             }))
     }
 
+    fn latest_blockheight(&self) -> Result<Option<BlockTime>, Error> {
+        self.db
+            .borrow()
+            .get_sync_time()
+            .map(|opt| opt.map(|sync_time| sync_time.block_time))
+    }
+
     fn new_address(&self, desc: &ExtendedDescriptor) -> Result<AddressInfo, Error> {
         let keychain = if desc == self.descriptor {
             KeychainKind::External
@@ -310,7 +326,7 @@ impl<'a, D: BatchDatabase> SpendableCollectionInner for SpendableDatabase<'a, D>
     }
 }
 
-impl<'a, D: BatchDatabase> SpendableCollection for SpendableDatabase<'a, D> {
+impl<'a, D: BatchDatabase> MultiTracker for LegacyTracker<'a, D> {
     fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<LocalUtxo>, Error> {
         self.db.borrow().get_utxo(outpoint)
     }
diff --git a/src/wallet/tx_builder.rs b/src/wallet/tx_builder.rs
index 5d2f32eab..9e137fb02 100644
--- a/src/wallet/tx_builder.rs
+++ b/src/wallet/tx_builder.rs
@@ -47,16 +47,17 @@ use bitcoin::{OutPoint, Script, Transaction};
 use miniscript::DescriptorTrait;
 
 use super::coin_selection::{CoinSelectionAlgorithm, DefaultCoinSelectionAlgorithm};
-use super::spendable_collection::SpendableCollection;
+use super::multi_tracker::MultiTracker;
 use super::utils::SecpCtx;
+use crate::database::MemoryDatabase;
 use crate::descriptor::ExtendedDescriptor;
 use crate::SignOptions;
 use crate::Wallet;
-use crate::{database::BatchDatabase, Error, Utxo};
 use crate::{
     types::{FeeRate, KeychainKind, LocalUtxo, WeightedUtxo},
     TransactionDetails,
 };
+use crate::{Error, Utxo};
 /// Context in which the [`TxBuilder`] is valid
 pub trait TxBuilderContext: std::fmt::Debug + Default + Clone {}
 
@@ -122,17 +123,12 @@ impl TxBuilderContext for BumpFee {}
 /// [`finish`]: Self::finish
 /// [`coin_selection`]: Self::coin_selection
 #[derive(Debug)]
-pub struct TxBuilder<'a, D, Sc, Cs, Ctx> {
-    pub(crate) spendable_collection: Sc,
+pub struct TxBuilder<'a, Mt, Cs, Ctx> {
+    pub(crate) multi_tracker: Mt,
     pub(crate) params: TxParams<'a>,
-    pub(crate) fallback_height: u32,
     pub(crate) coin_selection: Cs,
     pub(crate) secp: SecpCtx,
     pub(crate) phantom: PhantomData<Ctx>,
-
-    /// TODO @evanlinjin: We can remove the generic type parameter `D` once we actually
-    /// move the various methods out of [`Wallet`].
-    pub(crate) phantom_database: PhantomData<D>,
 }
 
 /// The parameters for transaction creation sans coin selection algorithm.
@@ -179,45 +175,36 @@ impl std::default::Default for FeePolicy {
     }
 }
 
-impl<'a, D, Sc: Clone, Cs: Clone, Ctx> Clone for TxBuilder<'a, D, Sc, Cs, Ctx> {
+impl<'a, Mt: Clone, Cs: Clone, Ctx> Clone for TxBuilder<'a, Mt, Cs, Ctx> {
     fn clone(&self) -> Self {
         TxBuilder {
-            spendable_collection: self.spendable_collection.clone(),
+            multi_tracker: self.multi_tracker.clone(),
             params: self.params.clone(),
             coin_selection: self.coin_selection.clone(),
-            fallback_height: self.fallback_height,
             phantom: PhantomData,
-            phantom_database: self.phantom_database,
             secp: self.secp.clone(),
         }
     }
 }
 
-impl<'a, D: BatchDatabase, Sc: SpendableCollection, Ctx: TxBuilderContext>
-    TxBuilder<'a, D, Sc, DefaultCoinSelectionAlgorithm, Ctx>
+impl<'a, Mt: MultiTracker, Ctx: TxBuilderContext>
+    TxBuilder<'a, Mt, DefaultCoinSelectionAlgorithm, Ctx>
 {
     /// Creates a new [`TxBuilder`]
-    pub fn new(spendables: Sc, fallback_block_height: u32) -> Self {
+    pub fn new(multi_tracker: Mt) -> Self {
         Self {
-            spendable_collection: spendables,
+            multi_tracker,
             params: TxParams::default(),
             coin_selection: DefaultCoinSelectionAlgorithm::default(),
-            fallback_height: fallback_block_height,
             secp: SecpCtx::new(),
             phantom: core::marker::PhantomData,
-            phantom_database: core::marker::PhantomData,
         }
     }
 }
 
 // methods supported by both contexts, for any CoinSelectionAlgorithm
-impl<
-        'a,
-        D: BatchDatabase,
-        Sc: SpendableCollection,
-        Cs: CoinSelectionAlgorithm,
-        Ctx: TxBuilderContext,
-    > TxBuilder<'a, D, Sc, Cs, Ctx>
+impl<'a, Mt: MultiTracker, Cs: CoinSelectionAlgorithm, Ctx: TxBuilderContext>
+    TxBuilder<'a, Mt, Cs, Ctx>
 {
     /// Set a custom fee rate
     pub fn fee_rate(&mut self, fee_rate: FeeRate) -> &mut Self {
@@ -314,7 +301,7 @@ impl<
         let utxos = outpoints
             .iter()
             .map(|outpoint| {
-                self.spendable_collection
+                self.multi_tracker
                     .get_utxo(outpoint)?
                     .ok_or(Error::UnknownUtxo)
             })
@@ -323,7 +310,7 @@ impl<
         let weighted_utxos = utxos
             .into_iter()
             .map(|utxo| {
-                self.spendable_collection
+                self.multi_tracker
                     .get_path_of_script_pubkey(&utxo.txout.script_pubkey)?
                     .map(|(item, _)| {
                         let utxo = Utxo::Local(utxo);
@@ -560,14 +547,12 @@ impl<
     pub fn coin_selection<P: CoinSelectionAlgorithm>(
         self,
         coin_selection: P,
-    ) -> TxBuilder<'a, D, Sc, P, Ctx> {
+    ) -> TxBuilder<'a, Mt, P, Ctx> {
         TxBuilder {
-            spendable_collection: self.spendable_collection,
+            multi_tracker: self.multi_tracker,
             params: self.params,
             coin_selection,
-            fallback_height: self.fallback_height,
             phantom: PhantomData,
-            phantom_database: self.phantom_database,
             secp: self.secp,
         }
     }
@@ -578,28 +563,24 @@ impl<
     ///
     /// [`BIP174`]: https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
     pub fn finish(self) -> Result<(Psbt, TransactionDetails), Error> {
-        // TODO @evalinjin: Get rid of the D. #NoPunIntended
-        Wallet::<D>::_create_tx(
-            &self.spendable_collection,
+        Wallet::<MemoryDatabase>::_create_tx(
+            &self.multi_tracker,
             self.coin_selection,
             self.params,
-            self.fallback_height,
             &self.secp,
         )
     }
 
     /// Finishes and signs the transaction.
     pub fn finish_and_sign(self, sign_options: SignOptions) -> Result<SignedResult, Error> {
-        let (mut psbt, details) = Wallet::<D>::_create_tx(
-            &self.spendable_collection,
+        let (mut psbt, details) = Wallet::<MemoryDatabase>::_create_tx(
+            &self.multi_tracker,
             self.coin_selection,
             self.params,
-            self.fallback_height,
             &self.secp,
         )?;
-        let is_finalized = Wallet::<D>::_sign(
-            &self.spendable_collection,
-            None,
+        let is_finalized = Wallet::<MemoryDatabase>::_sign(
+            &self.multi_tracker,
             &self.secp,
             &mut psbt,
             sign_options,
@@ -649,9 +630,7 @@ impl<
     }
 }
 
-impl<'a, D: BatchDatabase, Sc: SpendableCollection, Cs: CoinSelectionAlgorithm>
-    TxBuilder<'a, D, Sc, Cs, CreateTx>
-{
+impl<'a, Mt: MultiTracker, Cs: CoinSelectionAlgorithm> TxBuilder<'a, Mt, Cs, CreateTx> {
     /// Replace the recipients already added with a new list
     pub fn set_recipients(&mut self, recipients: Vec<(Script, u64)>) -> &mut Self {
         self.params.recipients = recipients;
@@ -722,12 +701,10 @@ impl<'a, D: BatchDatabase, Sc: SpendableCollection, Cs: CoinSelectionAlgorithm>
 }
 
 // methods supported only by bump_fee
-impl<'a, D: BatchDatabase, Sc: SpendableCollection>
-    TxBuilder<'a, D, Sc, DefaultCoinSelectionAlgorithm, BumpFee>
-{
+impl<'a, Mt: MultiTracker> TxBuilder<'a, Mt, DefaultCoinSelectionAlgorithm, BumpFee> {
     /// New transaction builder for fee bump.
-    pub fn new_fee_bump(spendables: Sc, txid: Txid, fallback_height: u32) -> Result<Self, Error> {
-        Wallet::<D>::_build_fee_bump(spendables, SecpCtx::new(), fallback_height, txid)
+    pub fn new_fee_bump(multi_tracker: Mt, txid: Txid) -> Result<Self, Error> {
+        Wallet::<MemoryDatabase>::_build_fee_bump(multi_tracker, SecpCtx::new(), txid)
     }
 
     /// Explicitly tells the wallet that it is allowed to reduce the amount of the output matching this

From 128eeb04c2068c0970d148095023fdb5e66f81bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Thu, 14 Jul 2022 20:54:10 +0800
Subject: [PATCH 10/16] WIP: Introduce LocalOutputItem

---
 src/wallet/multi_tracker.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/wallet/multi_tracker.rs b/src/wallet/multi_tracker.rs
index af0de7602..0ce639fb1 100644
--- a/src/wallet/multi_tracker.rs
+++ b/src/wallet/multi_tracker.rs
@@ -39,6 +39,23 @@ pub struct TransactionItem {
     pub fees: Option<u64>,
 }
 
+/// Contains a local tx output and it's associated data
+/// TODO @evanlinjin: Figure out if this is useful
+#[derive(Debug, Clone)]
+pub struct LocalOutputItem {
+    /// References this output
+    pub outpoint: OutPoint,
+    /// The actual tx output
+    pub txout: TxOut,
+    /// Confirmation time (if any) of the tx that contains this output
+    pub confirmed: Option<BlockTime>,
+    /// Path for `scriptPubKey` creation (descriptor_item, child_index)
+    pub script_path: (DescriptorItem, u32),
+    /// Satisfaction weight for the `scriptPubKey` (required weight of corresponding
+    /// `scriptSig`/`witness` data)
+    pub satisfaction_weight: u32,
+}
+
 /// Contains the "required" methods of [`MultiTracker`], where all other methods could be
 /// deried from (albiet probably not in an optimised manner).
 ///

From 930f3f12238b386b1c1fe79cad43d8c9b61925b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Sun, 17 Jul 2022 08:00:52 +0800
Subject: [PATCH 11/16] WIP: Add header comments for multi_tracker.rs

---
 src/wallet/multi_tracker.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/wallet/multi_tracker.rs b/src/wallet/multi_tracker.rs
index 0ce639fb1..e5aca843e 100644
--- a/src/wallet/multi_tracker.rs
+++ b/src/wallet/multi_tracker.rs
@@ -1,3 +1,14 @@
+// Bitcoin Dev Kit
+// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+//
+// Copyright (c) 2020-2022 Bitcoin Dev Kit Developers
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
 ///! MultiTracker
 ///
 /// This module defines the [`MultiTracker`] trait.

From ff7a93c5c2663f5d8cf46aad83191dbd8946f074 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Sun, 17 Jul 2022 08:09:51 +0800
Subject: [PATCH 12/16] WIP: Reduce iterations for
 MultiTracker:get_path_of_script_pubkey and comments

---
 src/wallet/multi_tracker.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/wallet/multi_tracker.rs b/src/wallet/multi_tracker.rs
index e5aca843e..b9d7e98e3 100644
--- a/src/wallet/multi_tracker.rs
+++ b/src/wallet/multi_tracker.rs
@@ -110,6 +110,8 @@ pub trait MultiTrackerInner {
 pub trait MultiTracker: MultiTrackerInner {
     /// Obtains parent [`ExtendedDescriptor`] and child index of the provided `ScriptPubKey`.
     /// Note that if the script is not owned, None shoud be returned.
+    ///
+    /// The default implementation of this method is very inefficient and should be overloaded.
     fn get_path_of_script_pubkey(
         &self,
         script: &Script,
@@ -118,7 +120,7 @@ pub trait MultiTracker: MultiTrackerInner {
 
         let secp = SecpCtx::new();
 
-        for index in 0..2100_u32 {
+        for index in 0..200_u32 {
             for item in &descriptors {
                 let desc = item.descriptor.clone();
                 let derived_script = desc.as_derived(index, &secp).script_pubkey();
@@ -395,7 +397,7 @@ impl<'a, D: BatchDatabase> MultiTracker for LegacyTracker<'a, D> {
 
         let descriptors = self.iter_descriptors()?.collect::<Vec<_>>();
 
-        for index in start..start + 2100_u32 {
+        for index in start..start + 200_u32 {
             for item in &descriptors {
                 let derived_script = item
                     .descriptor

From 7649de62edc4610107c852185e87780a05a92ee6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Sun, 17 Jul 2022 10:18:08 +0800
Subject: [PATCH 13/16] WIP: Fix `MultiTracker::get_output` logic

It should return `Ok(None)` when tx is not found, but return `Err` when
`OutPoint.vout` is invalid.
---
 src/wallet/multi_tracker.rs | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/wallet/multi_tracker.rs b/src/wallet/multi_tracker.rs
index b9d7e98e3..351b962c1 100644
--- a/src/wallet/multi_tracker.rs
+++ b/src/wallet/multi_tracker.rs
@@ -148,16 +148,14 @@ pub trait MultiTracker: MultiTrackerInner {
     /// Obtain output of the provided outpoint.
     /// Output may not be owned by us, just be part of a transaction that we are keeping track of.
     fn get_output(&self, outpoint: &OutPoint) -> Result<Option<TxOut>, Error> {
-        self.get_tx(&outpoint.txid)?.map_or_else(
-            || Err(Error::InvalidOutpoint(*outpoint)),
-            |tx_item| {
-                Ok(tx_item
-                    .raw
-                    .output
-                    .get(outpoint.vout as usize)
-                    .map(Clone::clone))
-            },
-        )
+        match self.get_tx(&outpoint.txid)? {
+            // return error if vout is invalid
+            Some(tx) => tx.raw.output.get(outpoint.vout as usize).map_or_else(
+                || Err(Error::InvalidOutpoint(*outpoint)),
+                |tx_out| Ok(Some(tx_out.clone())),
+            ),
+            None => Ok(None),
+        }
     }
 
     /// Returns whether given script is owned by us, or not.

From 400dbd19d9ae4c094da74213cb22ec1eef8a2e69 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Sun, 17 Jul 2022 10:24:03 +0800
Subject: [PATCH 14/16] WIP: Fix `MultiTracker::new_auto_address` logic

---
 src/wallet/multi_tracker.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/wallet/multi_tracker.rs b/src/wallet/multi_tracker.rs
index 351b962c1..c330d8260 100644
--- a/src/wallet/multi_tracker.rs
+++ b/src/wallet/multi_tracker.rs
@@ -167,12 +167,12 @@ pub trait MultiTracker: MultiTrackerInner {
     /// Obtains a new change address without a descriptor provided explicitly
     #[deprecated]
     fn new_auto_address(&self) -> Result<AddressInfo, Error> {
-        let (mut internal, mut external): (Vec<_>, Vec<_>) = self
+        let (internal, external): (Vec<_>, Vec<_>) = self
             .iter_descriptors()?
             .partition(|item| item.keychain == KeychainKind::Internal);
 
-        internal.append(&mut external);
-
+        // This should obtain the internal descriptor (if exists), all obtains the external
+        // descriptor as fallback.
         let item = internal.iter().chain(external.iter()).next().unwrap();
 
         #[allow(deprecated)]

From 2a302d2c7ef344331a23ee094b4bc52b106297c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Sun, 17 Jul 2022 10:38:57 +0800
Subject: [PATCH 15/16] WIP: Fix documentation in `coin_selection.rs`

---
 src/wallet/coin_selection.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/wallet/coin_selection.rs b/src/wallet/coin_selection.rs
index bffc530c1..702863c4a 100644
--- a/src/wallet/coin_selection.rs
+++ b/src/wallet/coin_selection.rs
@@ -141,15 +141,15 @@ impl CoinSelectionResult {
 
 /// Trait for generalized coin selection algorithms
 ///
-/// This trait can be implemented to make the [`Wallet`](super::Wallet) use a customized coin
-/// selection algorithm when it creates transactions.
+/// This trait can be implemented to make the [`TxBuilder`](super::tx_builder::TxBuilder) use a
+/// customized coin selection algorithm when it creates transactions.
 ///
 /// For an example see [this module](crate::wallet::coin_selection)'s documentation.
 pub trait CoinSelectionAlgorithm: std::fmt::Debug {
     /// Perform the coin selection
     ///
-    /// - `database`: a reference to the wallet's database that can be used to lookup additional
-    ///               details for a specific UTXO
+    /// - `multi_tracker`: a reference to the multi-descriptor tracker that can be used to lookup
+    ///                     additional details for a specific UTXO
     /// - `required_utxos`: the utxos that must be spent regardless of `amount_needed` with their
     ///                     weight cost
     /// - `optional_utxos`: the remaining available utxos to satisfy `amount_needed` with their
@@ -158,9 +158,9 @@ pub trait CoinSelectionAlgorithm: std::fmt::Debug {
     /// - `amount_needed`: the amount in satoshi to select
     /// - `fee_amount`: the amount of fees in satoshi already accumulated from adding outputs and
     ///                 the transaction's header
-    fn coin_select<Sc: MultiTracker>(
+    fn coin_select<Mt: MultiTracker>(
         &self,
-        database: &Sc,
+        multi_tracker: &Mt,
         required_utxos: Vec<WeightedUtxo>,
         optional_utxos: Vec<WeightedUtxo>,
         fee_rate: FeeRate,
@@ -177,9 +177,9 @@ pub trait CoinSelectionAlgorithm: std::fmt::Debug {
 pub struct LargestFirstCoinSelection;
 
 impl CoinSelectionAlgorithm for LargestFirstCoinSelection {
-    fn coin_select<D: MultiTracker>(
+    fn coin_select<Mt: MultiTracker>(
         &self,
-        _database: &D,
+        _multi_tracker: &Mt,
         required_utxos: Vec<WeightedUtxo>,
         mut optional_utxos: Vec<WeightedUtxo>,
         fee_rate: FeeRate,
@@ -215,9 +215,9 @@ impl CoinSelectionAlgorithm for LargestFirstCoinSelection {
 pub struct OldestFirstCoinSelection;
 
 impl CoinSelectionAlgorithm for OldestFirstCoinSelection {
-    fn coin_select<D: MultiTracker>(
+    fn coin_select<Mt: MultiTracker>(
         &self,
-        database: &D,
+        multi_tracker: &Mt,
         required_utxos: Vec<WeightedUtxo>,
         mut optional_utxos: Vec<WeightedUtxo>,
         fee_rate: FeeRate,
@@ -234,7 +234,7 @@ impl CoinSelectionAlgorithm for OldestFirstCoinSelection {
                     if bh_acc.contains_key(&txid) {
                         Ok(bh_acc)
                     } else {
-                        database.get_tx(&txid).map(|details| {
+                        multi_tracker.get_tx(&txid).map(|details| {
                             let conf_time =
                                 details.and_then(|tx| tx.confirmed.map(|conf| conf.height));
                             bh_acc.insert(txid, conf_time);
@@ -362,9 +362,9 @@ impl BranchAndBoundCoinSelection {
 const BNB_TOTAL_TRIES: usize = 100_000;
 
 impl CoinSelectionAlgorithm for BranchAndBoundCoinSelection {
-    fn coin_select<D: MultiTracker>(
+    fn coin_select<Mt: MultiTracker>(
         &self,
-        _database: &D,
+        _multi_tracker: &Mt,
         required_utxos: Vec<WeightedUtxo>,
         optional_utxos: Vec<WeightedUtxo>,
         fee_rate: FeeRate,

From 7432b07ad36942de3884d35906748d79c7e76183 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BF=97=E5=AE=87?= <hello@evanlinjin.me>
Date: Sun, 17 Jul 2022 10:51:25 +0800
Subject: [PATCH 16/16] WIP: Provide error message for
 `coin_selection::test::tx`

---
 src/wallet/coin_selection.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/wallet/coin_selection.rs b/src/wallet/coin_selection.rs
index 702863c4a..8d025a881 100644
--- a/src/wallet/coin_selection.rs
+++ b/src/wallet/coin_selection.rs
@@ -680,7 +680,7 @@ mod test {
     fn tx(utxo: &mut WeightedUtxo, lock_time: u32) -> (Transaction, Txid) {
         let local = match &mut utxo.utxo {
             Utxo::Local(local) => local,
-            _ => panic!(),
+            _ => panic!("utxo should be a `LocalUtxo`"),
         };
         let tx = Transaction {
             version: 2,