Add splice RBF support

bindings/ldk_node.udl

@@ -124,6 +124,8 @@ interface Node {
 	[Throws=NodeError]
 	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
 	[Throws=NodeError]
+	void bump_channel_funding_fee([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);

src/builder.rs

@@ -1618,6 +1618,8 @@ fn build_with_store_internal(
  Arc::clone(&pending_payment_store),
 	));
 
+	tx_broadcaster.set_wallet(Arc::downgrade(&wallet));
+
 	// Initialize the KeysManager
 	let cur_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).map_err(|e| {
  log_error!(logger, "Failed to get current time: {}", e);

src/chain/mod.rs

@@ -13,7 +13,7 @@ use std::collections::{HashMap, HashSet};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use bitcoin::{Script, Txid};
+use bitcoin::{Script, Transaction, Txid};
 use lightning::chain::{BlockLocator, Filter};
 
 use crate::chain::bitcoind::{BitcoindChainSource, UtxoSourceClient};
@@ -24,7 +24,7 @@ use crate::config::{
 	WALLET_SYNC_INTERVAL_MINIMUM_SECS,
 };
 use crate::fee_estimator::OnchainFeeEstimator;
-use crate::logger::{log_debug, log_info, log_trace, LdkLogger, Logger};
+use crate::logger::{log_debug, log_error, log_info, log_trace, LdkLogger, Logger};
 use crate::runtime::Runtime;
 use crate::types::{Broadcaster, ChainMonitor, ChannelManager, DynStore, Sweeper, Wallet};
 use crate::{Error, PersistedNodeMetrics};
@@ -453,15 +453,30 @@ impl ChainSource {
  return;
  }
  Some(next_package) = receiver.recv() => {
+ // Classify funding broadcasts into payment records before sending. If
+ // classification fails we skip the broadcast, since broadcasting a tx we
+ // failed to record would leave it on-chain without a payment.
+ let package = match self.tx_broadcaster.classify_package(next_package).await {
+ Ok(package) => package,
+ Err(e) => {
+ log_error!(
+ tx_bcast_logger,
+ "Skipping broadcast: failed to persist payment records: {:?}",
+ e,
+ );
+ continue;
+ },
+ };
+ let txs: Vec<Transaction> = package.into_transactions();
  match &self.kind {
  ChainSourceKind::Esplora(esplora_chain_source) => {
- esplora_chain_source.process_broadcast_package(next_package).await
+ esplora_chain_source.process_broadcast_package(txs).await
  },
  ChainSourceKind::Electrum(electrum_chain_source) => {
- electrum_chain_source.process_broadcast_package(next_package).await
+ electrum_chain_source.process_broadcast_package(txs).await
  },
  ChainSourceKind::Bitcoind(bitcoind_chain_source) => {
- bitcoind_chain_source.process_broadcast_package(next_package).await
+ bitcoind_chain_source.process_broadcast_package(txs).await
  },
  }
  }

src/fee_estimator.rs

@@ -164,3 +164,42 @@ pub(crate) fn apply_post_estimation_adjustments(
  _ => estimated_rate,
 	}
 }
+
+/// The most we are willing to pay for a channel funding transaction: `1.5x` our funding feerate
+/// estimate. Used as the `max_feerate` ceiling for splices and their RBF fee bumps.
+pub(crate) fn max_funding_feerate(estimate: FeeRate) -> FeeRate {
+	FeeRate::from_sat_per_kwu(estimate.to_sat_per_kwu() * 3 / 2)
+}
+
+/// Picks the `(target, max)` feerates for replacing a pending splice's in-flight funding
+/// transaction via RBF, or `None` if the RBF can't be done within our fee ceiling.
+///
+/// `max` is the most we are willing to pay (see [`max_funding_feerate`]), which tracks our current
+/// estimate and so may have risen or fallen since the original splice; it is never inflated to meet
+/// the RBF minimum. `target` is what we actually pay — our current estimate, or the template's RBF
+/// minimum if that is higher (required to replace the transaction). If that minimum exceeds `max`,
+/// we can't RBF.
+pub(crate) fn rbf_splice_feerates(
+	estimate: FeeRate, min_rbf_feerate: FeeRate,
+) -> Option<(FeeRate, FeeRate)> {
+	let max = max_funding_feerate(estimate);
+	let target = estimate.max(min_rbf_feerate);
+	(target <= max).then_some((target, max))
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn rbf_splice_feerates_target_and_max() {
+ let kwu = FeeRate::from_sat_per_kwu;
+ // Estimate below the RBF minimum but within our ceiling: pay the minimum to replace the
+ // transaction; the max stays 1.5x the estimate (never inflated) and already clears it.
+ assert_eq!(rbf_splice_feerates(kwu(253), kwu(278)), Some((kwu(278), kwu(253 * 3 / 2))));
+ // Estimate risen above the RBF minimum: pay the higher estimate, not the stale minimum.
+ assert_eq!(rbf_splice_feerates(kwu(500), kwu(278)), Some((kwu(500), kwu(500 * 3 / 2))));
+ // RBF minimum above our max (1.5x a fallen estimate): we can't RBF within our ceiling.
+ assert_eq!(rbf_splice_feerates(kwu(100), kwu(278)), None);
+	}
+}

src/lib.rs

@@ -119,8 +119,6 @@ pub use bitcoin;
 use bitcoin::secp256k1::PublicKey;
 #[cfg(feature = "uniffi")]
 pub use bitcoin::FeeRate;
-#[cfg(not(feature = "uniffi"))]
-use bitcoin::FeeRate;
 use bitcoin::{Address, Amount, BlockHash, Network};
 #[cfg(feature = "uniffi")]
 pub use builder::ArcedNodeBuilder as Builder;
@@ -138,7 +136,9 @@ pub use error::Error as NodeError;
 use error::Error;
 pub use event::Event;
 use event::{EventHandler, EventQueue};
-use fee_estimator::{ConfirmationTarget, FeeEstimator, OnchainFeeEstimator};
+use fee_estimator::{
+	max_funding_feerate, rbf_splice_feerates, ConfirmationTarget, FeeEstimator, OnchainFeeEstimator,
+};
 #[cfg(feature = "uniffi")]
 use ffi::*;
 use gossip::GossipSource;
@@ -1584,7 +1584,7 @@ impl Node {
  {
  let min_feerate =
  self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
- let max_feerate = FeeRate::from_sat_per_kwu(min_feerate.to_sat_per_kwu() * 3 / 2);
+ let max_feerate = max_funding_feerate(min_feerate);
 
  let splice_amount_sats = match splice_amount_sats {
  FundingAmount::Exact { amount_sats } => amount_sats,
@@ -1653,16 +1653,26 @@ impl Node {
  if funding_template.prior_contribution().is_some() {
  log_error!(
  self.logger,
- "Failed to splice channel: a prior splice contribution is pending"
+ "Failed to splice channel: a prior splice contribution is pending; use bump_channel_funding_fee to bump its fee"
  );
  return Err(Error::ChannelSplicingFailed);
  }
 
+ // When contributing to a pending splice, the funding template requires at least the RBF
+ // minimum feerate to replace the in-flight transaction. Use it in place of our funding
+ // feerate estimate when it's higher, as long as it stays within our max.
+ let feerate = match funding_template.min_rbf_feerate() {
+ Some(min_rbf_feerate) if min_rbf_feerate <= max_feerate => {
+ min_feerate.max(min_rbf_feerate)
+ },
+ _ => min_feerate,
+ };
+
  let contribution = self
  .runtime
  .block_on(funding_template.splice_in(
  Amount::from_sat(splice_amount_sats),
-min_feerate,
+feerate,
  max_feerate,
  Arc::clone(&self.wallet),
  ))
@@ -1763,7 +1773,7 @@ impl Node {
 
  let min_feerate =
  self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
- let max_feerate = FeeRate::from_sat_per_kwu(min_feerate.to_sat_per_kwu() * 3 / 2);
+ let max_feerate = max_funding_feerate(min_feerate);
 
  let funding_template = self
  .channel_manager
@@ -1776,17 +1786,27 @@ impl Node {
  if funding_template.prior_contribution().is_some() {
  log_error!(
  self.logger,
- "Failed to splice channel: a prior splice contribution is pending"
+ "Failed to splice channel: a prior splice contribution is pending; use bump_channel_funding_fee to bump its fee"
  );
  return Err(Error::ChannelSplicingFailed);
  }
 
+ // When contributing to a pending splice, the funding template requires at least the RBF
+ // minimum feerate to replace the in-flight transaction. Use it in place of our funding
+ // feerate estimate when it's higher, as long as it stays within our max.
+ let feerate = match funding_template.min_rbf_feerate() {
+ Some(min_rbf_feerate) if min_rbf_feerate <= max_feerate => {
+ min_feerate.max(min_rbf_feerate)
+ },
+ _ => min_feerate,
+ };
+
  let outputs = vec![bitcoin::TxOut {
  value: Amount::from_sat(splice_amount_sats),
  script_pubkey: address.script_pubkey(),
  }];
  let contribution =
- funding_template.splice_out(outputs, min_feerate, max_feerate).map_err(|e| {
+ funding_template.splice_out(outputs, feerate, max_feerate).map_err(|e| {
  log_error!(self.logger, "Failed to splice channel: {}", e);
  Error::ChannelSplicingFailed
  })?;
@@ -1813,6 +1833,77 @@ impl Node {
  }
 	}
 
+	/// Fee-bumps the pending splice on a channel by replacing its in-flight funding transaction
+	/// (RBF). The splice's amount and destination are preserved; only the fee rate is raised.
+	/// Errors if the channel has no pending splice to bump.
+	pub fn bump_channel_funding_fee(
+ &self, user_channel_id: &UserChannelId, counterparty_node_id: PublicKey,
+	) -> Result<(), Error> {
+ let open_channels =
+ self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ if let Some(channel_details) =
+ open_channels.iter().find(|c| c.user_channel_id == user_channel_id.0)
+ {
+ let min_feerate =
+ self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
+
+ let funding_template = self
+ .channel_manager
+ .splice_channel(&channel_details.channel_id, &counterparty_node_id)
+ .map_err(|e| {
+ log_error!(self.logger, "Failed to RBF channel: {:?}", e);
+ Error::ChannelSplicingFailed
+ })?;
+
+ let Some(min_rbf_feerate) = funding_template.min_rbf_feerate() else {
+ log_error!(self.logger, "Failed to RBF channel: no pending splice to replace");
+ return Err(Error::ChannelSplicingFailed);
+ };
+
+ let Some((target_feerate, max_feerate)) =
+ rbf_splice_feerates(min_feerate, min_rbf_feerate)
+ else {
+ log_error!(
+ self.logger,
+ "Failed to RBF channel: the RBF minimum feerate exceeds our maximum"
+ );
+ return Err(Error::ChannelSplicingFailed);
+ };
+
+ let contribution = self
+ .runtime
+ .block_on(funding_template.rbf_prior_contribution(
+ Some(target_feerate),
+ max_feerate,
+ Arc::clone(&self.wallet),
+ ))
+ .map_err(|e| {
+ log_error!(self.logger, "Failed to RBF channel: {}", e);
+ Error::ChannelSplicingFailed
+ })?;
+
+ self.channel_manager
+ .funding_contributed(
+ &channel_details.channel_id,
+ &counterparty_node_id,
+ contribution,
+ None,
+ )
+ .map_err(|e| {
+ log_error!(self.logger, "Failed to RBF channel: {:?}", e);
+ Error::ChannelSplicingFailed
+ })
+ } else {
+ log_error!(
+ self.logger,
+ "Channel not found for user_channel_id {} and counterparty {}",
+ user_channel_id,
+ counterparty_node_id
+ );
+ Err(Error::ChannelSplicingFailed)
+ }
+	}
+
 	/// Manually sync the LDK and BDK wallets with the current chain state and update the fee rate
 	/// cache.
 	///

src/payment/mod.rs

@@ -20,10 +20,11 @@ pub use bolt11::Bolt11Payment;
 pub(crate) use bolt11::PaymentMetadata;
 pub use bolt12::Bolt12Payment;
 pub use onchain::OnchainPayment;
+pub(crate) use pending_payment_store::FundingTxCandidate;
 pub(crate) use pending_payment_store::PendingPaymentDetails;
 pub use spontaneous::SpontaneousPayment;
 pub use store::{
-	ConfirmationStatus, LSPS2Parameters, PaymentDetails, PaymentDirection, PaymentKind,
-	PaymentStatus,
+Channel, ConfirmationStatus, LSPS2Parameters, PaymentDetails, PaymentDirection, PaymentKind,
+	PaymentStatus, TransactionType,
 };
 pub use unified::{UnifiedPayment, UnifiedPaymentResult};