draft: move weighted_utxo to seperate module

Author: yancyribbens

src/branch_and_bound.rs

@@ -171,8 +171,11 @@ pub fn branch_and_bound<'a, T: IntoIterator<Item = &'a WeightedUtxo> + std::mark
     let mut weighted_utxos: Vec<_> = weighted_utxos.into_iter().collect();
 
     // descending sort by effective_value, ascending sort by waste.
-    weighted_utxos
-        .sort_by(|a, b| b.effective_value().cmp(&a.effective_value()).then(a.waste.cmp(&b.waste)));
+    weighted_utxos.sort_by(|a, b| {
+        b.effective_value_raw()
+            .cmp(&a.effective_value_raw())
+            .then(a.waste_raw().cmp(&b.waste_raw()))
+    });
 
     if available_value < target {
         return Err(InsufficentFunds);
@@ -247,13 +250,13 @@ pub fn branch_and_bound<'a, T: IntoIterator<Item = &'a WeightedUtxo> + std::mark
                     break;
                 }
 
-                let eff_value = weighted_utxos[index].effective_value;
+                let eff_value = weighted_utxos[index].effective_value_raw();
                 available_value += eff_value;
             }
 
             assert_eq!(index, *index_selection.last().unwrap());
-            let eff_value = weighted_utxos[index].effective_value;
-            let utxo_waste = weighted_utxos[index].waste;
+            let eff_value = weighted_utxos[index].effective_value_raw();
+            let utxo_waste = weighted_utxos[index].waste_raw();
             let utxo_weight = weighted_utxos[index].weight();
             current_waste = current_waste.checked_sub(utxo_waste).ok_or(Overflow(Subtraction))?;
             value = value.checked_sub(eff_value).ok_or(Overflow(Addition))?;
@@ -262,9 +265,9 @@ pub fn branch_and_bound<'a, T: IntoIterator<Item = &'a WeightedUtxo> + std::mark
         }
         // * Add next node to the inclusion branch.
         else {
-            let eff_value = weighted_utxos[index].effective_value;
+            let eff_value = weighted_utxos[index].effective_value_raw();
             let utxo_weight = weighted_utxos[index].weight();
-            let utxo_waste = weighted_utxos[index].waste;
+            let utxo_waste = weighted_utxos[index].waste_raw();
 
             // unchecked sub is used her for performance.
             // The bounds for available_value are at most the sum of utxos
@@ -277,7 +280,7 @@ pub fn branch_and_bound<'a, T: IntoIterator<Item = &'a WeightedUtxo> + std::mark
                 // Check if the previous UTXO was included.
                 || index - 1 == *index_selection.last().unwrap()
                 // Check if the previous UTXO has the same value has the previous one.
-                || weighted_utxos[index].effective_value != weighted_utxos[index - 1].effective_value
+                || weighted_utxos[index].effective_value_raw() != weighted_utxos[index - 1].effective_value_raw()
             {
                 index_selection.push(index);
                 current_waste = current_waste.checked_add(utxo_waste).ok_or(Overflow(Addition))?;

src/coin_grinder.rs

@@ -672,7 +672,7 @@ mod tests {
                     let w = u.int_in_range::<u64>(1..=Weight::MAX.to_wu()).unwrap();
                     let wu = Weight::from_wu(w);
                     WeightedUtxo::new(
-                        utxo.value,
+                        utxo.value(),
                         wu,
                         exclusion_set.fee_rate,
                         exclusion_set.long_term_fee_rate,
@@ -685,14 +685,14 @@ mod tests {
                 .iter()
                 .map(|utxo| {
                     WeightedUtxo::new(
-                        utxo.value,
+                        utxo.value(),
                         Weight::ZERO,
                         inclusion_set.fee_rate,
                         inclusion_set.long_term_fee_rate,
                     )
                     .unwrap()
                 })
-                .filter(|utxo| utxo.value == Amount::ZERO)
+                .filter(|utxo| utxo.value() == Amount::ZERO)
                 .collect();
 
             if let Some(target) = weightless_pool.iter().map(|utxo| utxo.value()).checked_sum() {

src/lib.rs

@@ -15,11 +15,13 @@ mod branch_and_bound;
 mod coin_grinder;
 mod single_random_draw;
 
+mod weighted_utxo;
+
+pub use crate::weighted_utxo::WeightedUtxo;
+
 /// Possible returned error types if no match is found.
 pub mod errors;
 
-use std::cmp::Ordering;
-
 use bitcoin_units::{Amount, FeeRate, SignedAmount, Weight};
 #[cfg(feature = "rand")]
 #[cfg_attr(docsrs, doc(cfg(feature = "rand")))]
@@ -60,91 +62,6 @@ pub(crate) fn effective_value(
     Some(eff_value)
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-/// Represents the spendable conditions of a `UTXO`.
-pub struct WeightedUtxo {
-    /// The `Amount` that the output contributes towards the selection target.
-    value: Amount,
-    /// The estimated `Weight` (satisfaction weight + base weight) of the output.
-    weight: Weight,
-    /// The positive effective value `(value - fee)`.  This value is stored as a `u64` for
-    /// better performance.
-    effective_value: u64,
-    /// The `SignedAmount` required to spend the output at the given `fee_rate`.
-    fee: SignedAmount,
-    /// The `SignedAmount` required to spend the output at the given `long_term_fee_rate`.
-    long_term_fee: SignedAmount,
-    /// A metric for how wasteful it is to spend this `WeightedUtxo` given the current fee
-    /// environment.
-    waste: i64,
-}
-
-impl WeightedUtxo {
-    /// Creates a new `WeightedUtxo`.
-    pub fn new(
-        value: Amount,
-        weight: Weight,
-        fee_rate: FeeRate,
-        long_term_fee_rate: FeeRate,
-    ) -> Option<WeightedUtxo> {
-        let positive_effective_value = Self::positive_effective_value(fee_rate, weight, value);
-
-        if let Some(effective_value) = positive_effective_value {
-            let fee = fee_rate.fee_wu(weight)?.to_signed();
-            let long_term_fee: SignedAmount = long_term_fee_rate.fee_wu(weight)?.to_signed();
-            let waste = Self::calculate_waste(fee, long_term_fee);
-            return Some(Self { value, weight, effective_value, fee, long_term_fee, waste });
-        }
-
-        None
-    }
-
-    /// Calculates if the current fee environment is expensive.
-    pub fn is_fee_expensive(&self) -> bool { self.fee > self.long_term_fee }
-
-    /// Returns the associated value.
-    pub fn value(&self) -> Amount { self.value }
-
-    /// Returns the associated weight.
-    pub fn weight(&self) -> Weight { self.weight }
-
-    /// Returns the associated waste.
-    pub fn waste(&self) -> SignedAmount { SignedAmount::from_sat(self.waste).unwrap() }
-
-    /// Returns the calculated effective value.
-    pub fn effective_value(&self) -> Amount { Amount::from_sat(self.effective_value).unwrap() }
-
-    /// Returns the calculated effective value using the underlying type without transformation.
-    pub fn effective_value_raw(&self) -> u64 { self.effective_value }
-
-    /// Returns the calculated waste using the underlying type without transformation.
-    pub fn waste_raw(&self) -> i64 { self.waste }
-
-    fn positive_effective_value(fee_rate: FeeRate, weight: Weight, value: Amount) -> Option<u64> {
-        if let Some(eff_value) = effective_value(fee_rate, weight, value) {
-            if let Ok(unsigned) = eff_value.to_unsigned() {
-                return Some(unsigned.to_sat());
-            }
-        }
-
-        None
-    }
-
-    fn calculate_waste(fee: SignedAmount, long_term_fee: SignedAmount) -> i64 {
-        fee.to_sat() - long_term_fee.to_sat()
-    }
-}
-
-impl Ord for WeightedUtxo {
-    fn cmp(&self, other: &Self) -> Ordering {
-        other.effective_value.cmp(&self.effective_value).then(self.weight.cmp(&other.weight))
-    }
-}
-
-impl PartialOrd for WeightedUtxo {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
-}
-
 /// Attempt a match with [`branch_and_bound`] falling back to [`single_random_draw`].
 ///
 /// If [`branch_and_bound`] fails to find a changeless solution (basically, an exact match), then

src/weighted_utxo.rs

@@ -0,0 +1,90 @@
+use std::cmp::Ordering;
+
+use bitcoin_units::{Amount, FeeRate, SignedAmount, Weight};
+
+use crate::effective_value;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// Represents the spendable conditions of a `UTXO`.
+pub struct WeightedUtxo {
+    /// The `Amount` that the output contributes towards the selection target.
+    value: Amount,
+    /// The estimated `Weight` (satisfaction weight + base weight) of the output.
+    weight: Weight,
+    /// The positive effective value `(value - fee)`.  This value is stored as a `u64` for
+    /// better performance.
+    effective_value: u64,
+    /// The `SignedAmount` required to spend the output at the given `fee_rate`.
+    fee: SignedAmount,
+    /// The `SignedAmount` required to spend the output at the given `long_term_fee_rate`.
+    long_term_fee: SignedAmount,
+    /// A metric for how wasteful it is to spend this `WeightedUtxo` given the current fee
+    /// environment.
+    waste: i64,
+}
+
+impl WeightedUtxo {
+    /// Creates a new `WeightedUtxo`.
+    pub fn new(
+        value: Amount,
+        weight: Weight,
+        fee_rate: FeeRate,
+        long_term_fee_rate: FeeRate,
+    ) -> Option<WeightedUtxo> {
+        let positive_effective_value = Self::positive_effective_value(fee_rate, weight, value);
+
+        if let Some(effective_value) = positive_effective_value {
+            let fee = fee_rate.fee_wu(weight)?.to_signed();
+            let long_term_fee: SignedAmount = long_term_fee_rate.fee_wu(weight)?.to_signed();
+            let waste = Self::calculate_waste(fee, long_term_fee);
+            return Some(Self { value, weight, effective_value, fee, long_term_fee, waste });
+        }
+
+        None
+    }
+
+    /// Calculates if the current fee environment is expensive.
+    pub fn is_fee_expensive(&self) -> bool { self.fee > self.long_term_fee }
+
+    /// Returns the associated value.
+    pub fn value(&self) -> Amount { self.value }
+
+    /// Returns the associated weight.
+    pub fn weight(&self) -> Weight { self.weight }
+
+    /// Returns the associated waste.
+    pub fn waste(&self) -> SignedAmount { SignedAmount::from_sat(self.waste).unwrap() }
+
+    /// Returns the calculated effective value.
+    pub fn effective_value(&self) -> Amount { Amount::from_sat(self.effective_value).unwrap() }
+
+    /// Returns the calculated effective value using the underlying type without transformation.
+    pub fn effective_value_raw(&self) -> u64 { self.effective_value }
+
+    /// Returns the calculated waste using the underlying type without transformation.
+    pub fn waste_raw(&self) -> i64 { self.waste }
+
+    fn positive_effective_value(fee_rate: FeeRate, weight: Weight, value: Amount) -> Option<u64> {
+        if let Some(eff_value) = effective_value(fee_rate, weight, value) {
+            if let Ok(unsigned) = eff_value.to_unsigned() {
+                return Some(unsigned.to_sat());
+            }
+        }
+
+        None
+    }
+
+    fn calculate_waste(fee: SignedAmount, long_term_fee: SignedAmount) -> i64 {
+        fee.to_sat() - long_term_fee.to_sat()
+    }
+}
+
+impl Ord for WeightedUtxo {
+    fn cmp(&self, other: &Self) -> Ordering {
+        other.effective_value.cmp(&self.effective_value).then(self.weight.cmp(&other.weight))
+    }
+}
+
+impl PartialOrd for WeightedUtxo {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
+}