refactor(metrics): extract lp_min_cost_to_cover knapsack helper

The LP-relaxed knapsack inside `ChangelessWaste::bound`'s `rate_diff < 0`
branch — sort by contribution-per-cost descending, take greedily, fractional
last — is a generic primitive: "minimum cost of a fractional subset whose
contributions sum to at least delta". Moves it to `src/metrics.rs` next to
the other shared helpers (`resize_bound`, `excess_with_drain`,
`change_lower_bound`).

No behavior change; `ChangelessWaste` proptests still pass.

The helper has a second caller coming in the next commit (LowestFee's
"get rid of change" branch), which is what motivates the extraction.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: evanlinjin

src/metrics.rs

@@ -1,5 +1,7 @@
 //! Branch and bound metrics that can be passed to [`CoinSelector::bnb_solutions`] or
 //! [`CoinSelector::run_bnb`].
+use alloc::vec::Vec;
+
 use crate::{bnb::BnbMetric, float::Ordf32, Candidate, ChangePolicy, CoinSelector, Drain, Target};
 mod lowest_fee;
 pub use lowest_fee::*;
@@ -125,6 +127,53 @@ fn resize_bound<'a>(
     Some((cs_iter, to_resize, scale))
 }
 
+/// LP-relaxed fractional knapsack: minimum total `cost` of a fractional subset of `items`
+/// whose `contribution`s sum to at least `delta`.
+///
+/// `items` yields `(contribution, cost)` pairs; both must be positive. The LP-optimal greedy
+/// is to sort by `contribution / cost` descending (best ev-reduction per unit cost first) and
+/// take each item fully until the last one, which is taken fractionally to exactly cover the
+/// remaining deficit.
+///
+/// Returns `None` if even taking every item doesn't cover `delta` (infeasible). Otherwise
+/// returns `Some(min_total_cost)`. The LP-optimal cost is `<=` the cost of any integer
+/// solution, so the result is a safe lower bound on the achievable cost.
+///
+/// Used by metric bounds that need to estimate "minimum cost to satisfy a deficit":
+/// - `ChangelessWaste`'s `rate_diff < 0` UB: cost = excluded weight, contribution = ev to
+///   exclude in order to drop `excess_with_drain` below `min_value`.
+/// - `LowestFee`'s "get rid of change" branch: cost = value paid as fees, contribution = `|ev|`
+///   added to push excess below `min_value`.
+fn lp_min_cost_to_cover(items: impl IntoIterator<Item = (f32, f32)>, delta: f32) -> Option<f32> {
+    let mut sorted: Vec<_> = items.into_iter().collect();
+    sorted.sort_by(|a, b| {
+        let r_a = a.0 / a.1;
+        let r_b = b.0 / b.1;
+        r_b.partial_cmp(&r_a).unwrap_or(core::cmp::Ordering::Equal)
+    });
+
+    let mut remaining = delta;
+    let mut total_cost = 0.0_f32;
+    for (contribution, cost) in sorted {
+        if remaining <= 0.0 {
+            break;
+        }
+        if contribution >= remaining {
+            total_cost += cost * (remaining / contribution);
+            remaining = 0.0;
+        } else {
+            total_cost += cost;
+            remaining -= contribution;
+        }
+    }
+
+    if remaining > 0.0 {
+        None
+    } else {
+        Some(total_cost)
+    }
+}
+
 macro_rules! impl_for_tuple {
     ($($a:ident $b:tt)*) => {
         impl<$($a),*> BnbMetric for ($(($a, f32)),*)

src/metrics/changeless_waste.rs

@@ -1,6 +1,5 @@
-use super::{change_lower_bound, excess_with_drain, resize_bound};
+use super::{change_lower_bound, excess_with_drain, lp_min_cost_to_cover, resize_bound};
 use crate::{bnb::BnbMetric, float::Ordf32, ChangePolicy, CoinSelector, Drain, FeeRate, Target};
-use alloc::vec::Vec;
 
 /// Metric that minimizes the [waste metric] subject to the constraint that the selection produces
 /// no change output.
@@ -108,42 +107,25 @@ fn ub_changeless_input_weight(
     if delta <= 0 {
         return d_all_iw;
     }
-    let mut remaining = delta as f32;
 
-    let mut pos: Vec<(f32, f32)> = cs
-        .unselected()
-        .filter_map(|(_, c)| {
+    // LP-min weight to exclude such that excluded ev sum >= delta. Items: positive-ev_feerate
+    // unselected candidates (contribution = ev, cost = weight).
+    match lp_min_cost_to_cover(
+        cs.unselected().filter_map(|(_, c)| {
             let ev = c.effective_value(target.fee.rate);
             if ev > 0.0 {
                 Some((ev, c.weight as f32))
             } else {
                 None
             }
-        })
-        .collect();
-    pos.sort_by(|a, b| {
-        let r_a = a.0 / a.1;
-        let r_b = b.0 / b.1;
-        r_b.partial_cmp(&r_a).unwrap_or(core::cmp::Ordering::Equal)
-    });
-
-    let mut removed_weight = 0.0_f32;
-    for (ev, w) in pos {
-        if remaining <= 0.0 {
-            break;
-        }
-        if ev >= remaining {
-            removed_weight += w * (remaining / ev);
-            remaining = 0.0;
-        } else {
-            removed_weight += w;
-            remaining -= ev;
+        }),
+        delta as f32,
+    ) {
+        Some(removed_weight) => d_all_iw - removed_weight,
+        None => {
+            // Unreachable when `change_lower_bound = None` (which we already checked). Fall
+            // back to the loose `D_all`-based bound rather than fabricating a tight one.
+            d_all_iw
         }
     }
-    if remaining > 0.0 {
-        // Unreachable when `change_lower_bound = None` (which we already checked). Fall back
-        // to the loose `D_all`-based bound rather than fabricating a tight one.
-        return d_all_iw;
-    }
-    d_all_iw - removed_weight
 }