perf(metrics): tighten ChangelessWaste bound for rate_diff < 0

The previous bound for `rate_diff < 0` was `all_selected.input_weight * rate_diff`,
which ignored that selecting every candidate would typically force a change
output (making the selection infeasible under the changeless constraint). The
new bound recasts the problem as: minimize the weight of candidates excluded
from `D_all` such that `excess_with_drain` drops below `change_policy.min_value`.
This is a 0/1 covering knapsack; the LP relaxation (sort positive-ev_feerate
candidates by `ev/weight` descending and exclude fractionally) gives a safe
upper bound on `D.input_weight` for any feasible changeless descendant.

Benchmark improvements (round counts, BnB cap 2M):
  n=15 rate_diff_neg:  3,590  ->    415   (~9x)
  n=20 rate_diff_neg: 34,296  ->  2,138   (~16x)
  n=30 rate_diff_neg: 2M cap  -> 74,055   (>27x, was hitting cap)

rate_diff >= 0 paths are unchanged. `ensure_bound_is_not_too_tight` proptest
verifies the new LB across 256 randomized scenarios.

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

Author: evanlinjin

src/metrics/changeless_waste.rs

@@ -1,4 +1,5 @@
 use crate::{bnb::BnbMetric, float::Ordf32, CoinSelector, Drain, DrainWeights, FeeRate, Target};
+use alloc::vec::Vec;
 
 /// Metric that minimizes the [waste metric] subject to the constraint that the selection produces
 /// no change output.
@@ -41,34 +42,60 @@ impl ChangelessWaste {
     ///
     /// [`LowestFee`]: crate::metrics::LowestFee
     fn drain_value(&self, cs: &CoinSelector<'_>, target: Target) -> Option<u64> {
-        // The change output pays for its own weight, so the value we'd actually recover is the
-        // excess remaining after accounting for that weight.
-        let excess_with_drain_weight = cs.excess(
-            target,
-            Drain {
-                weights: self.drain_weights,
-                value: 0,
-            },
-        );
+        let excess_with_drain_weight = self.excess_with_drain_weight(cs, target);
 
         // Adding change is only worth it if the value we'd recover exceeds the future cost of
         // spending it (i.e. it lowers the long-term fee).
-        let drain_spend_cost = self
-            .long_term_feerate
-            .implied_fee_wu(self.drain_weights.spend_weight);
-        if excess_with_drain_weight <= drain_spend_cost as i64 {
+        if excess_with_drain_weight <= self.drain_spend_cost() as i64 {
             return None;
         }
 
         // ...and only if the change output would not be dust.
-        let dust_threshold = self.drain_weights.dust_threshold(self.dust_relay_feerate);
-        if excess_with_drain_weight < dust_threshold as i64 {
+        if excess_with_drain_weight < self.dust_threshold() as i64 {
             return None;
         }
 
         Some(excess_with_drain_weight.unsigned_abs())
     }
 
+    /// The excess of `cs` after accounting for the weight (but not value) of a would-be change
+    /// output. This is the quantity the change decision (see [`drain_value`]) is made on.
+    ///
+    /// [`drain_value`]: Self::drain_value
+    fn excess_with_drain_weight(&self, cs: &CoinSelector<'_>, target: Target) -> i64 {
+        // The change output pays for its own weight, so the value we'd actually recover is the
+        // excess remaining after accounting for that weight.
+        cs.excess(
+            target,
+            Drain {
+                weights: self.drain_weights,
+                value: 0,
+            },
+        )
+    }
+
+    /// The future fee of spending a would-be change output. Change below this is never worthwhile.
+    fn drain_spend_cost(&self) -> u64 {
+        self.long_term_feerate
+            .implied_fee_wu(self.drain_weights.spend_weight)
+    }
+
+    /// The dust threshold of a would-be change output. Change below this is never created.
+    fn dust_threshold(&self) -> u64 {
+        self.drain_weights.dust_threshold(self.dust_relay_feerate)
+    }
+
+    /// The largest `excess_with_drain_weight` for which a selection is still changeless.
+    ///
+    /// A selection is changeless (see [`drain_value`]) when its excess is `<= drain_spend_cost` OR
+    /// `< dust_threshold`. The union of those two regions is `excess <= max(drain_spend_cost,
+    /// dust_threshold - 1)`, so this is the inclusive upper edge of the changeless region.
+    ///
+    /// [`drain_value`]: Self::drain_value
+    fn changeless_max_excess(&self) -> i64 {
+        (self.drain_spend_cost() as i64).max(self.dust_threshold() as i64 - 1)
+    }
+
     /// Whether every selection reachable down this branch (the current one and any superset of it)
     /// would have a change output — so no changeless solution exists here and the branch can be
     /// pruned.
@@ -98,6 +125,72 @@ impl ChangelessWaste {
 
         self.drain_value(&least_excess, target).is_some()
     }
+
+    /// LP-relaxed upper bound on `D.input_weight` for changeless `D ⊇ cs` (used by the
+    /// `rate_diff < 0` branch of [`bound`]).
+    ///
+    /// Construct `D_all = cs ∪ all unselected`. If `D_all` itself is changeless, the UB is
+    /// `D_all.input_weight`. Otherwise we must exclude enough excess-contributing
+    /// (positive-`effective_value`) candidates to drop `excess_with_drain_weight` down to
+    /// [`changeless_max_excess`]. To MAXIMIZE the remaining `input_weight` we MINIMIZE the excluded
+    /// weight, sorting positive-`ev` candidates by `ev / weight` descending and removing
+    /// fractionally until the required `delta` is met.
+    ///
+    /// The LP relaxation gives a value `>=` any integer solution's excluded weight, so
+    /// `D_all.input_weight - LP_min` is a safe UB for any feasible `D.input_weight`. The
+    /// `input_weight()` segwit/varint corrections only ever ADD weight to the parent, never
+    /// subtract from a subset — so the additive subtraction is safe in the UB direction.
+    ///
+    /// [`bound`]: BnbMetric::bound
+    /// [`changeless_max_excess`]: Self::changeless_max_excess
+    fn ub_changeless_input_weight(&self, cs: &CoinSelector<'_>, target: Target) -> f32 {
+        let mut d_all = cs.clone();
+        d_all.select_all();
+        let d_all_iw = d_all.input_weight() as f32;
+
+        let delta = self.excess_with_drain_weight(&d_all, target) - self.changeless_max_excess();
+        if delta <= 0 {
+            return d_all_iw;
+        }
+        let mut remaining = delta as f32;
+
+        let mut pos: Vec<(f32, f32)> = 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;
+            }
+        }
+        if remaining > 0.0 {
+            // Unreachable when `change_unavoidable = false` (which the caller 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
+    }
 }
 
 impl BnbMetric for ChangelessWaste {
@@ -130,37 +223,34 @@ impl BnbMetric for ChangelessWaste {
         //     score(D) = D.input_weight * rate_diff + max(0, D.excess)
         //
         // and `D.excess >= 0` (target met), so `score(D) >= D.input_weight * rate_diff`. The
-        // bound therefore reduces to finding a lower bound on `D.input_weight * rate_diff`.
+        // bound therefore reduces to bounding `D.input_weight` in the right direction.
 
         if rate_diff < 0.0 {
-            // rate_diff < 0: the most negative `D.input_weight * rate_diff` comes from the
-            // largest possible input_weight, which is bounded by selecting every candidate.
-            // (`D` need not actually be feasible — we only need an LB on its score.)
-            let mut all = cs.clone();
-            all.select_all();
-            return Some(Ordf32(all.input_weight() as f32 * rate_diff));
+            // rate_diff < 0: we want an UPPER bound on `D.input_weight`. `all_selected` is a
+            // safe but loose UB; we tighten by LP-relaxed knapsack over candidates that
+            // *must* be excluded to keep the selection changeless.
+            let ub = self.ub_changeless_input_weight(cs, target);
+            return Some(Ordf32(ub * rate_diff));
         }
 
-        // rate_diff >= 0: smaller input_weight gives a smaller `input_weight * rate_diff`, so we
-        // want a lower bound on `D.input_weight`. `D.input_weight >= cs.input_weight` always
-        // (selecting only grows), but we can do much better when the target is not yet met.
+        // rate_diff >= 0: we want a LOWER bound on `D.input_weight`. `cs.input_weight` is a
+        // safe baseline (input_weight is monotone non-decreasing). Tighten with the resize
+        // trick when target is not yet met.
         if cs.is_target_met(target) {
             return Some(Ordf32(cs.input_weight() as f32 * rate_diff));
         }
 
-        // Target not met. Use the same resize trick as `LowestFee::bound`: walk the sorted
-        // unselected list until we cross the target, then pretend the crossing input was
-        // perfectly scaled so that the target is hit with zero excess. Among all subsets of
-        // unselected that reach target, the highest-`value_pwu` candidates are the most
-        // weight-efficient — so the resize-scaled prefix is a valid lower bound on any
-        // target-meeting descendant's input_weight.
+        // Target not met. Same resize trick as `LowestFee::bound`: walk the sorted unselected
+        // list until we cross the target, then pretend the crossing input was perfectly
+        // scaled so the target is hit with zero excess. Among all subsets of unselected that
+        // reach target, the highest-`value_pwu` candidates are the most weight-efficient — so
+        // the resize-scaled prefix is a valid lower bound on any target-meeting descendant's
+        // input_weight.
         let (mut cs, resize_index, to_resize) = cs
             .clone()
             .select_iter()
             .find(|(cs, _, _)| cs.is_target_met(target))?;
 
-        // If the find selection already hits target exactly, that's the minimum-weight
-        // target-meeting subset; the bound is its waste (with `Drain::NONE`).
         if cs.excess(target, Drain::NONE) == 0 {
             return Some(Ordf32(cs.waste(
                 target,
@@ -171,7 +261,6 @@ impl BnbMetric for ChangelessWaste {
         }
         cs.deselect(resize_index);
 
-        // Compute the smallest `scale` of `to_resize` that satisfies each fee constraint.
         let mut scale = Ordf32(0.0);
 
         let rate_excess = cs.rate_excess_wu(target, Drain::NONE) as f32;