psbt: Add method PsbtParams::add_utxos

- Changed type of `PsbtParams::utxos` field to `HashSet<OutPoint>`
- Fix logic of plan error in `create_psbt`
- Add test `test_create_psbt_cltv`

Author: ValuedMammal

wallet/src/psbt/params.rs

@@ -6,12 +6,14 @@ use bdk_tx::DefiniteDescriptor;
 use bitcoin::{absolute, transaction::Version, Amount, FeeRate, OutPoint, ScriptBuf, Sequence};
 use miniscript::plan::Assets;
 
+use crate::collections::HashSet;
+
 /// Parameters to create a PSBT.
 #[derive(Debug)]
 #[allow(unused)]
 pub struct PsbtParams {
     // Inputs
-    pub(crate) utxos: Vec<OutPoint>,
+    pub(crate) utxos: HashSet<OutPoint>,
 
     // Outputs
     pub(crate) recipients: Vec<(ScriptBuf, Amount)>,
@@ -50,6 +52,12 @@ impl Default for PsbtParams {
 
 // TODO: more setters for PsbtParams
 impl PsbtParams {
+    /// Add UTXOs by outpoint to fund the transaction.
+    pub fn add_utxos(&mut self, outpoints: &[OutPoint]) -> &mut Self {
+        self.utxos.extend(outpoints);
+        self
+    }
+
     /// Add the spend [`Assets`].
     ///
     /// Assets are required to create a spending plan for an output controlled by the wallet's

wallet/src/wallet/mod.rs

@@ -2705,19 +2705,14 @@ impl Wallet {
         };
 
         // Get input candidates
-        let manually_selected: HashSet<OutPoint> = params.utxos.clone().into_iter().collect();
         let (must_spend, mut may_spend): (Vec<Input>, Vec<Input>) = self
             .list_unspent()
             .flat_map(|output| self.plan_input(&output, &assets))
-            .partition(|input| manually_selected.contains(&input.prev_outpoint()));
+            .partition(|input| params.utxos.contains(&input.prev_outpoint()));
 
-        if must_spend
-            .iter()
-            .map(|input| input.prev_outpoint())
-            .any(|op| !manually_selected.contains(&op))
-        {
+        if must_spend.len() < params.utxos.len() {
             // Try plans again, this time propagating the error.
-            for op in manually_selected {
+            for op in params.utxos.iter().copied() {
                 if self.try_plan(op, &assets).is_none() {
                     return Err(CreatePsbtError::Plan(op));
                 }

wallet/tests/psbt.rs

@@ -1,3 +1,5 @@
+use bdk_chain::BlockId;
+use bdk_chain::ConfirmationBlockTime;
 use bdk_wallet::bitcoin::hashes::Hash;
 use bdk_wallet::bitcoin::secp256k1;
 use bdk_wallet::bitcoin::{Amount, FeeRate, Network, Psbt, TxIn};
@@ -17,8 +19,6 @@ fn test_create_psbt() {
         .unwrap();
 
     // Receive coins
-    use bdk_chain::BlockId;
-    use bdk_chain::ConfirmationBlockTime;
     let anchor = ConfirmationBlockTime {
         block_id: BlockId {
             height: 100,
@@ -67,6 +67,76 @@ fn test_create_psbt() {
         .any(|(_, (fp, _))| fp.to_string() == "f6a5cb8b")));
 }
 
+#[test]
+fn test_create_psbt_cltv() {
+    use bdk_wallet::CreatePsbtError;
+    use bitcoin::absolute::LockTime;
+    use miniscript::plan::Assets;
+
+    let desc = get_test_single_sig_cltv();
+    let mut wallet = Wallet::create_single(desc)
+        .network(Network::Regtest)
+        .create_wallet_no_persist()
+        .unwrap();
+
+    // Receive coins
+    let anchor = ConfirmationBlockTime {
+        block_id: BlockId {
+            height: 99_999,
+            hash: Hash::hash(b"abc"),
+        },
+        confirmation_time: 1234567000,
+    };
+    insert_checkpoint(&mut wallet, anchor.block_id);
+    let op = receive_output(&mut wallet, Amount::ONE_BTC, ReceiveTo::Block(anchor));
+
+    let mut rng = rand::thread_rng();
+
+    let addr = wallet.reveal_next_address(KeychainKind::External);
+
+    // No assets fail
+    {
+        let mut params = psbt::PsbtParams::default();
+        params
+            .add_utxos(&[op])
+            .add_recipients([(addr.script_pubkey(), Amount::from_btc(0.42).unwrap())]);
+        let res = wallet.create_psbt(params, &mut rng);
+        assert!(
+            matches!(res, Err(CreatePsbtError::Plan(err)) if err == op),
+            "UTXO requires CLTV but the assets are insufficient",
+        );
+    }
+
+    // Add assets ok
+    {
+        let mut params = psbt::PsbtParams::default();
+        params
+            .add_utxos(&[op])
+            .add_assets(Assets::new().after(LockTime::from_consensus(100_000)))
+            .add_recipients([(addr.script_pubkey(), Amount::from_btc(0.42).unwrap())]);
+        let _ = wallet
+            .create_psbt(params, &mut rng)
+            .expect("Create psbt should succeed");
+    }
+
+    // New chain tip (no assets) ok
+    {
+        let block_id = BlockId {
+            height: 100_000,
+            hash: Hash::hash(b"123"),
+        };
+        insert_checkpoint(&mut wallet, block_id);
+
+        let mut params = psbt::PsbtParams::default();
+        params
+            .add_utxos(&[op])
+            .add_recipients([(addr.script_pubkey(), Amount::from_btc(0.42).unwrap())]);
+        let _ = wallet
+            .create_psbt(params, &mut rng)
+            .expect("Create psbt should succeed");
+    }
+}
+
 #[test]
 #[should_panic(expected = "InputIndexOutOfRange")]
 fn test_psbt_malformed_psbt_input_legacy() {