Add support for partial updates to LSPS2 service configuration

- Introduced `LSPS2ServiceConfigUpdate` struct for partial updates.
- Updated `LSPS2Service` to use `Arc<RwLock<LSPS2ServiceConfig>>` for thread-safe configuration.
- Implemented `update_lsps2_service_config_partial` method for applying updates.
- Enhanced error handling for unconfigured services and invalid configurations.
- Added integration tests for partial configuration updates.

Author: moisesPompilio

src/error.rs

@@ -121,6 +121,12 @@ pub enum Error {
 	LiquiditySourceUnavailable,
 	/// The given operation failed due to the LSP's required opening fee being too high.
 	LiquidityFeeTooHigh,
+	/// The given LSP2 configuration is invalid.
+	InvalidLSP2Config,
+	/// The LSP2 service is not configured.
+	LSP2ServiceNotConfigured,
+	/// No liquidity source is configured.
+	NoLiquiditySourceConfigured,
 	/// The given blinded paths are invalid.
 	InvalidBlindedPaths,
 	/// Asynchronous payment services are disabled.
@@ -198,6 +204,9 @@ impl fmt::Display for Error {
 			Self::LiquidityFeeTooHigh => {
 				write!(f, "The given operation failed due to the LSP's required opening fee being too high.")
 			},
+			Self::InvalidLSP2Config => write!(f, "The given LSP2 configuration is invalid."),
+			Self::LSP2ServiceNotConfigured => write!(f, "The LSP2 service is not configured."),
+			Self::NoLiquiditySourceConfigured => write!(f, "No liquidity source is configured."),
 			Self::InvalidBlindedPaths => write!(f, "The given blinded paths are invalid."),
 			Self::AsyncPaymentServicesDisabled => {
 				write!(f, "Asynchronous payment services are disabled.")

src/lib.rs

@@ -963,6 +963,18 @@ impl Node {
 		))
 	}
 
+	/// Updates the LSPS2 service configuration with the provided partial update.
+	///
+	/// Returns an error if no liquidity source is configured.
+	pub fn lsps2_update_service_config(
+		&self, config_update: liquidity::LSPS2ServiceConfigUpdate,
+	) -> Result<(), Error> {
+		match self.liquidity_source.as_ref() {
+			Some(ls) => ls.lsps2_update_service_config(config_update),
+			None => Err(Error::NoLiquiditySourceConfigured),
+		}
+	}
+
 	/// Retrieve a list of known channels.
 	pub fn list_channels(&self) -> Vec<ChannelDetails> {
 		self.channel_manager.list_channels().into_iter().map(|c| c.into()).collect()

src/liquidity.rs

@@ -90,7 +90,7 @@ pub(crate) struct LSPS2ClientConfig {
 }
 
 struct LSPS2Service {
-	service_config: LSPS2ServiceConfig,
+	service_config: Arc<RwLock<LSPS2ServiceConfig>>,
 	ldk_service_config: LdkLSPS2ServiceConfig,
 }
 
@@ -132,6 +132,60 @@ pub struct LSPS2ServiceConfig {
 	pub max_payment_size_msat: u64,
 }
 
+/// Represents a partial update to the LSPS2 service configuration.
+///
+/// Only fields set to `Some` will be updated; fields set to `None` will be ignored.
+#[derive(Debug, Clone, Default)]
+pub struct LSPS2ServiceConfigUpdate {
+	/// Update the required token (None to remove, Some to set).
+	pub require_token: Option<Option<String>>,
+	/// Update the channel opening fee in parts-per-million.
+	pub channel_opening_fee_ppm: Option<u32>,
+	/// Update the proportional overprovisioning for the channel.
+	pub channel_over_provisioning_ppm: Option<u32>,
+	/// Update the minimum fee required for opening a channel.
+	pub min_channel_opening_fee_msat: Option<u64>,
+	/// Update the minimum number of blocks to keep the channel open.
+	pub min_channel_lifetime: Option<u32>,
+	/// Update the maximum client to_self_delay.
+	pub max_client_to_self_delay: Option<u32>,
+	/// Update the minimum payment size.
+	pub min_payment_size_msat: Option<u64>,
+	/// Update the maximum payment size.
+	pub max_payment_size_msat: Option<u64>,
+}
+
+impl LSPS2ServiceConfig {
+	/// Applies a partial update to the configuration.
+	/// Only fields present in `update` (i.e., `Some`) will be changed.
+	pub fn apply_update(&mut self, update: LSPS2ServiceConfigUpdate) {
+		if let Some(require_token) = update.require_token {
+			self.require_token = require_token;
+		}
+		if let Some(channel_opening_fee_ppm) = update.channel_opening_fee_ppm {
+			self.channel_opening_fee_ppm = channel_opening_fee_ppm;
+		}
+		if let Some(channel_over_provisioning_ppm) = update.channel_over_provisioning_ppm {
+			self.channel_over_provisioning_ppm = channel_over_provisioning_ppm;
+		}
+		if let Some(min_channel_opening_fee_msat) = update.min_channel_opening_fee_msat {
+			self.min_channel_opening_fee_msat = min_channel_opening_fee_msat;
+		}
+		if let Some(min_channel_lifetime) = update.min_channel_lifetime {
+			self.min_channel_lifetime = min_channel_lifetime;
+		}
+		if let Some(max_client_to_self_delay) = update.max_client_to_self_delay {
+			self.max_client_to_self_delay = max_client_to_self_delay;
+		}
+		if let Some(min_payment_size_msat) = update.min_payment_size_msat {
+			self.min_payment_size_msat = min_payment_size_msat;
+		}
+		if let Some(max_payment_size_msat) = update.max_payment_size_msat {
+			self.max_payment_size_msat = max_payment_size_msat;
+		}
+	}
+}
+
 pub(crate) struct LiquiditySourceBuilder<L: Deref>
 where
 	L::Target: LdkLogger,
@@ -217,16 +271,29 @@ where
 		&mut self, promise_secret: [u8; 32], service_config: LSPS2ServiceConfig,
 	) -> &mut Self {
 		let ldk_service_config = LdkLSPS2ServiceConfig { promise_secret };
-		self.lsps2_service = Some(LSPS2Service { service_config, ldk_service_config });
+		self.lsps2_service = Some(LSPS2Service {
+			service_config: Arc::new(RwLock::new(service_config)),
+			ldk_service_config,
+		});
 		self
 	}
 
 	pub(crate) async fn build(self) -> Result<LiquiditySource<L>, BuildError> {
-		let liquidity_service_config = self.lsps2_service.as_ref().map(|s| {
+		let liquidity_service_config = self.lsps2_service.as_ref().and_then(|s| {
 			let lsps2_service_config = Some(s.ldk_service_config.clone());
 			let lsps5_service_config = None;
-			let advertise_service = s.service_config.advertise_service;
-			LiquidityServiceConfig { lsps2_service_config, lsps5_service_config, advertise_service }
+			let advertise_service = match s.service_config.read() {
+				Ok(cfg) => cfg.advertise_service,
+				Err(e) => {
+					log_error!(self.logger, "Failed to acquire LSPS2 service config lock: {:?}", e);
+					return None;
+				},
+			};
+			Some(LiquidityServiceConfig {
+				lsps2_service_config,
+				lsps5_service_config,
+				advertise_service,
+			})
 		});
 
 		let lsps1_client_config = self.lsps1_client.as_ref().map(|s| s.ldk_client_config.clone());
@@ -305,6 +372,13 @@ where
 		self.lsps2_client.as_ref().map(|s| (s.lsp_node_id, s.lsp_address.clone()))
 	}
 
+	fn get_lsps2_service_config(&self) -> Option<LSPS2ServiceConfig> {
+		self.lsps2_service
+			.as_ref()
+			.and_then(|s| s.service_config.read().ok())
+			.map(|cfg| cfg.clone()) // Clone to release lock
+	}
+
 	pub(crate) async fn handle_next_event(&self) {
 		match self.liquidity_manager.next_event_async().await {
 			LiquidityEvent::LSPS1Client(LSPS1ClientEvent::SupportedOptionsReady {
@@ -485,7 +559,7 @@ where
 					self.liquidity_manager.lsps2_service_handler().as_ref()
 				{
 					let service_config = if let Some(service_config) =
-						self.lsps2_service.as_ref().map(|s| s.service_config.clone())
+						self.get_lsps2_service_config()
 					{
 						service_config
 					} else {
@@ -554,7 +628,7 @@ where
 					self.liquidity_manager.lsps2_service_handler().as_ref()
 				{
 					let service_config = if let Some(service_config) =
-						self.lsps2_service.as_ref().map(|s| s.service_config.clone())
+						self.get_lsps2_service_config()
 					{
 						service_config
 					} else {
@@ -626,9 +700,7 @@ where
 					return;
 				};
 
-				let service_config = if let Some(service_config) =
-					self.lsps2_service.as_ref().map(|s| s.service_config.clone())
-				{
+				let service_config = if let Some(service_config) = self.get_lsps2_service_config() {
 					service_config
 				} else {
 					log_error!(self.logger, "Failed to handle LSPS2ServiceEvent as LSPS2 liquidity service was not configured.",);
@@ -1000,6 +1072,27 @@ where
 		Ok(response)
 	}
 
+	pub(crate) fn lsps2_update_service_config(
+		&self, update: LSPS2ServiceConfigUpdate,
+	) -> Result<(), Error> {
+		if let Some(lsps2_service) = self.lsps2_service.as_ref() {
+			if let Ok(mut config) = lsps2_service.service_config.write() {
+				config.apply_update(update);
+				log_info!(self.logger, "Partially updated LSPS2 service configuration.");
+				Ok(())
+			} else {
+				log_error!(self.logger, "Failed to acquire LSPS2 service config lock.");
+				Err(Error::InvalidLSP2Config)
+			}
+		} else {
+			log_error!(
+				self.logger,
+				"Failed to update LSPS2 service config as LSPS2 service was not configured."
+			);
+			Err(Error::LSP2ServiceNotConfigured)
+		}
+	}
+
 	pub(crate) async fn lsps2_receive_to_jit_channel(
 		&self, amount_msat: u64, description: &Bolt11InvoiceDescription, expiry_secs: u32,
 		max_total_lsp_fee_limit_msat: Option<u64>, payment_hash: Option<PaymentHash>,

tests/integration_tests_rust.rs

@@ -1741,6 +1741,62 @@ fn lsps2_client_service_integration() {
 
 	expect_event!(payer_node, PaymentFailed);
 	assert_eq!(client_node.payment(&payment_id).unwrap().status, PaymentStatus::Failed);
+
+	////////////////////////////////////////////////////////////////////////////
+	// Test partial configuration updates on the provider side
+	////////////////////////////////////////////////////////////////////////////
+	// Update the channel opening fee to a new value
+	let new_channel_opening_fee_ppm = 20_000;
+	let new_channel_over_provisioning_ppm = 150_000; // Increase overprovisioning to 15%
+	service_node
+		.lsps2_update_service_config(ldk_node::liquidity::LSPS2ServiceConfigUpdate {
+			channel_opening_fee_ppm: Some(new_channel_opening_fee_ppm),
+			channel_over_provisioning_ppm: Some(new_channel_over_provisioning_ppm),
+			..Default::default()
+		})
+		.unwrap();
+
+	// Generate a new JIT invoice to test the updated fees
+	let jit_amount_msat = 150_000_000;
+	let jit_invoice = client_node
+		.bolt11_payment()
+		.receive_via_jit_channel(jit_amount_msat, &invoice_description.into(), 1024, None)
+		.unwrap();
+
+	// Pay the invoice and check if the new fee is applied
+	let payment_id = payer_node.bolt11_payment().send(&jit_invoice, None).unwrap();
+	let funding_txo = expect_channel_pending_event!(service_node, client_node.node_id());
+	expect_channel_ready_event!(service_node, client_node.node_id());
+	expect_event!(service_node, PaymentForwarded);
+	expect_channel_pending_event!(client_node, service_node.node_id());
+	expect_channel_ready_event!(client_node, service_node.node_id());
+
+	// Calculate expected fee with the new rate
+	let new_service_fee_msat = (jit_amount_msat * new_channel_opening_fee_ppm as u64) / 1_000_000;
+	let expected_received_amount_msat = jit_amount_msat - new_service_fee_msat;
+	expect_payment_successful_event!(payer_node, Some(payment_id), None);
+	let client_payment_id =
+		expect_payment_received_event!(client_node, expected_received_amount_msat).unwrap();
+	let client_payment = client_node.payment(&client_payment_id).unwrap();
+	match client_payment.kind {
+		PaymentKind::Bolt11Jit { counterparty_skimmed_fee_msat, .. } => {
+			assert_eq!(counterparty_skimmed_fee_msat, Some(new_service_fee_msat));
+		},
+		_ => panic!("Unexpected payment kind"),
+	}
+
+	// Check if the new overprovisioning is applied
+	let expected_channel_overprovisioning_msat =
+		(expected_received_amount_msat * new_channel_over_provisioning_ppm as u64) / 1_000_000;
+	let expected_channel_size_sat =
+		(expected_received_amount_msat + expected_channel_overprovisioning_msat) / 1000;
+	let channel_value_sats = client_node
+		.list_channels()
+		.iter()
+		.find(|c| c.funding_txo == Some(funding_txo))
+		.unwrap()
+		.channel_value_sats;
+	assert_eq!(channel_value_sats, expected_channel_size_sat);
 }
 
 #[test]