test: exercise Target::max_weight and add exact feasibility oracle

Thread `max_weight` through `Target`, `StrategyParams` and every proptest
(a 2k..30k wu cap that binds on a healthy fraction of cases), so BnB is
compared against exhaustive search *with* the cap active.

Add `exact_selection_possible` — an exhaustive oracle reusing the real
`is_target_met`/`is_within_max_weight`, independent of the BnB weight
prune — and a `bnb_respects_max_weight` proptest asserting BnB feasibility
matches it and that `is_selection_possible` never over-claims.

Fix `compare_against_benchmarks`: filter benchmarks by `score().is_some()`
rather than value-only `is_target_met`, so an over-cap benchmark (e.g.
`select_all` under a tight cap, whose score is `None`) isn't treated as a
valid solution to compare against.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: evanlinjin

benches/coin_selector.rs

@@ -42,6 +42,7 @@ fn make_bnb_inputs(candidates: &[Candidate]) -> (Target, FeeRate) {
     let target = Target {
         fee: TargetFee::from_feerate(target_fr),
         outputs: TargetOutputs::fund_outputs([(TXOUT_BASE_WEIGHT + TR_SPK_WEIGHT, total / 2)]),
+        max_weight: None,
     };
     (target, long_term_fr)
 }

tests/bnb.rs

@@ -92,6 +92,7 @@ fn bnb_finds_an_exact_solution_in_n_iter() {
         },
         // we're trying to find an exact selection value so set fees to 0
         fee: TargetFee::ZERO,
+        max_weight: None,
     };
 
     let solutions = cs.bnb_solutions(MinExcessThenWeight { target });
@@ -126,6 +127,7 @@ fn bnb_finds_solution_if_possible_in_n_iter() {
             n_outputs: 1,
         },
         fee: TargetFee::default(),
+        max_weight: None,
     };
 
     let solutions = cs.bnb_solutions(MinExcessThenWeight { target });
@@ -154,6 +156,7 @@ proptest! {
         let target = Target {
             outputs: TargetOutputs { value_sum: target_value, weight_sum: 0, n_outputs: 1 },
             fee: TargetFee::ZERO,
+            max_weight: None,
         };
 
         let solutions = cs.bnb_solutions(MinExcessThenWeight { target });
@@ -200,6 +203,7 @@ proptest! {
             outputs: TargetOutputs { value_sum: target_value, weight_sum: 0, n_outputs: 1 },
             // we're trying to find an exact selection value so set fees to 0
             fee: TargetFee::ZERO,
+            max_weight: None,
         };
 
         let solutions = cs.bnb_solutions(MinExcessThenWeight { target });

tests/changeless.rs

@@ -65,7 +65,8 @@ proptest! {
                 rate: feerate,
                 replace,
                 ..TargetFee::ZERO
-            }
+            },
+            max_weight: None,
         };
 
         let make_metric = || Changeless {

tests/common.rs

@@ -25,6 +25,13 @@ pub fn maybe_replace(
     proptest::option::of(replace(fee_strategy))
 }
 
+/// Strategy for an optional [`Target::max_weight`] cap (`None` = unconstrained).
+pub fn maybe_max_weight(
+    weight_strategy: impl Strategy<Value = u64>,
+) -> impl Strategy<Value = Option<u64>> {
+    proptest::option::of(weight_strategy)
+}
+
 /// Used for constructing a proptest that compares an exhaustive search result with a bnb result
 /// with the given metric.
 ///
@@ -208,6 +215,7 @@ pub struct StrategyParams {
     pub drain_spend_weight: u32,
     pub drain_dust: u64,
     pub n_drain_outputs: usize,
+    pub max_weight: Option<u64>,
 }
 
 impl StrategyParams {
@@ -223,6 +231,7 @@ impl StrategyParams {
                 weight_sum: self.target_weight as u64,
                 n_outputs: self.n_target_outputs,
             },
+            max_weight: self.max_weight,
         }
     }
 
@@ -294,7 +303,7 @@ pub struct ExhaustiveIter<'a> {
 }
 
 impl<'a> ExhaustiveIter<'a> {
-    fn new(cs: &CoinSelector<'a>) -> Option<Self> {
+    pub fn new(cs: &CoinSelector<'a>) -> Option<Self> {
         let mut iter = Self { stack: Vec::new() };
         iter.push_branches(cs);
         Some(iter)
@@ -369,6 +378,23 @@ where
     best.map(|(_, score)| (score, rounds))
 }
 
+/// Exact feasibility oracle: does *any* subset of the currently-unbanned candidates (added to the
+/// current selection) meet `target`, i.e. cover the value **and** stay within `max_weight`?
+///
+/// Enumerates every subset via [`ExhaustiveIter`] and reuses the real
+/// [`CoinSelector::is_target_met`] + [`CoinSelector::is_within_max_weight`], so it inherits the
+/// exact weight model and is independent of the BnB weight prune it audits. Exponential — small `n`
+/// only.
+pub fn exact_selection_possible(cs: &CoinSelector, target: Target) -> bool {
+    let feasible =
+        |s: &CoinSelector| s.is_target_met(target) && s.is_within_max_weight(target, Drain::NONE);
+    // the current selection itself (no additions) is a valid subset and isn't yielded by the iter
+    feasible(cs)
+        || ExhaustiveIter::new(cs)
+            .map(|mut iter| iter.any(|(subset, _)| feasible(&subset)))
+            .unwrap_or(false)
+}
+
 pub fn bnb_search<M>(
     cs: &mut CoinSelector,
     metric: M,
@@ -454,12 +480,16 @@ pub fn compare_against_benchmarks<M: BnbMetric + Clone>(
                 (0..10).map(|_| randomly_satisfy_target(&cs, target, &mut rng, metric.clone())),
             );
 
+            // Only compare against benchmarks that are themselves *valid* solutions. A benchmark
+            // can meet the target value yet bust `max_weight` (e.g. `select_all` on a tight cap),
+            // in which case its score is `None` and it isn't a real solution to compare against.
             let cmp_benchmarks = cmp_benchmarks
                 .into_iter()
-                .filter(|cs| cs.is_target_met(target));
+                .filter(|bench| metric.clone().score(bench).is_some())
+                .collect::<Vec<_>>();
             let sol_score = metric.score(&sol);
 
-            for (_bench_id, mut bench) in cmp_benchmarks.enumerate() {
+            for (_bench_id, mut bench) in cmp_benchmarks.into_iter().enumerate() {
                 let bench_score = metric.score(&bench);
                 if sol_score > bench_score {
                     dbg!(_bench_id);

tests/lowest_fee.rs

@@ -27,8 +27,9 @@ proptest! {
         drain_spend_weight in 1..=2000_u32, // drain spend weight (wu)
         drain_dust in 100..=1000_u64,       // drain dust (sats)
         n_drain_outputs in 1usize..150,     // the number of drain outputs
+        max_weight in common::maybe_max_weight(2_000u64..30_000), // optional max tx weight cap (wu)
     ) {
-        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs };
+        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs , max_weight };
         let candidates = common::gen_candidates(params.n_candidates);
         let metric = params.lowest_fee_metric();
         common::can_eventually_find_best_solution(params, candidates, metric)?;
@@ -48,8 +49,9 @@ proptest! {
         drain_spend_weight in 1..=2000_u32, // drain spend weight (wu)
         drain_dust in 100..=1000_u64,       // drain dust (sats)
         n_drain_outputs in 1usize..150,     // the number of drain outputs
+        max_weight in common::maybe_max_weight(2_000u64..30_000), // optional max tx weight cap (wu)
     ) {
-        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs };
+        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs , max_weight };
         let candidates = common::gen_candidates(params.n_candidates);
         let metric = params.lowest_fee_metric();
         common::ensure_bound_is_not_too_tight(params, candidates, metric)?;
@@ -69,10 +71,11 @@ proptest! {
         drain_spend_weight in 1..=2000_u32, // drain spend weight (wu)
         drain_dust in 100..=1000_u64,       // drain dust (sats)
         n_drain_outputs in 1usize..150,     // the number of drain outputs
+        max_weight in common::maybe_max_weight(2_000u64..30_000), // optional max tx weight cap (wu)
     ) {
         println!("== TEST ==");
 
-        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs };
+        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs , max_weight };
         println!("{:?}", params);
 
         let candidates = core::iter::repeat(Candidate {
@@ -112,15 +115,64 @@ proptest! {
         drain_spend_weight in 1..=2000_u32, // drain spend weight (wu)
         drain_dust in 100..=1000_u64,       // drain dust (sats)
         n_drain_outputs in 1usize..150,     // the number of drain outputs
+        max_weight in common::maybe_max_weight(2_000u64..30_000), // optional max tx weight cap (wu)
     ) {
 
-        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs };
+        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs , max_weight };
         let candidates = common::gen_candidates(params.n_candidates);
         let metric = params.lowest_fee_metric();
         common::compare_against_benchmarks(params, candidates, metric)?;
     }
 }
 
+proptest! {
+    // Cheap cases (small n), so run many more than the default to stress the max_weight prune.
+    #![proptest_config(ProptestConfig { cases: 4096, ..Default::default() })]
+
+    /// Cross-check `max_weight` handling against an exact, exhaustive feasibility oracle.
+    ///
+    /// BnB with unlimited rounds is itself an exact feasibility detector (nothing is pruned before
+    /// the first incumbent; the only pre-incumbent prune is the weight hard-prune). So
+    /// `bnb_found == exact_possible` must hold — a mismatch means the prune dropped a feasible
+    /// subtree. `n` is kept small because the exact oracle is exponential.
+    #[test]
+    #[cfg(not(debug_assertions))] // too slow if compiling for debug
+    fn bnb_respects_max_weight(
+        n_candidates in 1..16_usize,
+        target_value in 500..500_000_u64,
+        n_target_outputs in 1usize..150,
+        target_weight in 0..10_000_u32,
+        replace in common::maybe_replace(0u64..10_000),
+        feerate in 1.0..100.0_f32,
+        feerate_lt_diff in -5.0..50.0_f32,
+        drain_weight in 100..=500_u32,
+        drain_spend_weight in 1..=2000_u32,
+        drain_dust in 100..=1000_u64,
+        n_drain_outputs in 1usize..150,
+        max_weight in common::maybe_max_weight(2_000u64..15_000), // tighter -> binds often
+    ) {
+        let params = common::StrategyParams { n_candidates, target_value, n_target_outputs, target_weight, replace, feerate, feerate_lt_diff, drain_weight, drain_spend_weight, drain_dust, n_drain_outputs, max_weight };
+        let candidates = common::gen_candidates(params.n_candidates);
+        let target = params.target();
+        let metric = params.lowest_fee_metric();
+
+        let exact_possible = common::exact_selection_possible(&CoinSelector::new(&candidates), target);
+
+        let mut cs = CoinSelector::new(&candidates);
+        let bnb_found = common::bnb_search(&mut cs, metric, usize::MAX).is_ok();
+        prop_assert_eq!(
+            bnb_found, exact_possible,
+            "bnb_found={} but exact_possible={} (weight prune may have dropped a feasible subtree)",
+            bnb_found, exact_possible
+        );
+
+        // The shipped greedy `is_selection_possible` must never over-claim: a `true` is a real
+        // witness, so it must imply the exact oracle.
+        let greedy = CoinSelector::new(&candidates).is_selection_possible(target);
+        prop_assert!(!greedy || exact_possible, "is_selection_possible over-claimed");
+    }
+}
+
 /// We wrap `LowestFee` in `Changeless` to derive a metric that finds the lowest-fee changeless
 /// solution. Constraining to changeless should never take fewer rounds than the unconstrained
 /// `LowestFee`.
@@ -138,6 +190,7 @@ fn combined_changeless_metric() {
         drain_dust: 200,
         n_target_outputs: 1,
         n_drain_outputs: 1,
+        max_weight: None,
     };
 
     let candidates = common::gen_candidates(params.n_candidates);
@@ -178,6 +231,7 @@ fn does_not_create_change_below_spend_cost() {
             weight_sum: 200 - TX_FIXED_FIELD_WEIGHT - 1,
             n_outputs: 1,
         },
+        max_weight: None,
     };
 
     let candidates = vec![
@@ -256,6 +310,7 @@ fn zero_fee_tx() {
             weight_sum: 200 - TX_FIXED_FIELD_WEIGHT - 1,
             n_outputs: 1,
         },
+        max_weight: None,
     };
 
     let candidates = vec![