Add RBF integration tests with multi-node setup

- Test mempool-only RBF handling and balance adjustments.
- Test RBF transactions confirmed in block, ensuring stale unconfirmed txs are removed.
- Introduce `distribute_funds_unconfirmed` for creating unconfirmed outputs.

Author: moisesPompilio

tests/common/mod.rs

@@ -30,8 +30,10 @@ use lightning_types::payment::{PaymentHash, PaymentPreimage};
 use lightning_persister::fs_store::FilesystemStore;
 
 use bitcoin::hashes::sha256::Hash as Sha256;
-use bitcoin::hashes::Hash;
-use bitcoin::{Address, Amount, Network, OutPoint, Txid};
+use bitcoin::hashes::{hex::FromHex, Hash};
+use bitcoin::{
+	Address, Amount, Network, OutPoint, ScriptBuf, Sequence, Transaction, Txid, Witness,
+};
 
 use electrsd::corepc_node::Client as BitcoindClient;
 use electrsd::corepc_node::Node as BitcoinD;
@@ -42,7 +44,7 @@ use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
 use serde_json::{json, Value};
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::env;
 use std::path::PathBuf;
 use std::sync::{Arc, RwLock};
@@ -487,12 +489,25 @@ where
 pub(crate) fn premine_and_distribute_funds<E: ElectrumApi>(
 	bitcoind: &BitcoindClient, electrs: &E, addrs: Vec<Address>, amount: Amount,
 ) {
+	premine_blocks(bitcoind, electrs);
+
+	distribute_funds_unconfirmed(bitcoind, electrs, addrs, amount);
+	generate_blocks_and_wait(bitcoind, electrs, 1);
+}
+
+pub(crate) fn premine_blocks<E: ElectrumApi>(bitcoind: &BitcoindClient, electrs: &E) {
 	let _ = bitcoind.create_wallet("ldk_node_test");
 	let _ = bitcoind.load_wallet("ldk_node_test");
 	generate_blocks_and_wait(bitcoind, electrs, 101);
+}
 
-	let amounts: HashMap<String, f64> =
-		addrs.iter().map(|addr| (addr.to_string(), amount.to_btc())).collect();
+pub(crate) fn distribute_funds_unconfirmed<E: ElectrumApi>(
+	bitcoind: &BitcoindClient, electrs: &E, addrs: Vec<Address>, amount: Amount,
+) -> Txid {
+	let mut amounts = HashMap::<String, f64>::new();
+	for addr in &addrs {
+		amounts.insert(addr.to_string(), amount.to_btc());
+	}
 
 	let empty_account = json!("");
 	let amounts_json = json!(amounts);
@@ -505,7 +520,70 @@ pub(crate) fn premine_and_distribute_funds<E: ElectrumApi>(
 		.unwrap();
 
 	wait_for_tx(electrs, txid);
-	generate_blocks_and_wait(bitcoind, electrs, 1);
+
+	txid
+}
+
+pub(crate) fn prepare_rbf<E: ElectrumApi>(
+	electrs: &E, txid: Txid, scripts_buf: &HashSet<ScriptBuf>,
+) -> (Transaction, usize) {
+	let tx = electrs.transaction_get(&txid).unwrap();
+
+	let fee_output_index = tx
+		.output
+		.iter()
+		.position(|output| !scripts_buf.contains(&output.script_pubkey))
+		.expect("No output available for fee bumping");
+
+	(tx, fee_output_index)
+}
+
+pub(crate) fn bump_fee_and_broadcast<E: ElectrumApi>(
+	bitcoind: &BitcoindClient, electrs: &E, mut tx: Transaction, fee_output_index: usize,
+	is_insert_block: bool,
+) -> Transaction {
+	let mut bump_fee_amount_sat = tx.vsize() as u64;
+	let attempts = 5;
+
+	for _ in 0..attempts {
+		let fee_output = &mut tx.output[fee_output_index];
+		let new_fee_value = fee_output.value.to_sat().saturating_sub(bump_fee_amount_sat);
+		if new_fee_value < 546 {
+			panic!("Warning: Fee output approaching dust limit ({} sats)", new_fee_value);
+		}
+		fee_output.value = Amount::from_sat(new_fee_value);
+
+		for input in &mut tx.input {
+			input.sequence = Sequence::ENABLE_RBF_NO_LOCKTIME;
+			input.script_sig = ScriptBuf::new();
+			input.witness = Witness::new();
+		}
+
+		let signed_result = bitcoind.sign_raw_transaction_with_wallet(&tx).unwrap();
+		assert!(signed_result.complete, "Failed to sign RBF transaction");
+
+		let tx_bytes = Vec::<u8>::from_hex(&signed_result.hex).unwrap();
+		tx = bitcoin::consensus::encode::deserialize::<Transaction>(&tx_bytes).unwrap();
+
+		match bitcoind.send_raw_transaction(&tx) {
+			Ok(res) => {
+				if is_insert_block {
+					generate_blocks_and_wait(bitcoind, electrs, 1);
+				}
+				let new_txid: Txid = res.0.parse().unwrap();
+				wait_for_tx(electrs, new_txid);
+				return tx;
+			},
+			Err(_) => {
+				bump_fee_amount_sat += bump_fee_amount_sat * 5;
+				if tx.output[fee_output_index].value.to_sat() < bump_fee_amount_sat {
+					panic!("Insufficient funds to increase fee");
+				}
+			},
+		}
+	}
+
+	panic!("Failed to bump fee after {} attempts", attempts);
 }
 
 pub fn open_channel(

tests/integration_tests_rust.rs

@@ -8,13 +8,14 @@
 mod common;
 
 use common::{
-	do_channel_full_cycle, expect_channel_pending_event, expect_channel_ready_event, expect_event,
+	bump_fee_and_broadcast, distribute_funds_unconfirmed, do_channel_full_cycle,
+	expect_channel_pending_event, expect_channel_ready_event, expect_event,
 	expect_payment_claimable_event, expect_payment_received_event, expect_payment_successful_event,
 	generate_blocks_and_wait,
 	logging::{init_log_logger, validate_log_entry, TestLogWriter},
-	open_channel, premine_and_distribute_funds, random_config, random_listening_addresses,
-	setup_bitcoind_and_electrsd, setup_builder, setup_node, setup_two_nodes, wait_for_tx,
-	TestChainSource, TestSyncStore,
+	open_channel, premine_and_distribute_funds, premine_blocks, prepare_rbf, random_config,
+	random_listening_addresses, setup_bitcoind_and_electrsd, setup_builder, setup_node,
+	setup_two_nodes, wait_for_tx, TestChainSource, TestSyncStore,
 };
 
 use ldk_node::config::EsploraSyncConfig;
@@ -35,10 +36,10 @@ use lightning_types::payment::{PaymentHash, PaymentPreimage};
 use bitcoin::address::NetworkUnchecked;
 use bitcoin::hashes::sha256::Hash as Sha256Hash;
 use bitcoin::hashes::Hash;
-use bitcoin::Address;
-use bitcoin::Amount;
+use bitcoin::{Address, Amount, ScriptBuf};
 use log::LevelFilter;
 
+use std::collections::HashSet;
 use std::str::FromStr;
 use std::sync::Arc;
 
@@ -670,6 +671,141 @@ fn onchain_wallet_recovery() {
 	);
 }
 
+#[test]
+fn test_rbf_via_mempool() {
+	run_rbf_test(false);
+}
+
+#[test]
+fn test_rbf_via_direct_block_insertion() {
+	run_rbf_test(true);
+}
+
+// `is_insert_block`:
+// - `true`: transaction is mined immediately (no mempool), testing confirmed-Tx handling.
+// - `false`: transaction stays in mempool until confirmation, testing unconfirmed-Tx handling.
+fn run_rbf_test(is_insert_block: bool) {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source_bitcoind = TestChainSource::BitcoindRpcSync(&bitcoind);
+	let chain_source_electrsd = TestChainSource::Electrum(&electrsd);
+	let chain_source_esplora = TestChainSource::Esplora(&electrsd);
+
+	macro_rules! config_node {
+		($chain_source: expr, $anchor_channels: expr) => {{
+			let config_a = random_config($anchor_channels);
+			let node = setup_node(&$chain_source, config_a, None);
+			node
+		}};
+	}
+	let anchor_channels = false;
+	let nodes = vec![
+		config_node!(chain_source_electrsd, anchor_channels),
+		config_node!(chain_source_bitcoind, anchor_channels),
+		config_node!(chain_source_esplora, anchor_channels),
+	];
+
+	let (bitcoind, electrs) = (&bitcoind.client, &electrsd.client);
+	premine_blocks(bitcoind, electrs);
+
+	// Helpers declaration before starting the test
+	let all_addrs =
+		nodes.iter().map(|node| node.onchain_payment().new_address().unwrap()).collect::<Vec<_>>();
+	let amount_sat = 2_100_000;
+	let mut txid;
+	macro_rules! distribute_funds_all_nodes {
+		() => {
+			txid = distribute_funds_unconfirmed(
+				bitcoind,
+				electrs,
+				all_addrs.clone(),
+				Amount::from_sat(amount_sat),
+			);
+		};
+	}
+	macro_rules! validate_balances {
+		($expected_balance_sat: expr, $is_spendable: expr) => {
+			let spend_balance = if $is_spendable { $expected_balance_sat } else { 0 };
+			for node in &nodes {
+				node.sync_wallets().unwrap();
+				let balances = node.list_balances();
+				assert_eq!(balances.spendable_onchain_balance_sats, spend_balance);
+				assert_eq!(balances.total_onchain_balance_sats, $expected_balance_sat);
+			}
+		};
+	}
+
+	let scripts_buf: HashSet<ScriptBuf> =
+		all_addrs.iter().map(|addr| addr.script_pubkey()).collect();
+	let mut tx;
+	let mut fee_output_index;
+
+	// Modify the output to the nodes
+	distribute_funds_all_nodes!();
+	validate_balances!(amount_sat, false);
+	(tx, fee_output_index) = prepare_rbf(electrs, txid, &scripts_buf);
+	tx.output.iter_mut().for_each(|output| {
+		if scripts_buf.contains(&output.script_pubkey) {
+			let new_addr = bitcoind.new_address().unwrap();
+			output.script_pubkey = new_addr.script_pubkey();
+		}
+	});
+	bump_fee_and_broadcast(bitcoind, electrs, tx, fee_output_index, is_insert_block);
+	validate_balances!(0, is_insert_block);
+
+	// Not modifying the output scripts, but still bumping the fee.
+	distribute_funds_all_nodes!();
+	validate_balances!(amount_sat, false);
+	(tx, fee_output_index) = prepare_rbf(electrs, txid, &scripts_buf);
+	bump_fee_and_broadcast(bitcoind, electrs, tx, fee_output_index, is_insert_block);
+	validate_balances!(amount_sat, is_insert_block);
+
+	let mut final_amount_sat = amount_sat * 2;
+	let value_sat = 21_000;
+
+	// Increase the value of the nodes' outputs
+	distribute_funds_all_nodes!();
+	(tx, fee_output_index) = prepare_rbf(electrs, txid, &scripts_buf);
+	tx.output.iter_mut().for_each(|output| {
+		if scripts_buf.contains(&output.script_pubkey) {
+			output.value = Amount::from_sat(output.value.to_sat() + value_sat);
+		}
+	});
+	bump_fee_and_broadcast(bitcoind, electrs, tx, fee_output_index, is_insert_block);
+	final_amount_sat += value_sat;
+	validate_balances!(final_amount_sat, is_insert_block);
+
+	// Decreases the value of the nodes' outputs
+	distribute_funds_all_nodes!();
+	final_amount_sat += amount_sat;
+	(tx, fee_output_index) = prepare_rbf(electrs, txid, &scripts_buf);
+	tx.output.iter_mut().for_each(|output| {
+		if scripts_buf.contains(&output.script_pubkey) {
+			output.value = Amount::from_sat(output.value.to_sat() - value_sat);
+		}
+	});
+	bump_fee_and_broadcast(bitcoind, electrs, tx, fee_output_index, is_insert_block);
+	final_amount_sat -= value_sat;
+	validate_balances!(final_amount_sat, is_insert_block);
+
+	if !is_insert_block {
+		generate_blocks_and_wait(bitcoind, electrs, 1);
+		validate_balances!(final_amount_sat, true);
+	}
+
+	// Check if it is possible to send all funds from the node
+	let mut txids = Vec::new();
+	let addr = bitcoind.new_address().unwrap();
+	nodes.iter().for_each(|node| {
+		let txid = node.onchain_payment().send_all_to_address(&addr, true, None).unwrap();
+		txids.push(txid);
+	});
+	txids.iter().for_each(|txid| {
+		wait_for_tx(electrs, *txid);
+	});
+	generate_blocks_and_wait(bitcoind, electrs, 6);
+	validate_balances!(0, true);
+}
+
 #[test]
 fn sign_verify_msg() {
 	let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd();