Retry LSP protocol discovery after transient failures

- Add a background task that retries discovery for any LSP whose protocols
  are still undiscovered, using exponential backoff (5s up to 1h).
- Expose `Liquidity::retry_discovery(node_id)` so users can trigger
  re-discovery on demand, both to recover a stuck LSP and to pick up newly
  supported protocols after an LSP upgrade.

Author: Camillarhi

src/config.rs

@@ -111,6 +111,12 @@ pub(crate) const HRN_RESOLUTION_TIMEOUT_SECS: u64 = 5;
 // The timeout after which we abort an LNURL-auth operation.
 pub(crate) const LNURL_AUTH_TIMEOUT_SECS: u64 = 15;
 
+// The initial delay before retrying a failed liquidity protocol discovery operation.
+pub(crate) const LIQUIDITY_DISCOVERY_RETRY_INITIAL_DELAY_SECS: u64 = 5;
+
+// The maximum delay before retrying a failed liquidity protocol discovery operation.
+pub(crate) const LIQUIDITY_DISCOVERY_RETRY_MAX_DELAY_SECS: u64 = 3600;
+
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
 /// Represents the configuration of an [`Node`] instance.

src/lib.rs

@@ -184,6 +184,9 @@ pub use types::{
 };
 pub use vss_client;
 
+use crate::config::{
+	LIQUIDITY_DISCOVERY_RETRY_INITIAL_DELAY_SECS, LIQUIDITY_DISCOVERY_RETRY_MAX_DELAY_SECS,
+};
 use crate::ffi::maybe_wrap;
 use crate::liquidity::Liquidity;
 use crate::scoring::setup_background_pathfinding_scores_sync;
@@ -748,6 +751,62 @@ impl Node {
 			}
 		});
 
+		// Background retry for LSPs that failed the initial protocol-discovery batch, so a
+		// transient startup failure doesn't leave a configured LSP permanently unusable.
+		let mut stop_retry = self.stop_sender.subscribe();
+		let retry_ls = Arc::clone(&self.liquidity_source);
+		let retry_logger = Arc::clone(&self.logger);
+		let retry_cm = Arc::clone(&self.connection_manager);
+		self.runtime.spawn_background_task(async move {
+			let mut backoff = LIQUIDITY_DISCOVERY_RETRY_INITIAL_DELAY_SECS;
+			loop {
+				let undiscovered_lsps = retry_ls.get_undiscovered_lsps();
+				if undiscovered_lsps.is_empty() {
+					tokio::select! {
+						_ = stop_retry.changed() => return,
+						_ = tokio::time::sleep(Duration::from_secs(
+							LIQUIDITY_DISCOVERY_RETRY_MAX_DELAY_SECS,
+						)) => continue,
+					}
+				}
+
+				tokio::select! {
+					_ = stop_retry.changed() => return,
+					_ = tokio::time::sleep(Duration::from_secs(backoff)) => {},
+				}
+
+				for (node_id, address) in undiscovered_lsps {
+					if let Err(e) =
+						retry_cm.connect_peer_if_necessary(node_id, address.clone()).await
+					{
+						log_debug!(
+							retry_logger,
+							"Discovery retry: failed to connect to LSP {}: {}",
+							node_id,
+							e
+						);
+						continue;
+					}
+					match retry_ls.discover_lsp_protocols(&node_id).await {
+						Ok(protocols) => log_info!(
+							retry_logger,
+							"Discovery retry: discovered protocols for LSP {}: {:?}",
+							node_id,
+							protocols
+						),
+						Err(e) => log_debug!(
+							retry_logger,
+							"Discovery retry: failed for LSP {}: {:?}",
+							node_id,
+							e
+						),
+					}
+				}
+
+				backoff = (backoff * 2).min(LIQUIDITY_DISCOVERY_RETRY_MAX_DELAY_SECS);
+			}
+		});
+
 		log_info!(self.logger, "Startup complete.");
 		*is_running_lock = true;
 		Ok(())

src/liquidity/mod.rs

@@ -164,6 +164,40 @@ impl Liquidity {
 		Ok(())
 	}
 
+	/// Re-runs bLIP-50 / LSPS0 protocol discovery for an already-configured LSP.
+	///
+	/// Use this to recover an LSP that failed protocol discovery at startup or to
+	/// pick up newly supported protocols after the LSP has rolled out an upgrade.
+	///
+	/// The `node_id` must belong to an LSP configured at build time or added via
+	/// [`Liquidity::add_liquidity_source`]; otherwise [`Error::LiquiditySourceUnavailable`]
+	/// is returned.
+	pub fn retry_discovery(&self, node_id: PublicKey) -> Result<(), Error> {
+		let (_, address) = self
+			.liquidity_source
+			.get_single_lsp_details(&node_id)
+			.ok_or(Error::LiquiditySourceUnavailable)?;
+
+		let con_cm = Arc::clone(&self.connection_manager);
+		let connect_addr = address.clone();
+		self.runtime.block_on(async move {
+			con_cm.connect_peer_if_necessary(node_id, connect_addr).await
+		})?;
+		log_info!(
+			self.logger,
+			"Connected to LSP {}@{} for protocol re-discovery.",
+			node_id,
+			address
+		);
+
+		let protocols = self
+			.runtime
+			.block_on(async { self.liquidity_source.discover_lsp_protocols(&node_id).await })?;
+		log_info!(self.logger, "Re-discovered protocols for LSP {}: {:?}", node_id, protocols);
+
+		Ok(())
+	}
+
 	/// Returns a liquidity handler allowing to request channels via the [bLIP-51 / LSPS1] protocol.
 	///
 	/// [bLIP-51 / LSPS1]: https://github.com/lightning/blips/blob/master/blip-0051.md
@@ -432,6 +466,17 @@ where
 			.collect()
 	}
 
+	pub(crate) fn get_single_lsp_details(
+		&self, node_id: &PublicKey,
+	) -> Option<(PublicKey, SocketAddress)> {
+		self.lsp_nodes
+			.read()
+			.expect("lock")
+			.iter()
+			.find(|n| &n.node_id == node_id)
+			.map(|n| (n.node_id, n.address.clone()))
+	}
+
 	pub(crate) async fn discover_lsp_protocols(
 		&self, node_id: &PublicKey,
 	) -> Result<Vec<u16>, Error> {
@@ -517,6 +562,16 @@ where
 		select_lsps_for_protocol(&self.lsp_nodes, protocol, Some(node_id))
 	}
 
+	pub(crate) fn get_undiscovered_lsps(&self) -> Vec<(PublicKey, SocketAddress)> {
+		self.lsp_nodes
+			.read()
+			.expect("lock")
+			.iter()
+			.filter(|n| n.supported_protocols.is_none())
+			.map(|n| (n.node_id, n.address.clone()))
+			.collect()
+	}
+
 	/// Flips the `discovery_done` watch to `true`.
 	///
 	/// Called once after the *initial* batch of LSPs configured at build time has been