DEMO: Depend on a new psbt-v0 crate

Cargo.toml

@@ -25,3 +25,6 @@ authors = ["Bitcoin Dev Kit Developers"]
 [workspace.lints.clippy]
 print_stdout = "deny"
 print_stderr = "deny"
+
+[patch.crates-io.miniscript]
+path = "/home/tobin/build/github.com/tcharding/rust-miniscript/master"

crates/wallet/Cargo.toml

@@ -23,13 +23,14 @@ serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
 bdk_chain = { path = "../chain", version = "0.19.0", features = [ "miniscript", "serde" ], default-features = false }
 bdk_file_store = { path = "../file_store", version = "0.16.0", optional = true }
+psbt-v0 = { path = "/home/tobin/build/github.com/tcharding/rust-psbt-v0/master", version = "0.1.0", features = ["miniscript"], default-features = false }
 
 # Optional dependencies
 bip39 = { version = "2.0", optional = true }
 
 [features]
 default = ["std"]
-std = ["bitcoin/std", "bitcoin/rand-std", "miniscript/std", "bdk_chain/std"]
+std = ["bitcoin/std", "bitcoin/rand-std", "miniscript/std", "bdk_chain/std", "psbt-v0/std"]
 compiler = ["miniscript/compiler"]
 all-keys = ["keys-bip39"]
 keys-bip39 = ["bip39"]

crates/wallet/src/descriptor/mod.rs

@@ -20,7 +20,7 @@ use alloc::vec::Vec;
 
 use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, KeySource, Xpub};
 use bitcoin::{key::XOnlyPublicKey, secp256k1, PublicKey};
-use bitcoin::{psbt, taproot};
+use bitcoin::taproot;
 use bitcoin::{Network, TxOut};
 
 use miniscript::descriptor::{
@@ -55,18 +55,12 @@ pub type ExtendedDescriptor = Descriptor<DescriptorPublicKey>;
 /// Alias for a [`Descriptor`] that contains extended **derived** keys
 pub type DerivedDescriptor = Descriptor<DefiniteDescriptorKey>;
 
-/// Alias for the type of maps that represent derivation paths in a [`psbt::Input`] or
-/// [`psbt::Output`]
-///
-/// [`psbt::Input`]: bitcoin::psbt::Input
-/// [`psbt::Output`]: bitcoin::psbt::Output
+/// Alias for the type of maps that represent derivation paths in a [`psbt_v0::Input`] or
+/// [`psbt_v0::Output`]
 pub type HdKeyPaths = BTreeMap<secp256k1::PublicKey, KeySource>;
 
-/// Alias for the type of maps that represent taproot key origins in a [`psbt::Input`] or
-/// [`psbt::Output`]
-///
-/// [`psbt::Input`]: bitcoin::psbt::Input
-/// [`psbt::Output`]: bitcoin::psbt::Output
+/// Alias for the type of maps that represent taproot key origins in a [`psbt_v0::Input`] or
+/// [`psbt_v0::Output`]
 pub type TapKeyOrigins = BTreeMap<XOnlyPublicKey, (Vec<taproot::TapLeafHash>, KeySource)>;
 
 /// Trait for types which can be converted into an [`ExtendedDescriptor`] and a [`KeyMap`] usable by a wallet in a specific [`Network`]
@@ -399,7 +393,7 @@ pub(crate) trait DescriptorMeta {
     ) -> Option<DerivedDescriptor>;
     fn derive_from_psbt_input(
         &self,
-        psbt_input: &psbt::Input,
+        psbt_input: &psbt_v0::Input,
         utxo: Option<TxOut>,
         secp: &SecpCtx,
     ) -> Option<DerivedDescriptor>;
@@ -553,7 +547,7 @@ impl DescriptorMeta for ExtendedDescriptor {
 
     fn derive_from_psbt_input(
         &self,
-        psbt_input: &psbt::Input,
+        psbt_input: &psbt_v0::Input,
         utxo: Option<TxOut>,
         secp: &SecpCtx,
     ) -> Option<DerivedDescriptor> {
@@ -610,7 +604,8 @@ mod test {
     use assert_matches::assert_matches;
     use bitcoin::hex::FromHex;
     use bitcoin::secp256k1::Secp256k1;
-    use bitcoin::{bip32, Psbt};
+    use bitcoin::bip32;
+    use psbt_v0::Psbt;
     use bitcoin::{NetworkKind, ScriptBuf};
 
     use super::*;
@@ -890,7 +885,7 @@ mod test {
 
     #[test]
     fn test_sh_wsh_sortedmulti_redeemscript() {
-        use miniscript::psbt::PsbtInputExt;
+        use psbt_v0::miniscript::PsbtInputExt;
 
         let secp = Secp256k1::new();
 
@@ -904,7 +899,7 @@ mod test {
 
         let script = ScriptBuf::from_hex("5321022f533b667e2ea3b36e21961c9fe9dca340fbe0af5210173a83ae0337ab20a57621026bb53a98e810bd0ee61a0ed1164ba6c024786d76554e793e202dc6ce9c78c4ea2102d5b8a7d66a41ffdb6f4c53d61994022e886b4f45001fb158b95c9164d45f8ca3210324b75eead2c1f9c60e8adeb5e7009fec7a29afcdb30d829d82d09562fe8bae8521032d34f8932200833487bd294aa219dcbe000b9f9b3d824799541430009f0fa55121037468f8ea99b6c64788398b5ad25480cad08f4b0d65be54ce3a55fd206b5ae4722103f72d3d96663b0ea99b0aeb0d7f273cab11a8de37885f1dddc8d9112adb87169357ae").unwrap();
 
-        let mut psbt_input = psbt::Input::default();
+        let mut psbt_input = psbt_v0::Input::default();
         psbt_input
             .update_with_descriptor_unchecked(&descriptor)
             .unwrap();

crates/wallet/src/descriptor/policy.rs

@@ -67,8 +67,8 @@ use crate::wallet::utils::{After, Older, SecpCtx};
 use super::checksum::calc_checksum;
 use super::error::Error;
 use super::XKeyUtils;
-use bitcoin::psbt::{self, Psbt};
-use miniscript::psbt::PsbtInputSatisfier;
+use psbt_v0::Psbt;
+use psbt_v0::miniscript::PsbtInputSatisfier;
 
 /// A unique identifier for a key
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
@@ -785,9 +785,9 @@ fn make_generic_signature<M: Fn() -> SatisfiableItem, F: Fn(&Psbt) -> bool>(
 fn generic_sig_in_psbt<
     // C is for "check", it's a closure we use to *check* if a psbt input contains the signature
     // for a specific key
-    C: Fn(&psbt::Input, &SinglePubKey) -> bool,
+    C: Fn(&psbt_v0::Input, &SinglePubKey) -> bool,
     // E is for "extract", it extracts a key from the bip32 derivations found in the psbt input
-    E: Fn(&psbt::Input, Fingerprint) -> Option<SinglePubKey>,
+    E: Fn(&psbt_v0::Input, Fingerprint) -> Option<SinglePubKey>,
 >(
     psbt: &Psbt,
     key: &DescriptorPublicKey,

crates/wallet/src/psbt/mod.rs

@@ -14,7 +14,7 @@
 use alloc::vec::Vec;
 use bitcoin::Amount;
 use bitcoin::FeeRate;
-use bitcoin::Psbt;
+use psbt_v0::Psbt;
 use bitcoin::TxOut;
 
 // TODO upstream the functions here to `rust-bitcoin`?

crates/wallet/src/types.rs

@@ -14,7 +14,7 @@ use core::convert::AsRef;
 
 use bdk_chain::ConfirmationTime;
 use bitcoin::transaction::{OutPoint, Sequence, TxOut};
-use bitcoin::{psbt, Weight};
+use bitcoin::Weight;
 
 use serde::{Deserialize, Serialize};
 
@@ -90,7 +90,7 @@ pub enum Utxo {
         sequence: Option<Sequence>,
         /// The information about the input we require to add it to a PSBT.
         // Box it to stop the type being too big.
-        psbt_input: Box<psbt::Input>,
+        psbt_input: Box<psbt_v0::Input>,
     },
 }
 

crates/wallet/src/wallet/error.rs

@@ -16,7 +16,7 @@ use crate::descriptor::DescriptorError;
 use crate::wallet::coin_selection;
 use crate::{descriptor, KeychainKind};
 use alloc::string::String;
-use bitcoin::{absolute, psbt, Amount, OutPoint, Sequence, Txid};
+use bitcoin::{absolute, Amount, OutPoint, Sequence, Txid};
 use core::fmt;
 
 /// Errors returned by miniscript when updating inconsistent PSBTs
@@ -25,9 +25,9 @@ pub enum MiniscriptPsbtError {
     /// Descriptor key conversion error
     Conversion(miniscript::descriptor::ConversionError),
     /// Return error type for PsbtExt::update_input_with_descriptor
-    UtxoUpdate(miniscript::psbt::UtxoUpdateError),
+    UtxoUpdate(psbt_v0::miniscript::UtxoUpdateError),
     /// Return error type for PsbtExt::update_output_with_descriptor
-    OutputUpdate(miniscript::psbt::OutputUpdateError),
+    OutputUpdate(psbt_v0::miniscript::OutputUpdateError),
 }
 
 impl fmt::Display for MiniscriptPsbtError {
@@ -93,7 +93,7 @@ pub enum CreateTxError {
     /// Cannot build a tx without recipients
     NoRecipients,
     /// Partially signed bitcoin transaction error
-    Psbt(psbt::Error),
+    Psbt(psbt_v0::Error),
     /// In order to use the [`TxBuilder::add_global_xpubs`] option every extended
     /// key in the descriptor must either be a master key itself (having depth = 0) or have an
     /// explicit origin provided
@@ -198,8 +198,8 @@ impl From<MiniscriptPsbtError> for CreateTxError {
     }
 }
 
-impl From<psbt::Error> for CreateTxError {
-    fn from(err: psbt::Error) -> Self {
+impl From<psbt_v0::Error> for CreateTxError {
+    fn from(err: psbt_v0::Error) -> Self {
         CreateTxError::Psbt(err)
     }
 }

crates/wallet/src/wallet/mod.rs

@@ -39,23 +39,24 @@ use bdk_chain::{
 };
 use bitcoin::sighash::{EcdsaSighashType, TapSighashType};
 use bitcoin::{
-    absolute, psbt, Address, Block, FeeRate, Network, OutPoint, ScriptBuf, Sequence, Transaction,
+    absolute, Address, Block, FeeRate, Network, OutPoint, ScriptBuf, Sequence, Transaction,
     TxOut, Txid, Witness,
 };
-use bitcoin::{consensus::encode::serialize, transaction, BlockHash, Psbt};
+use bitcoin::{consensus::encode::serialize, transaction, BlockHash};
 use bitcoin::{constants::genesis_block, Amount};
 use bitcoin::{secp256k1::Secp256k1, Weight};
 use core::cmp::Ordering;
 use core::fmt;
 use core::mem;
 use core::ops::Deref;
 use rand_core::RngCore;
+use psbt_v0::Psbt;
 
 use descriptor::error::Error as DescriptorError;
 use miniscript::{
     descriptor::KeyMap,
-    psbt::{PsbtExt, PsbtInputExt, PsbtInputSatisfier},
 };
+use psbt_v0::miniscript::{PsbtExt, PsbtInputExt, PsbtInputSatisfier};
 
 use bdk_chain::tx_graph::CalculateFeeError;
 
@@ -935,7 +936,7 @@ impl Wallet {
     /// ```
     ///
     /// ```rust, no_run
-    /// # use bitcoin::Psbt;
+    /// # use psbt_v0::Psbt;
     /// # use bdk_wallet::Wallet;
     /// # let mut wallet: Wallet = todo!();
     /// # let mut psbt: Psbt = todo!();
@@ -966,7 +967,7 @@ impl Wallet {
     /// ```
     ///
     /// ```rust, no_run
-    /// # use bitcoin::Psbt;
+    /// # use psbt_v0::Psbt;
     /// # use bdk_wallet::Wallet;
     /// # let mut wallet: Wallet = todo!();
     /// # let mut psbt: Psbt = todo!();
@@ -996,7 +997,7 @@ impl Wallet {
     /// ```
     ///
     /// ```rust, no_run
-    /// # use bitcoin::Psbt;
+    /// # use psbt_v0::Psbt;
     /// # use bdk_wallet::Wallet;
     /// # let mut wallet: Wallet = todo!();
     /// # let mut psbt: Psbt = todo!();
@@ -1709,7 +1710,7 @@ impl Wallet {
                             utxo: Utxo::Foreign {
                                 outpoint: txin.previous_output,
                                 sequence: Some(txin.sequence),
-                                psbt_input: Box::new(psbt::Input {
+                                psbt_input: Box::new(psbt_v0::Input {
                                     witness_utxo: Some(txout.clone()),
                                     non_witness_utxo: Some(prev_tx.as_ref().clone()),
                                     ..Default::default()
@@ -2171,9 +2172,9 @@ impl Wallet {
                         match self.get_psbt_input(utxo, params.sighash, params.only_witness_utxo) {
                             Ok(psbt_input) => psbt_input,
                             Err(e) => match e {
-                                CreateTxError::UnknownUtxo => psbt::Input {
+                                CreateTxError::UnknownUtxo => psbt_v0::Input {
                                     sighash_type: params.sighash,
-                                    ..psbt::Input::default()
+                                    ..psbt_v0::Input::default()
                                 },
                                 _ => return Err(e),
                             },
@@ -2209,9 +2210,9 @@ impl Wallet {
     pub fn get_psbt_input(
         &self,
         utxo: LocalOutput,
-        sighash_type: Option<psbt::PsbtSighashType>,
+        sighash_type: Option<psbt_v0::PsbtSighashType>,
         only_witness_utxo: bool,
-    ) -> Result<psbt::Input, CreateTxError> {
+    ) -> Result<psbt_v0::Input, CreateTxError> {
         // Try to find the prev_script in our db to figure out if this is internal or external,
         // and the derivation index
         let &(keychain, child) = self
@@ -2220,9 +2221,9 @@ impl Wallet {
             .index_of_spk(utxo.txout.script_pubkey)
             .ok_or(CreateTxError::UnknownUtxo)?;
 
-        let mut psbt_input = psbt::Input {
+        let mut psbt_input = psbt_v0::Input {
             sighash_type,
-            ..psbt::Input::default()
+            ..psbt_v0::Input::default()
         };
 
         let desc = self.public_descriptor(keychain);

crates/wallet/src/wallet/signer.rs

@@ -93,15 +93,16 @@ use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, Xpriv};
 use bitcoin::hashes::hash160;
 use bitcoin::secp256k1::Message;
 use bitcoin::sighash::{EcdsaSighashType, TapSighash, TapSighashType};
-use bitcoin::{ecdsa, psbt, sighash, taproot};
+use bitcoin::{ecdsa, sighash, taproot};
 use bitcoin::{key::TapTweak, key::XOnlyPublicKey, secp256k1};
-use bitcoin::{PrivateKey, Psbt, PublicKey};
+use bitcoin::{PrivateKey, PublicKey};
 
 use miniscript::descriptor::{
     Descriptor, DescriptorMultiXKey, DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey,
     InnerXKey, KeyMap, SinglePriv, SinglePubKey,
 };
 use miniscript::{SigType, ToPublicKey};
+use psbt_v0::Psbt;
 
 use super::utils::SecpCtx;
 use crate::descriptor::{DescriptorMeta, XKeyUtils};
@@ -164,7 +165,7 @@ pub enum SignerError {
     /// Error while computing the hash to sign a Taproot input.
     SighashTaproot(sighash::TaprootError),
     /// PSBT sign error.
-    Psbt(psbt::SignError),
+    Psbt(psbt_v0::SignError),
     /// Miniscript PSBT error
     MiniscriptPsbt(MiniscriptPsbtError),
     /// To be used only by external libraries implementing [`InputSigner`] or
@@ -542,7 +543,7 @@ impl InputSigner for SignerWrapper<PrivateKey> {
 fn sign_psbt_ecdsa(
     secret_key: &secp256k1::SecretKey,
     pubkey: PublicKey,
-    psbt_input: &mut psbt::Input,
+    psbt_input: &mut psbt_v0::Input,
     msg: &Message,
     sighash_type: EcdsaSighashType,
     secp: &SecpCtx,
@@ -568,7 +569,7 @@ fn sign_psbt_schnorr(
     secret_key: &secp256k1::SecretKey,
     pubkey: XOnlyPublicKey,
     leaf_hash: Option<taproot::TapLeafHash>,
-    psbt_input: &mut psbt::Input,
+    psbt_input: &mut psbt_v0::Input,
     sighash: TapSighash,
     sighash_type: TapSighashType,
     secp: &SecpCtx,
@@ -851,7 +852,7 @@ fn compute_tap_sighash(
     let mut all_witness_utxos = vec![];
 
     let mut cache = sighash::SighashCache::new(&psbt.unsigned_tx);
-    let is_anyone_can_pay = psbt::PsbtSighashType::from(sighash_type).to_u32() & 0x80 != 0;
+    let is_anyone_can_pay = psbt_v0::PsbtSighashType::from(sighash_type).to_u32() & 0x80 != 0;
     let prevouts = if is_anyone_can_pay {
         sighash::Prevouts::One(
             input_index,