Refactor liquidity source to support multiple LSP nodes

Replace per-protocol single-LSP configuration `LSPS1Client, LSPS2Client`
with a unified `Vec<LspNode>` model where users configure LSP nodes via
`add_lsp()` and protocol support is discovered at runtime via LSPS0
`list_protocols`.

- Replace separate `LSPS1Client/LSPS2Client` with global pending request
  maps keyed by `LSPSRequestId`
- Add LSPS0 protocol discovery `discover_lsp_protocols` with event
  handling for `ListProtocolsResponse`
- Update events to use is_lsps_node() for multi-LSP counterparty
  checks
- Deprecate `set_liquidity_source_lsps1/lsps2` builder methods in favor
  of `add_lsp()`
- LSPS2 JIT channels now query all LSPS2-capable LSPs and automatically
  select the cheapest fee offer across all of them
- Add `request_channel_from_lsp()` for explicit LSPS1 LSP selection
- Spawn background discovery task on `Node::start()`

Author: Camillarhi

bindings/ldk_node.udl

@@ -45,6 +45,7 @@ interface Builder {
 	void set_pathfinding_scores_source(string url);
 	void set_liquidity_source_lsps1(PublicKey node_id, SocketAddress address, string? token);
 	void set_liquidity_source_lsps2(PublicKey node_id, SocketAddress address, string? token);
+	void add_lsp(PublicKey node_id, SocketAddress address, string? token);
 	void set_storage_dir_path(string storage_dir_path);
 	void set_filesystem_logger(string? log_file_path, LogLevel? max_log_level);
 	void set_log_facade_logger();
@@ -138,6 +139,8 @@ interface Node {
 	boolean verify_signature([ByRef]sequence<u8> msg, [ByRef]string sig, [ByRef]PublicKey pkey);
 	[Throws=NodeError]
 	bytes export_pathfinding_scores();
+	[Throws=NodeError]
+	void add_lsp(PublicKey node_id, SocketAddress address, string? token);
 };
 
 typedef interface Bolt11Payment;

src/builder.rs

@@ -65,9 +65,7 @@ use crate::io::{
 	PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 	PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 };
-use crate::liquidity::{
-	LSPS1ClientConfig, LSPS2ClientConfig, LSPS2ServiceConfig, LiquiditySourceBuilder,
-};
+use crate::liquidity::{LSPS2ServiceConfig, LiquiditySourceBuilder, LspConfig};
 use crate::lnurl_auth::LnurlAuth;
 use crate::logger::{log_error, LdkLogger, LogLevel, LogWriter, Logger};
 use crate::message_handler::NodeCustomMessageHandler;
@@ -120,10 +118,8 @@ struct PathfindingScoresSyncConfig {
 
 #[derive(Debug, Clone, Default)]
 struct LiquiditySourceConfig {
-	// Act as an LSPS1 client connecting to the given service.
-	lsps1_client: Option<LSPS1ClientConfig>,
-	// Act as an LSPS2 client connecting to the given service.
-	lsps2_client: Option<LSPS2ClientConfig>,
+	// Acts for both LSPS1 and LSPS2 clients connecting to the given service.
+	lsp_nodes: Vec<LspConfig>,
 	// Act as an LSPS2 service.
 	lsps2_service: Option<LSPS2ServiceConfig>,
 }
@@ -440,17 +436,12 @@ impl NodeBuilder {
 	/// The given `token` will be used by the LSP to authenticate the user.
 	///
 	/// [bLIP-51 / LSPS1]: https://github.com/lightning/blips/blob/master/blip-0051.md
+	#[deprecated(note = "Use `add_lsp` instead")]
+	#[allow(dead_code)]
 	pub fn set_liquidity_source_lsps1(
 		&mut self, node_id: PublicKey, address: SocketAddress, token: Option<String>,
 	) -> &mut Self {
-		// Mark the LSP as trusted for 0conf
-		self.config.trusted_peers_0conf.push(node_id.clone());
-
-		let liquidity_source_config =
-			self.liquidity_source_config.get_or_insert(LiquiditySourceConfig::default());
-		let lsps1_client_config = LSPS1ClientConfig { node_id, address, token };
-		liquidity_source_config.lsps1_client = Some(lsps1_client_config);
-		self
+		self.add_lsp(node_id, address, token)
 	}
 
 	/// Configures the [`Node`] instance to source just-in-time inbound liquidity from the given
@@ -461,16 +452,32 @@ impl NodeBuilder {
 	/// The given `token` will be used by the LSP to authenticate the user.
 	///
 	/// [bLIP-52 / LSPS2]: https://github.com/lightning/blips/blob/master/blip-0052.md
+	#[deprecated(note = "Use `add_lsp` instead")]
+	#[allow(dead_code)]
 	pub fn set_liquidity_source_lsps2(
 		&mut self, node_id: PublicKey, address: SocketAddress, token: Option<String>,
+	) -> &mut Self {
+		self.add_lsp(node_id, address, token)
+	}
+
+	/// Configures the [`Node`] instance to source inbound liquidity from the given LSP, without specifying
+	/// the exact protocol used (e.g., LSPS1 or LSPS2).
+	///
+	/// Will mark the LSP as trusted for 0-confirmation channels, see [`Config::trusted_peers_0conf`].
+	///
+	/// The given `token` will be used by the LSP to authenticate the user.
+	/// This method is useful when the user wants to connect to an LSP but does not want to be concerned with
+	///  the specific protocol used for liquidity provision. The node will automatically detect and use the
+	/// appropriate protocol supported by the LSP.
+	pub fn add_lsp(
+		&mut self, node_id: PublicKey, address: SocketAddress, token: Option<String>,
 	) -> &mut Self {
 		// Mark the LSP as trusted for 0conf
-		self.config.trusted_peers_0conf.push(node_id.clone());
+		self.config.trusted_peers_0conf.write().unwrap().push(node_id);
 
 		let liquidity_source_config =
 			self.liquidity_source_config.get_or_insert(LiquiditySourceConfig::default());
-		let lsps2_client_config = LSPS2ClientConfig { node_id, address, token };
-		liquidity_source_config.lsps2_client = Some(lsps2_client_config);
+		liquidity_source_config.lsp_nodes.push(LspConfig { node_id, address, token });
 		self
 	}
 
@@ -964,7 +971,7 @@ impl ArcedNodeBuilder {
 	pub fn set_liquidity_source_lsps1(
 		&self, node_id: PublicKey, address: SocketAddress, token: Option<String>,
 	) {
-		self.inner.write().unwrap().set_liquidity_source_lsps1(node_id, address, token);
+		self.inner.write().unwrap().add_lsp(node_id, address, token);
 	}
 
 	/// Configures the [`Node`] instance to source just-in-time inbound liquidity from the given
@@ -978,7 +985,20 @@ impl ArcedNodeBuilder {
 	pub fn set_liquidity_source_lsps2(
 		&self, node_id: PublicKey, address: SocketAddress, token: Option<String>,
 	) {
-		self.inner.write().unwrap().set_liquidity_source_lsps2(node_id, address, token);
+		self.inner.write().unwrap().add_lsp(node_id, address, token);
+	}
+
+	/// Configures the [`Node`] instance to source inbound liquidity from the given LSP, without specifying
+	/// the exact protocol used (e.g., LSPS1 or LSPS2).
+	///
+	/// Will mark the LSP as trusted for 0-confirmation channels, see [`Config::trusted_peers_0conf`].
+	///
+	/// The given `token` will be used by the LSP to authenticate the user.
+	/// This method is useful when the user wants to connect to an LSP but does not want to be concerned with
+	///  the specific protocol used for liquidity provision. The node will automatically detect and use the
+	/// appropriate protocol supported by the LSP.
+	pub fn add_lsp(&self, node_id: PublicKey, address: SocketAddress, token: Option<String>) {
+		self.inner.write().unwrap().add_lsp(node_id, address, token);
 	}
 
 	/// Configures the [`Node`] instance to provide an [LSPS2] service, issuing just-in-time
@@ -1803,21 +1823,7 @@ fn build_with_store_internal(
 				Arc::clone(&logger),
 			);
 
-			lsc.lsps1_client.as_ref().map(|config| {
-				liquidity_source_builder.lsps1_client(
-					config.node_id,
-					config.address.clone(),
-					config.token.clone(),
-				)
-			});
-
-			lsc.lsps2_client.as_ref().map(|config| {
-				liquidity_source_builder.lsps2_client(
-					config.node_id,
-					config.address.clone(),
-					config.token.clone(),
-				)
-			});
+			liquidity_source_builder.set_lsp_nodes(lsc.lsp_nodes.clone());
 
 			let promise_secret = {
 				let lsps_xpriv = derive_xprv(
@@ -1886,7 +1892,9 @@ fn build_with_store_internal(
 		}
 	}));
 
-	liquidity_source.as_ref().map(|l| l.set_peer_manager(Arc::downgrade(&peer_manager)));
+	liquidity_source
+		.as_ref()
+		.map(|l| l.lsps2_service().set_peer_manager(Arc::downgrade(&peer_manager)));
 
 	let connection_manager = Arc::new(ConnectionManager::new(
 		Arc::clone(&peer_manager),

src/config.rs

@@ -8,6 +8,7 @@
 //! Objects for configuring the node.
 
 use std::fmt;
+use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
 use bitcoin::secp256k1::PublicKey;
@@ -161,7 +162,7 @@ pub struct Config {
 	/// **Note:** Allowing payments via zero-confirmation channels is potentially insecure if the
 	/// funding transaction ends up never being confirmed on-chain. Zero-confirmation channels
 	/// should therefore only be accepted from trusted peers.
-	pub trusted_peers_0conf: Vec<PublicKey>,
+	pub trusted_peers_0conf: Arc<RwLock<Vec<PublicKey>>>,
 	/// The liquidity factor by which we filter the outgoing channels used for sending probes.
 	///
 	/// Channels with available liquidity less than the required amount times this value won't be
@@ -208,7 +209,7 @@ impl Default for Config {
 			network: DEFAULT_NETWORK,
 			listening_addresses: None,
 			announcement_addresses: None,
-			trusted_peers_0conf: Vec::new(),
+			trusted_peers_0conf: Arc::new(RwLock::new(Vec::new())),
 			probing_liquidity_limit_multiplier: DEFAULT_PROBING_LIQUIDITY_LIMIT_MULTIPLIER,
 			anchor_channels_config: Some(AnchorChannelsConfig::default()),
 			tor_config: None,

src/event.rs

@@ -581,15 +581,15 @@ where
 					Ok(final_tx) => {
 						let needs_manual_broadcast =
 							self.liquidity_source.as_ref().map_or(false, |ls| {
-								ls.as_ref().lsps2_channel_needs_manual_broadcast(
+								ls.as_ref().lsps2_service().lsps2_channel_needs_manual_broadcast(
 									counterparty_node_id,
 									user_channel_id,
 								)
 							});
 
 						let result = if needs_manual_broadcast {
 							self.liquidity_source.as_ref().map(|ls| {
-								ls.lsps2_store_funding_transaction(
+								ls.lsps2_service().lsps2_store_funding_transaction(
 									user_channel_id,
 									counterparty_node_id,
 									final_tx.clone(),
@@ -653,7 +653,8 @@ where
 			},
 			LdkEvent::FundingTxBroadcastSafe { user_channel_id, counterparty_node_id, .. } => {
 				self.liquidity_source.as_ref().map(|ls| {
-					ls.lsps2_funding_tx_broadcast_safe(user_channel_id, counterparty_node_id);
+					ls.lsps2_service()
+						.lsps2_funding_tx_broadcast_safe(user_channel_id, counterparty_node_id);
 				});
 			},
 			LdkEvent::PaymentClaimable {
@@ -1139,7 +1140,10 @@ where
 			LdkEvent::ProbeFailed { .. } => {},
 			LdkEvent::HTLCHandlingFailed { failure_type, .. } => {
 				if let Some(liquidity_source) = self.liquidity_source.as_ref() {
-					liquidity_source.handle_htlc_handling_failed(failure_type).await;
+					liquidity_source
+						.lsps2_service()
+						.handle_htlc_handling_failed(failure_type)
+						.await;
 				}
 			},
 			LdkEvent::SpendableOutputs { outputs, channel_id, counterparty_node_id } => {
@@ -1238,14 +1242,11 @@ where
 				let user_channel_id: u128 = u128::from_ne_bytes(
 					self.keys_manager.get_secure_random_bytes()[..16].try_into().unwrap(),
 				);
-				let allow_0conf = self.config.trusted_peers_0conf.contains(&counterparty_node_id);
+				let allow_0conf =
+					self.config.trusted_peers_0conf.read().unwrap().contains(&counterparty_node_id);
 				let mut channel_override_config = None;
-				if let Some((lsp_node_id, _)) = self
-					.liquidity_source
-					.as_ref()
-					.and_then(|ls| ls.as_ref().get_lsps2_lsp_details())
-				{
-					if lsp_node_id == counterparty_node_id {
+				if let Some(ls) = self.liquidity_source.as_ref() {
+					if ls.as_ref().is_lsps_node(&counterparty_node_id) {
 						// When we're an LSPS2 client, allow claiming underpaying HTLCs as the LSP will skim off some fee. We'll
 						// check that they don't take too much before claiming.
 						//
@@ -1379,6 +1380,7 @@ where
 				if let Some(liquidity_source) = self.liquidity_source.as_ref() {
 					let skimmed_fee_msat = skimmed_fee_msat.unwrap_or(0);
 					liquidity_source
+						.lsps2_service()
 						.handle_payment_forwarded(next_channel_id, skimmed_fee_msat)
 						.await;
 				}
@@ -1488,6 +1490,7 @@ where
 
 				if let Some(liquidity_source) = self.liquidity_source.as_ref() {
 					liquidity_source
+						.lsps2_service()
 						.handle_channel_ready(user_channel_id, &channel_id, &counterparty_node_id)
 						.await;
 				}
@@ -1559,6 +1562,7 @@ where
 			} => {
 				if let Some(liquidity_source) = self.liquidity_source.as_ref() {
 					liquidity_source
+						.lsps2_service()
 						.handle_htlc_intercepted(
 							requested_next_hop_scid,
 							intercept_id,

src/lib.rs

@@ -180,6 +180,7 @@ use types::{
 pub use types::{ChannelDetails, CustomTlvRecord, PeerDetails, SyncAndAsyncKVStore, UserChannelId};
 pub use vss_client;
 
+use crate::liquidity::LspConfig;
 use crate::scoring::setup_background_pathfinding_scores_sync;
 use crate::wallet::FundingAmount;
 
@@ -674,6 +675,29 @@ impl Node {
 			});
 		}
 
+		if let Some(liquidity_source) = self.liquidity_source.as_ref() {
+			let discovery_ls = Arc::clone(&liquidity_source);
+			let discovery_cm = Arc::clone(&self.connection_manager);
+			let discovery_logger = Arc::clone(&self.logger);
+			self.runtime.spawn_background_task(async move {
+				for (node_id, address) in discovery_ls.get_all_lsp_details() {
+					if let Err(e) =
+						discovery_cm.connect_peer_if_necessary(node_id, address.clone()).await
+					{
+						log_error!(
+							discovery_logger,
+							"Failed to connect to LSP {} for protocol discovery: {}",
+							node_id,
+							e
+						);
+						continue;
+					}
+				}
+
+				discovery_ls.discover_all_lsp_protocols().await;
+			});
+		}
+
 		log_info!(self.logger, "Startup complete.");
 		*is_running_lock = true;
 		Ok(())
@@ -1048,7 +1072,7 @@ impl Node {
 			Arc::clone(&self.runtime),
 			Arc::clone(&self.wallet),
 			Arc::clone(&self.connection_manager),
-			self.liquidity_source.clone(),
+			self.liquidity_source.as_ref().map(|ls| ls.lsps1_client()),
 			Arc::clone(&self.logger),
 		)
 	}
@@ -1062,7 +1086,7 @@ impl Node {
 			Arc::clone(&self.runtime),
 			Arc::clone(&self.wallet),
 			Arc::clone(&self.connection_manager),
-			self.liquidity_source.clone(),
+			self.liquidity_source.as_ref().map(|ls| ls.lsps1_client()),
 			Arc::clone(&self.logger),
 		))
 	}
@@ -1949,6 +1973,41 @@ impl Node {
 			Error::PersistenceFailed
 		})
 	}
+
+	/// Configures the [`Node`] instance to source inbound liquidity from the given LSP at runtime,
+	/// without specifying the exact protocol used (e.g., LSPS1 or LSPS2).
+	///
+	/// Will mark the LSP as trusted for 0-confirmation channels, see [`Config::trusted_peers_0conf`].
+	///
+	/// The given `token` will be used by the LSP to authenticate the user.
+	/// This method is useful when the user wants to connect to an LSP but does not want to be concerned with
+	/// the specific protocol used for liquidity provision. The node will automatically detect and use the
+	/// appropriate protocol supported by the LSP.
+	pub fn add_lsp(
+		&self, node_id: PublicKey, address: SocketAddress, token: Option<String>,
+	) -> Result<(), Error> {
+		// Mark the LSP as trusted for 0conf
+		self.config.trusted_peers_0conf.write().unwrap().push(node_id);
+		let liquidity_source =
+			self.liquidity_source.as_ref().ok_or(Error::LiquiditySourceUnavailable)?;
+		let lsp_config = LspConfig { node_id, address, token };
+		liquidity_source.add_lsp_node(lsp_config.clone())?;
+
+		let con_node_id = lsp_config.node_id;
+		let con_addr = lsp_config.address.clone();
+		let con_cm = Arc::clone(&self.connection_manager);
+
+		self.runtime.block_on(async move {
+			con_cm.connect_peer_if_necessary(con_node_id, con_addr).await
+		})?;
+
+		log_info!(self.logger, "Connected to LSP {}@{}. ", lsp_config.node_id, lsp_config.address);
+
+		let node_id = lsp_config.node_id;
+		self.runtime
+			.block_on(async move { liquidity_source.discover_lsp_protocols(&node_id).await })?;
+		Ok(())
+	}
 }
 
 impl Drop for Node {