port 236

yancyribbens · yancyribbens · commit 938881e1502d · 2026-07-05T10:28:41.000-05:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -34,10 +34,9 @@ use crate::errors::{OverflowError, SelectionError};
 #[cfg_attr(docsrs, doc(cfg(feature = "rand")))]
 pub use crate::single_random_draw::single_random_draw;
 
-pub(crate) type Return<'a> = Result<(u32, Vec<&'a WeightedUtxo>), SelectionError>;
+use bitcoin_units::NumOpResult;
 
-// https://github.com/bitcoin/bitcoin/blob/f722a9bd132222d9d5cd503b5af25c905b205cdb/src/wallet/coinselection.h#L20
-const CHANGE_LOWER: Amount = Amount::from_sat_u32(50_000);
+pub(crate) type Return<'a> = Result<(u32, Vec<&'a WeightedUtxo>), SelectionError>;
 
 /// Computes the value of an output accounting for the cost to spend it.
 ///
@@ -251,7 +250,7 @@ mod tests {
     #[test]
     fn select_coins_no_solution() {
         // Test the code branch where both SRD and BnB fail.
-        let target = Amount::from_sat_u32(255432);
+        let target = Amount::from_sat_u32(262644);
         let cost_of_change = Amount::ZERO;
         let max_weight = Weight::from_wu(40_000);
         let pool = build_pool(); // eff value sum 262643
@@ -264,23 +263,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn select_coins_srd_solution() {
-        let target = (Amount::from_sat_u32(255432) - CHANGE_LOWER).unwrap();
-        let cost_of_change = Amount::ZERO;
-        let max_weight = Weight::from_wu(40_000);
-        let pool = build_pool();
-
-        let result = select_coins(target, cost_of_change, max_weight, &pool);
-        let (_iterations, utxos) = result.unwrap();
-        let sum: Amount = utxos
-            .into_iter()
-            .map(|u| u.value())
-            .try_fold(Amount::ZERO, Amount::checked_add)
-            .unwrap();
-        assert!(sum > target);
-    }
-
     #[test]
     fn select_coins_bnb_solution() {
         let target = Amount::from_sat_u32(255432);
@@ -305,6 +287,25 @@ mod tests {
         assert_eq!(16, iterations);
     }
 
+    #[test]
+    fn select_coins_srd_solution() {
+        let fee_rate = FeeRate::from_sat_per_vb(10);
+        let target = Amount::from_sat_u32(50_000);
+        let utxo_amt = Amount::from_sat_u32(100_000);
+        let weight = Weight::from_wu(230); // TR output size
+        let w_utxo = WeightedUtxo::new(utxo_amt, weight, fee_rate, fee_rate).unwrap();
+        let utxo_pool = vec![w_utxo];
+        let cost_of_change = Amount::from_sat_u32(678);
+
+        let (iterations, utxos) =
+            select_coins(target, cost_of_change, Weight::MAX, &utxo_pool).unwrap();
+
+        let sum: Amount = utxos.into_iter().map(|u| u.value()).map(NumOpResult::from).sum::<NumOpResult<Amount>>().unwrap();
+
+        assert!(sum > target);
+        assert_eq!(1, iterations);
+    }
+
     #[test]
     fn select_coins_proptest() {
         arbtest(|u| {
@@ -323,15 +324,13 @@ mod tests {
                 }
                 Err(InsufficentFunds) => {
                     let available_value = candidate_selection.available_value().unwrap();
-                    assert!(available_value < (target + CHANGE_LOWER).unwrap());
+                    assert!(available_value < target);
                 }
                 Err(Overflow(_)) => {
                     let available_value = candidate_selection.available_value();
                     let weight_total = candidate_selection.weight_total();
                     assert!(
-                        available_value.is_none()
-                            || weight_total.is_none()
-                            || target.checked_add(CHANGE_LOWER).is_none()
+                        available_value.is_none() || weight_total.is_none()
                     );
                 }
                 Err(ProgramError) => panic!("un-expected program error"),
diff --git a/src/single_random_draw.rs b/src/single_random_draw.rs
@@ -13,7 +13,7 @@ use rand::seq::SliceRandom;
 
 use crate::OverflowError::Addition;
 use crate::SelectionError::{InsufficentFunds, MaxWeightExceeded, Overflow, ProgramError};
-use crate::{Return, WeightedUtxo, CHANGE_LOWER};
+use crate::{Return, WeightedUtxo};
 
 /// Select coins by Single Random Draw (SRD).
 ///
@@ -59,8 +59,7 @@ pub fn single_random_draw<
         .try_fold(Amount::ZERO, Amount::checked_add)
         .ok_or(Overflow(Addition))?;
 
-    let threshold = target.checked_add(CHANGE_LOWER).ok_or(Overflow(Addition))?;
-    if available_value < threshold {
+    if available_value < target {
         return Err(InsufficentFunds);
     }
 
@@ -69,7 +68,6 @@ pub fn single_random_draw<
     let mut heap: BinaryHeap<&WeightedUtxo> = BinaryHeap::new();
 
     let mut value = Amount::ZERO;
-
     let mut iteration = 0;
     let mut max_tx_weight_exceeded = false;
     let mut weight_total = Weight::ZERO;
@@ -93,7 +91,7 @@ pub fn single_random_draw<
             };
         }
 
-        if value >= threshold {
+        if value >= target {
             let result: Vec<_> = heap.into_sorted_vec();
             return Ok((iteration, result));
         }
@@ -233,55 +231,21 @@ mod tests {
         .assert();
     }
 
-    #[test]
-    fn select_coins_srd_change_output_too_small() {
-        // The resulting change must be greater than CHANGE_LOWER
-        // therefore, an exact match will fail.
-        TestSRD {
-            target: "3 cBTC",
-            fee_rate: "10 sat/kwu",
-            max_weight: "40000 wu",
-            weighted_utxos: &["e(1 cBTC)/68 vB", "e(2 cBTC)/68 vB"],
-            expected_utxos: &[],
-            expected_error: Some(InsufficentFunds),
-            expected_iterations: 0,
-        }
-        .assert();
-    }
-
     #[test]
     fn select_coins_srd_with_high_fee() {
-        // Although the first selected UTXO valued at 2050000 meets the
-        // target and meets the threshold of target + CHANGE, the value
-        // is not enough since when the effective value is calculated,
-        // it falls bellow the threshold.  Therefore multiple UTXOs are
-        // selected.
+        // Both UTXOs are selected since neither has enough effective_value individually
         TestSRD {
             target: "2 cBTC",
             fee_rate: "10 sat/kwu",
             max_weight: "40000 wu",
-            weighted_utxos: &["1 cBTC/68 vB", "2050000 sats/68 vB"],
-            expected_utxos: &["2050000 sats/68 vB", "1 cBTC/68 vB"],
+            weighted_utxos: &["1 cBTC/68 vB", "2 cBTC/68 vB"],
+            expected_utxos: &["2 cBTC/68 vB", "1 cBTC/68 vB"],
             expected_error: None,
             expected_iterations: 2,
         }
         .assert();
     }
 
-    #[test]
-    fn select_coins_srd_threshold_overflow() {
-        TestSRD {
-            target: "2100000000000000 sat", // Amount::MAX
-            fee_rate: "10 sat/kwu",
-            max_weight: "40000 wu",
-            weighted_utxos: &["1 cBTC/68 vB"],
-            expected_utxos: &[],
-            expected_error: Some(Overflow(Addition)),
-            expected_iterations: 0,
-        }
-        .assert();
-    }
-
     #[test]
     fn select_coins_srd_utxo_pool_sum_overflow() {
         TestSRD {
@@ -328,7 +292,7 @@ mod tests {
     #[test]
     fn select_coins_srd_max_weight_eff_value() {
         TestSRD {
-            target: "10000 sats", //threshold = 60k sats
+            target: "60000 sats",
             fee_rate: "10 sat/kwu",
             max_weight: "1000 wu",
             // after rand: [30k sats/500 wu, 29,999 sats/700 wu, 30k sats/500 wu]
@@ -347,7 +311,7 @@ mod tests {
     #[test]
     fn select_coins_srd_max_weight_eff_value_tie() {
         TestSRD {
-            target: "10000 sats", // threshold = 60k sats
+            target: "60000 sats",
             fee_rate: "10 sat/kwu",
             max_weight: "1000 wu",
             // after rand: [30k sats/500 wu, 30k sats/700 wu, 30k sats/500 wu]
@@ -381,7 +345,7 @@ mod tests {
                 }
                 Err(InsufficentFunds) => {
                     let available_value = candidate.available_value().unwrap();
-                    assert!(available_value < (target + CHANGE_LOWER).unwrap());
+                    assert!(available_value < target);
                 }
                 Err(crate::SelectionError::IterationLimitReached) => panic!("un-expected result"),
                 Err(MaxWeightExceeded) => {
@@ -392,9 +356,7 @@ mod tests {
                     let available_value = candidate.available_value();
                     let weight_total = candidate.weight_total();
                     assert!(
-                        available_value.is_none()
-                            || weight_total.is_none()
-                            || target.checked_add(CHANGE_LOWER).is_none()
+                        available_value.is_none() || weight_total.is_none()
                     );
                 }
                 Err(ProgramError) => panic!("un-expected program error"),
