WIP: Make RBF easier to reason about

Author: evanlinjin

src/coin_control.rs

@@ -6,7 +6,7 @@ use crate::{
 };
 use alloc::vec::Vec;
 use bdk_chain::{BlockId, ChainOracle, ConfirmationBlockTime, TxGraph};
-use bitcoin::{absolute, OutPoint, Txid};
+use bitcoin::{absolute, OutPoint, Transaction, Txid};
 use miniscript::{bitcoin, plan::Plan};
 
 /// Coin control.

src/input.rs

@@ -423,6 +423,22 @@ impl InputGroup {
             .expect("group must not be empty")
     }
 
+    /// Whether any contained input satisfies the predicate.
+    pub fn any<F>(&self, f: F) -> bool
+    where
+        F: FnMut(&Input) -> bool,
+    {
+        self.inputs().iter().any(f)
+    }
+
+    /// Whether all of the contained inputs satisfies the predicate.
+    pub fn all<F>(&self, f: F) -> bool
+    where
+        F: FnMut(&Input) -> bool,
+    {
+        self.inputs().iter().all(f)
+    }
+
     /// Total value of all contained inputs.
     pub fn value(&self) -> Amount {
         self.inputs().iter().map(|input| input.txout.value).sum()

src/input_candidates.rs

@@ -53,10 +53,7 @@ impl InputCandidates {
     /// Returns the original [`InputCandidates`] if any outpoint is not found.
     pub fn with_must_select(self, outpoints: HashSet<OutPoint>) -> Result<Self, Self> {
         let (must_select, can_select) = self.groups.iter().partition::<Vec<_>, _>(|group| {
-            group
-                .inputs()
-                .iter()
-                .any(|input| outpoints.contains(&input.prev_outpoint()))
+            group.any(|input| outpoints.contains(&input.prev_outpoint()))
         });
 
         // `must_select` must contaon all outpoints.
@@ -90,6 +87,15 @@ impl InputCandidates {
         })
     }
 
+    /// Like [`InputCandidates::with_must_select`], but with a policy closure.
+    pub fn with_must_select_policy<P>(self, mut policy: P) -> Result<Self, Self>
+    where
+        P: FnMut(&Self) -> HashSet<OutPoint>,
+    {
+        let outpoints = policy(&self);
+        self.with_must_select(outpoints)
+    }
+
     /// Whether the outpoint is contained in our candidates.
     pub fn contains(&self, outpoint: OutPoint) -> bool {
         self.groups.iter().any(|group| {

src/lib.rs

@@ -14,6 +14,7 @@ mod finalizer;
 mod input; // TODO: Move into `bdk_tx_core`.
 mod input_candidates;
 mod output; // TODO: Move into `bdk_tx_core`.
+mod rbf;
 mod selection;
 mod selector;
 mod signer;
@@ -26,6 +27,7 @@ pub use miniscript;
 pub use miniscript::bitcoin;
 use miniscript::{DefiniteDescriptorKey, Descriptor};
 pub use output::*;
+pub use rbf::*;
 pub use selection::*;
 pub use selector::*;
 pub use signer::*;

src/output.rs

@@ -107,25 +107,4 @@ impl Output {
             script_pubkey: self.script_pubkey_source.script(),
         }
     }
-
-    /// To coin select drain (change) output weights.
-    ///
-    /// Returns `None` if no descriptor is avaliable or the output is unspendable.
-    pub fn to_drain_weights(&self) -> Option<bdk_coin_select::DrainWeights> {
-        let descriptor = self.descriptor()?;
-        Some(bdk_coin_select::DrainWeights {
-            output_weight: self.txout().weight().to_wu(),
-            spend_weight: descriptor.max_weight_to_satisfy().ok()?.to_wu(),
-            n_outputs: 1,
-        })
-    }
-
-    /// To coin select target outputs.
-    pub fn to_target_outputs(&self) -> bdk_coin_select::TargetOutputs {
-        bdk_coin_select::TargetOutputs {
-            value_sum: self.txout().value.to_sat(),
-            weight_sum: self.txout().weight().to_wu(),
-            n_outputs: 1,
-        }
-    }
 }

src/rbf.rs

@@ -0,0 +1,141 @@
+use alloc::vec::Vec;
+use bitcoin::{absolute, Amount, OutPoint, Transaction, TxOut, Txid};
+use miniscript::bitcoin;
+
+use crate::collections::{HashMap, HashSet};
+use crate::{InputCandidates, InputGroup, RbfParams};
+
+/// Set of txs to replace.
+pub struct RbfSet<'t> {
+    txs: HashMap<Txid, &'t Transaction>,
+    prev_txouts: HashMap<OutPoint, TxOut>,
+}
+
+impl<'t> RbfSet<'t> {
+    /// Create.
+    ///
+    /// Returns `None` if we have missing `prev_txouts` for the `txs`.
+    ///
+    /// If any transactions in `txs` are ancestors or descendants of others in `txs`, be sure to
+    /// include any intermediary transactions needed to resolve those dependencies.
+    ///
+    /// TODO: Error if trying to replace coinbase.
+    pub fn new<T, O>(txs: T, prev_txouts: O) -> Option<Self>
+    where
+        T: IntoIterator<Item = &'t Transaction>,
+        O: IntoIterator<Item = (OutPoint, TxOut)>,
+    {
+        let set = Self {
+            txs: txs.into_iter().map(|tx| (tx.compute_txid(), tx)).collect(),
+            prev_txouts: prev_txouts.into_iter().collect(),
+        };
+        let no_missing_previous_txouts = set
+            .txs
+            .values()
+            .flat_map(|tx| tx.input.iter().map(|txin| txin.previous_output))
+            .all(|op: OutPoint| set.prev_txouts.contains_key(&op));
+        if no_missing_previous_txouts {
+            Some(set)
+        } else {
+            None
+        }
+    }
+
+    /// Txids of the original txs that are to be replaced.
+    ///
+    /// Used for modifying canonicalization to exclude the original txs.
+    pub fn txids(&self) -> impl ExactSizeIterator<Item = Txid> + '_ {
+        self.txs.keys().copied()
+    }
+
+    /// Filters input candidates according to rule 2.
+    ///
+    /// According to rule 2, we cannot spend unconfirmed txs in the replacement unless it
+    /// was a spend that was already part of the original tx.
+    pub fn candidate_filter(
+        &self,
+        tip_height: absolute::Height,
+    ) -> impl Fn(&InputGroup) -> bool + '_ {
+        let prev_spends = self
+            .txs
+            .values()
+            .flat_map(|tx| {
+                tx.input
+                    .iter()
+                    .map(|txin| txin.previous_output)
+                    .collect::<Vec<_>>()
+            })
+            .collect::<HashSet<OutPoint>>();
+        move |group| {
+            group.all(|input| {
+                prev_spends.contains(&input.prev_outpoint()) || input.confirmations(tip_height) > 0
+            })
+        }
+    }
+
+    /// Returns a policy that selects the largest input of every original tx.
+    ///
+    /// This guarantees that the txs are replaced.
+    pub fn must_select_largest_input_per_tx(
+        &self,
+    ) -> impl FnMut(&InputCandidates) -> HashSet<OutPoint> + '_ {
+        |input_candidates| {
+            let mut must_select = HashSet::new();
+
+            for original_tx in self.txs.values() {
+                let mut largest_value = Amount::ZERO;
+                let mut largest_value_not_canonical = Amount::ZERO;
+                let mut largest_spend = Option::<OutPoint>::None;
+                let original_tx_spends = original_tx.input.iter().map(|txin| txin.previous_output);
+                for spend in original_tx_spends {
+                    // If this spends from another original tx , we do not consider it as replacing
+                    // the parent will replace this one.
+                    if self.txs.contains_key(&spend.txid) {
+                        continue;
+                    }
+                    let txout = self.prev_txouts.get(&spend).expect("must have prev txout");
+
+                    // not canonical
+                    if !input_candidates.contains(spend) {
+                        if largest_value == Amount::ZERO
+                            && txout.value > largest_value_not_canonical
+                        {
+                            largest_value_not_canonical = txout.value;
+                            largest_spend = Some(spend);
+                        }
+                        continue;
+                    }
+
+                    if txout.value > largest_value {
+                        largest_value = txout.value;
+                        largest_spend = Some(spend);
+                    }
+                }
+                let largest_spend = largest_spend.expect("tx must have atleast one input");
+                must_select.insert(largest_spend);
+            }
+
+            must_select
+        }
+    }
+
+    fn _fee(&self, tx: &'t Transaction) -> Amount {
+        let output_sum: Amount = tx.output.iter().map(|txout| txout.value).sum();
+        let input_sum: Amount = tx
+            .input
+            .iter()
+            .map(|txin| {
+                self.prev_txouts
+                    .get(&txin.previous_output)
+                    .expect("prev output must exist")
+                    .value
+            })
+            .sum();
+        input_sum - output_sum
+    }
+
+    /// Coin selector RBF parameters.
+    pub fn selector_rbf_params(&self) -> RbfParams {
+        RbfParams::new(self.txs.values().map(|tx| (*tx, self._fee(tx))))
+    }
+}

src/selector.rs

@@ -2,7 +2,7 @@ use bdk_coin_select::{
     float::Ordf32, metrics::LowestFee, ChangePolicy, DrainWeights, InsufficientFunds,
     NoBnbSolution, Replace, Target, TargetFee, TargetOutputs,
 };
-use bitcoin::{Amount, FeeRate, TxOut, Weight};
+use bitcoin::{Amount, FeeRate, Transaction, TxOut, Weight};
 use miniscript::bitcoin;
 
 use crate::{cs_feerate, DefiniteDescriptor, InputCandidates, InputGroup, Output, Selection};
@@ -54,10 +54,23 @@ pub struct SelectorParams {
 /// Rbf original tx stats.
 #[derive(Debug, Clone, Copy)]
 pub struct OriginalTxStats {
-    /// Total fee amount of the original tx.
-    pub fee: Amount,
     /// Total weight of the original tx.
     pub weight: Weight,
+    /// Total fee amount of the original tx.
+    pub fee: Amount,
+}
+
+impl From<(Weight, Amount)> for OriginalTxStats {
+    fn from((weight, fee): (Weight, Amount)) -> Self {
+        Self { weight, fee }
+    }
+}
+
+impl From<(&Transaction, Amount)> for OriginalTxStats {
+    fn from((tx, fee): (&Transaction, Amount)) -> Self {
+        let weight = tx.weight();
+        Self { weight, fee }
+    }
 }
 
 /// Rbf params.
@@ -93,6 +106,18 @@ impl OriginalTxStats {
 }
 
 impl RbfParams {
+    /// Construct RBF parameters.
+    pub fn new<I>(tx_to_replace: I) -> Self
+    where
+        I: IntoIterator,
+        I::Item: Into<OriginalTxStats>,
+    {
+        Self {
+            original_txs: tx_to_replace.into_iter().map(Into::into).collect(),
+            incremental_relay_feerate: FeeRate::from_sat_per_vb_unchecked(1),
+        }
+    }
+
     /// To coin select `Replace` params.
     pub fn to_cs_replace(&self) -> Replace {
         let replace = Replace {