wallet: Add ConfirmationSpendPolicy to spend only [un]confirmed outputs

Author: stevenroose

crates/wallet/src/wallet/mod.rs

@@ -1998,6 +1998,7 @@ impl Wallet {
     ) -> (Vec<WeightedUtxo>, Vec<WeightedUtxo>) {
         let TxParams {
             change_policy,
+            confirmation_policy,
             unspendable,
             utxos,
             drain_wallet,
@@ -2068,6 +2069,7 @@ impl Wallet {
         let mut i = 0;
         may_spend.retain(|u| {
             let retain = (self.keychains().count() == 1 || change_policy.is_satisfied_by(&u.0))
+                && confirmation_policy.is_satisfied_by(&u.0)
                 && !unspendable.contains(&u.0.outpoint)
                 && satisfies_confirmed[i];
             i += 1;

crates/wallet/src/wallet/tx_builder.rs

@@ -134,6 +134,7 @@ pub(crate) struct TxParams {
     pub(crate) sequence: Option<Sequence>,
     pub(crate) version: Option<Version>,
     pub(crate) change_policy: ChangeSpendPolicy,
+    pub(crate) confirmation_policy: ConfirmationSpendPolicy,
     pub(crate) only_witness_utxo: bool,
     pub(crate) add_global_xpubs: bool,
     pub(crate) include_output_redeem_witness_script: bool,
@@ -493,6 +494,31 @@ impl<'a, Cs> TxBuilder<'a, Cs> {
         self
     }
 
+    /// Only spend confirmed outputs
+    ///
+    /// This effectively adds all the unconfirmed outputs to the "unspendable" list. See
+    /// [`TxBuilder::unspendable`].
+    pub fn only_spend_confirmed(&mut self) -> &mut Self {
+        self.params.confirmation_policy = ConfirmationSpendPolicy::OnlyConfirmed;
+        self
+    }
+
+    /// Only spend unconfirmed outputs
+    ///
+    /// This effectively adds all the confirmed outputs to the "unspendable" list. See
+    /// [`TxBuilder::unspendable`].
+    pub fn only_spend_unconfirmed(&mut self) -> &mut Self {
+        self.params.confirmation_policy = ConfirmationSpendPolicy::OnlyUnconfirmed;
+        self
+    }
+
+    /// Set a specific [`ConfirmationSpendPolicy`]. See [`TxBuilder::only_spend_confirmed`] and
+    /// [`TxBuilder::only_spend_unconfirmed`] for some shortcuts.
+    pub fn confirmation_policy(&mut self, confirmation_policy: ConfirmationSpendPolicy) -> &mut Self {
+        self.params.confirmation_policy = confirmation_policy;
+        self
+    }
+
     /// Only Fill-in the [`psbt::Input::witness_utxo`](bitcoin::psbt::Input::witness_utxo) field when spending from
     /// SegWit descriptors.
     ///
@@ -818,6 +844,28 @@ impl ChangeSpendPolicy {
     }
 }
 
+/// Policy regarding the use of unconfirmed outputs when creating a transaction
+#[derive(Default, Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
+pub enum ConfirmationSpendPolicy {
+    /// Use both confirmed and unconfirmed outputs (default)
+    #[default]
+    UnconfirmedAllowed,
+    /// Only use confirmed outputs (see [`TxBuilder::only_spend_confirmed`])
+    OnlyConfirmed,
+    /// Only use unconfirmed outputs (see [`TxBuilder::only_spend_unconfirmed`])
+    OnlyUnconfirmed,
+}
+
+impl ConfirmationSpendPolicy {
+    pub(crate) fn is_satisfied_by(&self, utxo: &LocalOutput) -> bool {
+        match self {
+            ConfirmationSpendPolicy::UnconfirmedAllowed => true,
+            ConfirmationSpendPolicy::OnlyConfirmed => utxo.chain_position.is_confirmed(),
+            ConfirmationSpendPolicy::OnlyUnconfirmed => !utxo.chain_position.is_confirmed(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     const ORDERING_TEST_TX: &str = "0200000003c26f3eb7932f7acddc5ddd26602b77e7516079b03090a16e2c2f54\

crates/wallet/tests/wallet.rs

@@ -766,6 +766,92 @@ fn test_create_tx_change_policy() {
     ));
 }
 
+#[test]
+fn test_create_tx_confirmation_policy() {
+    let (mut wallet, funding_txid) = get_funded_wallet_wpkh();
+    // confirm the funding tx
+    let anchor = ConfirmationBlockTime {
+        block_id: wallet.latest_checkpoint().get(2000).unwrap().block_id(),
+        confirmation_time: 200,
+    };
+    insert_anchor(&mut wallet, funding_txid, anchor);
+    assert_eq!(wallet.balance().confirmed, Amount::from_sat(50_000));
+
+    let confirmed_tx = Transaction {
+        input: vec![],
+        output: vec![TxOut {
+            script_pubkey: wallet
+                .next_unused_address(KeychainKind::External)
+                .script_pubkey(),
+            value: Amount::from_sat(25_000),
+        }],
+        version: transaction::Version::non_standard(0),
+        lock_time: absolute::LockTime::ZERO,
+    };
+    let confirmed_txid = confirmed_tx.compute_txid();
+    insert_tx(&mut wallet, confirmed_tx);
+    let anchor = ConfirmationBlockTime {
+        block_id: wallet.latest_checkpoint().get(2000).unwrap().block_id(),
+        confirmation_time: 200,
+    };
+    insert_anchor(&mut wallet, confirmed_txid, anchor);
+    let unconfirmed_tx = Transaction {
+        input: vec![],
+        output: vec![TxOut {
+            script_pubkey: wallet
+                .next_unused_address(KeychainKind::External)
+                .script_pubkey(),
+            value: Amount::from_sat(25_000),
+        }],
+        version: transaction::Version::non_standard(0),
+        lock_time: absolute::LockTime::ZERO,
+    };
+    let unconfirmed_txid = unconfirmed_tx.compute_txid();
+    insert_tx(&mut wallet, unconfirmed_tx);
+
+    let addr = wallet.next_unused_address(KeychainKind::External);
+
+    let mut builder = wallet.build_tx();
+    builder
+        .add_recipient(addr.script_pubkey(), Amount::from_sat(51_000))
+        .only_spend_confirmed();
+    let ret = builder.finish().unwrap();
+    assert_eq!(ret.unsigned_tx.input.len(), 2);
+    assert!(ret.unsigned_tx.input.iter().find(|i| i.previous_output.txid == confirmed_txid).is_some());
+    assert!(ret.unsigned_tx.input.iter().find(|i| i.previous_output.txid == unconfirmed_txid).is_none());
+
+    let mut builder = wallet.build_tx();
+    builder
+        .add_recipient(addr.script_pubkey(), Amount::from_sat(24_000))
+        .only_spend_unconfirmed();
+    let ret = builder.finish().unwrap();
+    assert_eq!(ret.unsigned_tx.input.len(), 1);
+    assert!(ret.unsigned_tx.input.iter().find(|i| i.previous_output.txid == unconfirmed_txid).is_some());
+    assert!(ret.unsigned_tx.input.iter().find(|i| i.previous_output.txid == confirmed_txid).is_none());
+
+    let mut builder = wallet.build_tx();
+    builder
+        .add_recipient(addr.script_pubkey(), Amount::from_sat(76_000))
+        .only_spend_confirmed();
+    assert!(matches!(
+        builder.finish(),
+        Err(CreateTxError::CoinSelection(
+            coin_selection::InsufficientFunds { .. }
+        )),
+    ));
+
+    let mut builder = wallet.build_tx();
+    builder
+        .add_recipient(addr.script_pubkey(), Amount::from_sat(76_000))
+        .only_spend_unconfirmed();
+    assert!(matches!(
+        builder.finish(),
+        Err(CreateTxError::CoinSelection(
+            coin_selection::InsufficientFunds { .. }
+        )),
+    ));
+}
+
 #[test]
 fn test_create_tx_default_sequence() {
     let (mut wallet, _) = get_funded_wallet_wpkh();