wip: implement create_psbt for Wallet

psbt_params: Add optional plan Assets to Params

wallet: Update `create_psbt` to get assets from the params

- Add variant `CreatePsbtError::Plan` which happens when a manually
selected output can not be planned.

example: Change `psbt` example to sign using `bip32::Xpriv`

fix: map the change keychain in `create_psbt`

Move psbt Params to src/psbt/params.rs

Make `SelectionStrategy` non-exhaustive

wallet: Enhance `plan_input` by including after + older

The idea is that if the local chain has surpassed the lock height
needed to spend a utxo, then the wallet can respond accordingly
with no interaction on the part of the user.

params: Fix `add_assets` function signature

Rename PsbtParams

test: Add `test_create_psbt`

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`

psbt,params: Add `remove_utxo`

wip: Introduce `ReplaceParams`

fix clippy nit

test: improve `test_sanitize_rbf_set`

test: Add `test_replace_by_fee`

Author: ValuedMammal

wallet/Cargo.toml

@@ -22,12 +22,14 @@ bitcoin = { version = "0.32.6", features = [ "serde", "base64" ], default-featur
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
 bdk_chain = { version = "0.23.1", features = [ "miniscript", "serde" ], default-features = false }
-anyhow = { version = "1.0.98", optional = true }
-tempfile = { version = "3.20.0", optional = true }
+bdk_tx = { version = "0.1.0" }
+bdk_coin_select = { version = "0.4.0" }
 
 # Optional dependencies
 bip39 = { version = "2.0", optional = true }
 bdk_file_store = { version = "0.21.1", optional = true }
+anyhow = { version = "1.0.98", optional = true }
+tempfile = { version = "3.20.0", optional = true }
 
 [features]
 default = ["std"]
@@ -60,3 +62,11 @@ required-features = ["all-keys"]
 name = "miniscriptc"
 path = "examples/compiler.rs"
 required-features = ["compiler"]
+
+[[example]]
+name = "psbt"
+required-features = ["test-utils"]
+
+[[example]]
+name = "replace_by_fee"
+required-features = ["test-utils"]

wallet/examples/psbt.rs

@@ -0,0 +1,153 @@
+#![allow(clippy::print_stdout)]
+
+use std::collections::HashMap;
+use std::str::FromStr;
+use std::sync::Arc;
+
+use bdk_chain::BlockId;
+use bdk_chain::ConfirmationBlockTime;
+use bdk_chain::TxUpdate;
+use bdk_wallet::psbt::{PsbtParams, SelectionStrategy::*};
+use bdk_wallet::test_utils::*;
+use bdk_wallet::{KeychainKind::*, Update, Wallet};
+use bitcoin::{
+    bip32, consensus,
+    secp256k1::{self, rand},
+    Address, Amount, OutPoint, TxIn, TxOut,
+};
+use rand::Rng;
+
+// This example shows how to create a PSBT using BDK Wallet.
+
+const NETWORK: bitcoin::Network = bitcoin::Network::Signet;
+const SEND_TO: &str = "tb1pw3g5qvnkryghme7pyal228ekj6vq48zc5k983lqtlr2a96n4xw0q5ejknw";
+const AMOUNT: Amount = Amount::from_sat(42_000);
+const FEERATE: f64 = 2.0; // sat/vb
+
+fn main() -> anyhow::Result<()> {
+    let (desc, change_desc) = get_test_wpkh_and_change_desc();
+    let secp = secp256k1::Secp256k1::new();
+
+    // Xpriv to be used for signing the PSBT
+    let xprv = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPdy6LMhUtFHAgpocR8GC6QmwMSFpZs7h6Eziw3SpThFfczTDh5rW2krkqffa11UpX3XkeTTB2FvzZKWXqPY54Y6Rq4AQ5R8L")?;
+
+    // Create wallet and fund it.
+    let mut wallet = Wallet::create(desc, change_desc)
+        .network(NETWORK)
+        .create_wallet_no_persist()?;
+
+    fund_wallet(&mut wallet)?;
+
+    let utxos = wallet
+        .list_unspent()
+        .map(|output| (output.outpoint, output))
+        .collect::<HashMap<_, _>>();
+
+    // Build params.
+    let mut params = PsbtParams::default();
+    let addr = Address::from_str(SEND_TO)?.require_network(NETWORK)?;
+    let feerate = feerate_unchecked(FEERATE);
+    params
+        .add_recipients([(addr, AMOUNT)])
+        .feerate(feerate)
+        .coin_selection(SingleRandomDraw);
+
+    // Create PSBT (which also returns the Finalizer).
+    let (mut psbt, finalizer) = wallet.create_psbt(params)?;
+
+    dbg!(&psbt);
+
+    let tx = &psbt.unsigned_tx;
+    for txin in &tx.input {
+        let op = txin.previous_output;
+        let output = utxos.get(&op).unwrap();
+        println!("TxIn: {}", output.txout.value);
+    }
+    for txout in &tx.output {
+        println!("TxOut: {}", txout.value);
+    }
+
+    let _ = psbt.sign(&xprv, &secp);
+    println!("Signed: {}", !psbt.inputs[0].partial_sigs.is_empty());
+    let finalize_res = finalizer.finalize(&mut psbt);
+    println!("Finalized: {}", finalize_res.is_finalized());
+
+    let tx = psbt.extract_tx()?;
+    let feerate = wallet.calculate_fee_rate(&tx)?;
+    println!("Fee rate: {} sat/vb", bdk_wallet::floating_rate!(feerate));
+
+    println!("{}", consensus::encode::serialize_hex(&tx));
+
+    Ok(())
+}
+
+fn fund_wallet(wallet: &mut Wallet) -> anyhow::Result<()> {
+    let anchor = ConfirmationBlockTime {
+        block_id: BlockId {
+            height: 260071,
+            hash: "000000099f67ae6469d1ad0525d756e24d4b02fbf27d65b3f413d5feb367ec48".parse()?,
+        },
+        confirmation_time: 1752184658,
+    };
+    insert_checkpoint(wallet, anchor.block_id);
+
+    let mut rng = rand::thread_rng();
+
+    // Fund wallet with several random utxos
+    for i in 0..21 {
+        let value = 10_000 * (i + 1) + (100 * rng.gen_range(0..10));
+        let addr = wallet.reveal_next_address(External).address;
+        receive_output_to_addr(
+            wallet,
+            addr,
+            Amount::from_sat(value),
+            ReceiveTo::Block(anchor),
+        );
+    }
+
+    let tip = BlockId {
+        height: 260171,
+        hash: "0000000b9efb77450e753ae9fd7be9f69219511c27b6e95c28f4126f3e1591c3".parse()?,
+    };
+    insert_checkpoint(wallet, tip);
+
+    Ok(())
+}
+
+// Note: this is borrowed from `test-utils`, but here the tx appears as a coinbase tx
+// and inserting it does not automatically include a timestamp.
+fn receive_output_to_addr(
+    wallet: &mut Wallet,
+    addr: Address,
+    value: Amount,
+    receive_to: impl Into<ReceiveTo>,
+) -> OutPoint {
+    let tx = bitcoin::Transaction {
+        lock_time: bitcoin::absolute::LockTime::ZERO,
+        version: bitcoin::transaction::Version::TWO,
+        input: vec![TxIn::default()],
+        output: vec![TxOut {
+            script_pubkey: addr.script_pubkey(),
+            value,
+        }],
+    };
+
+    // Insert tx
+    let txid = tx.compute_txid();
+    let mut tx_update = TxUpdate::default();
+    tx_update.txs = vec![Arc::new(tx)];
+    wallet
+        .apply_update(Update {
+            tx_update,
+            ..Default::default()
+        })
+        .unwrap();
+
+    // Insert anchor or last-seen.
+    match receive_to.into() {
+        ReceiveTo::Block(anchor) => insert_anchor(wallet, txid, anchor),
+        ReceiveTo::Mempool(last_seen) => insert_seen_at(wallet, txid, last_seen),
+    }
+
+    OutPoint { txid, vout: 0 }
+}

wallet/examples/replace_by_fee.rs

@@ -0,0 +1,116 @@
+#![allow(clippy::print_stdout)]
+
+use std::str::FromStr;
+use std::sync::Arc;
+
+use bdk_chain::BlockId;
+use bdk_chain::ConfirmationBlockTime;
+use bdk_chain::TxUpdate;
+use bdk_wallet::test_utils::*;
+use bdk_wallet::{Update, Wallet};
+use bitcoin::{bip32, consensus, secp256k1, Address, FeeRate, Transaction};
+
+// This example shows how to create a Replace-By-Fee (RBF) transaction using BDK Wallet.
+
+const NETWORK: bitcoin::Network = bitcoin::Network::Regtest;
+const SEND_TO: &str = "bcrt1q3yfqg2v9d605r45y5ddt5unz5n8v7jl5yk4a4f";
+
+fn main() -> anyhow::Result<()> {
+    let desc = "wpkh(tprv8ZgxMBicQKsPe5tkv8BYJRupCNULhJYDv6qrtVAK9fNVheU6TbscSedVi8KQk8vVZqXMnsGomtVkR4nprbgsxTS5mAQPV4dpPXNvsmYcgZU/84h/1h/0h/0/*)";
+    let change_desc = "wpkh(tprv8ZgxMBicQKsPe5tkv8BYJRupCNULhJYDv6qrtVAK9fNVheU6TbscSedVi8KQk8vVZqXMnsGomtVkR4nprbgsxTS5mAQPV4dpPXNvsmYcgZU/84h/1h/0h/1/*)";
+    let secp = secp256k1::Secp256k1::new();
+
+    // Xpriv to be used for signing the PSBT
+    let xprv = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPe5tkv8BYJRupCNULhJYDv6qrtVAK9fNVheU6TbscSedVi8KQk8vVZqXMnsGomtVkR4nprbgsxTS5mAQPV4dpPXNvsmYcgZU")?;
+
+    // Create wallet and "fund" it.
+    let mut wallet = Wallet::create(desc, change_desc)
+        .network(NETWORK)
+        .create_wallet_no_persist()?;
+
+    // `tx_1` is the unconfirmed wallet tx that we want to replace.
+    let tx_1 = fund_wallet(&mut wallet)?;
+    wallet.apply_unconfirmed_txs([(tx_1.clone(), 1234567000)]);
+
+    // We'll need to fill in the original recipient details.
+    let addr = Address::from_str(SEND_TO)?.require_network(NETWORK)?;
+    let txo = tx_1
+        .output
+        .iter()
+        .find(|txo| txo.script_pubkey == addr.script_pubkey())
+        .expect("failed to find orginal recipient")
+        .clone();
+
+    // Now build fee bump.
+    let (mut psbt, finalizer) = wallet.replace_by_fee_and_recipients(
+        &[Arc::clone(&tx_1)],
+        FeeRate::from_sat_per_vb_unchecked(5),
+        vec![(txo.script_pubkey, txo.value)],
+    )?;
+
+    let _ = psbt.sign(&xprv, &secp);
+    println!("Signed: {}", !psbt.inputs[0].partial_sigs.is_empty());
+    let finalize_res = finalizer.finalize(&mut psbt);
+    println!("Finalized: {}", finalize_res.is_finalized());
+
+    let tx = psbt.extract_tx()?;
+    let feerate = wallet.calculate_fee_rate(&tx)?;
+    println!("Fee rate: {} sat/vb", bdk_wallet::floating_rate!(feerate));
+
+    println!("{}", consensus::encode::serialize_hex(&tx));
+
+    wallet.apply_unconfirmed_txs([(tx.clone(), 1234567001)]);
+
+    let txid_2 = tx.compute_txid();
+
+    assert!(
+        wallet
+            .tx_graph()
+            .direct_conflicts(&tx_1)
+            .any(|(_, txid)| txid == txid_2),
+        "ERROR: RBF tx does not conflict with `tx_1`",
+    );
+
+    Ok(())
+}
+
+fn fund_wallet(wallet: &mut Wallet) -> anyhow::Result<Arc<Transaction>> {
+    // The parent of `tx`. This is needed to compute the original fee.
+    let tx0: Arc<Transaction> = consensus::encode::deserialize_hex(
+        "020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff025100ffffffff0200f2052a010000001600144d34238b9c4c59b9e2781e2426a142a75b8901ab0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    )
+    .map(Arc::new)?;
+
+    let anchor_block = BlockId {
+        height: 101,
+        hash: "3bcc1c447c6b3886f43e416b5c21cf5c139dc4829a71dc78609bc8f6235611c5".parse()?,
+    };
+    insert_tx_anchor(wallet, tx0, anchor_block);
+
+    let tx: Arc<Transaction> = consensus::encode::deserialize_hex(
+        "020000000001014cb96536e94ba3f840cb5c2c965c8f9a306209de63fcd02060219aaf14f1d7b30000000000fdffffff0280de80020000000016001489120429856e9f41d684a35aba7262a4cecf4bf4f312852701000000160014757a57b3009c0e9b2b9aa548434dc295e21aeb05024730440220400c0a767ce42e0ea02b72faabb7f3433e607b475111285e0975bba1e6fd2e13022059453d83cbacb6652ba075f59ca0437036f3f94cae1959c7c5c0f96a8954707a012102c0851c2d2bddc1dd0b05caeac307703ec0c4b96ecad5a85af47f6420e2ef6c661b000000",
+    )
+    .map(Arc::new)?;
+
+    Ok(tx)
+}
+
+fn insert_tx_anchor(wallet: &mut Wallet, tx: Arc<Transaction>, block_id: BlockId) {
+    insert_checkpoint(wallet, block_id);
+    let anchor = ConfirmationBlockTime {
+        block_id,
+        confirmation_time: 1234567000,
+    };
+    let txid = tx.compute_txid();
+
+    let mut tx_update = TxUpdate::default();
+    tx_update.txs = vec![tx];
+    tx_update.anchors = [(anchor, txid)].into();
+
+    wallet
+        .apply_update(Update {
+            tx_update,
+            ..Default::default()
+        })
+        .expect("failed to apply update");
+}

wallet/src/psbt/mod.rs

@@ -17,6 +17,10 @@ use bitcoin::FeeRate;
 use bitcoin::Psbt;
 use bitcoin::TxOut;
 
+mod params;
+
+pub use params::*;
+
 // TODO upstream the functions here to `rust-bitcoin`?
 
 /// Trait to add functions to extract utxos and calculate fees.