Add back coin_selection tests

Author: evanlinjin

src/psbt/mod.rs

@@ -192,27 +192,15 @@ mod test {
         let mut builder = wallet.build_tx();
         builder.drain_to(addr.script_pubkey()).drain_wallet();
         builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
-        let (mut psbt, details) = builder.finish().unwrap();
+        let (mut psbt, _) = builder.finish().unwrap();
         let fee_amount = psbt.fee_amount();
         assert!(fee_amount.is_some());
-        let unfinalized_fee_rate = psbt.fee_rate().unwrap();
-        println!("unfinalized fee rate: {:?}", unfinalized_fee_rate);
 
+        let unfinalized_fee_rate = psbt.fee_rate().unwrap();
         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
         assert!(finalized);
 
-        let tx = psbt.clone().extract_tx();
-        // println!("tx: {:#?}", tx);
-        println!("scriptSig weight: {}", tx.input[0].script_sig.len() * 4);
-        println!("weight: {}", tx.weight());
-        let vb = tx.weight() as f32 / 4.0;
-        println!("vbytes: {}", vb);
-        let fee = details.fee.unwrap_or(0);
-        println!("fee: {}", details.fee.unwrap_or(0));
-        println!("feerate: {} sats/vb", fee as f32 / vb);
-
         let finalized_fee_rate = psbt.fee_rate().unwrap();
-        println!("finalized fee rate: {:?}", finalized_fee_rate);
         assert!(finalized_fee_rate.as_sat_per_vb() >= expected_fee_rate);
         assert!(finalized_fee_rate.as_sat_per_vb() < unfinalized_fee_rate.as_sat_per_vb());
     }

src/wallet/coin_selection.rs

@@ -216,6 +216,7 @@ impl CoinSelectionAlgorithm for LargestFirstCoinSelection {
             let mut pool = selector.unselected().collect::<Vec<_>>();
             pool.sort_unstable_by_key(|(_, candidate)| candidate.value);
             pool.reverse();
+            println!("pool: {:?}", pool);
             pool
         };
 
@@ -384,6 +385,7 @@ mod test {
     use bitcoin::{OutPoint, Script, TxOut};
 
     use super::*;
+    use crate::bdk_core::CoinSelectorOpt;
     // use crate::database::{BatchOperations, MemoryDatabase};
     use crate::types::*;
     // use crate::wallet::WeightUnits;
@@ -419,12 +421,25 @@ mod test {
         }
     }
 
-    fn get_test_utxos() -> Vec<WeightedUtxo> {
-        vec![
+    fn get_test_utxos() -> (Vec<WeightedUtxo>, Vec<bdk_core::WeightedValue>) {
+        let utxos = vec![
             utxo(100_000, 0),
             utxo(FEE_AMOUNT as u64 - 40, 1),
             utxo(200_000, 2),
-        ]
+        ];
+
+        let candidates = utxos
+            .iter()
+            .map(|utxo| {
+                bdk_core::WeightedValue::new(
+                    utxo.utxo.txout().value,
+                    utxo.satisfaction_weight as u32,
+                    utxo.utxo.txout().script_pubkey.is_witness_program(),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        (utxos, candidates)
     }
 
     fn setup_database_and_get_oldest_first_test_utxos<D: Database>(
@@ -531,46 +546,60 @@ mod test {
             .map(|u| u.utxo.txout().value)
             .sum()
     }
-    // fn test_largest_first_coin_selection_success() {
-    //     let utxos = get_test_utxos();
-    //     let drain_script = Script::default();
-    //     let target_amount = 250_000 + FEE_AMOUNT;
 
-    //     let result = LargestFirstCoinSelection::default()
-    //         .coin_select(
-    //             utxos,
-    //             vec![],
-    //             FeeRate::from_sat_per_vb(1.0),
-    //             target_amount,
-    //             &drain_script,
-    //         )
-    //         .unwrap();
+    fn new_opts(target_value: u64, feerate: f32, drain_script: Script) -> CoinSelectorOpt {
+        CoinSelectorOpt {
+            target_feerate: feerate,
+            ..CoinSelectorOpt::fund_outputs(
+                &[TxOut {
+                    value: target_value,
+                    script_pubkey: Script::default(),
+                }],
+                &TxOut {
+                    value: 0,
+                    script_pubkey: drain_script,
+                },
+                0,
+            )
+        }
+    }
 
-    //     assert_eq!(result.selected.len(), 3);
-    //     assert_eq!(result.selected_amount(), 300_010);
-    //     assert_eq!(result.fee_amount, 204)
-    // }
+    #[test]
+    fn test_largest_first_coin_selection_success() {
+        let (utxos, candidates) = get_test_utxos();
+        let target_amount = 250_000 + FEE_AMOUNT;
 
-    // #[test]
-    // fn test_largest_first_coin_selection_use_all() {
-    //     let utxos = get_test_utxos();
-    //     let drain_script = Script::default();
-    //     let target_amount = 20_000 + FEE_AMOUNT;
+        let opts = new_opts(target_amount, 0.25, Script::default());
+        let selector = bdk_core::CoinSelector::new(&candidates, &opts);
 
-    //     let result = LargestFirstCoinSelection::default()
-    //         .coin_select(
-    //             utxos,
-    //             vec![],
-    //             FeeRate::from_sat_per_vb(1.0),
-    //             target_amount,
-    //             &drain_script,
-    //         )
-    //         .unwrap();
+        let result = LargestFirstCoinSelection::default()
+            .coin_select(&utxos, selector)
+            .unwrap();
+        let (strategy_kind, strategy) = result.best_strategy();
+        println!("strategy_kind: {}", strategy_kind);
 
-    //     assert_eq!(result.selected.len(), 3);
-    //     assert_eq!(result.selected_amount(), 300_010);
-    //     assert_eq!(result.fee_amount, 204);
-    // }
+        assert_eq!(result.selected.len(), 2);
+        assert_eq!(strategy.fee, 164);
+    }
+
+    #[test]
+    fn test_largest_first_coin_selection_use_all() {
+        let (utxos, candidates) = get_test_utxos();
+        let target_amount = 20_000 + FEE_AMOUNT;
+
+        let opts = new_opts(target_amount, 0.25, Script::default());
+        let mut selector = bdk_core::CoinSelector::new(&candidates, &opts);
+        selector.select_all();
+
+        let result = LargestFirstCoinSelection::default()
+            .coin_select(&utxos, selector)
+            .unwrap();
+        let (_, strategy) = result.best_strategy();
+
+        assert_eq!(result.selected.len(), 3);
+        // assert_eq!(result.selected_amount(), 300_010);
+        assert_eq!(strategy.fee, 232);
+    }
 
     // #[test]
     // fn test_largest_first_coin_selection_use_only_necessary() {