fix(key-wallet): defer CoinSelector candidate filter to Utxo::is_spendable

`CoinSelector` carried its own confirmation policy
(`min_confirmations`, `include_unconfirmed`) and filtered candidates
with `(include_unconfirmed || is_confirmed || is_instantlocked)` plus
a `current_height - utxo.height >= min_confirmations` depth check.
Two consequences:

  1. `is_trusted` was missing from the OR — mempool change from a tx
     the wallet itself authored was rejected, even though the balance
     UI shows it as spendable. Users hit this as
     `CoinSelection(NoUtxosAvailable)` immediately after sending.
  2. The depth check used `>= 1`, which silently rejected a UTXO mined
     into the wallet's tip block (depth 0, but 1 confirmation in the
     usual sense), and gated all unconfirmed incoming through the same
     path.

The `Utxo` itself already has `is_spendable(current_height)` — which
checks not-locked and coinbase maturity — and the wallet decides what
to put in the UTXO map (with `is_confirmed`, `is_instantlocked`,
`is_trusted` flags reflecting its policy). The coin selector having a
*second*, divergent policy on top is what produced the bug.

Drop the duplicated machinery: remove `min_confirmations`,
`include_unconfirmed`, and the per-call helpers. Both filter sites
now defer to `Utxo::is_spendable`, so coin selection accepts every
UTXO the wallet tracks as spendable — confirmed, IS-locked, trusted
self-send change, and incoming mempool alike.

Tightens `tests_transaction_builder.rs` accordingly: the workaround
that mined an extra "bump" tx so `last_processed_height` advanced past
the funding UTXO is no longer needed.

All 482 key-wallet unit tests and 26 dashd_sync integration tests pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ZocoLini

dash-spv/tests/dashd_sync/tests_transaction_builder.rs

@@ -154,47 +154,23 @@ async fn test_spend_unconfirmed_change_balance() {
 
     // Step 1: fund the SPV wallet with a confirmed UTXO from dashd's
     // default wallet (an external sender, since it uses a different
-    // mnemonic). We then send a *second* small tx in a separate block so
-    // the wallet's `last_processed_height` advances past the funding UTXO's
-    // height — the coin selector filter `current_height - utxo.height >=
-    // min_confirmations` (default 1) silently skips UTXOs whose height
-    // equals the wallet's tip, even though they're visibly confirmed.
+    // mnemonic).
     let receive_address = reserve_first_address(EMPTY_MNEMONIC).await;
     let funding_amount = Amount::from_sat(500_000_000);
     let funding_txid = ctx.dashd.node.send_to_address(&receive_address, funding_amount);
     tracing::info!("Funded fresh SPV wallet with {}, txid: {}", funding_amount, funding_txid);
 
     let miner_address = ctx.dashd.node.get_new_address_from_wallet("default");
     ctx.dashd.node.generate_blocks(1, &miner_address);
-    let h_funded = ctx.dashd.initial_height + 1;
-    wait_for_sync(&mut client_handle.progress_receiver, h_funded).await;
-    wait_for_wallet_synced(&wallet, &wallet_id, h_funded).await;
-
-    // Second tx + block so `last_processed_height` ticks past `h_funded`.
-    // SPV only "processes" blocks whose filter matches one of our addresses,
-    // so an empty miner block alone won't advance `last_processed_height`.
-    // Sending a small follow-up payment to the wallet's next receive
-    // address gives block N+1 a wallet-relevant filter match, which forces
-    // process_block to run and advance the height.
-    let receive_address_2 = {
-        let mut wallet_lock = wallet.write().await;
-        let (w_ref, info) = wallet_lock.get_wallet_and_info_mut(&wallet_id).expect("wallet");
-        let xpub = w_ref.get_bip44_account(0).expect("bip44 0").account_xpub;
-        let acc = info.accounts_mut().standard_bip44_accounts.get_mut(&0).expect("acc 0");
-        acc.next_receive_address(Some(&xpub), true).expect("derive next receive address")
-    };
-    let _bump_txid =
-        ctx.dashd.node.send_to_address(&receive_address_2, Amount::from_sat(20_000_000));
-    ctx.dashd.node.generate_blocks(1, &miner_address);
-    let funded_height = h_funded + 1;
+    let funded_height = ctx.dashd.initial_height + 1;
     wait_for_sync(&mut client_handle.progress_receiver, funded_height).await;
     wait_for_wallet_synced(&wallet, &wallet_id, funded_height).await;
 
     let initial_spendable = reported_spendable(&wallet, &wallet_id).await;
-    assert!(
-        initial_spendable >= funding_amount.to_sat(),
-        "wallet should report at least the funding amount as spendable, got {}",
-        initial_spendable
+    assert_eq!(
+        initial_spendable,
+        funding_amount.to_sat(),
+        "wallet should report exactly the funding amount as spendable"
     );
 
     // Step 2: build + sign + broadcast a tx that sends part of the funding

key-wallet/src/wallet/managed_wallet_info/coin_selection.rs

@@ -79,34 +79,23 @@ pub struct SelectionResult {
 /// - High-frequency receivers: **SmallestFirstTill(10)** (balanced approach)
 pub struct CoinSelector {
     strategy: SelectionStrategy,
-    min_confirmations: u32,
-    include_unconfirmed: bool,
     dust_threshold: u64,
 }
 
 impl CoinSelector {
-    /// Create a new coin selector
+    /// Create a new coin selector with defaults that match the wallet's
+    /// spendable-balance semantics: confirmed, InstantSend-locked, trusted
+    /// self-send change, and untrusted unconfirmed incoming are all
+    /// candidates. Callers that want stricter filtering (e.g. exclude
+    /// mempool incoming, or require N confirmations) opt in via
+    /// [`with_min_confirmations`] / [`exclude_unconfirmed`].
     pub fn new(strategy: SelectionStrategy) -> Self {
         Self {
             strategy,
-            min_confirmations: 1,
-            include_unconfirmed: false,
             dust_threshold: 546, // Standard dust threshold
         }
     }
 
-    /// Set minimum confirmations required
-    pub fn with_min_confirmations(mut self, confirmations: u32) -> Self {
-        self.min_confirmations = confirmations;
-        self
-    }
-
-    /// Include unconfirmed UTXOs
-    pub fn include_unconfirmed(mut self) -> Self {
-        self.include_unconfirmed = true;
-        self
-    }
-
     /// Set dust threshold
     pub fn with_dust_threshold(mut self, threshold: u64) -> Self {
         self.dust_threshold = threshold;
@@ -159,15 +148,8 @@ impl CoinSelector {
             | SelectionStrategy::BranchAndBound
             | SelectionStrategy::OptimalConsolidation => {
                 // These strategies need all UTXOs to sort/analyze
-                let mut available: Vec<&'a Utxo> = utxos
-                    .into_iter()
-                    .filter(|u| {
-                        u.is_spendable(current_height)
-                            && (self.include_unconfirmed || u.is_confirmed || u.is_instantlocked)
-                            && (current_height.saturating_sub(u.height) >= self.min_confirmations
-                                || u.height == 0)
-                    })
-                    .collect();
+                let mut available: Vec<&'a Utxo> =
+                    utxos.into_iter().filter(|u| u.is_spendable(current_height)).collect();
 
                 if available.is_empty() {
                     return Err(SelectionError::NoUtxosAvailable);
@@ -261,12 +243,7 @@ impl CoinSelector {
             }
             SelectionStrategy::Random => {
                 // Random can work with iterators directly
-                let filtered = utxos.into_iter().filter(|u| {
-                    u.is_spendable(current_height)
-                        && (self.include_unconfirmed || u.is_confirmed || u.is_instantlocked)
-                        && (current_height.saturating_sub(u.height) >= self.min_confirmations
-                            || u.height == 0)
-                });
+                let filtered = utxos.into_iter().filter(|u| u.is_spendable(current_height));
 
                 // For Random (currently just uses accumulate as-is)
                 // TODO: Implement proper random selection for privacy