standalone cpfp logic using CpfpParams and rebuilding Wallet::create_cpfp_tx example

Author: aagbotemi

Cargo.toml

@@ -13,14 +13,14 @@ readme = "README.md"
 [dependencies]
 miniscript = { version = "12", default-features = false }
 bdk_coin_select = "0.4.0"
-bdk_chain = { version = "0.23.0" }
 
 [dev-dependencies]
 anyhow = "1"
 bdk_tx = { path = "." }
 bitcoin = { version = "0.32", features = ["rand-std"] }
 bdk_testenv = "0.13.0"
 bdk_bitcoind_rpc = "0.20.0"
+bdk_chain = { version = "0.23.0" }
 
 [features]
 default = ["std"]
@@ -29,6 +29,9 @@ std = ["miniscript/std"]
 [[example]]
 name = "synopsis"
 
+[[example]]
+name = "cpfp"
+
 [[example]]
 name = "common"
 crate-type = ["lib"]

examples/common.rs

@@ -9,9 +9,9 @@ use bdk_chain::{
 use bdk_coin_select::DrainWeights;
 use bdk_testenv::{bitcoincore_rpc::RpcApi, TestEnv};
 use bdk_tx::{
-    CanonicalUnspents, Input, InputCandidates, RbfParams, Selection, TxStatus, TxWithStatus,
+    CanonicalUnspents, CpfpParams, Input, InputCandidates, RbfParams, ScriptSource, Selection, TxStatus, TxWithStatus
 };
-use bitcoin::{absolute, Address, BlockHash, FeeRate, OutPoint, Transaction, Txid};
+use bitcoin::{absolute, Address, Amount, BlockHash, FeeRate, OutPoint, Transaction, Txid, Weight};
 use miniscript::{
     plan::{Assets, Plan},
     Descriptor, DescriptorPublicKey, ForEachKey,
@@ -204,35 +204,81 @@ impl Wallet {
         ))
     }
 
-    pub fn create_cpfp_transaction(
+    pub fn create_cpfp_tx(
         &mut self,
         parent_txids: impl IntoIterator<Item = Txid>,
         target_package_feerate: FeeRate,
     ) -> anyhow::Result<Selection> {
+        let parent_txids: Vec<Txid> = parent_txids.into_iter().collect();
+
+        // Check for empty parent_txids
+        if parent_txids.is_empty() {
+            return Err(anyhow::anyhow!("No parent transactions provided"));
+        }
+
         let assets = self.assets();
         let canon_utxos = CanonicalUnspents::new(self.canonical_txs());
+        let graph = self.graph.graph();
 
-        let script_pubkey = self.next_address().unwrap().script_pubkey();
         let ownership_check =
             |outpoint: OutPoint| -> bool { self.graph.index.txout(outpoint).is_some() };
 
-        let cpfpset = canon_utxos.build_cpfp_set_from_txids(
-            parent_txids,
-            self.graph.graph(),
-            ownership_check,
-        )?;
-        let plans = cpfpset
-            .selected_outpoints
-            .iter()
-            .filter_map(|op| self.plan_of_output(*op, &assets));
-
-        let selection = cpfpset.create_cpfp_transaction(
-            &canon_utxos,
+        // Collect inputs and calculate package fee and weight
+        let mut inputs = Vec::new();
+        let mut package_fee = Amount::ZERO;
+        let mut package_weight = Weight::ZERO;
+
+        for txid in parent_txids {
+            let tx = canon_utxos
+                .get_tx(&txid)
+                .ok_or_else(|| anyhow::anyhow!("parent transaction {} not found", txid))?;
+
+            if canon_utxos.get_status(&txid).is_none() {
+                package_fee += graph.calculate_fee(tx)?;
+                package_weight += tx.weight();
+            }
+
+            let mut found = false;
+
+            for (vout, _) in tx.output.iter().enumerate() {
+                let outpoint = OutPoint::new(txid, vout as u32);
+
+                if canon_utxos.is_unspent(outpoint) && ownership_check(outpoint) {
+                    let plan = self
+                        .plan_of_output(outpoint, &assets)
+                        .ok_or_else(|| anyhow::anyhow!("no plan for outpoint {}", outpoint))?;
+                    let input = canon_utxos.try_get_unspent(outpoint, plan).ok_or_else(|| {
+                        anyhow::anyhow!("failed to get input for outpoint {}", outpoint)
+                    })?;
+                    inputs.push(input);
+                    found = true;
+                    break;
+                }
+            }
+
+            if !found {
+                return Err(anyhow::anyhow!(
+                    "no owned unspent output found for txid {}",
+                    txid
+                ));
+            }
+        }
+
+        let script_pubkey = self
+            .next_address()
+            .ok_or_else(|| anyhow::anyhow!("failed to get next address"))?
+            .script_pubkey();
+        let output_script = ScriptSource::from_script(script_pubkey);
+
+        let cpfp_params = CpfpParams::new(
+            package_fee,
+            package_weight,
+            inputs,
             target_package_feerate,
-            &script_pubkey,
-            plans,
-        )?;
+            output_script,
+        );
 
+        let selection = cpfp_params.into_selection()?;
         Ok(selection)
     }
 }

examples/cpfp.rs

@@ -85,7 +85,7 @@ fn main() -> anyhow::Result<()> {
     }
 
     // Create CPFP transaction to boost both parents
-    let cpfp_selection = wallet.create_cpfp_transaction(
+    let cpfp_selection = wallet.create_cpfp_tx(
         parent_txids.clone(),
         FeeRate::from_sat_per_vb_unchecked(10), // user specified
     )?;

src/canonical_unspents.rs

@@ -2,13 +2,12 @@ use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::fmt;
 
+use bitcoin::{psbt, OutPoint, Sequence, Transaction, TxOut, Txid};
+use miniscript::{bitcoin, plan::Plan};
+
 use crate::{
-    collections::HashMap, input::CoinbaseMismatch, CPFPError, CPFPSet, FromPsbtInputError, Input,
-    RbfSet, TxStatus,
+    collections::HashMap, input::CoinbaseMismatch, FromPsbtInputError, Input, RbfSet, TxStatus,
 };
-use bdk_chain::TxGraph;
-use bitcoin::{psbt, Amount, OutPoint, Sequence, Transaction, TxOut, Txid, Weight};
-use miniscript::{bitcoin, plan::Plan};
 
 /// Tx with confirmation status.
 pub type TxWithStatus<T> = (T, Option<TxStatus>);
@@ -21,22 +20,6 @@ pub struct CanonicalUnspents {
     spends: HashMap<OutPoint, Txid>,
 }
 
-fn select_upper_middle_output(candidates: &[(OutPoint, &TxOut)]) -> OutPoint {
-    let len = candidates.len();
-
-    let index = match len {
-        1..=2 => len - 1, // select the largest for small sets
-        3..=5 => len - 2, // select second largest for medium sets
-        _ => {
-            let upper_third_start = (len * 2) / 3;
-            let upper_third_end = len - 1;
-            (upper_third_start + upper_third_end) / 2
-        }
-    };
-
-    candidates[index].0
-}
-
 impl CanonicalUnspents {
     /// Construct [`CanonicalUnspents`] from an iterator of txs with confirmation status.
     pub fn new<T>(canonical_txs: impl IntoIterator<Item = TxWithStatus<T>>) -> Self
@@ -143,83 +126,6 @@ impl CanonicalUnspents {
         )
     }
 
-    /// Constructs a '[CPFPSet]' from a set of parent transaction IDs.
-    pub fn build_cpfp_set_from_txids<F>(
-        &self,
-        parent_txids: impl IntoIterator<Item = Txid>,
-        graph: &TxGraph,
-        ownership_check: F,
-    ) -> Result<CPFPSet, CPFPError>
-    where
-        F: Fn(OutPoint) -> bool + Clone,
-    {
-        let parent_txids: Vec<Txid> = parent_txids.into_iter().collect();
-
-        const MAX_ANCESTORS: usize = 25;
-        if parent_txids.len() > MAX_ANCESTORS {
-            return Err(CPFPError::ExcessUnconfirmedAncestor);
-        }
-
-        let (parent_weight, parent_fee, selected_outpoints) = parent_txids.iter().try_fold(
-            (Weight::ZERO, Amount::ZERO, Vec::new()),
-            |(mut weight, mut fee, mut outpoints), txid| -> Result<_, CPFPError> {
-                let tx = self.get_tx(txid).ok_or(CPFPError::MissingParent(*txid))?;
-
-                weight += tx.weight();
-                fee += graph.calculate_fee(tx)?;
-
-                let selected_outpoint =
-                    self.select_owned_unspent_output(tx.clone(), ownership_check.clone())?;
-                outpoints.push(selected_outpoint);
-
-                Ok((weight, fee, outpoints))
-            },
-        )?;
-
-        Ok(CPFPSet::new(parent_fee, parent_weight, selected_outpoints))
-    }
-
-    /// Selects the unspent output from a given transaction
-    pub fn select_owned_unspent_output<F>(
-        &self,
-        tx: Arc<Transaction>,
-        ownership_check: F,
-    ) -> Result<OutPoint, CPFPError>
-    where
-        F: Fn(OutPoint) -> bool,
-    {
-        let txid = tx.compute_txid();
-        let mut candidates: Vec<_> = tx
-            .output
-            .iter()
-            .enumerate()
-            .map(|(vout, txout)| {
-                (
-                    OutPoint {
-                        txid,
-                        vout: vout as u32,
-                    },
-                    txout,
-                )
-            })
-            .filter(|(op, tx_out)| {
-                // Must be unspent, owned and above dust threshold
-                self.is_unspent(*op)
-                    && ownership_check(*op)
-                    && tx_out.value >= tx_out.script_pubkey.minimal_non_dust()
-            })
-            .collect();
-
-        if candidates.is_empty() {
-            return Err(CPFPError::NoUnspentOutput(txid));
-        }
-
-        candidates.sort_by_key(|(_, txout)| txout.value);
-        let selected_outpoint = select_upper_middle_output(&candidates);
-
-        Ok(selected_outpoint)
-    }
-
     /// Whether outpoint is a leaf (unspent).
     pub fn is_unspent(&self, outpoint: OutPoint) -> bool {
         if self.spends.contains_key(&outpoint) {
@@ -323,6 +229,11 @@ impl CanonicalUnspents {
     pub fn get_tx(&self, txid: &Txid) -> Option<&Arc<Transaction>> {
         self.txs.get(txid)
     }
+
+    /// Retrieves a status by its transaction ID.
+    pub fn get_status(&self, txid: &Txid) -> Option<&TxStatus> {
+        self.statuses.get(txid)
+    }
 }
 
 /// Canonical unspents error