upgrading to bdk_wallet v2.2 and signing with psbt

Author: ulrichard

Cargo.toml

@@ -2,7 +2,7 @@
 name = "bdk-reserves"
 version = "2.2.0"
 authors = ["Richard Ulrich <[email protected]>"]
-edition = "2018"
+edition = "2024"
 description = "Proof of reserves for bitcoin dev kit"
 keywords = ["proof", "reserves", "bitcoin", "psbt"]
 readme = "README.md"
@@ -11,6 +11,7 @@ repository = "https://github.com/bitcoindevkit/bdk-reserves"
 
 [dependencies]
 bdk_wallet = { version = "2.2.0", default-features = false, features = ["std"] }
+bdk_coin_select = "0.4"
 bitcoinconsensus = "0.19.0-3"
 log = "^0.4"
 

src/reserves.rs

@@ -23,7 +23,7 @@ use bdk_wallet::bitcoin::blockdata::script::{Builder, Script, ScriptBuf};
 use bdk_wallet::bitcoin::blockdata::transaction::{OutPoint, TxIn, TxOut};
 use bdk_wallet::bitcoin::consensus::encode::serialize;
 use bdk_wallet::bitcoin::hash_types::Txid;
-use bdk_wallet::bitcoin::hashes::{hash160, sha256d, Hash};
+use bdk_wallet::bitcoin::hashes::{Hash, hash160, sha256d};
 use bdk_wallet::bitcoin::psbt::ExtractTxError;
 use bdk_wallet::bitcoin::psbt::{Input, Psbt};
 use bdk_wallet::bitcoin::sighash::EcdsaSighashType;
@@ -335,13 +335,23 @@ fn challenge_txin(message: &str) -> TxIn {
 #[cfg(test)]
 mod test {
     use super::*;
+    use bdk_coin_select::{Candidate, NoBnbSolution, metrics::LowestFee};
     use bdk_tx::Signer;
-    use bdk_wallet::bitcoin::{Address, Network, Witness};
+    use bdk_tx::{
+        ChangePolicyType, Output, PsbtParams, ScriptSource, Selector, SelectorParams,
+        filter_unspendable_now, group_by_spk, selection_algorithm_lowest_fee_bnb,
+    };
+    use bdk_wallet::bitcoin::{Address, FeeRate, Network, Witness};
     use bdk_wallet::descriptor::Descriptor;
     use bdk_wallet::test_utils::get_funded_wallet_single;
     use secp256k1::Secp256k1;
     use std::str::FromStr;
 
+    /// Select all UTXOs
+    pub fn selection_algorithm_leave() -> impl FnMut(&mut Selector) -> Result<(), NoBnbSolution> {
+        move |_selector| Ok(())
+    }
+
     #[test]
     fn test_proof() {
         let descriptor = "wpkh(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW)";
@@ -357,10 +367,41 @@ mod test {
         assert_eq!(psbt_b64, expected);
 
         let secp = Secp256k1::new();
-        let (_, keymap) = Descriptor::parse_descriptor(&secp, descriptor).unwrap();
+        let (desc, keymap) = Descriptor::parse_descriptor(&secp, descriptor).unwrap();
         let signer = Signer(keymap.into_iter().collect());
         psbt.sign(&signer, &secp).unwrap();
 
+        /*
+        let selection = wallet
+            .all_candidates()
+            //.regroup(group_by_spk())
+            //.filter(filter_unspendable_now(tip_height, tip_time))
+            .into_selection(
+                selection_algorithm_leave(),
+                SelectorParams::new(
+                    FeeRate::from_sat_per_vb_unchecked(10),
+                    vec![],
+                    ScriptSource::from_descriptor(desc),
+                    ChangePolicyType::NoDust,
+                    wallet.change_weight(),
+                ),
+            )?;
+        let finalizer = selection.into_finalizer();
+        assert!(
+            finalizer.finalize(&mut psbt).is_finalized(),
+            "must finalize"
+        );
+        */
+
+
+        let signopts = bdk_wallet::SignOptions {
+            trust_witness_utxo: true,
+            //remove_partial_sigs: false,
+            ..Default::default()
+        };
+        let finalized = wallet.finalize_psbt(&mut psbt, signopts).unwrap();
+
+
         let spendable = wallet.verify_proof(&psbt, message, None).unwrap();
         assert_eq!(spendable, Amount::from_sat(50_000));
 

tests/mempool.rs

@@ -1,6 +1,6 @@
 mod regtestenv;
 use bdk_electrum::electrum_client::{Client, ElectrumApi};
-use bdk_electrum::{electrum_client, BdkElectrumClient};
+use bdk_electrum::{BdkElectrumClient, electrum_client};
 use bdk_reserves::reserves::*;
 use bdk_tx::Signer;
 use bdk_wallet::bitcoin::{Amount, FeeRate, Network};

tests/multi_sig.rs

@@ -1,9 +1,13 @@
 mod regtestenv;
 use bdk_reserves::reserves::*;
+use bdk_tx::Signer;
+use bdk_wallet::bitcoin::Network;
 use bdk_wallet::bitcoin::key::{PrivateKey, PublicKey};
 use bdk_wallet::bitcoin::psbt::Psbt;
 use bdk_wallet::bitcoin::secp256k1::Secp256k1;
-use bdk_wallet::bitcoin::Network;
+use bdk_wallet::descriptor::DescriptorPublicKey;
+use bdk_wallet::keys::{SinglePriv, SinglePub, SinglePubKey};
+use bdk_wallet::miniscript::descriptor::{DescriptorSecretKey, KeyMap};
 use bdk_wallet::{KeychainKind, Wallet};
 use regtestenv::RegTestEnv;
 use rstest::rstest;
@@ -79,6 +83,10 @@ fn test_proof_multisig(
     let mut wallet1 = construct_multisig_wallet(&signer2, &pubkeys, &script_type)?;
     let mut wallet2 = construct_multisig_wallet(&signer3, &pubkeys, &script_type)?;
     let mut wallets = [&mut wallet0, &mut wallet1, &mut wallet2];
+    let signer1 = signer_from_priv(signer1, pubkeys[0]);
+    let signer2 = signer_from_priv(signer2, pubkeys[1]);
+    let signer3 = signer_from_priv(signer3, pubkeys[2]);
+    let signers = [&signer1, &signer2, &signer3];
 
     wallets
         .iter_mut()
@@ -98,8 +106,7 @@ fn test_proof_multisig(
         });
 
     let regtestenv = RegTestEnv::new();
-    /*
-    regtestenv.generate(&mut wallets);
+    regtestenv.generate(&mut wallets, &signers);
 
     wallets.iter().enumerate().for_each(|(i, wallet)| {
         let balance = wallet.balance();
@@ -131,31 +138,28 @@ fn test_proof_multisig(
         })
     };
 
-    let signopts = SignOptions {
-        trust_witness_utxo: true,
-        //remove_partial_sigs: false,
-        ..Default::default()
-    };
-    let finalized = wallets[0].sign(&mut psbt, signopts.clone())?;
+    psbt.sign(signers[0], &secp).unwrap();
     assert_eq!(count_signatures(&psbt), (num_inp - 1, 1, 0));
-    assert!(!finalized);
 
-    let finalized = wallets[1].sign(&mut psbt, signopts.clone())?;
+    psbt.sign(signers[1], &secp).unwrap();
     assert_eq!(
         count_signatures(&psbt),
         (0, num_inp.pow(count_mult.0), (num_inp - 1) * count_mult.1)
     );
-    assert!(finalized);
 
     // 2 signatures are enough. Just checking what happens...
-    let finalized = wallets[2].sign(&mut psbt, signopts.clone())?;
+    psbt.sign(signers[2], &secp).unwrap();
     assert_eq!(
         count_signatures(&psbt),
         (0, num_inp.pow(count_mult.0), (num_inp - 1) * count_mult.1)
     );
-    assert!(finalized);
 
-    let finalized = wallets[0].finalize_psbt(&mut psbt, signopts)?;
+    let signopts = bdk_wallet::SignOptions {
+        trust_witness_utxo: true,
+        //remove_partial_sigs: false,
+        ..Default::default()
+    };
+    let finalized = wallets[0].finalize_psbt(&mut psbt, signopts).unwrap();
     assert_eq!(
         count_signatures(&psbt),
         (0, num_inp.pow(count_mult.0), (num_inp - 1) * count_mult.1)
@@ -170,7 +174,23 @@ fn test_proof_multisig(
         spendable,
         balance.confirmed,
     );
-    */
 
     Ok(())
 }
+
+fn signer_from_priv(prvk: PrivateKey, pubk: PublicKey) -> Signer {
+    let mut keymap = KeyMap::new();
+
+    let pubk = DescriptorPublicKey::Single(SinglePub {
+        origin: None,
+        key: SinglePubKey::FullKey(pubk),
+    });
+    let prvk = DescriptorSecretKey::Single(SinglePriv {
+        //let prvk = KeyMap::V::Single(SinglePriv {
+        origin: None,
+        key: prvk,
+    });
+    keymap.insert(pubk, prvk);
+
+    Signer(keymap)
+}

tests/regtestenv.rs

@@ -1,12 +1,12 @@
 use bdk_electrum::electrum_client::Client;
-use bdk_electrum::{electrum_client, BdkElectrumClient};
+use bdk_electrum::{BdkElectrumClient, electrum_client};
 use bdk_tx::Signer;
 use bdk_wallet::bitcoin::{Amount, FeeRate};
 use bdk_wallet::{KeychainKind, Wallet};
-use electrsd::corepc_node::client::bitcoin::{Address, Network};
+use electrsd::ElectrsD;
 use electrsd::corepc_node::Node;
+use electrsd::corepc_node::client::bitcoin::{Address, Network};
 use electrsd::electrum_client::ElectrumApi;
-use electrsd::ElectrsD;
 use secp256k1::Secp256k1;
 use std::str::FromStr;
 use std::time::Duration;