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

Thread `max_weight` through `Target`, `StrategyParams` and the proptests so
BnB is checked against exhaustive search with the cap active. Add
`exact_selection_possible`, an exhaustive value-and-weight feasibility oracle,
and a `bnb_respects_max_weight` proptest asserting BnB matches it — this
validates the metric's weight hard-prune. Impossibility assertions switch from
the value-only `is_selection_possible` to this oracle where the cap is in play.

Tighten `compare_against_benchmarks`: filter benchmarks by `score().is_some()`
(actually-valid solutions, reusing the computed score) rather than the
value-only `is_target_met`, add a value-per-weight greedy benchmark so the
comparison isn't vacuous under a tight cap, and assert BnB itself found a valid
solution whenever a benchmark did (a `None` score used to pass silently). Cap
its `n` — the no-solution branch's oracle is O(2^n).

Also mark `bnb_always_finds_solution_if_possible` release-only, matching its
sibling proptest; it's too slow under debug assertions.

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

@@ -90,6 +90,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(target, MinExcessThenWeight);
@@ -124,6 +125,7 @@ fn bnb_finds_solution_if_possible_in_n_iter() {
             n_outputs: 1,
         },
         fee: TargetFee::default(),
+        max_weight: None,
     };
 
     let solutions = cs.bnb_solutions(target, MinExcessThenWeight);
@@ -143,6 +145,7 @@ fn bnb_finds_solution_if_possible_in_n_iter() {
 
 proptest! {
     #[test]
+    #[cfg(not(debug_assertions))] // too slow if compiling for debug
     fn bnb_always_finds_solution_if_possible(num_inputs in 1usize..18, target_value in 0u64..10_000) {
         let mut rng = TestRng::deterministic_rng(RngAlgorithm::ChaCha);
         let wv = test_wv(&mut rng);
@@ -152,6 +155,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(target, MinExcessThenWeight);
@@ -198,6 +202,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(target, MinExcessThenWeight);

tests/changeless.rs

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

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,
         }
     }
 
@@ -293,7 +302,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)
@@ -372,6 +381,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,
     target: Target,
@@ -451,20 +477,42 @@ pub fn compare_against_benchmarks<M: BnbMetric + Clone>(
                     all_effective_selected.select_all_effective(target.fee.rate);
                     all_effective_selected
                 },
+                {
+                    // Lightest value-meeting greedy selection. Under a binding `max_weight` the
+                    // bulk benchmarks above are all over-cap (score `None`) and get filtered out;
+                    // this one is the relevant baseline that stays feasible when a light solution
+                    // exists, so the comparison below isn't vacuous.
+                    let mut greedy = cs.clone();
+                    greedy.sort_candidates_by_descending_value_pwu();
+                    let _ = greedy.select_until_target_met(target);
+                    greedy
+                },
             ];
 
             // add some random selections -- technically it's possible that one of these is better but it's very unlikely if our algorithm is working correctly.
             cmp_benchmarks.extend(
                 (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_map(|cs| {
+                    let score = metric.clone().score(&cs, target)?;
+                    Some((cs, score))
+                })
+                .collect::<Vec<_>>();
             let sol_score = metric.score(&sol, target);
 
-            for (_bench_id, mut bench) in cmp_benchmarks.enumerate() {
-                let bench_score = metric.score(&bench, target);
+            for (_bench_id, (mut bench, bench_score)) in cmp_benchmarks.into_iter().enumerate() {
+                prop_assert!(
+                    sol_score.is_some(),
+                    "bnb must be able to find solution if benchmark can"
+                );
+                let sol_score = sol_score.expect("must be some");
+
                 if sol_score > bench_score {
                     dbg!(_bench_id);
                     println!("bnb solution: {}", sol);
@@ -475,7 +523,9 @@ pub fn compare_against_benchmarks<M: BnbMetric + Clone>(
             }
         }
         None => {
-            prop_assert!(!cs.is_selection_possible(target));
+            // Full feasibility (value *and* max_weight) is needed here; `is_selection_possible`
+            // only covers value, so use the exact exhaustive oracle to assert impossibility.
+            prop_assert!(!exact_selection_possible(&cs, target));
         }
     }
 

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(500u64..4_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(500u64..4_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,20 +71,25 @@ 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
+        // No `max_weight` here: `n` is too large for the exhaustive oracle, and this test's
+        // impossibility check relies on the (value-only) `is_selection_possible`, so a weight cap
+        // (which BnB could fail on while value is reachable) would break it. Cap handling is
+        // covered by `bnb_respects_max_weight` and `can_eventually_find_best_solution`.
     ) {
         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: None };
         println!("{:?}", params);
 
-        let candidates = core::iter::repeat(Candidate {
+        let candidates = vec![
+            Candidate {
                 value: 20_000,
                 weight: (32 + 4 + 4 + 1) * 4 + 64 + 32,
                 input_count: 1,
                 is_segwit: true,
-            })
-            .take(params.n_candidates)
-            .collect::<Vec<_>>();
+            };
+            params.n_candidates
+        ];
 
         let mut cs = CoinSelector::new(&candidates);
 
@@ -101,7 +108,9 @@ proptest! {
     #[test]
     #[cfg(not(debug_assertions))] // too slow if compiling for debug
     fn compare_against_benchmarks(
-        n_candidates in 0..50_usize,        // candidates (n)
+        // `n` is kept small: the no-solution branch asserts against `exact_selection_possible`,
+        // an exhaustive O(2^n) oracle (needed because it must be exact w.r.t. the weight cap).
+        n_candidates in 0..16_usize,        // candidates (n)
         target_value in 500..1_000_000_u64,   // target value (sats)
         n_target_outputs in 1usize..150,    // the number of outputs we're funding
         target_weight in 0..10_000_u32,         // the sum of the weight of the outputs (wu)
@@ -112,15 +121,59 @@ 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(500u64..4_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: 512, ..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..12_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(500u64..4_000), // TRUC-tight -> binds often, small DP
+    ) {
+        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, target, 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
+        );
+    }
+}
+
 /// 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 +191,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);
@@ -177,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![
@@ -259,6 +314,7 @@ fn zero_fee_tx() {
             weight_sum: 200 - TX_FIXED_FIELD_WEIGHT - 1,
             n_outputs: 1,
         },
+        max_weight: None,
     };
 
     let candidates = vec![