Merge branch 'master' into feature/cpfp_support

# Conflicts:
#	examples/common.rs

Author: aagbotemi

examples/common.rs

@@ -6,12 +6,15 @@ use bdk_bitcoind_rpc::{Emitter, NO_EXPECTED_MEMPOOL_TXIDS};
 use bdk_chain::{
     bdk_core, Anchor, Balance, CanonicalizationParams, ChainPosition, ConfirmationBlockTime,
 };
+use bdk_coin_select::DrainWeights;
 use bdk_testenv::{bitcoincore_rpc::RpcApi, TestEnv};
 use bdk_tx::{
     CanonicalUnspents, CpfpParams, Input, InputCandidates, RbfParams, ScriptSource, Selection,
     TxStatus, TxWithStatus,
 };
-use bitcoin::{absolute, Address, Amount, BlockHash, FeeRate, OutPoint, Transaction, Txid, Weight};
+use bitcoin::{
+    absolute, Address, Amount, BlockHash, FeeRate, OutPoint, Transaction, TxOut, Txid, Weight,
+};
 use miniscript::{
     plan::{Assets, Plan},
     Descriptor, DescriptorPublicKey, ForEachKey,
@@ -137,6 +140,30 @@ impl Wallet {
             .map(|c_tx| (c_tx.tx_node.tx, status_from_position(c_tx.chain_position)))
     }
 
+    /// Computes an upper bound on the weight of a change output plus the future weight to spend it.
+    pub fn change_weight(&self) -> DrainWeights {
+        let desc = self
+            .graph
+            .index
+            .get_descriptor(INTERNAL)
+            .unwrap()
+            .at_derivation_index(0)
+            .unwrap();
+        let output_weight = TxOut {
+            script_pubkey: desc.script_pubkey(),
+            value: Amount::ZERO,
+        }
+        .weight()
+        .to_wu();
+        let spend_weight = desc.max_weight_to_satisfy().unwrap().to_wu();
+
+        DrainWeights {
+            output_weight,
+            spend_weight,
+            n_outputs: 1,
+        }
+    }
+
     pub fn all_candidates(&self) -> bdk_tx::InputCandidates {
         let index = &self.graph.index;
         let assets = self.assets();

examples/synopsis.rs

@@ -1,7 +1,7 @@
 use bdk_testenv::{bitcoincore_rpc::RpcApi, TestEnv};
 use bdk_tx::{
     filter_unspendable_now, group_by_spk, selection_algorithm_lowest_fee_bnb, ChangePolicyType,
-    Output, PsbtParams, SelectorParams, Signer,
+    Output, PsbtParams, ScriptSource, SelectorParams, Signer,
 };
 use bitcoin::{key::Secp256k1, Amount, FeeRate, Sequence};
 use miniscript::Descriptor;
@@ -60,8 +60,9 @@ fn main() -> anyhow::Result<()> {
                     recipient_addr.script_pubkey(),
                     Amount::from_sat(21_000_000),
                 )],
-                internal.at_derivation_index(0)?,
-                bdk_tx::ChangePolicyType::NoDustAndLeastWaste { longterm_feerate },
+                ScriptSource::Descriptor(Box::new(internal.at_derivation_index(0)?)),
+                ChangePolicyType::NoDustAndLeastWaste { longterm_feerate },
+                wallet.change_weight(),
             ),
         )?;
 
@@ -134,8 +135,11 @@ fn main() -> anyhow::Result<()> {
                     // be less wasteful to have no output, however that will not be a valid tx).
                     // If you only want to fee bump, put the original txs' recipients here.
                     target_outputs: vec![],
-                    change_descriptor: internal.at_derivation_index(1)?,
+                    change_script: ScriptSource::Descriptor(Box::new(
+                        internal.at_derivation_index(1)?,
+                    )),
                     change_policy: ChangePolicyType::NoDustAndLeastWaste { longterm_feerate },
+                    change_weight: wallet.change_weight(),
                     // This ensures that we satisfy mempool-replacement policy rules 4 and 6.
                     replace: Some(rbf_params),
                 },

src/output.rs

@@ -74,6 +74,15 @@ impl From<(DefiniteDescriptor, Amount)> for Output {
     }
 }
 
+impl From<(ScriptSource, Amount)> for Output {
+    fn from((src, value): (ScriptSource, Amount)) -> Self {
+        match src {
+            ScriptSource::Descriptor(desc) => Self::with_descriptor(*desc, value),
+            ScriptSource::Script(s) => Self::with_script(s, value),
+        }
+    }
+}
+
 impl Output {
     /// From script
     pub fn with_script(script: ScriptBuf, value: Amount) -> Self {

src/selector.rs

@@ -1,10 +1,10 @@
 use bdk_coin_select::{
     ChangePolicy, DrainWeights, InsufficientFunds, Replace, Target, TargetFee, TargetOutputs,
 };
-use bitcoin::{Amount, FeeRate, Transaction, TxOut, Weight};
+use bitcoin::{Amount, FeeRate, Transaction, Weight};
 use miniscript::bitcoin;
 
-use crate::{cs_feerate, DefiniteDescriptor, InputCandidates, InputGroup, Output, Selection};
+use crate::{cs_feerate, InputCandidates, InputGroup, Output, ScriptSource, Selection};
 use alloc::vec::Vec;
 use core::fmt;
 
@@ -15,7 +15,7 @@ pub struct Selector<'c> {
     target_outputs: Vec<Output>,
     target: Target,
     change_policy: bdk_coin_select::ChangePolicy,
-    change_descriptor: DefiniteDescriptor,
+    change_script: ScriptSource,
     inner: bdk_coin_select::CoinSelector<'c>,
 }
 
@@ -42,11 +42,14 @@ pub struct SelectorParams {
     /// To derive change output.
     ///
     /// Will error if this is unsatisfiable descriptor.
-    pub change_descriptor: DefiniteDescriptor,
+    pub change_script: ScriptSource,
 
     /// The policy to determine whether we create a change output.
     pub change_policy: ChangePolicyType,
 
+    /// Weight of the change output plus the future weight to spend the change
+    pub change_weight: DrainWeights,
+
     /// Params for replacing tx(s).
     pub replace: Option<RbfParams>,
 }
@@ -140,14 +143,16 @@ impl SelectorParams {
     pub fn new(
         target_feerate: bitcoin::FeeRate,
         target_outputs: Vec<Output>,
-        change_descriptor: DefiniteDescriptor,
+        change_script: ScriptSource,
         change_policy: ChangePolicyType,
+        change_weight: DrainWeights,
     ) -> Self {
         Self {
-            change_descriptor,
-            change_policy,
             target_feerate,
             target_outputs,
+            change_script,
+            change_policy,
+            change_weight,
             replace: None,
         }
     }
@@ -171,36 +176,14 @@ impl SelectorParams {
         }
     }
 
-    /// To change output weights.
-    ///
-    /// # Error
-    ///
-    /// Fails if `change_descriptor` cannot be satisfied.
-    pub fn to_cs_change_weights(&self) -> Result<bdk_coin_select::DrainWeights, miniscript::Error> {
-        Ok(DrainWeights {
-            output_weight: (TxOut {
-                script_pubkey: self.change_descriptor.script_pubkey(),
-                value: Amount::ZERO,
-            })
-            .weight()
-            .to_wu(),
-            spend_weight: self.change_descriptor.max_weight_to_satisfy()?.to_wu(),
-            n_outputs: 1,
-        })
-    }
-
     /// To change policy.
     ///
     /// # Error
     ///
     /// Fails if `change_descriptor` cannot be satisfied.
     pub fn to_cs_change_policy(&self) -> Result<bdk_coin_select::ChangePolicy, miniscript::Error> {
-        let change_weights = self.to_cs_change_weights()?;
-        let dust_value = self
-            .change_descriptor
-            .script_pubkey()
-            .minimal_non_dust()
-            .to_sat();
+        let change_weights = self.change_weight;
+        let dust_value = self.change_script.script().minimal_non_dust().to_sat();
         Ok(match self.change_policy {
             ChangePolicyType::NoDust => ChangePolicy::min_value(change_weights, dust_value),
             ChangePolicyType::NoDustAndLeastWaste { longterm_feerate } => {
@@ -268,7 +251,7 @@ impl<'c> Selector<'c> {
             .to_cs_change_policy()
             .map_err(SelectorError::Miniscript)?;
         let target_outputs = params.target_outputs;
-        let change_descriptor = params.change_descriptor;
+        let change_script = params.change_script;
         if target.value() > candidates.groups().map(|grp| grp.value().to_sat()).sum() {
             return Err(SelectorError::CannotMeetTarget(CannotMeetTarget));
         }
@@ -281,7 +264,7 @@ impl<'c> Selector<'c> {
             target,
             target_outputs,
             change_policy,
-            change_descriptor,
+            change_script,
             inner,
         })
     }
@@ -358,10 +341,10 @@ impl<'c> Selector<'c> {
             outputs: {
                 let mut outputs = self.target_outputs.clone();
                 if maybe_change.is_some() {
-                    outputs.push(Output::with_descriptor(
-                        self.change_descriptor.clone(),
+                    outputs.push(Output::from((
+                        self.change_script.clone(),
                         Amount::from_sat(maybe_change.value),
-                    ));
+                    )));
                 }
                 outputs
             },

src/signer.rs

@@ -1,4 +1,6 @@
 use alloc::string::ToString;
+use alloc::vec::Vec;
+use std::collections::BTreeMap;
 
 use bitcoin::{
     psbt::{GetKey, GetKeyError, KeyRequest},
@@ -24,9 +26,10 @@ impl GetKey for Signer {
         for entry in &self.0 {
             match entry {
                 (_, DescriptorSecretKey::Single(prv)) => {
-                    let pk = prv.key.public_key(secp);
-                    if key_request == KeyRequest::Pubkey(pk) {
-                        return Ok(Some(prv.key));
+                    let map: BTreeMap<_, _> =
+                        core::iter::once((prv.key.public_key(secp), prv.key)).collect();
+                    if let Ok(Some(prv)) = GetKey::get_key(&map, key_request.clone(), secp) {
+                        return Ok(Some(prv));
                     }
                 }
                 (_, desc_sk) => {
@@ -44,7 +47,11 @@ impl GetKey for Signer {
                                     if fingerprint == fp
                                         && derivation.to_string().starts_with(&path.to_string())
                                     {
-                                        let to_derive = &derivation[k.xkey.depth as usize..];
+                                        let to_derive = derivation
+                                            .into_iter()
+                                            .skip(path.len())
+                                            .cloned()
+                                            .collect::<Vec<_>>();
                                         let derived = k.xkey.derive_priv(secp, &to_derive)?;
                                         return Ok(Some(derived.to_priv()));
                                     }
@@ -61,6 +68,8 @@ impl GetKey for Signer {
 
 #[cfg(test)]
 mod test {
+    use crate::bitcoin::bip32::ChildNumber;
+    use core::str::FromStr;
     use std::string::String;
 
     use bitcoin::bip32::{DerivationPath, Xpriv};
@@ -89,6 +98,26 @@ mod test {
         Ok(())
     }
 
+    #[test]
+    fn get_key_x_only_pubkey() -> anyhow::Result<()> {
+        let secp = Secp256k1::new();
+        let wif = "cU6BxEezV8FnkEPBCaFtc4WNuUKmgFaAu6sJErB154GXgMUjhgWe";
+        let prv = bitcoin::PrivateKey::from_wif(wif)?;
+        let (x_only_pk, _parity) = prv.inner.x_only_public_key(&secp);
+
+        let s = format!("wpkh({wif})");
+        let (_, keymap) = Descriptor::parse_descriptor(&secp, &s).unwrap();
+
+        let signer = Signer(keymap);
+        let req = KeyRequest::XOnlyPubkey(x_only_pk);
+        let res = signer.get_key(req, &secp);
+        assert!(matches!(
+            res,
+            Ok(Some(k)) if k.inner.x_only_public_key(&secp).0 == x_only_pk
+        ));
+        Ok(())
+    }
+
     // Test `Signer` can fulfill a bip32 KeyRequest if we know the key origin
     #[test]
     fn get_key_bip32() -> anyhow::Result<()> {
@@ -141,4 +170,35 @@ mod test {
 
         Ok(())
     }
+
+    #[test]
+    fn get_key_xpriv_with_key_origin() -> anyhow::Result<()> {
+        let secp = Secp256k1::new();
+        let s = "wpkh([d34db33f/84h/1h/0h]tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)";
+        let (_, keymap) = Descriptor::parse_descriptor(&secp, s)?;
+
+        let desc_sk = DescriptorSecretKey::from_str("[d34db33f/84h/1h/0h]tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*")?;
+        let desc_xkey = match desc_sk {
+            DescriptorSecretKey::XPrv(k) => k,
+            _ => panic!(),
+        };
+
+        let (fp, _) = desc_xkey.origin.clone().unwrap();
+        let path = DerivationPath::from_str("84h/1h/0h/7")?;
+        let req = KeyRequest::Bip32((fp, path));
+
+        let exp_prv = desc_xkey
+            .xkey
+            .derive_priv(&secp, &[ChildNumber::from(7)])?
+            .to_priv();
+
+        let res = Signer(keymap).get_key(req, &secp);
+
+        assert!(matches!(
+            res,
+            Ok(Some(k)) if k == exp_prv,
+        ));
+
+        Ok(())
+    }
 }