refactor!: rename value-only predicates to is_funded/is_fundable

`Target` now carries two constraints of opposite monotonicity — the value
target (a lower bound, monotone) and `max_weight` (an upper bound,
anti-monotone). Rename the value-only predicates so their names say which one
they check:

- `is_target_met`            -> `is_funded`
- `is_target_met_with_drain` -> `is_funded_with_drain`
- `is_selection_possible`    -> `is_fundable`

"funded"/"fundable" is money-centric and so naturally excludes weight; the
`-ed`/`-able` pair distinguishes "this selection covers the value" from "these
candidates *can* cover it". Pure rename, no behaviour change.

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

Author: evanlinjin

README.md

@@ -57,10 +57,10 @@ let candidates = vec![
 let mut coin_selector = CoinSelector::new(&candidates);
 coin_selector.select(0);
 
-assert!(!coin_selector.is_target_met(target), "we didn't select enough");
+assert!(!coin_selector.is_funded(target), "we didn't select enough");
 println!("we didn't select enough yet we're missing: {}", coin_selector.missing(target));
 coin_selector.select(1);
-assert!(coin_selector.is_target_met(target), "we should have enough now");
+assert!(coin_selector.is_funded(target), "we should have enough now");
 
 // Now we need to know if we need a change output to drain the excess if we overshot too much
 //

src/coin_selector.rs

@@ -112,7 +112,7 @@ impl<'a> CoinSelector<'a> {
     }
 
     /// Whether the candidates can cover this `target`'s **value** (net of input fees) — i.e. whether
-    /// enough value is reachable for [`is_target_met`] to hold. Respects [`ban`]ned candidates.
+    /// enough value is reachable for [`is_funded`] to hold. Respects [`ban`]ned candidates.
     ///
     /// Selecting *all* effective inputs maximizes the value available, so if that can't meet the
     /// target value, nothing can. Monotone, hence exact.
@@ -122,12 +122,12 @@ impl<'a> CoinSelector<'a> {
     /// which enforce the cap) to actually build a selection.
     ///
     /// [`ban`]: Self::ban
-    /// [`is_target_met`]: Self::is_target_met
+    /// [`is_funded`]: Self::is_funded
     /// [`select_until_target_met`]: Self::select_until_target_met
-    pub fn is_selection_possible(&self, target: Target) -> bool {
+    pub fn is_fundable(&self, target: Target) -> bool {
         let mut test = self.clone();
         test.select_all_effective(target.fee.rate);
-        test.is_target_met(target)
+        test.is_funded(target)
     }
 
     /// Returns true if no candidates have been selected.
@@ -439,7 +439,7 @@ impl<'a> CoinSelector<'a> {
     ///
     /// Always `true` when `max_weight` is `None`. Note this is the *anti-monotone* half of
     /// feasibility (adding inputs adds weight), so it is kept separate from the monotone
-    /// value-only [`is_target_met`](Self::is_target_met).
+    /// value-only [`is_funded`](Self::is_funded).
     pub fn is_within_max_weight(&self, target: Target, drain: Drain) -> bool {
         match target.max_weight {
             Some(max_weight) => self.weight(target.outputs, drain.weights) <= max_weight,
@@ -452,21 +452,21 @@ impl<'a> CoinSelector<'a> {
     ///
     /// This is **monotone**: selecting more never un-meets it. It deliberately does *not* include
     /// the weight cap — see [`is_within_max_weight`](Self::is_within_max_weight).
-    pub fn is_target_met_with_drain(&self, target: Target, drain: Drain) -> bool {
+    pub fn is_funded_with_drain(&self, target: Target, drain: Drain) -> bool {
         self.excess(target, drain) >= 0
     }
 
     /// Whether the selection covers the target **value** (net of input fees), i.e. [`excess`] is
     /// non-negative. **Monotone** (selecting more never un-meets it), and it deliberately does
     /// *not* check [`Target::max_weight`] — that is the separate, anti-monotone
-    /// [`is_within_max_weight`]. See [`is_target_met_with_drain`] for the version that
+    /// [`is_within_max_weight`]. See [`is_funded_with_drain`] for the version that
     /// accounts for a specific `drain`.
     ///
     /// [`excess`]: Self::excess
     /// [`is_within_max_weight`]: Self::is_within_max_weight
-    /// [`is_target_met_with_drain`]: Self::is_target_met_with_drain
-    pub fn is_target_met(&self, target: Target) -> bool {
-        self.is_target_met_with_drain(target, Drain::NONE)
+    /// [`is_funded_with_drain`]: Self::is_funded_with_drain
+    pub fn is_funded(&self, target: Target) -> bool {
+        self.is_funded_with_drain(target, Drain::NONE)
     }
 
     /// Select all unselected candidates
@@ -492,8 +492,8 @@ impl<'a> CoinSelector<'a> {
         );
         if excess > change_policy.min_value as i64 {
             debug_assert_eq!(
-                self.is_target_met(target),
-                self.is_target_met_with_drain(
+                self.is_funded(target),
+                self.is_funded_with_drain(
                     target,
                     Drain {
                         weights: change_policy.drain_weights,
@@ -512,12 +512,12 @@ impl<'a> CoinSelector<'a> {
     /// `change_policy`. If it should not, then it will return [`Drain::NONE`]. The value of the
     /// `Drain` will be the same as [`drain_value`].
     ///
-    /// If [`is_target_met`] returns true for this selection then [`is_target_met_with_drain`] will
+    /// If [`is_funded`] returns true for this selection then [`is_funded_with_drain`] will
     /// also be true if you pass in the drain returned from this method.
     ///
     /// [`drain_value`]: Self::drain_value
-    /// [`is_target_met_with_drain`]: Self::is_target_met_with_drain
-    /// [`is_target_met`]: Self::is_target_met
+    /// [`is_funded_with_drain`]: Self::is_funded_with_drain
+    /// [`is_funded`]: Self::is_funded
     #[must_use]
     pub fn drain(&self, target: Target, change_policy: ChangePolicy) -> Drain {
         match self.drain_value(target, change_policy) {
@@ -554,7 +554,7 @@ impl<'a> CoinSelector<'a> {
     ///   [`Target::max_weight`]. Note this only reflects *this* in-order greedy selection; a
     ///   different selection might still fit the cap (use branch and bound to search for one).
     pub fn select_until_target_met(&mut self, target: Target) -> Result<(), SelectError> {
-        self.select_until(|cs| cs.is_target_met(target))
+        self.select_until(|cs| cs.is_funded(target))
             .ok_or_else(|| {
                 SelectError::InsufficientFunds(InsufficientFunds {
                     missing: self.excess(target, Drain::NONE).unsigned_abs(),

src/metrics/lowest_fee.rs

@@ -73,7 +73,7 @@ impl LowestFee {
     /// inadmissible; [`score`](BnbMetric::score) reuses the returned drain for its cap check so the
     /// drain is only decided once.
     fn fee_score(&self, cs: &CoinSelector<'_>, target: Target) -> Option<(Ordf32, Drain)> {
-        if !cs.is_target_met(target) {
+        if !cs.is_funded(target) {
             return None;
         }
         let drain = self
@@ -125,7 +125,7 @@ impl BnbMetric for LowestFee {
             return None;
         }
 
-        if cs.is_target_met(target) {
+        if cs.is_funded(target) {
             let current_score = self.fee_score(cs, target).unwrap().0;
 
             // `current_score` is already a valid lower bound for a selection that has change: a
@@ -172,7 +172,7 @@ impl BnbMetric for LowestFee {
             let (mut cs, resize_index, to_resize) = cs
                 .clone()
                 .select_iter()
-                .find(|(cs, _, _)| cs.is_target_met(target))?;
+                .find(|(cs, _, _)| cs.is_funded(target))?;
 
             // If this selection is already perfect, return its score directly.
             if cs.excess(target, Drain::NONE) == 0 {
@@ -243,7 +243,7 @@ impl BnbMetric for LowestFee {
                 }
             }
 
-            // `scale` could be 0 even if `is_target_met` is `false` due to the latter being based on
+            // `scale` could be 0 even if `is_funded` is `false` due to the latter being based on
             // rounded-up vbytes.
             let ideal_fee = scale.0 * to_resize.value as f32 + cs.selected_value() as f32
                 - target.value() as f32;

tests/bnb.rs

@@ -162,7 +162,7 @@ proptest! {
 
         match solutions.enumerate().filter_map(|(i, sol)| Some((i, sol?))).last() {
             Some((_i, (sol, _score))) => assert!(sol.selected_value() >= target_value),
-            _ => prop_assert!(!cs.is_selection_possible(target)),
+            _ => prop_assert!(!cs.is_fundable(target)),
         }
     }
 

tests/common.rs

@@ -190,7 +190,7 @@ where
                         cs,
                         parent_has_change,
                         lb_score,
-                        cs.is_target_met(target),
+                        cs.is_funded(target),
                         descendant_cs,
                         descendant_has_change,
                         descendant_score,
@@ -385,12 +385,12 @@ where
 /// 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
+/// [`CoinSelector::is_funded`] + [`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);
+        |s: &CoinSelector| s.is_funded(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)
@@ -523,7 +523,7 @@ pub fn compare_against_benchmarks<M: BnbMetric + Clone>(
             }
         }
         None => {
-            // Full feasibility (value *and* max_weight) is needed here; `is_selection_possible`
+            // Full feasibility (value *and* max_weight) is needed here; `is_fundable`
             // only covers value, so use the exact exhaustive oracle to assert impossibility.
             prop_assert!(!exact_selection_possible(&cs, target));
         }
@@ -545,7 +545,7 @@ fn randomly_satisfy_target<'a, R: rand::Rng>(
     let mut last_score: Option<Ordf32> = None;
     while let Some(next) = cs.unselected_indices().choose(rng) {
         cs.select(next);
-        if cs.is_target_met(target) {
+        if cs.is_funded(target) {
             let curr_score = metric.score(&cs, target);
             if let Some(last_score) = last_score {
                 if curr_score.is_none() || curr_score.unwrap() > last_score {

tests/lowest_fee.rs

@@ -72,7 +72,7 @@ proptest! {
         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
+        // impossibility check relies on the (value-only) `is_fundable`, 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`.
     ) {
@@ -94,7 +94,7 @@ proptest! {
         let mut cs = CoinSelector::new(&candidates);
 
         let metric = params.lowest_fee_metric();
-        let is_impossible = !cs.is_selection_possible(params.target());
+        let is_impossible = !cs.is_fundable(params.target());
         match common::bnb_search(&mut cs, params.target(), metric, params.n_candidates * 10) {
             Ok((score, rounds)) => {
                 // the +1 is because the iterator will always try selecting nothing as a solution so we have