Add test seven

yancyribbens · yancyribbens · commit e8e35c55c88d · 2025-02-20T19:14:47.000-06:00
diff --git a/src/coin_grinder.rs b/src/coin_grinder.rs
@@ -45,24 +45,10 @@ fn calc_effective_values<Utxo: WeightedUtxo>(weighted_utxos: &[Utxo], fee_rate:
         .collect()
 }
 
-// A Vector of Weights that is the same size as utxo_pool.  Provides a lookup
-// to derermine the smallest possible Weight a UTXO can be after a given index.
+// Provides a lookup to derermine the minimum UTXO weight after a given index.
 fn build_min_tail_weight<Utxo: WeightedUtxo>(weighted_utxos: Vec<(Amount, &Utxo)>) -> Vec<Weight> {
-    let mut min_group_weight: Vec<Weight> = vec![];
-    let mut min = Weight::MAX;
-
-    for (_, u) in &weighted_utxos {
-        min_group_weight.push(min);
-
-        // weight is used instead of satisfaction_weight to mirror core.
-        let weight = u.weight();
-
-        if weight < min {
-            min = weight;
-        }
-    }
-
-    min_group_weight.into_iter().rev().collect()
+    let min_element = weighted_utxos.iter().min_by(|a, b| a.1.weight().cmp(&b.1.weight())).unwrap();
+    vec![min_element.1.weight(); weighted_utxos.len()]
 }
 
 fn index_to_utxo_list<Utxo: WeightedUtxo>(
@@ -138,11 +124,16 @@ pub fn select_coins<Utxo: WeightedUtxo>(
     });
 
     let lookahead = build_lookahead(w_utxos.clone(), available_value);
-
-    //let min_group_weight = w_utxos.clone();
     let min_tail_weight = build_min_tail_weight(w_utxos.clone());
 
+    for i in &min_tail_weight {
+        println!("{:?}", i);
+    }
+
     let total_target = target + change_target;
+    println!("total_target: {:?}", total_target);
+    println!("target: {:?}", target);
+    println!("change_target: {:?}", change_target);
 
     if available_value < total_target {
         return None
@@ -166,6 +157,10 @@ pub fn select_coins<Utxo: WeightedUtxo>(
 
         // EXPLORE
         let (eff_value, u) = w_utxos[next_utxo_index];
+        println!("");
+        println!("* amt: {:?}", eff_value);
+        println!("* amount_sum: {:?}", amount_sum);
+        println!("* weight_sum: {:?}", weight_sum);
 
         amount_sum += eff_value;
         weight_sum += u.weight();
@@ -175,12 +170,19 @@ pub fn select_coins<Utxo: WeightedUtxo>(
         iteration += 1;
 
         let tail: usize = *selection.last().unwrap();
-
         // no possibility of hitting the total along this branch.
         // CUT
+        println!("weight sum: {:?}", weight_sum.to_wu());
+        println!("min tail weight: {:?}", min_tail_weight[tail].to_wu());
+        println!("total target {:?}: ", total_target);
+        println!("amount sum: {:?}", amount_sum);
+        println!("tail: {:?}", w_utxos[tail].0.to_sat());
+        println!("best_weight_sum: {:?}", best_weight_sum);
         if amount_sum + lookahead[tail] < total_target {
+            println!("amount_sum + lookahead[tail] < total_target");
             cut = true;
         } else if weight_sum > best_weight_sum {
+            println!("weight_sum > best_weight_sum");
             // check if a better solution could exist.  IE there exists a utxo with a better
             // weight along the current branch
             if w_utxos[tail].1.weight() <= min_tail_weight[tail] {
@@ -197,12 +199,33 @@ pub fn select_coins<Utxo: WeightedUtxo>(
                 shift = true;
             }
         } else if amount_sum >= total_target {
+            println!("amount_sum >= total_target");
             shift = true;
             if weight_sum < best_weight_sum || weight_sum == best_weight_sum && amount_sum < best_amount_sum {
                 best_selection = selection.clone();
                 best_weight_sum = weight_sum;
                 best_amount_sum = amount_sum;
             }
+        } else if !best_selection.is_empty() && weight_sum + min_tail_weight[tail] * ((total_target.to_sat() - amount_sum.to_sat() + w_utxos[tail].0.to_sat() - 1)/ w_utxos[tail].0.to_sat()) > best_weight_sum {
+            //println!("num: {:?}", total_target.to_sat() - amount_sum.to_sat() + w_utxos[tail].0.to_sat() - 1);
+            //println!("denom: {:?}", w_utxos[tail].0.to_sat());
+            //println!("eval: {:?}", min_tail_weight[tail].to_wu() * ((total_target.to_sat() - amount_sum.to_sat() + w_utxos[tail].0.to_sat() - 1)/ w_utxos[tail].0.to_sat()));
+            //println!("eval: {:?}", weight_sum + min_tail_weight[tail] * ((total_target.to_sat() - amount_sum.to_sat() + w_utxos[tail].0.to_sat() - 1)/ w_utxos[tail].0.to_sat()));
+
+            println!("weight sum: {:?}", weight_sum.to_wu());
+            println!("min tail weight: {:?}", min_tail_weight[tail].to_wu());
+            println!("total target {:?}: ", total_target);
+            println!("amount sum: {:?}", amount_sum);
+            println!("tail: {:?}", w_utxos[tail].0.to_sat());
+            println!("best_weight_sum: {:?}", best_weight_sum);
+
+            if w_utxos[tail].1.weight() <= min_tail_weight[tail] {
+                println!("cut");
+                cut = true;
+            } else {
+                println!("shift");
+                shift = true;
+            }
         }
 
         // check if evaluating a leaf node.
@@ -216,7 +239,6 @@ pub fn select_coins<Utxo: WeightedUtxo>(
             amount_sum -= eff_value;
             weight_sum -= u.weight();
             selection.pop();
-
             shift = true;
         }
 
@@ -316,28 +338,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn min_tail_weight() {
-        let weighted_utxos = vec![
-            "10 sats/8",
-            "7 sats/4",
-            "5 sats/4",
-            "4 sats/8"
-        ];
-
-        let utxos: Vec<_> = build_utxos(weighted_utxos);
-        let eff_values: Vec<(Amount, &Utxo)> = calc_effective_values(&utxos, FeeRate::ZERO);
-        let min_tail_weight = build_min_tail_weight(eff_values.clone());
-
-        let expect: Vec<Weight> = [
-            4u64,
-            4u64,
-            8u64,
-            18446744073709551615u64
-        ].iter().map(|w| Weight::from_wu(*w)).collect();
-        assert_eq!(min_tail_weight, expect);
-    }
-
     #[test]
     fn lookahead() {
         let weighted_utxos = vec![
@@ -447,7 +447,7 @@ mod tests {
             expected.push("0.33 BTC");
         }
 
-        assert_coin_select_params(&params, 184, Some(&expected));
+        assert_coin_select_params(&params, 37, Some(&expected));
     }
 
     #[test]
@@ -499,13 +499,13 @@ mod tests {
             weighted_utxos: coins
         };
 
-        assert_coin_select_params(&params, 213, Some(&["14 BTC", "13 BTC", "4 BTC"]));
+        assert_coin_select_params(&params, 92, Some(&["14 BTC", "13 BTC", "4 BTC"]));
     }
 
     #[test]
-    // 6) Test that the lightest solution among many clones is found
-    // https://github.com/bitcoin/bitcoin/blob/43e71f74988b2ad87e4bfc0e1b5c921ab86ec176/src/wallet/test/coinselector_tests.cpp#L1244
-    fn lightest_amount_many_clones() {
+    fn lightest_amoung_many_clones() {
+        // 6) Test that the lightest solution among many clones is found
+        // https://github.com/bitcoin/bitcoin/blob/43e71f74988b2ad87e4bfc0e1b5c921ab86ec176/src/wallet/test/coinselector_tests.cpp#L1244
         let mut coins = vec![
             "4 BTC/400",
             "3 BTC/400",
@@ -521,7 +521,7 @@ mod tests {
         }
 
         let params = ParamsStr {
-            target: "9.9 BTC",
+            target: "989999999 sats",
             change_target: "1000000 sats",
             max_weight: "400000",
             fee_rate: "5",
@@ -535,6 +535,39 @@ mod tests {
             "1 BTC"
         ];
 
-        assert_coin_select_params(&params, 31, Some(&expected));
+        assert_coin_select_params(&params, 38, Some(&expected));
+    }
+
+    #[test]
+    fn skip_tiny_inputs() {
+        // 7) Test that lots of tiny UTXOs can be skipped if they are too heavy while there are enough funds in lookahead
+        // https://github.com/bitcoin/bitcoin/blob/43e71f74988b2ad87e4bfc0e1b5c921ab86ec176/src/wallet/test/coinselector_tests.cpp#L1153
+        let mut coins = vec![
+            "1.8 BTC/10000",
+            "1 BTC/4000",
+            "1 BTC/4000"
+        ];
+        let mut tiny_coins = vec![];
+        for i in 0..100 {
+            tiny_coins.push(0.01 * 100000000 as f64 + i as f64);
+        }
+        let tiny_coins: Vec<String> = tiny_coins.iter().map(|a| format!("{} sats/440", a)).collect();
+        let mut tiny_coins: Vec<&str> = tiny_coins.iter().map(|s| s as &str).collect();
+        coins.append(&mut tiny_coins);
+
+        let params = ParamsStr {
+            target: "1.9 BTC",
+            change_target: "1000000 sats",
+            max_weight: "400000",
+            fee_rate: "5",
+            weighted_utxos: coins
+        };
+
+        let expected = vec![
+            "1 BTC",
+            "1 BTC"
+        ];
+
+        assert_coin_select_params(&params, 7, Some(&expected));
     }
 }
