example to test anti fee snipping, extracted the height from tx

checking expected range of values

Author: aagbotemi

Cargo.toml

@@ -12,14 +12,14 @@ readme = "README.md"
 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"] }
+bitcoin = { version = "0.32", default-features = false }
 
 [dev-dependencies]
 anyhow = "1"
 bdk_tx = { path = "." }
 bdk_testenv = "0.11.1"
 bdk_bitcoind_rpc = "0.18.0"
+bdk_chain = { version = "0.21" }
 
 [features]
 default = ["std"]
@@ -31,3 +31,6 @@ name = "synopsis"
 [[example]]
 name = "common"
 crate-type = ["lib"]
+
+[[example]]
+name = "anti_fee_snipping"

examples/anti_fee_snipping.rs

@@ -0,0 +1,133 @@
+#![allow(dead_code)]
+use bdk_testenv::{bitcoincore_rpc::RpcApi, TestEnv};
+use bdk_tx::{
+    filter_unspendable_now, group_by_spk, selection_algorithm_lowest_fee_bnb, Output, PsbtParams,
+    SelectorParams,
+};
+use bitcoin::{absolute::LockTime, key::Secp256k1, Amount, FeeRate, Sequence};
+use miniscript::Descriptor;
+
+mod common;
+
+use common::Wallet;
+
+fn main() -> anyhow::Result<()> {
+    let secp = Secp256k1::new();
+    let (external, _) = Descriptor::parse_descriptor(&secp, bdk_testenv::utils::DESCRIPTORS[0])?;
+    let (internal, _) = Descriptor::parse_descriptor(&secp, bdk_testenv::utils::DESCRIPTORS[1])?;
+
+    let env = TestEnv::new()?;
+    let genesis_hash = env.genesis_hash()?;
+    env.mine_blocks(101, None)?;
+
+    let mut wallet = Wallet::new(genesis_hash, external, internal.clone())?;
+    wallet.sync(&env)?;
+
+    let addr = wallet.next_address().expect("must derive address");
+
+    let txid = env.send(&addr, Amount::ONE_BTC)?;
+    env.mine_blocks(1, None)?;
+    wallet.sync(&env)?;
+    println!("Received {}", txid);
+    println!("Balance (confirmed): {}", wallet.balance());
+
+    let txid = env.send(&addr, Amount::ONE_BTC)?;
+    wallet.sync(&env)?;
+    println!("Received {txid}");
+    println!("Balance (pending): {}", wallet.balance());
+
+    let (tip_height, tip_time) = wallet.tip_info(env.rpc_client())?;
+    println!("Height: {}", tip_height);
+    let longterm_feerate = FeeRate::from_sat_per_vb_unchecked(1);
+
+    let recipient_addr = env
+        .rpc_client()
+        .get_new_address(None, None)?
+        .assume_checked();
+
+    // Okay now create tx.
+    let selection = wallet
+        .all_candidates()
+        .regroup(group_by_spk())
+        .filter(filter_unspendable_now(tip_height, tip_time))
+        .into_selection(
+            selection_algorithm_lowest_fee_bnb(longterm_feerate, 100_000),
+            SelectorParams::new(
+                FeeRate::from_sat_per_vb_unchecked(10),
+                vec![Output::with_script(
+                    recipient_addr.script_pubkey(),
+                    Amount::from_sat(21_000_000),
+                )],
+                internal.at_derivation_index(0)?,
+                bdk_tx::ChangePolicyType::NoDustAndLeastWaste { longterm_feerate },
+            ),
+        )?;
+
+    // Convert the consensus‐height (u32) into an absolute::LockTime
+    let fallback_locktime: LockTime = LockTime::from_consensus(tip_height.to_consensus_u32());
+
+    let psbt = selection.create_psbt(PsbtParams {
+        enable_anti_fee_sniping: true,
+        fallback_locktime,
+        fallback_sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
+        ..Default::default()
+    })?;
+
+    let tx = psbt.unsigned_tx;
+
+    // Locktime is used, if rbf is disabled or any input requires locktime
+    // (e.g. non-taproot, unconfirmed, or >65535 confirmation) or there are
+    // no taproot inputs or the 50/50 coin flip chose locktime (USE_NLOCKTIME_PROBABILITY)
+    // Further-back randomness with 10% chance (FURTHER_BACK_PROBABILITY),
+    // will subtract a random 0–99 block offset to desynchronize from tip
+    //
+    // Sequence will use the opposite condition of locktime, and locktime will
+    // be set to zero. Further-back randomness: with 10% chance, will
+    // subtract a random 0–99 block offset (but at least 1).
+    //
+    // Whenever locktime is used, the sequence value will remain as it is.
+
+    if tx.lock_time != LockTime::ZERO {
+        let height_val = tx.lock_time.to_consensus_u32();
+        let min_expected = tip_height.to_consensus_u32().saturating_sub(99);
+        let max_expected = tip_height.to_consensus_u32();
+
+        assert!(
+            (min_expected..=max_expected).contains(&height_val),
+            "Value {} is out of range {}..={}",
+            height_val,
+            min_expected,
+            max_expected
+        );
+
+        if height_val >= min_expected && height_val <= max_expected {
+            println!("✓ Locktime is within expected range");
+        } else {
+            println!("⚠ Locktime is outside expected range");
+        }
+    } else {
+        for (i, inp) in tx.input.iter().enumerate() {
+            let sequence_value = inp.sequence.to_consensus_u32();
+
+            let min_expected = 1;
+            let max_expected = Sequence(0xFFFFFFFE).to_consensus_u32();
+            let index = i + 1;
+
+            if sequence_value >= min_expected && sequence_value <= max_expected {
+                println!(
+                    "✓ Input #{}: sequence {} is within anti-fee sniping range",
+                    index, sequence_value
+                );
+            } else if sequence_value == 0xfffffffd || sequence_value == 0xfffffffe {
+                println!("✓ Input #{}: using standard RBF sequence", index);
+            } else {
+                println!(
+                    "⚠ Input #{}: sequence {} outside typical ranges",
+                    index, sequence_value
+                );
+            }
+        }
+    }
+
+    Ok(())
+}

src/input.rs

@@ -1,7 +1,7 @@
+use alloc::boxed::Box;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::fmt;
-use std::boxed::Box;
 
 use bitcoin::constants::COINBASE_MATURITY;
 use bitcoin::transaction::OutputsIndexError;

src/output.rs

@@ -1,4 +1,4 @@
-use std::boxed::Box;
+use alloc::boxed::Box;
 
 use bitcoin::{Amount, ScriptBuf, TxOut};
 use miniscript::bitcoin;

src/selection.rs

@@ -1,8 +1,11 @@
+use alloc::{boxed::Box, vec::Vec};
 use core::fmt::{Debug, Display};
-use std::{boxed::Box, vec::Vec};
 
 use bdk_coin_select::FeeRate;
-use bitcoin::{absolute, transaction, Sequence};
+use bitcoin::{
+    absolute::{self, LockTime},
+    transaction, Psbt, Sequence,
+};
 use miniscript::bitcoin;
 use miniscript::psbt::PsbtExt;
 
@@ -56,7 +59,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,
+            enable_anti_fee_sniping: false,
         }
     }
 }
@@ -78,6 +81,8 @@ pub enum CreatePsbtError {
     InvalidLockTime(absolute::LockTime),
     /// Invalid height
     InvalidHeight(u32),
+    /// Unsupported version for anti fee snipping
+    UnsupportedVersion(transaction::Version),
 }
 
 impl core::fmt::Display for CreatePsbtError {
@@ -104,6 +109,9 @@ impl core::fmt::Display for CreatePsbtError {
             CreatePsbtError::InvalidHeight(height) => {
                 write!(f, "The height - {}, is invalid", height)
             }
+            CreatePsbtError::UnsupportedVersion(version) => {
+                write!(f, "Unsupported version {}", version)
+            }
         }
     }
 }
@@ -163,20 +171,18 @@ impl Selection {
         };
 
         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))?;
+            let rbf_enabled = tx.is_explicitly_rbf();
+            let current_height = match tx.lock_time {
+                LockTime::Blocks(height) => height,
+                LockTime::Seconds(_) => {
+                    return Err(CreatePsbtError::InvalidLockTime(tx.lock_time));
+                }
+            };
 
-            apply_anti_fee_sniping(&mut tx, &self.inputs, current_height, rbf_enabled);
+            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)?;
+        let mut psbt = 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

@@ -1,10 +1,10 @@
-use crate::Input;
-use bitcoin::{
+use crate::{CreatePsbtError, Input};
+use alloc::vec::Vec;
+use miniscript::bitcoin::{
     absolute::{self, LockTime},
     transaction::Version,
     Sequence, Transaction, WitnessVersion,
 };
-use std::vec::Vec;
 
 use rand_core::{OsRng, RngCore};
 
@@ -14,34 +14,31 @@ pub fn apply_anti_fee_sniping(
     inputs: &[Input],
     current_height: absolute::Height,
     rbf_enabled: bool,
-) {
+) -> Result<(), CreatePsbtError> {
     const MAX_SEQUENCE_VALUE: u32 = 65_535;
-    const USE_NLOCKTIME_PROBABILITY: f64 = 0.5;
+    const USE_NLOCKTIME_PROBABILITY: u32 = 2;
     const MIN_SEQUENCE_VALUE: u32 = 1;
-    const FURTHER_BACK_PROBABILITY: f64 = 0.1;
+    const FURTHER_BACK_PROBABILITY: u32 = 10;
     const MAX_RANDOM_OFFSET: u32 = 99;
 
-    tx.version = Version::TWO;
+    let mut rng = OsRng;
 
-    let taproot_inputs: Vec<_> = inputs
-        .iter()
-        .enumerate()
-        .filter(|(_, input)| {
-            matches!(
-                input.plan().and_then(|plan| plan.witness_version()),
-                Some(WitnessVersion::V1)
-            )
+    if tx.version < Version::TWO {
+        return Err(CreatePsbtError::UnsupportedVersion(tx.version));
+    }
+
+    let taproot_inputs: Vec<usize> = (0..tx.input.len())
+        .filter(|&idx| {
+            // Check if this input is taproot using the corresponding Input data
+            inputs
+                .get(idx)
+                .and_then(|input| input.plan())
+                .and_then(|plan| plan.witness_version())
+                .map(|version| version == WitnessVersion::V1)
+                .unwrap_or(false)
         })
         .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);
@@ -56,68 +53,46 @@ pub fn apply_anti_fee_sniping(
     let use_locktime = !rbf_enabled
         || must_use_locktime
         || taproot_inputs.is_empty()
-        || random_probability(USE_NLOCKTIME_PROBABILITY);
+        || random_probability(&mut rng, 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);
+        if random_probability(&mut rng, FURTHER_BACK_PROBABILITY) {
+            let random_offset = random_range(&mut rng, MAX_RANDOM_OFFSET);
             locktime = locktime.saturating_sub(random_offset);
         }
 
-        tx.lock_time = LockTime::from_height(locktime).unwrap();
+        let new_locktime = LockTime::from_height(locktime)
+            .map_err(|_| CreatePsbtError::InvalidHeight(locktime))?;
+
+        tx.lock_time = new_locktime;
     } 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 input_index = random_range(&mut rng, taproot_inputs.len() as u32) as usize;
+        let confirmation = inputs[input_index].confirmations(current_height);
 
         let mut sequence_value = confirmation;
-
-        if random_probability(FURTHER_BACK_PROBABILITY) {
-            let random_offset = random_range(0, MAX_RANDOM_OFFSET);
+        if random_probability(&mut rng, FURTHER_BACK_PROBABILITY) {
+            let random_offset = random_range(&mut rng, MAX_RANDOM_OFFSET);
             sequence_value = sequence_value
                 .saturating_sub(random_offset)
                 .max(MIN_SEQUENCE_VALUE);
         }
 
-        tx.input[*idx].sequence = Sequence(sequence_value);
+        tx.input[input_index].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"
-    );
+    Ok(())
+}
 
-    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_probability(rng: &mut OsRng, probability: u32) -> bool {
+    let rand_val = rng.next_u32();
+    rand_val % probability == 0
 }
 
-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)
+fn random_range(rng: &mut OsRng, max: u32) -> u32 {
+    rng.next_u32() % max
 }