feat(wallet)!: enable RBF by default on TxBuilder

diff --git a/crates/wallet/README.md b/crates/wallet/README.md
index 3b5422b63b566055da4ec84dba86a33e3695ae65..937176e04d8369cb4d16bf208f29182b2652c6ec 100644 (file)
--- a/crates/wallet/README.md
+++ b/crates/wallet/README.md
@@ -174,7 +174,6 @@ println!("Your new receive address is: {}", receive_address.address);
 <!--         let mut builder = wallet.build_tx(); -->
 <!--         builder -->
 <!--             .add_recipient(send_to.script_pubkey(), 50_000) -->
-<!--             .enable_rbf() -->
 <!--             .do_not_spend_change() -->
 <!--             .fee_rate(FeeRate::from_sat_per_vb(5.0)); -->
 <!--         builder.finish()? -->

diff --git a/crates/wallet/src/wallet/error.rs b/crates/wallet/src/wallet/error.rs
index 2264aac9ece45308e4b00f3b152be7e697388800..adce5b1881095a6e7dc3bab78c8f98896ebe439c 100644 (file)
--- a/crates/wallet/src/wallet/error.rs
+++ b/crates/wallet/src/wallet/error.rs
@@ -65,12 +65,10 @@ pub enum CreateTxError {
         /// Required `LockTime`
         required: absolute::LockTime,
     },
-    /// Cannot enable RBF with a `Sequence` >= 0xFFFFFFFE
-    RbfSequence,
     /// Cannot enable RBF with `Sequence` given a required OP_CSV
     RbfSequenceCsv {
         /// Given RBF `Sequence`
-        rbf: Sequence,
+        sequence: Sequence,
         /// Required OP_CSV `Sequence`
         csv: Sequence,
     },
@@ -131,14 +129,11 @@ impl fmt::Display for CreateTxError {
             } => {
                 write!(f, "TxBuilder requested timelock of `{:?}`, but at least `{:?}` is required to spend from this script", required, requested)
             }
-            CreateTxError::RbfSequence => {
-                write!(f, "Cannot enable RBF with a nSequence >= 0xFFFFFFFE")
-            }
-            CreateTxError::RbfSequenceCsv { rbf, csv } => {
+            CreateTxError::RbfSequenceCsv { sequence, csv } => {
                 write!(
                     f,
                     "Cannot enable RBF with nSequence `{:?}` given a required OP_CSV of `{:?}`",
-                    rbf, csv
+                    sequence, csv
                 )
             }
             CreateTxError::FeeTooLow { required } => {

diff --git a/crates/wallet/src/wallet/mod.rs b/crates/wallet/src/wallet/mod.rs
index 1a25e7d7d2414f380577ca89fe75cb546c20b1ec..19604f4416209eb5189405cb7b7588396dae621c 100644 (file)
--- a/crates/wallet/src/wallet/mod.rs
+++ b/crates/wallet/src/wallet/mod.rs
@@ -1366,36 +1366,20 @@ impl Wallet {
             }
         };
 
-        // The nSequence to be by default for inputs unless an explicit sequence is specified.
-        let n_sequence = match (params.rbf, requirements.csv) {
-            // No RBF or CSV but there's an nLockTime, so the nSequence cannot be final
-            (None, None) if lock_time != absolute::LockTime::ZERO => {
-                Sequence::ENABLE_LOCKTIME_NO_RBF
-            }
-            // No RBF, CSV or nLockTime, make the transaction final
-            (None, None) => Sequence::MAX,
-
-            // No RBF requested, use the value from CSV. Note that this value is by definition
-            // non-final, so even if a timelock is enabled this nSequence is fine, hence why we
-            // don't bother checking for it here. The same is true for all the other branches below
+        // nSequence value for inputs
+        // When not explicitly specified, defaults to 0xFFFFFFFD,
+        // meaning RBF signaling is enabled
+        let n_sequence = match (params.sequence, requirements.csv) {
+            // Enable RBF by default
+            (None, None) => Sequence::ENABLE_RBF_NO_LOCKTIME,
+            // None requested, use required
             (None, Some(csv)) => csv,
-
-            // RBF with a specific value but that value is too high
-            (Some(tx_builder::RbfValue::Value(rbf)), _) if !rbf.is_rbf() => {
-                return Err(CreateTxError::RbfSequence)
+            // Requested sequence is incompatible with requirements
+            (Some(sequence), Some(csv)) if !check_nsequence_rbf(sequence, csv) => {
+                return Err(CreateTxError::RbfSequenceCsv { sequence, csv })
             }
-            // RBF with a specific value requested, but the value is incompatible with CSV
-            (Some(tx_builder::RbfValue::Value(rbf)), Some(csv))
-                if !check_nsequence_rbf(rbf, csv) =>
-            {
-                return Err(CreateTxError::RbfSequenceCsv { rbf, csv })
-            }
-
-            // RBF enabled with the default value with CSV also enabled. CSV takes precedence
-            (Some(tx_builder::RbfValue::Default), Some(csv)) => csv,
-            // Valid RBF, either default or with a specific value. We ignore the `CSV` value
-            // because we've already checked it before
-            (Some(rbf), _) => rbf.get_value(),
+            // Use requested nSequence value
+            (Some(sequence), _) => sequence,
         };
 
         let (fee_rate, mut fee_amount) = match params.fee_policy.unwrap_or_default() {
@@ -1609,8 +1593,7 @@ impl Wallet {
     /// let mut psbt = {
     ///     let mut builder = wallet.build_tx();
     ///     builder
-    ///         .add_recipient(to_address.script_pubkey(), Amount::from_sat(50_000))
-    ///         .enable_rbf();
+    ///         .add_recipient(to_address.script_pubkey(), Amount::from_sat(50_000));
     ///     builder.finish()?
     /// };
     /// let _ = wallet.sign(&mut psbt, SignOptions::default())?;

diff --git a/crates/wallet/src/wallet/tx_builder.rs b/crates/wallet/src/wallet/tx_builder.rs
index 08b0f32498f11d03e6e2d641fd575f05935cbec1..c3dde73305981c894e6f9e62bee23afae2af8b7d 100644 (file)
--- a/crates/wallet/src/wallet/tx_builder.rs
+++ b/crates/wallet/src/wallet/tx_builder.rs
@@ -31,9 +31,7 @@
 //!     // With a custom fee rate of 5.0 satoshi/vbyte
 //!     .fee_rate(FeeRate::from_sat_per_vb(5).expect("valid feerate"))
 //!     // Only spend non-change outputs
-//!     .do_not_spend_change()
-//!     // Turn on RBF signaling
-//!     .enable_rbf();
+//!     .do_not_spend_change();
 //! let psbt = tx_builder.finish()?;
 //! # Ok::<(), anyhow::Error>(())
 //! ```
@@ -134,7 +132,7 @@ pub(crate) struct TxParams {
     pub(crate) sighash: Option<psbt::PsbtSighashType>,
     pub(crate) ordering: TxOrdering,
     pub(crate) locktime: Option<absolute::LockTime>,
-    pub(crate) rbf: Option<RbfValue>,
+    pub(crate) sequence: Option<Sequence>,
     pub(crate) version: Option<Version>,
     pub(crate) change_policy: ChangeSpendPolicy,
     pub(crate) only_witness_utxo: bool,
@@ -554,23 +552,12 @@ impl<'a, Cs> TxBuilder<'a, Cs> {
         }
     }
 
-    /// Enable signaling RBF
+    /// Set an exact nSequence value
     ///
-    /// This will use the default nSequence value of `0xFFFFFFFD`.
-    pub fn enable_rbf(&mut self) -> &mut Self {
-        self.params.rbf = Some(RbfValue::Default);
-        self
-    }
-
-    /// Enable signaling RBF with a specific nSequence value
-    ///
-    /// This can cause conflicts if the wallet's descriptors contain an "older" (OP_CSV) operator
-    /// and the given `nsequence` is lower than the CSV value.
-    ///
-    /// If the `nsequence` is higher than `0xFFFFFFFD` an error will be thrown, since it would not
-    /// be a valid nSequence to signal RBF.
-    pub fn enable_rbf_with_sequence(&mut self, nsequence: Sequence) -> &mut Self {
-        self.params.rbf = Some(RbfValue::Value(nsequence));
+    /// This can cause conflicts if the wallet's descriptors contain an
+    /// "older" (OP_CSV) operator and the given `nsequence` is lower than the CSV value.
+    pub fn set_exact_sequence(&mut self, n_sequence: Sequence) -> &mut Self {
+        self.params.sequence = Some(n_sequence);
         self
     }
 
@@ -654,8 +641,7 @@ impl<'a, Cs> TxBuilder<'a, Cs> {
     ///     .drain_wallet()
     ///     // Send the excess (which is all the coins minus the fee) to this address.
     ///     .drain_to(to_address.script_pubkey())
-    ///     .fee_rate(FeeRate::from_sat_per_vb(5).expect("valid feerate"))
-    ///     .enable_rbf();
+    ///     .fee_rate(FeeRate::from_sat_per_vb(5).expect("valid feerate"));
     /// let psbt = tx_builder.finish()?;
     /// # Ok::<(), anyhow::Error>(())
     /// ```
@@ -835,24 +821,6 @@ impl Default for Version {
     }
 }
 
-/// RBF nSequence value
-///
-/// Has a default value of `0xFFFFFFFD`
-#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
-pub(crate) enum RbfValue {
-    Default,
-    Value(Sequence),
-}
-
-impl RbfValue {
-    pub(crate) fn get_value(&self) -> Sequence {
-        match self {
-            RbfValue::Default => Sequence::ENABLE_RBF_NO_LOCKTIME,
-            RbfValue::Value(v) => *v,
-        }
-    }
-}
-
 /// Policy regarding the use of change outputs when creating a transaction
 #[derive(Default, Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
 pub enum ChangeSpendPolicy {

diff --git a/crates/wallet/src/wallet/utils.rs b/crates/wallet/src/wallet/utils.rs
index bca07b48adbafc259fd190c87503af7b050ecd3d..76d0aaa7515d547d685cf076a9cb0dd357f06dc6 100644 (file)
--- a/crates/wallet/src/wallet/utils.rs
+++ b/crates/wallet/src/wallet/utils.rs
@@ -52,20 +52,20 @@ impl After {
     }
 }
 
-pub(crate) fn check_nsequence_rbf(rbf: Sequence, csv: Sequence) -> bool {
-    // The RBF value must enable relative timelocks
-    if !rbf.is_relative_lock_time() {
+pub(crate) fn check_nsequence_rbf(sequence: Sequence, csv: Sequence) -> bool {
+    // The nSequence value must enable relative timelocks
+    if !sequence.is_relative_lock_time() {
         return false;
     }
 
     // Both values should be represented in the same unit (either time-based or
     // block-height based)
-    if rbf.is_time_locked() != csv.is_time_locked() {
+    if sequence.is_time_locked() != csv.is_time_locked() {
         return false;
     }
 
     // The value should be at least `csv`
-    if rbf < csv {
+    if sequence < csv {
         return false;
     }
 

diff --git a/crates/wallet/tests/wallet.rs b/crates/wallet/tests/wallet.rs
index 6375937802392999b0ae3d2772b62a01fa94e5f2..5914ce2897afa8f75bc5ed55f61712e39c43e073 100644 (file)
--- a/crates/wallet/tests/wallet.rs
+++ b/crates/wallet/tests/wallet.rs
@@ -639,63 +639,65 @@ fn test_create_tx_custom_locktime_incompatible_with_cltv() {
 }
 
 #[test]
-fn test_create_tx_no_rbf_csv() {
+fn test_create_tx_custom_csv() {
+    // desc: wsh(and_v(v:pk(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW),older(6)))
     let (mut wallet, _) = get_funded_wallet(get_test_single_sig_csv());
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
-    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
+    builder
+        .set_exact_sequence(Sequence(42))
+        .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
     let psbt = builder.finish().unwrap();
-
-    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(6));
+    // we allow setting a sequence higher than required
+    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(42));
 }
 
 #[test]
-fn test_create_tx_with_default_rbf_csv() {
+fn test_create_tx_no_rbf_csv() {
     let (mut wallet, _) = get_funded_wallet(get_test_single_sig_csv());
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
     let psbt = builder.finish().unwrap();
-    // When CSV is enabled it takes precedence over the rbf value (unless forced by the user).
-    // It will be set to the OP_CSV value, in this case 6
+
     assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(6));
 }
 
 #[test]
-fn test_create_tx_with_custom_rbf_csv() {
+fn test_create_tx_incompatible_csv() {
     let (mut wallet, _) = get_funded_wallet(get_test_single_sig_csv());
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
     builder
         .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
-        .enable_rbf_with_sequence(Sequence(3));
+        .set_exact_sequence(Sequence(3));
     assert!(matches!(builder.finish(),
-        Err(CreateTxError::RbfSequenceCsv { rbf, csv })
-        if rbf.to_consensus_u32() == 3 && csv.to_consensus_u32() == 6));
+        Err(CreateTxError::RbfSequenceCsv { sequence, csv })
+        if sequence.to_consensus_u32() == 3 && csv.to_consensus_u32() == 6));
 }
 
 #[test]
-fn test_create_tx_no_rbf_cltv() {
-    let (mut wallet, _) = get_funded_wallet(get_test_single_sig_cltv());
+fn test_create_tx_with_default_rbf_csv() {
+    let (mut wallet, _) = get_funded_wallet(get_test_single_sig_csv());
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
     builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
     let psbt = builder.finish().unwrap();
-
-    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFE));
+    // When CSV is enabled it takes precedence over the rbf value (unless forced by the user).
+    // It will be set to the OP_CSV value, in this case 6
+    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(6));
 }
 
 #[test]
-fn test_create_tx_invalid_rbf_sequence() {
-    let (mut wallet, _) = get_funded_wallet_wpkh();
+fn test_create_tx_no_rbf_cltv() {
+    let (mut wallet, _) = get_funded_wallet(get_test_single_sig_cltv());
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
-        .enable_rbf_with_sequence(Sequence(0xFFFFFFFE));
-    assert!(matches!(builder.finish(), Err(CreateTxError::RbfSequence)));
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
+    builder.set_exact_sequence(Sequence(0xFFFFFFFE));
+    let psbt = builder.finish().unwrap();
+
+    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFE));
 }
 
 #[test]
@@ -705,7 +707,7 @@ fn test_create_tx_custom_rbf_sequence() {
     let mut builder = wallet.build_tx();
     builder
         .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
-        .enable_rbf_with_sequence(Sequence(0xDEADBEEF));
+        .set_exact_sequence(Sequence(0xDEADBEEF));
     let psbt = builder.finish().unwrap();
 
     assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xDEADBEEF));
@@ -743,7 +745,7 @@ fn test_create_tx_default_sequence() {
     builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
     let psbt = builder.finish().unwrap();
 
-    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFE));
+    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFD));
 }
 
 macro_rules! check_fee {
@@ -1328,7 +1330,7 @@ fn test_create_tx_policy_path_no_csv() {
         .policy_path(path, KeychainKind::External);
     let psbt = builder.finish().unwrap();
 
-    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFF));
+    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFD));
 }
 
 #[test]
@@ -1370,7 +1372,7 @@ fn test_create_tx_policy_path_ignored_subtree_with_csv() {
         .policy_path(path, KeychainKind::External);
     let psbt = builder.finish().unwrap();
 
-    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFE));
+    assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFD));
 }
 
 #[test]
@@ -1797,6 +1799,7 @@ fn test_bump_fee_irreplaceable_tx() {
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
     builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
+    builder.set_exact_sequence(Sequence(0xFFFFFFFE));
     let psbt = builder.finish().unwrap();
 
     let tx = psbt.extract_tx().expect("failed to extract tx");
@@ -1836,9 +1839,8 @@ fn test_bump_fee_low_fee_rate() {
     let (mut wallet, _) = get_funded_wallet_wpkh();
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
+
     let psbt = builder.finish().unwrap();
     let feerate = psbt.fee_rate().unwrap();
 
@@ -1869,9 +1871,7 @@ fn test_bump_fee_low_abs() {
     let (mut wallet, _) = get_funded_wallet_wpkh();
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
     let psbt = builder.finish().unwrap();
 
     let tx = psbt.extract_tx().expect("failed to extract tx");
@@ -1891,9 +1891,7 @@ fn test_bump_fee_zero_abs() {
     let (mut wallet, _) = get_funded_wallet_wpkh();
     let addr = wallet.next_unused_address(KeychainKind::External);
     let mut builder = wallet.build_tx();
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
     let psbt = builder.finish().unwrap();
 
     let tx = psbt.extract_tx().expect("failed to extract tx");
@@ -1913,9 +1911,7 @@ fn test_bump_fee_reduce_change() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx();
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
     let psbt = builder.finish().unwrap();
     let original_sent_received =
         wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
@@ -1928,7 +1924,7 @@ fn test_bump_fee_reduce_change() {
 
     let feerate = FeeRate::from_sat_per_kwu(625); // 2.5 sat/vb
     let mut builder = wallet.build_fee_bump(txid).unwrap();
-    builder.fee_rate(feerate).enable_rbf();
+    builder.fee_rate(feerate);
     let psbt = builder.finish().unwrap();
     let sent_received =
         wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
@@ -1964,7 +1960,6 @@ fn test_bump_fee_reduce_change() {
 
     let mut builder = wallet.build_fee_bump(txid).unwrap();
     builder.fee_absolute(Amount::from_sat(200));
-    builder.enable_rbf();
     let psbt = builder.finish().unwrap();
     let sent_received =
         wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
@@ -2011,10 +2006,7 @@ fn test_bump_fee_reduce_single_recipient() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx();
-    builder
-        .drain_to(addr.script_pubkey())
-        .drain_wallet()
-        .enable_rbf();
+    builder.drain_to(addr.script_pubkey()).drain_wallet();
     let psbt = builder.finish().unwrap();
     let tx = psbt.clone().extract_tx().expect("failed to extract tx");
     let original_sent_received = wallet.sent_and_received(&tx);
@@ -2058,10 +2050,7 @@ fn test_bump_fee_absolute_reduce_single_recipient() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx();
-    builder
-        .drain_to(addr.script_pubkey())
-        .drain_wallet()
-        .enable_rbf();
+    builder.drain_to(addr.script_pubkey()).drain_wallet();
     let psbt = builder.finish().unwrap();
     let original_fee = check_fee!(wallet, psbt);
     let tx = psbt.extract_tx().expect("failed to extract tx");
@@ -2135,8 +2124,7 @@ fn test_bump_fee_drain_wallet() {
             vout: 0,
         })
         .unwrap()
-        .manually_selected_only()
-        .enable_rbf();
+        .manually_selected_only();
     let psbt = builder.finish().unwrap();
     let tx = psbt.extract_tx().expect("failed to extract tx");
     let original_sent_received = wallet.sent_and_received(&tx);
@@ -2201,8 +2189,7 @@ fn test_bump_fee_remove_output_manually_selected_only() {
         .drain_to(addr.script_pubkey())
         .add_utxo(outpoint)
         .unwrap()
-        .manually_selected_only()
-        .enable_rbf();
+        .manually_selected_only();
     let psbt = builder.finish().unwrap();
     let tx = psbt.extract_tx().expect("failed to extract tx");
     let original_sent_received = wallet.sent_and_received(&tx);
@@ -2247,9 +2234,7 @@ fn test_bump_fee_add_input() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx().coin_selection(LargestFirstCoinSelection);
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000));
     let psbt = builder.finish().unwrap();
     let tx = psbt.extract_tx().expect("failed to extract tx");
     let original_details = wallet.sent_and_received(&tx);
@@ -2303,9 +2288,7 @@ fn test_bump_fee_absolute_add_input() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx().coin_selection(LargestFirstCoinSelection);
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000));
     let psbt = builder.finish().unwrap();
     let tx = psbt.extract_tx().expect("failed to extract tx");
     let original_sent_received = wallet.sent_and_received(&tx);
@@ -2366,8 +2349,7 @@ fn test_bump_fee_no_change_add_input_and_change() {
         .drain_to(addr.script_pubkey())
         .add_utxo(op)
         .unwrap()
-        .manually_selected_only()
-        .enable_rbf();
+        .manually_selected_only();
     let psbt = builder.finish().unwrap();
     let original_sent_received =
         wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
@@ -2428,9 +2410,7 @@ fn test_bump_fee_add_input_change_dust() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx().coin_selection(LargestFirstCoinSelection);
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000));
     let psbt = builder.finish().unwrap();
     let original_sent_received =
         wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
@@ -2504,9 +2484,7 @@ fn test_bump_fee_force_add_input() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx().coin_selection(LargestFirstCoinSelection);
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000));
     let psbt = builder.finish().unwrap();
     let mut tx = psbt.extract_tx().expect("failed to extract tx");
     let original_sent_received = wallet.sent_and_received(&tx);
@@ -2569,9 +2547,7 @@ fn test_bump_fee_absolute_force_add_input() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx().coin_selection(LargestFirstCoinSelection);
-    builder
-        .add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
-        .enable_rbf();
+    builder.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000));
     let psbt = builder.finish().unwrap();
     let mut tx = psbt.extract_tx().expect("failed to extract tx");
     let original_sent_received = wallet.sent_and_received(&tx);
@@ -2641,10 +2617,7 @@ fn test_bump_fee_unconfirmed_inputs_only() {
         .unwrap()
         .assume_checked();
     let mut builder = wallet.build_tx();
-    builder
-        .drain_wallet()
-        .drain_to(addr.script_pubkey())
-        .enable_rbf();
+    builder.drain_wallet().drain_to(addr.script_pubkey());
     let psbt = builder.finish().unwrap();
     // Now we receive one transaction with 0 confirmations. We won't be able to use that for
     // fee bumping, as it's still unconfirmed!
@@ -2680,10 +2653,7 @@ fn test_bump_fee_unconfirmed_input() {
     // in the drain tx.
     receive_output(&mut wallet, 25_000, ConfirmationTime::unconfirmed(0));
     let mut builder = wallet.build_tx();
-    builder
-        .drain_wallet()
-        .drain_to(addr.script_pubkey())
-        .enable_rbf();
+    builder.drain_wallet().drain_to(addr.script_pubkey());
     let psbt = builder.finish().unwrap();
     let mut tx = psbt.extract_tx().expect("failed to extract tx");
     let txid = tx.compute_txid();
@@ -2727,7 +2697,6 @@ fn test_fee_amount_negative_drain_val() {
         .add_recipient(send_to.script_pubkey(), Amount::from_sat(8630))
         .add_utxo(incoming_op)
         .unwrap()
-        .enable_rbf()
         .fee_rate(fee_rate);
     let psbt = builder.finish().unwrap();
     let fee = check_fee!(wallet, psbt);

diff --git a/example-crates/example_wallet_electrum/src/main.rs b/example-crates/example_wallet_electrum/src/main.rs
index f3320d821a76a4fe342e1fff18403725ca35bc7a..5942714ef4fb148f4bd787f5208955b025b4ec7b 100644 (file)
--- a/example-crates/example_wallet_electrum/src/main.rs
+++ b/example-crates/example_wallet_electrum/src/main.rs
@@ -82,9 +82,7 @@ fn main() -> Result<(), anyhow::Error> {
     }
 
     let mut tx_builder = wallet.build_tx();
-    tx_builder
-        .add_recipient(address.script_pubkey(), SEND_AMOUNT)
-        .enable_rbf();
+    tx_builder.add_recipient(address.script_pubkey(), SEND_AMOUNT);
 
     let mut psbt = tx_builder.finish()?;
     let finalized = wallet.sign(&mut psbt, SignOptions::default())?;

diff --git a/example-crates/example_wallet_esplora_async/src/main.rs b/example-crates/example_wallet_esplora_async/src/main.rs
index 4133982c6a114b778ef5f4e81e7bd18a9908f4ed..b6ab5d6dc45ad4bdac51c4176cfe01c6553c69c7 100644 (file)
--- a/example-crates/example_wallet_esplora_async/src/main.rs
+++ b/example-crates/example_wallet_esplora_async/src/main.rs
@@ -77,9 +77,7 @@ async fn main() -> Result<(), anyhow::Error> {
     }
 
     let mut tx_builder = wallet.build_tx();
-    tx_builder
-        .add_recipient(address.script_pubkey(), SEND_AMOUNT)
-        .enable_rbf();
+    tx_builder.add_recipient(address.script_pubkey(), SEND_AMOUNT);
 
     let mut psbt = tx_builder.finish()?;
     let finalized = wallet.sign(&mut psbt, SignOptions::default())?;

diff --git a/example-crates/example_wallet_esplora_blocking/src/main.rs b/example-crates/example_wallet_esplora_blocking/src/main.rs
index d12dbd926a82b2377ca7ce06f9062224e2c68675..7966f19f554626bfe7efb6c6361d4273dafbcc2c 100644 (file)
--- a/example-crates/example_wallet_esplora_blocking/src/main.rs
+++ b/example-crates/example_wallet_esplora_blocking/src/main.rs
@@ -77,9 +77,7 @@ fn main() -> Result<(), anyhow::Error> {
     }
 
     let mut tx_builder = wallet.build_tx();
-    tx_builder
-        .add_recipient(address.script_pubkey(), SEND_AMOUNT)
-        .enable_rbf();
+    tx_builder.add_recipient(address.script_pubkey(), SEND_AMOUNT);
 
     let mut psbt = tx_builder.finish()?;
     let finalized = wallet.sign(&mut psbt, SignOptions::default())?;