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

src/builder.rs

@@ -738,6 +738,22 @@ impl NodeBuilder {
 			kv_store,
 		)
 	}
+
+	/// Sets whether to automatically rebroadcast unconfirmed transactions (e.g., funding or sweep transactions).
+	///
+	/// If enabled (default), the node will periodically rebroadcast unconfirmed transactions to increase
+	/// the likelihood of confirmation. This helps recover from mempool drops or poor initial propagation.
+	///
+	/// Disabling this may be desired for privacy or bandwidth-constrained environments, but could result
+	/// in slower or failed confirmations if transactions are not re-announced.
+	///
+	/// Default: `true`
+	pub fn set_auto_rebroadcast_unconfirmed(
+		&mut self, enable: bool,
+	) -> Result<&mut Self, BuildError> {
+		self.config.auto_rebroadcast_unconfirmed_tx = Some(enable);
+		Ok(self)
+	}
 }
 
 /// A builder for an [`Node`] instance, allowing to set some configuration and module choices from

src/config.rs

@@ -94,6 +94,9 @@ pub(crate) const RGS_SYNC_TIMEOUT_SECS: u64 = 5;
 /// The length in bytes of our wallets' keys seed.
 pub const WALLET_KEYS_SEED_LEN: usize = 64;
 
+// 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.
 ///
@@ -179,6 +182,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 sending_parameters: Option<SendingParameters>,
+	/// 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: Option<bool>,
 }
 
 impl Default for Config {
@@ -193,6 +206,7 @@ impl Default for Config {
 			anchor_channels_config: Some(AnchorChannelsConfig::default()),
 			sending_parameters: None,
 			node_alias: None,
+			auto_rebroadcast_unconfirmed_tx: Some(true),
 		}
 	}
 }
@@ -534,6 +548,45 @@ impl From<MaxDustHTLCExposure> for LdkMaxDustHTLCExposure {
 	}
 }
 
+/// 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: 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: 300, max_broadcast_attempts: 24, backoff_factor: 1.5 }
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use std::str::FromStr;

src/lib.rs

@@ -129,7 +129,7 @@ pub use builder::NodeBuilder as Builder;
 use chain::ChainSource;
 use config::{
 	default_user_config, may_announce_channel, ChannelConfig, Config, NODE_ANN_BCAST_INTERVAL,
-	PEER_RECONNECTION_INTERVAL, RGS_SYNC_INTERVAL,
+	PEER_RECONNECTION_INTERVAL, RGS_SYNC_INTERVAL, UNCONFIRMED_TX_BROADCAST_INTERVAL,
 };
 use connection::ConnectionManager;
 use event::{EventHandler, EventQueue};
@@ -402,6 +402,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 let Some(true) = &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);