WIP: More functional

evanlinjin · evanlinjin · commit 030018ad3bde · 2025-04-10T09:14:56.000+10:00
diff --git a/src/coin_control.rs b/src/coin_control.rs
@@ -6,7 +6,7 @@ use crate::{
 };
 use alloc::vec::Vec;
 use bdk_chain::{BlockId, ChainOracle, ConfirmationBlockTime, TxGraph};
-use bitcoin::{absolute, OutPoint, Transaction, Txid};
+use bitcoin::{absolute, OutPoint, Txid};
 use miniscript::{bitcoin, plan::Plan};
 
 /// Coin control.
diff --git a/src/input_candidates.rs b/src/input_candidates.rs
@@ -1,7 +1,12 @@
-use crate::collections::HashSet;
+use core::{
+    fmt::{Debug, Display},
+    ops::Deref,
+};
+
+use crate::{collections::HashSet, cs_feerate, Selection, Selector, SelectorParams};
 use alloc::vec::Vec;
-use bdk_coin_select::Candidate;
-use bitcoin::OutPoint;
+use bdk_coin_select::{metrics::LowestFee, Candidate, NoBnbSolution};
+use bitcoin::{FeeRate, OutPoint};
 use miniscript::bitcoin;
 
 use crate::InputGroup;
@@ -15,6 +20,101 @@ pub struct InputCandidates {
     cs_candidates: Vec<Candidate>,
 }
 
+/// Occurs when we cannot find a solution for selection.
+#[derive(Debug)]
+pub enum IntoSelectionError<E> {
+    /// Parameters provided created an invalid change policy.
+    InvalidChangePolicy(miniscript::Error),
+    /// Selection algorithm failed.
+    SelectionAlgorithm(E),
+    /// Cannot meet target.
+    CannotMeetTarget,
+}
+
+impl<E: Display> Display for IntoSelectionError<E> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            IntoSelectionError::InvalidChangePolicy(error) => {
+                write!(f, "invalid change policy: {}", error)
+            }
+            IntoSelectionError::SelectionAlgorithm(error) => {
+                write!(f, "selection algorithm failed: {}", error)
+            }
+            IntoSelectionError::CannotMeetTarget => write!(f, "cannot meet target"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<E: Debug + Display> std::error::Error for IntoSelectionError<E> {}
+
+/// Occurs when we are missing ouputs.
+#[derive(Debug)]
+pub struct MissingOutputs(HashSet<OutPoint>);
+
+impl Deref for MissingOutputs {
+    type Target = HashSet<OutPoint>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Display for MissingOutputs {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "missing outputs: {:?}", self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for MissingOutputs {}
+
+/// Occurs when a must-select policy cannot be fulfilled.
+#[derive(Debug)]
+pub enum PolicyFailure<PF> {
+    /// Missing outputs.
+    MissingOutputs(MissingOutputs),
+    /// Policy failure.
+    PolicyFailure(PF),
+}
+
+impl<PF: Debug> Display for PolicyFailure<PF> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            PolicyFailure::MissingOutputs(missing_outputs) => Debug::fmt(missing_outputs, f),
+            PolicyFailure::PolicyFailure(failure) => {
+                write!(f, "policy failure: {:?}", failure)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<PF: Debug> std::error::Error for PolicyFailure<PF> {}
+
+/// Select for lowest fee with bnb
+pub fn selection_algorithm_lowest_fee_bnb(
+    longterm_feerate: FeeRate,
+    max_rounds: usize,
+) -> impl FnMut(&InputCandidates, &mut Selector) -> Result<(), NoBnbSolution> {
+    let long_term_feerate = cs_feerate(longterm_feerate);
+    move |_, selector| {
+        let target = selector.target();
+        let change_policy = selector.change_policy();
+        selector
+            .inner_mut()
+            .run_bnb(
+                LowestFee {
+                    target,
+                    long_term_feerate,
+                    change_policy,
+                },
+                max_rounds,
+            )
+            .map(|_| ())
+    }
+}
+
 impl InputCandidates {
     /// Create
     ///
@@ -51,7 +151,7 @@ impl InputCandidates {
     /// # Error
     ///
     /// Returns the original [`InputCandidates`] if any outpoint is not found.
-    pub fn with_must_select(self, outpoints: HashSet<OutPoint>) -> Result<Self, Self> {
+    pub fn with_must_select(self, outpoints: HashSet<OutPoint>) -> Result<Self, MissingOutputs> {
         let (must_select, can_select) = self.groups.iter().partition::<Vec<_>, _>(|group| {
             group.any(|input| outpoints.contains(&input.prev_outpoint()))
         });
@@ -62,7 +162,9 @@ impl InputCandidates {
             .flat_map(|group| group.inputs().iter().map(|input| input.prev_outpoint()))
             .collect::<HashSet<OutPoint>>();
         if !must_select_map.is_superset(&outpoints) {
-            return Err(self);
+            return Err(MissingOutputs(
+                outpoints.difference(&must_select_map).copied().collect(),
+            ));
         }
 
         let must_select_count = must_select.len();
@@ -88,12 +190,32 @@ impl InputCandidates {
     }
 
     /// Like [`InputCandidates::with_must_select`], but with a policy closure.
-    pub fn with_must_select_policy<P>(self, mut policy: P) -> Result<Self, Self>
+    pub fn with_must_select_policy<P, PF>(self, mut policy: P) -> Result<Self, PolicyFailure<PF>>
     where
-        P: FnMut(&Self) -> HashSet<OutPoint>,
+        P: FnMut(&Self) -> Result<HashSet<OutPoint>, PF>,
     {
-        let outpoints = policy(&self);
+        let outpoints = policy(&self).map_err(PolicyFailure::PolicyFailure)?;
         self.with_must_select(outpoints)
+            .map_err(PolicyFailure::MissingOutputs)
+    }
+
+    /// Into selection.
+    pub fn into_selection<A, E>(
+        self,
+        mut selection_algorithm: A,
+        params: SelectorParams,
+    ) -> Result<Selection, IntoSelectionError<E>>
+    where
+        A: FnMut(&Self, &mut Selector) -> Result<(), E>,
+    {
+        let mut selector =
+            Selector::new(&self, params).map_err(IntoSelectionError::InvalidChangePolicy)?;
+        selection_algorithm(&self, &mut selector)
+            .map_err(IntoSelectionError::SelectionAlgorithm)?;
+        let selection = selector
+            .try_finalize()
+            .ok_or(IntoSelectionError::CannotMeetTarget)?;
+        Ok(selection)
     }
 
     /// Whether the outpoint is contained in our candidates.
diff --git a/src/rbf.rs b/src/rbf.rs
@@ -1,3 +1,5 @@
+use core::fmt::Display;
+
 use alloc::vec::Vec;
 use bitcoin::{absolute, Amount, OutPoint, Transaction, TxOut, Txid};
 use miniscript::bitcoin;
@@ -11,6 +13,26 @@ pub struct RbfSet<'t> {
     prev_txouts: HashMap<OutPoint, TxOut>,
 }
 
+/// Occurs when the given original tx has no input spend that is still available for spending.
+#[derive(Debug)]
+pub struct OriginalTxHasNoInputsAvailable {
+    /// Original txid.
+    pub txid: Txid,
+}
+
+impl Display for OriginalTxHasNoInputsAvailable {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(
+            f,
+            "original tx {} has no input spend that is still available",
+            self.txid
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for OriginalTxHasNoInputsAvailable {}
+
 impl<'t> RbfSet<'t> {
     /// Create.
     ///
@@ -78,13 +100,13 @@ impl<'t> RbfSet<'t> {
     /// This guarantees that the txs are replaced.
     pub fn must_select_largest_input_per_tx(
         &self,
-    ) -> impl FnMut(&InputCandidates) -> HashSet<OutPoint> + '_ {
+    ) -> impl FnMut(&InputCandidates) -> Result<HashSet<OutPoint>, OriginalTxHasNoInputsAvailable> + '_
+    {
         |input_candidates| {
             let mut must_select = HashSet::new();
 
             for original_tx in self.txs.values() {
                 let mut largest_value = Amount::ZERO;
-                let mut largest_value_not_canonical = Amount::ZERO;
                 let mut largest_spend = Option::<OutPoint>::None;
                 let original_tx_spends = original_tx.input.iter().map(|txin| txin.previous_output);
                 for spend in original_tx_spends {
@@ -95,14 +117,8 @@ impl<'t> RbfSet<'t> {
                     }
                     let txout = self.prev_txouts.get(&spend).expect("must have prev txout");
 
-                    // not canonical
+                    // not available
                     if !input_candidates.contains(spend) {
-                        if largest_value == Amount::ZERO
-                            && txout.value > largest_value_not_canonical
-                        {
-                            largest_value_not_canonical = txout.value;
-                            largest_spend = Some(spend);
-                        }
                         continue;
                     }
 
@@ -111,11 +127,13 @@ impl<'t> RbfSet<'t> {
                         largest_spend = Some(spend);
                     }
                 }
-                let largest_spend = largest_spend.expect("tx must have atleast one input");
+                let largest_spend = largest_spend.ok_or(OriginalTxHasNoInputsAvailable {
+                    txid: original_tx.compute_txid(),
+                })?;
                 must_select.insert(largest_spend);
             }
 
-            must_select
+            Ok(must_select)
         }
     }
 
diff --git a/tests/synopsis.rs b/tests/synopsis.rs
@@ -2,8 +2,8 @@ use bdk_bitcoind_rpc::Emitter;
 use bdk_chain::{bdk_core, local_chain::LocalChain, Balance};
 use bdk_testenv::{bitcoincore_rpc::RpcApi, TestEnv};
 use bdk_tx::{
-    filter_unspendable_now, group_by_spk, no_grouping, ChangePolicyType, CoinControl, Output,
-    PsbtParams, RbfSet, Selector, SelectorParams, Signer,
+    filter_unspendable_now, group_by_spk, no_grouping, selection_algorithm_lowest_fee_bnb,
+    ChangePolicyType, CoinControl, Output, PsbtParams, RbfSet, Selector, SelectorParams, Signer,
 };
 use bitcoin::{absolute, key::Secp256k1, Address, Amount, BlockHash, FeeRate, Sequence, Txid};
 use miniscript::{plan::Assets, Descriptor, DescriptorPublicKey, ForEachKey};
@@ -138,42 +138,29 @@ fn synopsis() -> anyhow::Result<()> {
     println!("balance: {}", wallet.balance());
 
     let (tip_height, tip_time) = wallet.tip_info(env.rpc_client())?;
+    let longterm_feerate = FeeRate::from_sat_per_vb_unchecked(1);
 
     let recipient_addr = env
         .rpc_client()
         .get_new_address(None, None)?
         .assume_checked();
 
     // okay now create tx.
-    let coin_control = wallet.coin_control(None)?;
-    println!("excluded: {:?}", coin_control.excluded());
-    let input_candidates =
-        coin_control.into_candidates(group_by_spk(), filter_unspendable_now(tip_height, tip_time));
-    println!(
-        ":: input candidate groups: {}",
-        input_candidates.groups().len()
-    );
-
-    let longterm_feerate = FeeRate::from_sat_per_vb_unchecked(1);
-    let mut selector = Selector::new(
-        &input_candidates,
-        SelectorParams::new(
-            FeeRate::from_sat_per_vb_unchecked(10),
-            vec![Output::with_script(
-                recipient_addr.script_pubkey(),
-                Amount::from_sat(21_000_000),
-            )],
-            internal.at_derivation_index(0)?,
-            bdk_tx::ChangePolicyType::NoDustAndLeastWaste { longterm_feerate },
-        ),
-    )?;
-    println!(
-        "bnb score: {}",
-        selector.select_for_lowest_fee(longterm_feerate, 100_000)?
-    );
-    let selection = selector
-        .try_finalize()
-        .ok_or(anyhow::anyhow!("failed to find solution"))?;
+    let selection = wallet
+        .coin_control(None)?
+        .into_candidates(group_by_spk(), filter_unspendable_now(tip_height, tip_time))
+        .into_selection(
+            selection_algorithm_lowest_fee_bnb(longterm_feerate, 100_000),
+            SelectorParams::new(
+                FeeRate::from_sat_per_vb_unchecked(10),
+                vec![Output::with_script(
+                    recipient_addr.script_pubkey(),
+                    Amount::from_sat(21_000_000),
+                )],
+                internal.at_derivation_index(0)?,
+                bdk_tx::ChangePolicyType::NoDustAndLeastWaste { longterm_feerate },
+            ),
+        )?;
 
     let mut psbt = selection.create_psbt(PsbtParams {
         fallback_sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
@@ -227,7 +214,7 @@ fn synopsis() -> anyhow::Result<()> {
         .expect("must have no missing prevouts");
 
         // Input candidates.
-        let candidates = wallet
+        let selection = wallet
             // We canonicalize first.
             // This ensures all input candidates are of a consistent UTXO set.
             // The canonicalization is modified by excluding the original txs and their
@@ -242,34 +229,26 @@ fn synopsis() -> anyhow::Result<()> {
             // need to guarantee atleast one prevout of each original tx is picked, otherwise we
             // may not actually replace the original txs.
             // The policy used here is to choose the largest value prevout of each original tx.
-            .with_must_select_policy(rbf_set.must_select_largest_input_per_tx())
-            .expect("this cannot fail here");
-
-        // Now we actually do coin selection.
-        let mut selector = Selector::new(
-            &candidates,
-            SelectorParams {
-                // This is just a lower-bound feerate. The actual result will be much higher to
-                // satisfy mempool-replacement policy.
-                target_feerate: FeeRate::from_sat_per_vb_unchecked(1),
-                // We cancel the tx by specifying no target outputs. This way, all excess returns
-                // to our change output (unless if the prevouts picked are so small that it will
-                // 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_policy: ChangePolicyType::NoDustAndLeastWaste { longterm_feerate },
-                // This ensures that we satisfy mempool-replacement policy rules 4 and 6.
-                replace: Some(rbf_set.selector_rbf_params()),
-            },
-        )?;
-        println!(
-            "replacement tx score: {}",
-            selector.select_for_lowest_fee(longterm_feerate, 100_000)?
-        );
-        let selection = selector
-            .try_finalize()
-            .expect("failed to finalize replacement tx");
+            .with_must_select_policy(rbf_set.must_select_largest_input_per_tx())?
+            // Do coin selection.
+            .into_selection(
+                // Coin selection algorithm.
+                selection_algorithm_lowest_fee_bnb(longterm_feerate, 100_000),
+                SelectorParams {
+                    // This is just a lower-bound feerate. The actual result will be much higher to
+                    // satisfy mempool-replacement policy.
+                    target_feerate: FeeRate::from_sat_per_vb_unchecked(1),
+                    // We cancel the tx by specifying no target outputs. This way, all excess returns
+                    // to our change output (unless if the prevouts picked are so small that it will
+                    // 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_policy: ChangePolicyType::NoDustAndLeastWaste { longterm_feerate },
+                    // This ensures that we satisfy mempool-replacement policy rules 4 and 6.
+                    replace: Some(rbf_set.selector_rbf_params()),
+                },
+            )?;
 
         let mut psbt = selection.create_psbt(PsbtParams {
             // Not strictly necessary, but it may help us replace this replacement faster.
