Introduce new bdk_coin_select implementation

Cargo.1.48.0.toml

@@ -0,0 +1,4 @@
+[workspace]
+members = [
+    "nursery/coin_select"
+]

build-msrv-crates.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env sh
+trap '
+    signal=$?;
+    cleanup
+    exit $signal;
+' INT
+
+cleanup() {
+    mv Cargo.tmp.toml Cargo.toml 2>/dev/null
+}
+
+cp Cargo.toml Cargo.tmp.toml
+cp Cargo.1.48.0.toml Cargo.toml
+cat Cargo.toml
+cargo build --release
+cleanup

crates/bdk/src/wallet/coin_selection.rs

@@ -836,7 +836,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 250_000 + FEE_AMOUNT;
 
-        let result = LargestFirstCoinSelection::default()
+        let result = LargestFirstCoinSelection
             .coin_select(
                 utxos,
                 vec![],
@@ -857,7 +857,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 20_000 + FEE_AMOUNT;
 
-        let result = LargestFirstCoinSelection::default()
+        let result = LargestFirstCoinSelection
             .coin_select(
                 utxos,
                 vec![],
@@ -878,7 +878,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 20_000 + FEE_AMOUNT;
 
-        let result = LargestFirstCoinSelection::default()
+        let result = LargestFirstCoinSelection
             .coin_select(
                 vec![],
                 utxos,
@@ -900,7 +900,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 500_000 + FEE_AMOUNT;
 
-        LargestFirstCoinSelection::default()
+        LargestFirstCoinSelection
             .coin_select(
                 vec![],
                 utxos,
@@ -918,7 +918,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 250_000 + FEE_AMOUNT;
 
-        LargestFirstCoinSelection::default()
+        LargestFirstCoinSelection
             .coin_select(
                 vec![],
                 utxos,
@@ -935,7 +935,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 180_000 + FEE_AMOUNT;
 
-        let result = OldestFirstCoinSelection::default()
+        let result = OldestFirstCoinSelection
             .coin_select(
                 vec![],
                 utxos,
@@ -956,7 +956,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 20_000 + FEE_AMOUNT;
 
-        let result = OldestFirstCoinSelection::default()
+        let result = OldestFirstCoinSelection
             .coin_select(
                 utxos,
                 vec![],
@@ -977,7 +977,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 20_000 + FEE_AMOUNT;
 
-        let result = OldestFirstCoinSelection::default()
+        let result = OldestFirstCoinSelection
             .coin_select(
                 vec![],
                 utxos,
@@ -999,7 +999,7 @@ mod test {
         let drain_script = ScriptBuf::default();
         let target_amount = 600_000 + FEE_AMOUNT;
 
-        OldestFirstCoinSelection::default()
+        OldestFirstCoinSelection
             .coin_select(
                 vec![],
                 utxos,
@@ -1018,7 +1018,7 @@ mod test {
         let target_amount: u64 = utxos.iter().map(|wu| wu.utxo.txout().value).sum::<u64>() - 50;
         let drain_script = ScriptBuf::default();
 
-        OldestFirstCoinSelection::default()
+        OldestFirstCoinSelection
             .coin_select(
                 vec![],
                 utxos,

example-crates/example_cli/src/lib.rs

@@ -1,9 +1,9 @@
 pub use anyhow;
 use anyhow::Context;
-use bdk_coin_select::{coin_select_bnb, CoinSelector, CoinSelectorOpt, WeightedValue};
+use bdk_coin_select::{Candidate, CoinSelector};
 use bdk_file_store::Store;
 use serde::{de::DeserializeOwned, Serialize};
-use std::{cmp::Reverse, collections::HashMap, path::PathBuf, sync::Mutex, time::Duration};
+use std::{cmp::Reverse, collections::HashMap, path::PathBuf, sync::Mutex};
 
 use bdk_chain::{
     bitcoin::{
@@ -17,7 +17,7 @@ use bdk_chain::{
         descriptor::{DescriptorSecretKey, KeyMap},
         Descriptor, DescriptorPublicKey,
     },
-    Anchor, Append, ChainOracle, DescriptorExt, FullTxOut, Persist, PersistBackend,
+    Anchor, Append, ChainOracle, FullTxOut, Persist, PersistBackend,
 };
 pub use bdk_file_store;
 pub use clap;
@@ -208,39 +208,18 @@ where
     };
 
     // TODO use planning module
-    let mut candidates = planned_utxos(graph, chain, &assets)?;
-
-    // apply coin selection algorithm
-    match cs_algorithm {
-        CoinSelectionAlgo::LargestFirst => {
-            candidates.sort_by_key(|(_, utxo)| Reverse(utxo.txout.value))
-        }
-        CoinSelectionAlgo::SmallestFirst => candidates.sort_by_key(|(_, utxo)| utxo.txout.value),
-        CoinSelectionAlgo::OldestFirst => {
-            candidates.sort_by_key(|(_, utxo)| utxo.chain_position.clone())
-        }
-        CoinSelectionAlgo::NewestFirst => {
-            candidates.sort_by_key(|(_, utxo)| Reverse(utxo.chain_position.clone()))
-        }
-        CoinSelectionAlgo::BranchAndBound => {}
-    }
-
+    let raw_candidates = planned_utxos(graph, chain, &assets)?;
     // turn the txos we chose into weight and value
-    let wv_candidates = candidates
+    let candidates = raw_candidates
         .iter()
         .map(|(plan, utxo)| {
-            WeightedValue::new(
+            Candidate::new(
                 utxo.txout.value,
                 plan.expected_weight() as _,
                 plan.witness_version().is_some(),
             )
         })
-        .collect();
-
-    let mut outputs = vec![TxOut {
-        value,
-        script_pubkey: address.script_pubkey(),
-    }];
+        .collect::<Vec<_>>();
 
     let internal_keychain = if graph.index.keychains().get(&Keychain::Internal).is_some() {
         Keychain::Internal
@@ -253,7 +232,7 @@ where
     changeset.append(change_changeset);
 
     // Clone to drop the immutable reference.
-    let change_script = change_script.into();
+    let change_script = change_script.to_owned();
 
     let change_plan = bdk_tmp_plan::plan_satisfaction(
         &graph
@@ -267,68 +246,103 @@ where
     )
     .expect("failed to obtain change plan");
 
-    let mut change_output = TxOut {
-        value: 0,
-        script_pubkey: change_script,
+    let mut transaction = Transaction {
+        version: 0x02,
+        // because the temporary planning module does not support timelocks, we can use the chain
+        // tip as the `lock_time` for anti-fee-sniping purposes
+        lock_time: chain
+            .get_chain_tip()?
+            .and_then(|block_id| absolute::LockTime::from_height(block_id.height).ok())
+            .unwrap_or(absolute::LockTime::ZERO),
+        input: vec![],
+        output: vec![TxOut {
+            value,
+            script_pubkey: address.script_pubkey(),
+        }],
     };
 
-    let cs_opts = CoinSelectorOpt {
-        target_feerate: 0.5,
-        min_drain_value: graph
-            .index
-            .keychains()
-            .get(&internal_keychain)
-            .expect("must exist")
-            .dust_value(),
-        ..CoinSelectorOpt::fund_outputs(
-            &outputs,
-            &change_output,
-            change_plan.expected_weight() as u32,
-        )
+    let target = bdk_coin_select::Target {
+        feerate: bdk_coin_select::FeeRate::from_sat_per_vb(2.0),
+        min_fee: 0,
+        value: transaction.output.iter().map(|txo| txo.value).sum(),
     };
 
-    // TODO: How can we make it easy to shuffle in order of inputs and outputs here?
-    // apply coin selection by saying we need to fund these outputs
-    let mut coin_selector = CoinSelector::new(&wv_candidates, &cs_opts);
-
-    // just select coins in the order provided until we have enough
-    // only use the first result (least waste)
-    let selection = match cs_algorithm {
+    let drain_weights = bdk_coin_select::DrainWeights {
+        output_weight: {
+            // we calculate the weight difference of including the drain output in the base tx
+            // this method will detect varint size changes of txout count
+            let tx_weight = transaction.weight();
+            let tx_weight_with_drain = {
+                let mut tx = transaction.clone();
+                tx.output.push(TxOut {
+                    script_pubkey: change_script.clone(),
+                    ..Default::default()
+                });
+                tx.weight()
+            };
+            (tx_weight_with_drain - tx_weight).to_wu() as u32 - 1
+        },
+        spend_weight: change_plan.expected_weight() as u32,
+    };
+    let long_term_feerate = bdk_coin_select::FeeRate::from_sat_per_vb(5.0);
+    let drain_policy = bdk_coin_select::change_policy::min_value_and_waste(
+        drain_weights,
+        change_script.dust_value().to_sat(),
+        long_term_feerate,
+    );
+
+    let mut selector = CoinSelector::new(&candidates, transaction.weight().to_wu() as u32);
+    match cs_algorithm {
         CoinSelectionAlgo::BranchAndBound => {
-            coin_select_bnb(Duration::from_secs(10), coin_selector.clone())
-                .map_or_else(|| coin_selector.select_until_finished(), |cs| cs.finish())?
+            let metric = bdk_coin_select::metrics::Waste {
+                target,
+                long_term_feerate,
+                change_policy: &drain_policy,
+            };
+            if let Err(bnb_err) = selector.run_bnb(metric, 100_000) {
+                selector.sort_candidates_by_descending_value_pwu();
+                println!(
+                    "Error: {} Falling back to select until target met.",
+                    bnb_err
+                );
+            };
         }
-        _ => coin_selector.select_until_finished()?,
+        CoinSelectionAlgo::LargestFirst => {
+            selector.sort_candidates_by_key(|(_, c)| Reverse(c.value))
+        }
+        CoinSelectionAlgo::SmallestFirst => selector.sort_candidates_by_key(|(_, c)| c.value),
+        CoinSelectionAlgo::OldestFirst => {
+            selector.sort_candidates_by_key(|(i, _)| raw_candidates[i].1.chain_position.clone())
+        }
+        CoinSelectionAlgo::NewestFirst => selector
+            .sort_candidates_by_key(|(i, _)| Reverse(raw_candidates[i].1.chain_position.clone())),
     };
-    let (_, selection_meta) = selection.best_strategy();
+
+    // ensure target is met
+    selector.select_until_target_met(target, drain_policy(&selector, target))?;
 
     // get the selected utxos
-    let selected_txos = selection.apply_selection(&candidates).collect::<Vec<_>>();
+    let selected_txos = selector
+        .apply_selection(&raw_candidates)
+        .collect::<Vec<_>>();
 
-    if let Some(drain_value) = selection_meta.drain_value {
-        change_output.value = drain_value;
-        // if the selection tells us to use change and the change value is sufficient, we add it as an output
-        outputs.push(change_output)
+    let drain = drain_policy(&selector, target);
+    if drain.is_some() {
+        transaction.output.push(TxOut {
+            value: drain.value,
+            script_pubkey: change_script,
+        });
     }
 
-    let mut transaction = Transaction {
-        version: 0x02,
-        // because the temporary planning module does not support timelocks, we can use the chain
-        // tip as the `lock_time` for anti-fee-sniping purposes
-        lock_time: chain
-            .get_chain_tip()?
-            .and_then(|block_id| absolute::LockTime::from_height(block_id.height).ok())
-            .unwrap_or(absolute::LockTime::ZERO),
-        input: selected_txos
-            .iter()
-            .map(|(_, utxo)| TxIn {
-                previous_output: utxo.outpoint,
-                sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
-                ..Default::default()
-            })
-            .collect(),
-        output: outputs,
-    };
+    // fill transaction inputs
+    transaction.input = selected_txos
+        .iter()
+        .map(|(_, utxo)| TxIn {
+            previous_output: utxo.outpoint,
+            sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
+            ..Default::default()
+        })
+        .collect();
 
     let prevouts = selected_txos
         .iter()
@@ -389,7 +403,7 @@ where
         }
     }
 
-    let change_info = if selection_meta.drain_value.is_some() {
+    let change_info = if drain.is_some() {
         Some((changeset, (internal_keychain, change_index)))
     } else {
         None

nursery/coin_select/Cargo.toml

@@ -1,10 +1,22 @@
 [package]
 name = "bdk_coin_select"
-version = "0.0.1"
-authors = [ "LLFourn <lloyd.fourn@gmail.com>" ]
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.57"
+homepage = "https://bitcoindevkit.org"
+repository = "https://github.com/bitcoindevkit/bdk"
+documentation = "https://docs.rs/bdk_coin_select"
+description = "Tools for input selection for making Bitcoin transactions."
+license = "MIT OR Apache-2.0"
+readme = "README.md"
 
 [dependencies]
-bdk_chain = { path = "../../crates/chain" }
+# No dependencies! Don't add any please!
+
+[dev-dependencies]
+rand = "0.7"
+proptest = "0.10"
+bitcoin = "0.30"
 
 [features]
 default = ["std"]