fix(wallet): allow fee bump without opt-in RBF signaling

src/wallet/error.rs

@@ -333,8 +333,6 @@ pub enum BuildFeeBumpError {
     TransactionNotFound(Txid),
     /// Happens when trying to bump a transaction that is already confirmed
     TransactionConfirmed(Txid),
-    /// Trying to replace a tx that has a sequence >= `0xFFFFFFFE`
-    IrreplaceableTransaction(Txid),
     /// Node doesn't have data to estimate a fee rate
     FeeRateUnavailable,
     /// Input references an invalid output index in the previous transaction
@@ -358,9 +356,6 @@ impl fmt::Display for BuildFeeBumpError {
             Self::TransactionConfirmed(txid) => {
                 write!(f, "Transaction already confirmed with txid: {txid}")
             }
-            Self::IrreplaceableTransaction(txid) => {
-                write!(f, "Transaction can't be replaced with txid: {txid}")
-            }
             Self::FeeRateUnavailable => write!(f, "Fee rate unavailable"),
             Self::InvalidOutputIndex(op) => {
                 write!(f, "A txin referenced an invalid output: {op}")

src/wallet/mod.rs

@@ -1589,9 +1589,13 @@ impl Wallet {
 
     /// Bump the fee of a transaction previously created with this wallet.
     ///
-    /// Returns an error if the transaction is already confirmed or doesn't explicitly signal
-    /// *replace by fee* (RBF). If the transaction can be fee bumped then it returns a [`TxBuilder`]
-    /// pre-populated with the inputs and outputs of the original transaction.
+    /// Returns an error if the transaction is already confirmed. If the transaction can be fee
+    /// bumped then it returns a [`TxBuilder`] pre-populated with the inputs and outputs of the
+    /// original transaction.
+    ///
+    /// This builder does not require the original transaction to signal opt-in RBF
+    /// (`nSequence` <= `0xFFFFFFFD`). Whether the resulting replacement is accepted
+    /// for relay or mining depends on the local policy of the broadcasting node.
     ///
     /// ## Example
     ///
@@ -1654,16 +1658,6 @@ impl Wallet {
             return Err(BuildFeeBumpError::TransactionConfirmed(txid));
         }
 
-        if !tx
-            .input
-            .iter()
-            .any(|txin| txin.sequence.to_consensus_u32() <= 0xFFFFFFFD)
-        {
-            return Err(BuildFeeBumpError::IrreplaceableTransaction(
-                tx.compute_txid(),
-            ));
-        }
-
         let fee = self
             .calculate_fee(&tx)
             .map_err(|_| BuildFeeBumpError::FeeRateUnavailable)?;

tests/build_fee_bump.rs

@@ -16,19 +16,51 @@ mod common;
 use common::*;
 
 #[test]
-#[should_panic(expected = "IrreplaceableTransaction")]
-fn test_bump_fee_irreplaceable_tx() {
+fn test_bump_fee_tx_without_rbf_signaling() {
     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));
     builder.set_exact_sequence(Sequence(0xFFFFFFFE));
     let psbt = builder.finish().unwrap();
+    let original_fee = check_fee!(wallet, psbt);
 
     let tx = psbt.extract_tx().expect("failed to extract tx");
+    assert!(!tx.is_explicitly_rbf());
+    let original_prevouts = tx
+        .input
+        .iter()
+        .map(|txin| txin.previous_output)
+        .collect::<Vec<_>>();
     let txid = tx.compute_txid();
     insert_tx(&mut wallet, tx);
-    wallet.build_fee_bump(txid).unwrap().finish().unwrap();
+
+    let feerate = FeeRate::from_sat_per_kwu(625);
+    let mut builder = wallet
+        .build_fee_bump(txid)
+        .expect("fee bump without opt-in RBF");
+    builder.fee_rate(feerate);
+    let psbt = builder.finish().expect("finish fee bump");
+    let fee = check_fee!(wallet, psbt);
+    assert!(
+        fee > original_fee,
+        "fee bump must increase absolute fee: {fee} > {original_fee}"
+    );
+
+    let new_tx = psbt.clone().extract_tx().expect("failed to extract tx");
+    assert!(
+        new_tx
+            .input
+            .iter()
+            .any(|txin| original_prevouts.contains(&txin.previous_output)),
+    );
+    assert_ne!(
+        new_tx.compute_txid(),
+        txid,
+        "replacement transaction must differ from the original"
+    );
+
+    assert_fee_rate!(psbt, fee, feerate, @add_signature);
 }
 
 #[test]