Support client_trusts_lsp=true on ldk-node

implement changes introduced on lightningdevkit/rust-lightning#3838
as discussed, client_trusts_lsp is a flag set at startup.
a new function receive_via_jit_channel_manual_claim is introduced to bolt11 so we allow the client to
manually claim a payment (used on tests).

Author: martinsaposnic

bindings/ldk_node.udl

@@ -44,6 +44,7 @@ dictionary LSPS2ServiceConfig {
 	u32 max_client_to_self_delay;
 	u64 min_payment_size_msat;
 	u64 max_payment_size_msat;
+	boolean client_trusts_lsp;
 };
 
 enum LogLevel {
@@ -197,6 +198,13 @@ interface Bolt11Payment {
 	Bolt11Invoice receive_variable_amount_via_jit_channel([ByRef]Bolt11InvoiceDescription description, u32 expiry_secs, u64? max_proportional_lsp_fee_limit_ppm_msat);
 	[Throws=NodeError]
 	Bolt11Invoice receive_variable_amount_via_jit_channel_for_hash([ByRef]Bolt11InvoiceDescription description, u32 expiry_secs, u64? max_proportional_lsp_fee_limit_ppm_msat, PaymentHash payment_hash);
+	[Throws=NodeError]
+	JitChannelManualClaim receive_via_jit_channel_manual_claim(u64 amount_msat, [ByRef]Bolt11InvoiceDescription description, u32 expiry_secs, u64? max_total_lsp_fee_limit_msat);
+};
+
+dictionary JitChannelManualClaim {
+    Bolt11Invoice invoice;
+    PaymentPreimage preimage;
 };
 
 interface Bolt12Payment {

src/builder.rs

@@ -1613,6 +1613,7 @@ fn build_with_store_internal(
 				Arc::clone(&kv_store),
 				Arc::clone(&config),
 				Arc::clone(&logger),
+				Arc::clone(&tx_broadcaster),
 			);
 
 			lsc.lsps1_client.as_ref().map(|config| {

src/event.rs

@@ -487,7 +487,7 @@ where
 				counterparty_node_id,
 				channel_value_satoshis,
 				output_script,
-				..
+				user_channel_id,
 			} => {
 				// Construct the raw transaction with the output that is paid the amount of the
 				// channel.
@@ -506,12 +506,43 @@ where
 					locktime,
 				) {
 					Ok(final_tx) => {
-						// Give the funding transaction back to LDK for opening the channel.
-						match self.channel_manager.funding_transaction_generated(
-							temporary_channel_id,
-							counterparty_node_id,
-							final_tx,
-						) {
+						let needs_manual_broadcast =
+							match self.liquidity_source.as_ref().map(|ls| {
+								ls.as_ref().lsps2_channel_needs_manual_broadcast(
+									counterparty_node_id,
+									user_channel_id,
+								)
+							}) {
+								Some(Ok(v)) => v,
+								Some(Err(e)) => {
+									log_error!(self.logger, "Failed to determine if channel needs manual broadcast: {:?}", e);
+									false
+								},
+								None => false,
+							};
+
+						let result = if needs_manual_broadcast {
+							self.liquidity_source.as_ref().map(|ls| {
+								ls.lsps2_store_funding_transaction(
+									user_channel_id,
+									counterparty_node_id,
+									final_tx.clone(),
+								);
+							});
+							self.channel_manager.funding_transaction_generated_manual_broadcast(
+								temporary_channel_id,
+								counterparty_node_id,
+								final_tx,
+							)
+						} else {
+							self.channel_manager.funding_transaction_generated(
+								temporary_channel_id,
+								counterparty_node_id,
+								final_tx,
+							)
+						};
+
+						match result {
 							Ok(()) => {},
 							Err(APIError::APIMisuseError { err }) => {
 								log_error!(self.logger, "Panicking due to APIMisuseError: {}", err);
@@ -550,8 +581,10 @@ where
 					},
 				}
 			},
-			LdkEvent::FundingTxBroadcastSafe { .. } => {
-				debug_assert!(false, "We currently only support safe funding, so this event should never be emitted.");
+			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);
+				});
 			},
 			LdkEvent::PaymentClaimable {
 				payment_hash,
@@ -676,7 +709,7 @@ where
 					match info.kind {
 						PaymentKind::Bolt11 { preimage, .. }
 						| PaymentKind::Bolt11Jit { preimage, .. } => {
-							if purpose.preimage().is_none() {
+							if preimage.is_none() || purpose.preimage().is_none() {
 								debug_assert!(
 									preimage.is_none(),
 									"We would have registered the preimage if we knew"

src/ffi/types.rs

@@ -1164,6 +1164,15 @@ impl UniffiCustomTypeConverter for LSPSDateTime {
 	}
 }
 
+/// A payable invoice and its corresponding preimage for manual claiming via a JIT channel.
+#[derive(Debug, Clone)]
+pub struct JitChannelManualClaim {
+	/// The payable invoice.
+	pub invoice: Arc<Bolt11Invoice>,
+	/// The payment preimage.
+	pub preimage: PaymentPreimage,
+}
+
 #[cfg(test)]
 mod tests {
 	use std::num::NonZeroU64;

src/liquidity.rs

@@ -51,7 +51,6 @@ use crate::{total_anchor_channels_reserve_sats, Config, Error};
 const LIQUIDITY_REQUEST_TIMEOUT_SECS: u64 = 5;
 
 const LSPS2_GETINFO_REQUEST_EXPIRY: Duration = Duration::from_secs(60 * 60 * 24);
-const LSPS2_CLIENT_TRUSTS_LSP_MODE: bool = true;
 const LSPS2_CHANNEL_CLTV_EXPIRY_DELTA: u32 = 72;
 
 struct LSPS1Client {
@@ -130,6 +129,8 @@ pub struct LSPS2ServiceConfig {
 	pub min_payment_size_msat: u64,
 	/// The maximum payment size that we will accept when opening a channel.
 	pub max_payment_size_msat: u64,
+	/// Use the client trusts lsp model
+	pub client_trusts_lsp: bool,
 }
 
 pub(crate) struct LiquiditySourceBuilder<L: Deref>
@@ -147,6 +148,7 @@ where
 	kv_store: Arc<DynStore>,
 	config: Arc<Config>,
 	logger: L,
+	broadcaster: Arc<Broadcaster>,
 }
 
 impl<L: Deref> LiquiditySourceBuilder<L>
@@ -155,8 +157,12 @@ where
 {
 	pub(crate) fn new(
 		wallet: Arc<Wallet>, channel_manager: Arc<ChannelManager>, keys_manager: Arc<KeysManager>,
-		chain_source: Arc<ChainSource>, tx_broadcaster: Arc<Broadcaster>, kv_store: Arc<DynStore>,
-		config: Arc<Config>, logger: L,
+		chain_source: Arc<ChainSource>, 
+		tx_broadcaster: Arc<Broadcaster>, 
+		kv_store: Arc<DynStore>,
+		config: Arc<Config>, 
+		logger: L,
+		broadcaster: Arc<Broadcaster>,
 	) -> Self {
 		let lsps1_client = None;
 		let lsps2_client = None;
@@ -173,6 +179,7 @@ where
 			kv_store,
 			config,
 			logger,
+			broadcaster,
 		}
 	}
 
@@ -305,6 +312,79 @@ where
 		self.lsps2_client.as_ref().map(|s| (s.lsp_node_id, s.lsp_address.clone()))
 	}
 
+	pub(crate) fn lsps2_channel_needs_manual_broadcast(
+		&self, counterparty_node_id: PublicKey, user_channel_id: u128,
+	) -> Result<bool, APIError> {
+		// if we are not in a client_trusts_lsp model, we don't check and just return false
+		if !self.is_client_trusts_lsp() {
+			log_debug!(self.logger, "Skipping funding transaction broadcast as client trusts LSP.");
+			return Ok(false);
+		}
+
+		// if we are in a client_trusts_lsp model, then we check if the LSP has an LSPS2 operation in progress
+		self.lsps2_service.as_ref().map_or(Ok(false), |_| {
+			let lsps2_service_handler = self.liquidity_manager.lsps2_service_handler();
+			if let Some(handler) = lsps2_service_handler {
+				handler.channel_needs_manual_broadcast(user_channel_id, &counterparty_node_id)
+			} else {
+				log_error!(self.logger, "LSPS2 service handler is not available.");
+				Ok(false)
+			}
+		})
+	}
+
+	pub(crate) fn lsps2_store_funding_transaction(
+		&self, user_channel_id: u128, counterparty_node_id: PublicKey, funding_tx: Transaction,
+	) {
+		if !self.is_client_trusts_lsp() {
+			log_debug!(self.logger, "Skipping funding transaction broadcast as client trusts LSP.");
+			return;
+		}
+		self.lsps2_service.as_ref().map(|_| {
+			let lsps2_service_handler = self.liquidity_manager.lsps2_service_handler();
+			if let Some(handler) = lsps2_service_handler {
+				handler
+					.store_funding_transaction(user_channel_id, &counterparty_node_id, funding_tx)
+					.unwrap_or_else(|e| {
+						debug_assert!(false, "Failed to store funding transaction: {:?}", e);
+						log_error!(self.logger, "Failed to store funding transaction: {:?}", e);
+					});
+			} else {
+				log_error!(self.logger, "LSPS2 service handler is not available.");
+			}
+		});
+	}
+
+	pub(crate) fn lsps2_funding_tx_broadcast_safe(
+		&self, user_channel_id: u128, counterparty_node_id: PublicKey,
+	) {
+		if !self.is_client_trusts_lsp() {
+			log_debug!(self.logger, "Skipping funding transaction broadcast as client trusts LSP.");
+			return;
+		}
+		self.lsps2_service.as_ref().map(|_| {
+			let lsps2_service_handler = self.liquidity_manager.lsps2_service_handler();
+			if let Some(handler) = lsps2_service_handler {
+				handler
+					.set_funding_tx_broadcast_safe(user_channel_id, &counterparty_node_id)
+					.unwrap_or_else(|e| {
+						debug_assert!(false, "Failed to store funding transaction: {:?}", e);
+						log_error!(self.logger, "Failed to store funding transaction: {:?}", e);
+					});
+			} else {
+				log_error!(self.logger, "LSPS2 service handler is not available.");
+			}
+		});
+	}
+
+	fn is_client_trusts_lsp(&self) -> bool {
+		if let Some(lsps2_service) = self.lsps2_service.as_ref() {
+			lsps2_service.service_config.client_trusts_lsp
+		} else {
+			false
+		}
+	}
+
 	pub(crate) async fn handle_next_event(&self) {
 		match self.liquidity_manager.next_event_async().await {
 			LiquidityEvent::LSPS1Client(LSPS1ClientEvent::SupportedOptionsReady {
@@ -594,7 +674,7 @@ where
 							request_id,
 							intercept_scid,
 							LSPS2_CHANNEL_CLTV_EXPIRY_DELTA,
-							LSPS2_CLIENT_TRUSTS_LSP_MODE,
+							service_config.client_trusts_lsp,,
 							user_channel_id,
 						)
 						.await