feat: bip326 anti-fee sniping made compatible with new current library

Author: aagbotemi

Cargo.toml

@@ -13,11 +13,11 @@ miniscript = { version = "12", default-features = false }
 bdk_coin_select = "0.4.0"
 rand_core = { version = "0.6.0", features = ["getrandom"] }
 bdk_chain = { version = "0.21" }
+bitcoin = { version = "0.32", features = ["rand-std"] }
 
 [dev-dependencies]
 anyhow = "1"
 bdk_tx = { path = "." }
-bitcoin = { version = "0.32", features = ["rand-std"] }
 bdk_testenv = "0.11.1"
 bdk_bitcoind_rpc = "0.18.0"
 

src/lib.rs

@@ -18,6 +18,7 @@ mod rbf;
 mod selection;
 mod selector;
 mod signer;
+mod utils;
 
 pub use canonical_unspents::*;
 pub use finalizer::*;
@@ -31,6 +32,7 @@ pub use rbf::*;
 pub use selection::*;
 pub use selector::*;
 pub use signer::*;
+use utils::*;
 
 pub(crate) mod collections {
     #![allow(unused)]

src/selection.rs

@@ -6,7 +6,7 @@ use bitcoin::{absolute, transaction, Sequence};
 use miniscript::bitcoin;
 use miniscript::psbt::PsbtExt;
 
-use crate::{Finalizer, Input, Output};
+use crate::{apply_anti_fee_sniping, Finalizer, Input, Output};
 
 const FALLBACK_SEQUENCE: bitcoin::Sequence = bitcoin::Sequence::ENABLE_LOCKTIME_NO_RBF;
 
@@ -44,6 +44,9 @@ pub struct PsbtParams {
     ///
     /// [`non_witness_utxo`]: bitcoin::psbt::Input::non_witness_utxo
     pub mandate_full_tx_for_segwit_v0: bool,
+
+    /// Whether to use BIP326 anti-fee-sniping
+    pub enable_anti_fee_sniping: bool,
 }
 
 impl Default for PsbtParams {
@@ -53,6 +56,7 @@ impl Default for PsbtParams {
             fallback_locktime: absolute::LockTime::ZERO,
             fallback_sequence: FALLBACK_SEQUENCE,
             mandate_full_tx_for_segwit_v0: true,
+            enable_anti_fee_sniping: true,
         }
     }
 }
@@ -70,6 +74,10 @@ pub enum CreatePsbtError {
     Psbt(bitcoin::psbt::Error),
     /// Update psbt output with descriptor error.
     OutputUpdate(miniscript::psbt::OutputUpdateError),
+    /// Invalid locktime
+    InvalidLockTime(absolute::LockTime),
+    /// Invalid height
+    InvalidHeight(u32),
 }
 
 impl core::fmt::Display for CreatePsbtError {
@@ -90,6 +98,12 @@ impl core::fmt::Display for CreatePsbtError {
             CreatePsbtError::OutputUpdate(output_update_error) => {
                 Display::fmt(&output_update_error, f)
             }
+            CreatePsbtError::InvalidLockTime(locktime) => {
+                write!(f, "The locktime - {}, is invalid", locktime)
+            }
+            CreatePsbtError::InvalidHeight(height) => {
+                write!(f, "The height - {}, is invalid", height)
+            }
         }
     }
 }
@@ -127,7 +141,7 @@ impl Selection {
 
     /// Create psbt.
     pub fn create_psbt(&self, params: PsbtParams) -> Result<bitcoin::Psbt, CreatePsbtError> {
-        let mut psbt = bitcoin::Psbt::from_unsigned_tx(bitcoin::Transaction {
+        let mut tx = bitcoin::Transaction {
             version: params.version,
             lock_time: Self::_accumulate_max_locktime(
                 self.inputs
@@ -146,8 +160,23 @@ impl Selection {
                 })
                 .collect(),
             output: self.outputs.iter().map(|output| output.txout()).collect(),
-        })
-        .map_err(CreatePsbtError::Psbt)?;
+        };
+
+        if params.enable_anti_fee_sniping {
+            let rbf_enabled = params.fallback_sequence.is_rbf();
+            let height = params
+                .fallback_locktime
+                .is_block_height()
+                .then(|| params.fallback_locktime.to_consensus_u32())
+                .ok_or(CreatePsbtError::InvalidLockTime(params.fallback_locktime))?;
+
+            let current_height = bitcoin::absolute::Height::from_consensus(height)
+                .map_err(|_conversion_error| CreatePsbtError::InvalidHeight(height))?;
+
+            apply_anti_fee_sniping(&mut tx, &self.inputs, current_height, rbf_enabled);
+        };
+
+        let mut psbt = bitcoin::Psbt::from_unsigned_tx(tx).map_err(CreatePsbtError::Psbt)?;
 
         for (plan_input, psbt_input) in self.inputs.iter().zip(psbt.inputs.iter_mut()) {
             if let Some(finalized_psbt_input) = plan_input.psbt_input() {

src/utils.rs

@@ -0,0 +1,123 @@
+use crate::Input;
+use bitcoin::{
+    absolute::{self, LockTime},
+    transaction::Version,
+    Sequence, Transaction, WitnessVersion,
+};
+use std::vec::Vec;
+
+use rand_core::{OsRng, RngCore};
+
+/// Applies BIP326 anti‐fee‐sniping
+pub fn apply_anti_fee_sniping(
+    tx: &mut Transaction,
+    inputs: &[Input],
+    current_height: absolute::Height,
+    rbf_enabled: bool,
+) {
+    const MAX_SEQUENCE_VALUE: u32 = 65_535;
+    const USE_NLOCKTIME_PROBABILITY: f64 = 0.5;
+    const MIN_SEQUENCE_VALUE: u32 = 1;
+    const FURTHER_BACK_PROBABILITY: f64 = 0.1;
+    const MAX_RANDOM_OFFSET: u32 = 99;
+
+    tx.version = Version::TWO;
+
+    let taproot_inputs: Vec<_> = inputs
+        .iter()
+        .enumerate()
+        .filter(|(_, input)| {
+            matches!(
+                input.plan().and_then(|plan| plan.witness_version()),
+                Some(WitnessVersion::V1)
+            )
+        })
+        .collect();
+
+    // Initialize all nsequence to indicate the requested RBF state
+    for input in &mut tx.input {
+        input.sequence = if rbf_enabled {
+            Sequence(0xFFFFFFFF - 2) // 2^32 - 3
+        } else {
+            Sequence(0xFFFFFFFF - 1) // 2^32 - 2
+        }
+    }
+    // Check always‐locktime conditions
+    let must_use_locktime = inputs.iter().any(|input| {
+        let confirmation = input.confirmations(current_height);
+        confirmation == 0
+            || confirmation > MAX_SEQUENCE_VALUE
+            || !matches!(
+                input.plan().and_then(|plan| plan.witness_version()),
+                Some(WitnessVersion::V1)
+            )
+    });
+
+    let use_locktime = !rbf_enabled
+        || must_use_locktime
+        || taproot_inputs.is_empty()
+        || random_probability(USE_NLOCKTIME_PROBABILITY);
+
+    if use_locktime {
+        // Use nLockTime
+        let mut locktime = current_height.to_consensus_u32();
+
+        if random_probability(FURTHER_BACK_PROBABILITY) {
+            let random_offset = random_range(0, MAX_RANDOM_OFFSET);
+            locktime = locktime.saturating_sub(random_offset);
+        }
+
+        tx.lock_time = LockTime::from_height(locktime).unwrap();
+    } else {
+        // Use Sequence
+        tx.lock_time = LockTime::ZERO;
+
+        let input_index = random_range(0, taproot_inputs.len() as u32) as usize;
+
+        let (idx, input) = &taproot_inputs[input_index];
+
+        let confirmation = input.confirmations(current_height);
+
+        let mut sequence_value = confirmation;
+
+        if random_probability(FURTHER_BACK_PROBABILITY) {
+            let random_offset = random_range(0, MAX_RANDOM_OFFSET);
+            sequence_value = sequence_value
+                .saturating_sub(random_offset)
+                .max(MIN_SEQUENCE_VALUE);
+        }
+
+        tx.input[*idx].sequence = Sequence(sequence_value);
+    }
+}
+
+fn random_probability(probability: f64) -> bool {
+    debug_assert!(
+        (0.0..=1.0).contains(&probability),
+        "Probability must be between 0.0 and 1.0"
+    );
+
+    let mut rng = OsRng;
+    let rand_val = rng.next_u32() as f64;
+    let max_u32 = u32::MAX as f64;
+    (rand_val / max_u32) < probability
+}
+
+fn random_range(min: u32, max: u32) -> u32 {
+    if min >= max {
+        return min;
+    }
+    let mut rng = OsRng;
+    let range = max.saturating_sub(min);
+    let threshold = u32::MAX.saturating_sub(u32::MAX % range);
+    let min_val = min + (rng.next_u32() % (max - min));
+    let mut r;
+
+    loop {
+        r = rng.next_u32();
+        if r < threshold {
+            break;
+        }
+    }
+    min_val.saturating_add(r % range)
+}