bench: add lowest_fee_bounds for V1 vs V2 comparison

Adds a Criterion bench that runs both bound versions side-by-side on a
synthetic pool (mix of normal UTXOs + low-value dust to exercise the
"go changeless via neg-ev" branch). Prints round-count comparison at
the start and times each version.

In this synthetic, V1 and V2 produce identical round counts — the tightening
case (`amount_above_change_threshold > |ev_benchmark|`) doesn't fire because
the dust candidates all have similar |ev|/value ratios, so the
single-benchmark estimate happens to coincide with the LP-optimal cost.
The proptest is what validates V2 is correct on more diverse pools.

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

Author: evanlinjin

Cargo.toml

@@ -29,3 +29,7 @@ criterion = "0.5"
 [[bench]]
 name = "coin_selector"
 harness = false
+
+[[bench]]
+name = "lowest_fee_bounds"
+harness = false

benches/lowest_fee_bounds.rs

@@ -0,0 +1,370 @@
+//! Benchmark comparing `LowestFee` bound versions:
+//! - V1: the previous bound — single-benchmark estimate (uses only the lowest-`value_pwu`
+//!   unselected candidate to estimate the cost of going changeless when `cs` has change).
+//! - V2: the LP-relaxed knapsack bound — sorts all negative-`ev` unselected candidates by
+//!   `|ev|/value` descending and fractionally fills until the deficit is covered. Tighter
+//!   when the single benchmark candidate's `|ev|` is smaller than the amount-above-threshold.
+
+use bdk_coin_select::{
+    float::Ordf32, metrics::LowestFee, BnbMetric, Candidate, ChangePolicy, CoinSelector, Drain,
+    DrainWeights, FeeRate, Target, TargetFee, TargetOutputs, TR_SPK_WEIGHT, TXIN_BASE_WEIGHT,
+    TXOUT_BASE_WEIGHT,
+};
+use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
+use std::hint::black_box;
+
+// ---------------------------------------------------------------------------
+// V1: previous bound. Single-benchmark "extra value to extinguish change" estimate.
+// ---------------------------------------------------------------------------
+
+#[derive(Clone, Copy)]
+struct LowestFeeV1 {
+    target: Target,
+    long_term_feerate: FeeRate,
+    change_policy: ChangePolicy,
+}
+
+impl BnbMetric for LowestFeeV1 {
+    fn score(&mut self, cs: &CoinSelector<'_>) -> Option<Ordf32> {
+        if !cs.is_target_met(self.target) {
+            return None;
+        }
+        let drain = cs.drain(self.target, self.change_policy);
+        let fee_for_the_tx = cs.fee(self.target.value(), drain.value);
+        assert!(fee_for_the_tx >= 0);
+        let spend_fee = drain.weights.spend_fee(self.long_term_feerate);
+        Some(Ordf32((fee_for_the_tx as u64 + spend_fee) as f32))
+    }
+
+    fn bound(&mut self, cs: &CoinSelector<'_>) -> Option<Ordf32> {
+        if cs.is_target_met(self.target) {
+            let current_score = self.score(cs).unwrap();
+            let drain_value = cs.drain_value(self.target, self.change_policy);
+            if let Some(drain_value) = drain_value {
+                // V1: single-benchmark candidate (the last unselected = lowest value_pwu).
+                let amount_above_change_threshold = drain_value - self.change_policy.min_value;
+                if let Some((_, low_sats_per_wu_candidate)) = cs.unselected().next_back() {
+                    let ev = low_sats_per_wu_candidate.effective_value(self.target.fee.rate);
+                    if ev < -0.0 {
+                        let value_per_negative_effective_value =
+                            low_sats_per_wu_candidate.value as f32 / ev.abs();
+                        let extra_value_needed_to_get_rid_of_change = amount_above_change_threshold
+                            as f32
+                            * value_per_negative_effective_value;
+                        let cost_of_getting_rid_of_change =
+                            extra_value_needed_to_get_rid_of_change + drain_value as f32;
+                        let cost_of_change = self.change_policy.drain_weights.waste(
+                            self.target.fee.rate,
+                            self.long_term_feerate,
+                            self.target.outputs.n_outputs,
+                        );
+                        let best_score_without_change = Ordf32(
+                            current_score.0 + cost_of_getting_rid_of_change - cost_of_change,
+                        );
+                        if best_score_without_change < current_score {
+                            return Some(best_score_without_change);
+                        }
+                    }
+                }
+            } else {
+                let cost_of_adding_change = self.change_policy.drain_weights.waste(
+                    self.target.fee.rate,
+                    self.long_term_feerate,
+                    self.target.outputs.n_outputs,
+                );
+                let cost_of_no_change = cs.excess(self.target, Drain::NONE);
+                let best_score_with_change =
+                    Ordf32(current_score.0 - cost_of_no_change as f32 + cost_of_adding_change);
+                if best_score_with_change < current_score {
+                    return Some(best_score_with_change);
+                }
+            }
+            return Some(current_score);
+        }
+        // Target not met — same resize trick as the current LowestFee, inlined for the
+        // benchmark (we don't share with the in-src `resize_bound` helper to keep V1 fully
+        // self-contained).
+        let (mut cs, resize_index, to_resize) = cs
+            .clone()
+            .select_iter()
+            .find(|(c, _, _)| c.is_target_met(self.target))?;
+        if cs.excess(self.target, Drain::NONE) == 0 {
+            return Some(self.score(&cs).unwrap());
+        }
+        cs.deselect(resize_index);
+        let mut scale = 0.0_f32;
+        let rate_excess = cs.rate_excess_wu(self.target, Drain::NONE) as f32;
+        if rate_excess < 0.0 {
+            let r = rate_excess.abs();
+            let ev = to_resize.effective_value(self.target.fee.rate);
+            if ev > 0.0 {
+                scale = scale.max(r / ev);
+            } else {
+                return None;
+            }
+        }
+        if let Some(replace) = self.target.fee.replace {
+            let r = cs.replacement_excess_wu(self.target, Drain::NONE) as f32;
+            if r < 0.0 {
+                let ev = to_resize.effective_value(replace.incremental_relay_feerate);
+                if ev > 0.0 {
+                    scale = scale.max(r.abs() / ev);
+                } else {
+                    return None;
+                }
+            }
+        }
+        let abs_excess = cs.absolute_excess(self.target, Drain::NONE) as f32;
+        if abs_excess < 0.0 {
+            if to_resize.value > 0 {
+                scale = scale.max(abs_excess.abs() / to_resize.value as f32);
+            } else {
+                return None;
+            }
+        }
+        let ideal_fee = scale * to_resize.value as f32 + cs.selected_value() as f32
+            - self.target.value() as f32;
+        Some(Ordf32(ideal_fee.max(0.0)))
+    }
+
+    fn requires_ordering_by_descending_value_pwu(&self) -> bool {
+        true
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Pool / scenarios.
+// ---------------------------------------------------------------------------
+
+/// Diverse synthetic pool: bulk of normal-sized UTXOs plus a sprinkling of low-value
+/// "dust" UTXOs that will have negative `ev` at the test feerates. The dust ones are what
+/// trigger the "go changeless by adding negative-ev inputs" branch of `LowestFee::bound`.
+fn make_candidates(n: usize) -> Vec<Candidate> {
+    const P2WPKH_SAT_W: u64 = 107;
+    let dust_every = 4; // every 4th candidate is dust
+    (0..n)
+        .map(|i| {
+            let i_u = i as u64;
+            let (value, weight) = if i % dust_every == 0 {
+                // Dust: small value, larger weight. value=200, weight ~= 400 -> value_pwu=0.5.
+                // At feerate 10 vb (= 2.5 sat/wu), ev = 200 - 400*2.5 = -800 (negative).
+                (200 + (i_u % 50), TXIN_BASE_WEIGHT + 250 + (i_u % 50))
+            } else {
+                // Normal: scaled up. value range ~1k-70k.
+                (
+                    1_000 + i_u * 137 + i_u * i_u,
+                    TXIN_BASE_WEIGHT + P2WPKH_SAT_W,
+                )
+            };
+            Candidate {
+                value,
+                weight,
+                input_count: 1,
+                is_segwit: true,
+            }
+        })
+        .collect()
+}
+
+#[derive(Clone, Copy)]
+struct Scenario {
+    name: &'static str,
+    target_feerate_vb: f32,
+    long_term_feerate_vb: f32,
+    target_fraction: f32, // fraction of total candidate value as target
+}
+
+const SCENARIOS: &[Scenario] = &[
+    Scenario {
+        name: "rate_pos_half",
+        target_feerate_vb: 10.0,
+        long_term_feerate_vb: 2.0,
+        target_fraction: 0.5,
+    },
+    Scenario {
+        name: "rate_neg_half",
+        target_feerate_vb: 2.0,
+        long_term_feerate_vb: 10.0,
+        target_fraction: 0.5,
+    },
+    // Small-target scenarios are where the V1 single-benchmark estimate is most likely to
+    // diverge from V2 — the "amount above change threshold" is large relative to a single
+    // candidate's `|ev|`.
+    Scenario {
+        name: "rate_pos_small",
+        target_feerate_vb: 10.0,
+        long_term_feerate_vb: 2.0,
+        target_fraction: 0.05,
+    },
+    Scenario {
+        name: "rate_neg_small",
+        target_feerate_vb: 2.0,
+        long_term_feerate_vb: 10.0,
+        target_fraction: 0.05,
+    },
+];
+
+fn make_inputs(candidates: &[Candidate], s: Scenario) -> (Target, ChangePolicy, FeeRate) {
+    let target_fr = FeeRate::from_sat_per_vb(s.target_feerate_vb);
+    let long_term_fr = FeeRate::from_sat_per_vb(s.long_term_feerate_vb);
+    let total: u64 = candidates.iter().map(|c| c.value).sum();
+    let target_value = ((total as f32) * s.target_fraction) as u64;
+    let target = Target {
+        fee: TargetFee::from_feerate(target_fr),
+        outputs: TargetOutputs::fund_outputs([(TXOUT_BASE_WEIGHT + TR_SPK_WEIGHT, target_value)]),
+    };
+    let change_policy =
+        ChangePolicy::min_value_and_waste(DrainWeights::TR_KEYSPEND, 294, target_fr, long_term_fr);
+    (target, change_policy, long_term_fr)
+}
+
+struct RunResult {
+    best: Option<f32>,
+    rounds: usize,
+    completed: bool,
+}
+
+fn run_and_count<M: BnbMetric>(cs: &CoinSelector<'_>, metric: M, max_rounds: usize) -> RunResult {
+    let mut rounds = 0usize;
+    let mut best: Option<f32> = None;
+    let mut iter = cs.bnb_solutions(metric);
+    while rounds < max_rounds {
+        match iter.next() {
+            Some(step) => {
+                rounds += 1;
+                if let Some((_, score)) = step {
+                    best = Some(score.0);
+                }
+            }
+            None => {
+                return RunResult {
+                    best,
+                    rounds,
+                    completed: true,
+                };
+            }
+        }
+    }
+    RunResult {
+        best,
+        rounds,
+        completed: false,
+    }
+}
+
+fn fmt_rounds(r: &RunResult) -> String {
+    if r.completed {
+        format!("{}", r.rounds)
+    } else {
+        format!("{} (cap)", r.rounds)
+    }
+}
+
+fn print_round_report() {
+    const MAX_ROUNDS: usize = 2_000_000;
+    println!();
+    println!(
+        "=== LowestFee bound version comparison (cap {}) ===",
+        MAX_ROUNDS
+    );
+    println!(
+        "{:>16} {:>5} {:>14} {:>14}",
+        "scenario", "n", "v1_rounds", "v2_rounds"
+    );
+    for &n in &[20usize, 50, 100, 200] {
+        let candidates = make_candidates(n);
+        for &s in SCENARIOS {
+            let (target, change_policy, long_term_feerate) = make_inputs(&candidates, s);
+            let cs = CoinSelector::new(&candidates);
+
+            let r1 = run_and_count(
+                &cs,
+                LowestFeeV1 {
+                    target,
+                    long_term_feerate,
+                    change_policy,
+                },
+                MAX_ROUNDS,
+            );
+            let r2 = run_and_count(
+                &cs,
+                LowestFee {
+                    target,
+                    long_term_feerate,
+                    change_policy,
+                },
+                MAX_ROUNDS,
+            );
+
+            if r1.completed && r2.completed {
+                assert_eq!(
+                    r1.best, r2.best,
+                    "V1 and V2 disagree at n={n} scenario={}",
+                    s.name
+                );
+            }
+
+            println!(
+                "{:>16} {:>5} {:>14} {:>14}",
+                s.name,
+                n,
+                fmt_rounds(&r1),
+                fmt_rounds(&r2),
+            );
+        }
+    }
+    println!();
+}
+
+fn bench_versions(c: &mut Criterion) {
+    print_round_report();
+
+    let mut group = c.benchmark_group("lowest_fee_bounds");
+    group.sample_size(10);
+
+    for &n in &[50usize, 100] {
+        let candidates = make_candidates(n);
+        for &s in SCENARIOS {
+            let (target, change_policy, long_term_feerate) = make_inputs(&candidates, s);
+            let selector = CoinSelector::new(&candidates);
+
+            let id_v1 = BenchmarkId::new(format!("v1/{}", s.name), n);
+            group.bench_with_input(id_v1, &n, |b, _| {
+                b.iter_batched(
+                    || selector.clone(),
+                    |mut sel| {
+                        let m = LowestFeeV1 {
+                            target,
+                            long_term_feerate,
+                            change_policy,
+                        };
+                        let _ = sel.run_bnb(m, black_box(2_000_000));
+                        sel
+                    },
+                    BatchSize::SmallInput,
+                );
+            });
+
+            let id_v2 = BenchmarkId::new(format!("v2/{}", s.name), n);
+            group.bench_with_input(id_v2, &n, |b, _| {
+                b.iter_batched(
+                    || selector.clone(),
+                    |mut sel| {
+                        let m = LowestFee {
+                            target,
+                            long_term_feerate,
+                            change_policy,
+                        };
+                        let _ = sel.run_bnb(m, black_box(2_000_000));
+                        sel
+                    },
+                    BatchSize::SmallInput,
+                );
+            });
+        }
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench_versions);
+criterion_main!(benches);