Implement background job for transaction rebroadcasting

Introduces a `RebroadcastPolicy` to manage the automatic rebroadcasting
of unconfirmed transactions with exponential backoff. This prevents
excessive network spam while systematically retrying stuck transactions.

The feature is enabled by default but can be disabled via the builder:
`builder.set_auto_rebroadcast_unconfirmed(false)`.

Configuration options:
- min_rebroadcast_interval: Base delay between attempts (seconds)
- max_broadcast_attempts: Total attempts before abandonment
- backoff_factor: Multiplier for exponential delay increase

Sensible defaults are provided (300s, 24 attempts, 1.5x backoff).

Author: Camillarhi

bindings/ldk_node.udl

@@ -13,6 +13,7 @@ dictionary Config {
 	u64 probing_liquidity_limit_multiplier;
 	AnchorChannelsConfig? anchor_channels_config;
 	RouteParametersConfig? route_parameters;
+	boolean auto_rebroadcast_unconfirmed_tx;
 };
 
 dictionary AnchorChannelsConfig {
@@ -266,6 +267,10 @@ interface OnchainPayment {
 	Txid send_to_address([ByRef]Address address, u64 amount_sats, FeeRate? fee_rate);
 	[Throws=NodeError]
 	Txid send_all_to_address([ByRef]Address address, boolean retain_reserve, FeeRate? fee_rate);
+	[Throws=NodeError]
+	void rebroadcast_transaction(PaymentId payment_id);
+	[Throws=NodeError]
+	Txid bump_fee_rbf(PaymentId payment_id);
 };
 
 interface FeeRate {
@@ -351,6 +356,7 @@ enum NodeError {
 	"InvalidBlindedPaths",
 	"AsyncPaymentServicesDisabled",
 	"HrnParsingFailed",
+	"InvalidTransaction",
 };
 
 dictionary NodeStatus {

src/config.rs

@@ -28,6 +28,9 @@ const DEFAULT_LDK_WALLET_SYNC_INTERVAL_SECS: u64 = 30;
 const DEFAULT_FEE_RATE_CACHE_UPDATE_INTERVAL_SECS: u64 = 60 * 10;
 const DEFAULT_PROBING_LIQUIDITY_LIMIT_MULTIPLIER: u64 = 3;
 const DEFAULT_ANCHOR_PER_CHANNEL_RESERVE_SATS: u64 = 25_000;
+const DEFAULT_MIN_REBROADCAST_INTERVAL_SECS: u64 = 300;
+const DEFAULT_MAX_BROADCAST_ATTEMPTS: u32 = 24;
+const DEFAULT_BACKOFF_FACTOR: f32 = 1.5;
 
 /// The default log level.
 pub const DEFAULT_LOG_LEVEL: LogLevel = LogLevel::Debug;
@@ -107,6 +110,9 @@ pub(crate) const EXTERNAL_PATHFINDING_SCORES_SYNC_TIMEOUT_SECS: u64 = 5;
 // The timeout after which we abort a parsing/looking up an HRN resolution.
 pub(crate) const HRN_RESOLUTION_TIMEOUT_SECS: u64 = 5;
 
+// The time in-between unconfirmed transaction broadcasts.
+pub(crate) const UNCONFIRMED_TX_BROADCAST_INTERVAL: Duration = Duration::from_secs(300);
+
 #[derive(Debug, Clone)]
 /// Represents the configuration of an [`Node`] instance.
 ///
@@ -128,6 +134,7 @@ pub(crate) const HRN_RESOLUTION_TIMEOUT_SECS: u64 = 5;
 /// | `log_level`                            | Debug              |
 /// | `anchor_channels_config`               | Some(..)           |
 /// | `route_parameters`                   | None               |
+/// | `auto_rebroadcast_unconfirmed_tx`      | true               |
 ///
 /// See [`AnchorChannelsConfig`] and [`RouteParametersConfig`] for more information regarding their
 /// respective default values.
@@ -192,6 +199,16 @@ pub struct Config {
 	/// **Note:** If unset, default parameters will be used, and you will be able to override the
 	/// parameters on a per-payment basis in the corresponding method calls.
 	pub route_parameters: Option<RouteParametersConfig>,
+	/// This will determine whether to automatically rebroadcast unconfirmed transactions
+	/// (e.g., channel funding or sweep transactions).
+	///
+	/// If enabled, the node will periodically attempt to rebroadcast any unconfirmed transactions to
+	/// increase propagation and confirmation likelihood. This is helpful in cases where transactions
+	/// were dropped by the mempool or not widely propagated.
+	///
+	/// Defaults to `true`. Disabling this may be desired for privacy-sensitive use cases or low-bandwidth
+	/// environments, but may result in slower or failed confirmations if transactions are not re-announced.
+	pub auto_rebroadcast_unconfirmed_tx: bool,
 }
 
 impl Default for Config {
@@ -206,6 +223,7 @@ impl Default for Config {
 			anchor_channels_config: Some(AnchorChannelsConfig::default()),
 			route_parameters: None,
 			node_alias: None,
+			auto_rebroadcast_unconfirmed_tx: true,
 		}
 	}
 }
@@ -561,6 +579,49 @@ pub enum AsyncPaymentsRole {
 	Server,
 }
 
+/// Policy for controlling transaction rebroadcasting behavior.
+///
+/// Determines the strategy for resending unconfirmed transactions to the network
+/// to ensure they remain in mempools and eventually get confirmed.
+#[derive(Clone, Debug)]
+pub struct RebroadcastPolicy {
+	/// Minimum time between rebroadcast attempts in seconds.
+	///
+	/// This prevents excessive network traffic by ensuring a minimum delay
+	/// between consecutive rebroadcast attempts.
+	///
+	/// **Recommended values**: 60-600 seconds (1-10 minutes)
+	pub min_rebroadcast_interval_secs: u64,
+	/// Maximum number of broadcast attempts before giving up.
+	///
+	/// After reaching this limit, the transaction will no longer be rebroadcast
+	/// automatically. Manual intervention may be required.
+	///
+	/// **Recommended values**: 12-48 attempts
+	pub max_broadcast_attempts: u32,
+	/// Exponential backoff factor for increasing intervals between attempts.
+	///
+	/// Each subsequent rebroadcast wait time is multiplied by this factor,
+	/// creating an exponential backoff pattern.
+	///
+	/// - `1.0`: No backoff (constant interval)
+	/// - `1.5`: 50% increase each attempt
+	/// - `2.0`: 100% increase (doubling) each attempt
+	///
+	/// **Recommended values**: 1.2-2.0
+	pub backoff_factor: f32,
+}
+
+impl Default for RebroadcastPolicy {
+	fn default() -> Self {
+		Self {
+			min_rebroadcast_interval_secs: DEFAULT_MIN_REBROADCAST_INTERVAL_SECS,
+			max_broadcast_attempts: DEFAULT_MAX_BROADCAST_ATTEMPTS,
+			backoff_factor: DEFAULT_BACKOFF_FACTOR,
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use std::str::FromStr;

src/error.rs

@@ -131,6 +131,8 @@ pub enum Error {
 	AsyncPaymentServicesDisabled,
 	/// Parsing a Human-Readable Name has failed.
 	HrnParsingFailed,
+	/// The given transaction is invalid.
+	InvalidTransaction,
 }
 
 impl fmt::Display for Error {
@@ -213,6 +215,7 @@ impl fmt::Display for Error {
 			Self::HrnParsingFailed => {
 				write!(f, "Failed to parse a human-readable name.")
 			},
+			Self::InvalidTransaction => write!(f, "The given transaction is invalid."),
 		}
 	}
 }

src/lib.rs

@@ -125,6 +125,7 @@ use chain::ChainSource;
 use config::{
 	default_user_config, may_announce_channel, AsyncPaymentsRole, ChannelConfig, Config,
 	NODE_ANN_BCAST_INTERVAL, PEER_RECONNECTION_INTERVAL, RGS_SYNC_INTERVAL,
+	UNCONFIRMED_TX_BROADCAST_INTERVAL,
 };
 use connection::ConnectionManager;
 pub use error::Error as NodeError;
@@ -459,6 +460,33 @@ impl Node {
 			}
 		});
 
+		// Regularly rebroadcast unconfirmed transactions.
+		let rebroadcast_wallet = Arc::clone(&self.wallet);
+		let rebroadcast_logger = Arc::clone(&self.logger);
+		let mut stop_rebroadcast = self.stop_sender.subscribe();
+		if self.config.auto_rebroadcast_unconfirmed_tx {
+			self.runtime.spawn_cancellable_background_task(async move {
+				let mut interval = tokio::time::interval(UNCONFIRMED_TX_BROADCAST_INTERVAL);
+				interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+				loop {
+					tokio::select! {
+						_ = stop_rebroadcast.changed() => {
+							log_debug!(
+								rebroadcast_logger,
+								"Stopping rebroadcasting unconfirmed transactions."
+							);
+							return;
+						}
+						_ = interval.tick() => {
+							if let Err(e) = rebroadcast_wallet.rebroadcast_unconfirmed_transactions() {
+								log_error!(rebroadcast_logger, "Background rebroadcast failed: {}", e);
+							}
+						}
+					}
+				}
+			});
+		}
+
 		// Regularly broadcast node announcements.
 		let bcast_cm = Arc::clone(&self.channel_manager);
 		let bcast_pm = Arc::clone(&self.peer_manager);

src/payment/onchain.rs

@@ -17,6 +17,11 @@ use crate::logger::{log_info, LdkLogger, Logger};
 use crate::types::{ChannelManager, Wallet};
 use crate::wallet::OnchainSendAmount;
 
+use bitcoin::{Address, Txid};
+use lightning::ln::channelmanager::PaymentId;
+
+use std::sync::{Arc, RwLock};
+
 #[cfg(not(feature = "uniffi"))]
 type FeeRate = bitcoin::FeeRate;
 #[cfg(feature = "uniffi")]
@@ -120,4 +125,15 @@ impl OnchainPayment {
 		let fee_rate_opt = maybe_map_fee_rate_opt!(fee_rate);
 		self.wallet.send_to_address(address, send_amount, fee_rate_opt)
 	}
+
+	/// Manually trigger a rebroadcast of a specific transaction according to the default policy.
+	///
+	/// This is useful if you suspect a transaction may not have propagated properly through the
+	/// network and you want to attempt to rebroadcast it immediately rather than waiting for the
+	/// automatic background job to handle it.
+	///
+	/// updating the attempt count and last broadcast time for the transaction in the payment store.
+	pub fn rebroadcast_transaction(&self, payment_id: PaymentId) -> Result<(), Error> {
+		self.wallet.rebroadcast_transaction(payment_id)
+	}
 }

src/payment/pending_payment_store.rs

@@ -5,7 +5,7 @@
 // http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
 // accordance with one or both of these licenses.
 
-use bitcoin::Txid;
+use bitcoin::{Transaction, Txid};
 use lightning::{impl_writeable_tlv_based, ln::channelmanager::PaymentId};
 
 use crate::{
@@ -20,11 +20,20 @@ pub struct PendingPaymentDetails {
 	pub details: PaymentDetails,
 	/// Transaction IDs that have replaced or conflict with this payment.
 	pub conflicting_txids: Vec<Txid>,
+	/// The raw transaction for rebroadcasting
+	pub raw_tx: Option<Transaction>,
+	/// Last broadcast attempt timestamp (UNIX seconds)
+	pub last_broadcast_time: Option<u64>,
+	/// Number of broadcast attempts
+	pub broadcast_attempts: Option<u32>,
 }
 
 impl PendingPaymentDetails {
-	pub(crate) fn new(details: PaymentDetails, conflicting_txids: Vec<Txid>) -> Self {
-		Self { details, conflicting_txids }
+	pub(crate) fn new(
+		details: PaymentDetails, conflicting_txids: Vec<Txid>, raw_tx: Option<Transaction>,
+		last_broadcast_time: Option<u64>, broadcast_attempts: Option<u32>,
+	) -> Self {
+		Self { details, conflicting_txids, raw_tx, last_broadcast_time, broadcast_attempts }
 	}
 
 	/// Convert to finalized payment for the main payment store
@@ -36,13 +45,19 @@ impl PendingPaymentDetails {
 impl_writeable_tlv_based!(PendingPaymentDetails, {
 	(0, details, required),
 	(2, conflicting_txids, optional_vec),
+	(3, raw_tx, option),
+	(5, last_broadcast_time, option),
+	(7, broadcast_attempts, option),
 });
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct PendingPaymentDetailsUpdate {
 	pub id: PaymentId,
 	pub payment_update: Option<PaymentDetailsUpdate>,
 	pub conflicting_txids: Option<Vec<Txid>>,
+	pub raw_tx: Option<Option<Transaction>>,
+	pub last_broadcast_time: Option<Option<u64>>,
+	pub broadcast_attempts: Option<Option<u32>>,
 }
 
 impl StorableObject for PendingPaymentDetails {
@@ -56,16 +71,34 @@ impl StorableObject for PendingPaymentDetails {
 	fn update(&mut self, update: &Self::Update) -> bool {
 		let mut updated = false;
 
+		macro_rules! update_if_necessary {
+			($val:expr, $update:expr) => {
+				if $val != $update {
+					$val = $update;
+					updated = true;
+				}
+			};
+		}
+
 		// Update the underlying payment details if present
 		if let Some(payment_update) = &update.payment_update {
 			updated |= self.details.update(payment_update);
 		}
 
 		if let Some(new_conflicting_txids) = &update.conflicting_txids {
-			if &self.conflicting_txids != new_conflicting_txids {
-				self.conflicting_txids = new_conflicting_txids.clone();
-				updated = true;
-			}
+			update_if_necessary!(self.conflicting_txids, new_conflicting_txids.clone());
+		}
+
+		if let Some(new_raw_tx) = &update.raw_tx {
+			update_if_necessary!(self.raw_tx, new_raw_tx.clone());
+		}
+
+		if let Some(new_last_broadcast_time) = update.last_broadcast_time {
+			update_if_necessary!(self.last_broadcast_time, new_last_broadcast_time);
+		}
+
+		if let Some(new_broadcast_attempts) = update.broadcast_attempts {
+			update_if_necessary!(self.broadcast_attempts, new_broadcast_attempts);
 		}
 
 		updated
@@ -88,6 +121,9 @@ impl From<&PendingPaymentDetails> for PendingPaymentDetailsUpdate {
 			id: value.id(),
 			payment_update: Some(value.details.to_update()),
 			conflicting_txids: Some(value.conflicting_txids.clone()),
+			raw_tx: Some(value.raw_tx.clone()),
+			last_broadcast_time: Some(value.last_broadcast_time),
+			broadcast_attempts: Some(value.broadcast_attempts),
 		}
 	}
 }