diff --git a/fuzz/src/lsps_message.rs b/fuzz/src/lsps_message.rs
index 299b9f07955..7ca15e05eeb 100644
--- a/fuzz/src/lsps_message.rs
+++ b/fuzz/src/lsps_message.rs
@@ -82,6 +82,7 @@ pub fn do_test(data: &[u8]) {
 		Arc::clone(&keys_manager),
 		Arc::clone(&manager),
 		None::<Arc<dyn Filter + Send + Sync>>,
+		Arc::clone(&tx_broadcaster),
 		None,
 		None,
 		None,
diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs
index 1376f43a349..47635c83ca4 100644
--- a/lightning-background-processor/src/lib.rs
+++ b/lightning-background-processor/src/lib.rs
@@ -631,7 +631,7 @@ use futures_util::{dummy_waker, Joiner, OptionalSelector, Selector, SelectorOutp
 /// # type P2PGossipSync<UL> = lightning::routing::gossip::P2PGossipSync<Arc<NetworkGraph>, Arc<UL>, Arc<Logger>>;
 /// # type ChannelManager<B, F, FE> = lightning::ln::channelmanager::SimpleArcChannelManager<ChainMonitor<B, F, FE>, B, FE, Logger>;
 /// # type OnionMessenger<B, F, FE> = lightning::onion_message::messenger::OnionMessenger<Arc<lightning::sign::KeysManager>, Arc<lightning::sign::KeysManager>, Arc<Logger>, Arc<ChannelManager<B, F, FE>>, Arc<lightning::onion_message::messenger::DefaultMessageRouter<Arc<NetworkGraph>, Arc<Logger>, Arc<lightning::sign::KeysManager>>>, Arc<ChannelManager<B, F, FE>>, lightning::ln::peer_handler::IgnoringMessageHandler, lightning::ln::peer_handler::IgnoringMessageHandler, lightning::ln::peer_handler::IgnoringMessageHandler>;
-/// # type LiquidityManager<B, F, FE> = lightning_liquidity::LiquidityManager<Arc<lightning::sign::KeysManager>, Arc<lightning::sign::KeysManager>, Arc<ChannelManager<B, F, FE>>, Arc<F>, Arc<DefaultTimeProvider>>;
+/// # type LiquidityManager<B, F, FE> = lightning_liquidity::LiquidityManager<Arc<lightning::sign::KeysManager>, Arc<lightning::sign::KeysManager>, Arc<ChannelManager<B, F, FE>>, Arc<F>, Arc<DefaultTimeProvider>, Arc<B>>;
 /// # type Scorer = RwLock<lightning::routing::scoring::ProbabilisticScorer<Arc<NetworkGraph>, Arc<Logger>>>;
 /// # type PeerManager<B, F, FE, UL> = lightning::ln::peer_handler::SimpleArcPeerManager<SocketDescriptor, ChainMonitor<B, F, FE>, B, FE, Arc<UL>, Logger, F, StoreSync>;
 /// # type OutputSweeper<B, D, FE, F, O> = lightning::util::sweep::OutputSweeper<Arc<B>, Arc<D>, Arc<FE>, Arc<F>, Arc<Store>, Arc<Logger>, Arc<O>>;
@@ -1796,6 +1796,7 @@ mod tests {
 		Arc<ChannelManager>,
 		Arc<dyn Filter + Sync + Send>,
 		Arc<DefaultTimeProvider>,
+		Arc<test_utils::TestBroadcaster>,
 	>;
 
 	struct Node {
@@ -2247,6 +2248,7 @@ mod tests {
 				Arc::clone(&keys_manager),
 				Arc::clone(&manager),
 				None,
+				Arc::clone(&tx_broadcaster),
 				None,
 				None,
 				None,
diff --git a/lightning-liquidity/src/lsps2/event.rs b/lightning-liquidity/src/lsps2/event.rs
index f738dc0d7bc..4af1efe76c0 100644
--- a/lightning-liquidity/src/lsps2/event.rs
+++ b/lightning-liquidity/src/lsps2/event.rs
@@ -160,4 +160,23 @@ pub enum LSPS2ServiceEvent {
 		/// The intercept short channel id to use in the route hint.
 		intercept_scid: u64,
 	},
+	/// You should broadcast the funding transaction to finalize opening the channel.
+	///
+	/// This event is emitted once both [`Event::FundingTxBroadcastSafe`] and the
+	/// corresponding payment has been successfully claimed.
+	///
+	/// Call [`LSPS2ServiceHandler::broadcast_transaction`] with the funding
+	/// transaction to publish it on-chain.
+	///
+	/// [`Event::FundingTxBroadcastSafe`]: lightning::events::Event::FundingTxBroadcastSafe
+	/// [`Event::PaymentClaimed`]: lightning::events::Event::PaymentClaimed
+	/// [`LSPS2ServiceHandler::broadcast_transaction`]: crate::lsps2::service::LSPS2ServiceHandler::broadcast_transaction
+	BroadcastFundingTransaction {
+		/// The node id of the counterparty.
+		counterparty_node_id: PublicKey,
+		/// The user channel id that was used to open the channel.
+		user_channel_id: u128,
+		/// The funding transaction to broadcast.
+		funding_tx: bitcoin::Transaction,
+	},
 }
diff --git a/lightning-liquidity/src/lsps2/msgs.rs b/lightning-liquidity/src/lsps2/msgs.rs
index 2a01d6ee32f..17882667e0c 100644
--- a/lightning-liquidity/src/lsps2/msgs.rs
+++ b/lightning-liquidity/src/lsps2/msgs.rs
@@ -168,7 +168,14 @@ pub struct LSPS2BuyResponse {
 	pub jit_channel_scid: LSPS2InterceptScid,
 	/// The locktime expiry delta the lsp requires.
 	pub lsp_cltv_expiry_delta: u32,
-	/// A flag that indicates who is trusting who.
+	/// Trust model flag (default: false).
+	///
+	/// false => "LSP trusts client": LSP immediately (or as soon as safe) broadcasts the
+	///          funding transaction; client may wait for broadcast / confirmations
+	///          before revealing the preimage.
+	/// true  => "Client trusts LSP": LSP may defer broadcasting until after the client
+	///          reveals the preimage; client MUST send the preimage once HTLC(s) are
+	///          irrevocably committed.
 	#[serde(default)]
 	pub client_trusts_lsp: bool,
 }
diff --git a/lightning-liquidity/src/lsps2/service.rs b/lightning-liquidity/src/lsps2/service.rs
index 114ed8b250d..5cdeca6eff1 100644
--- a/lightning-liquidity/src/lsps2/service.rs
+++ b/lightning-liquidity/src/lsps2/service.rs
@@ -32,6 +32,7 @@ use crate::prelude::hash_map::Entry;
 use crate::prelude::{new_hash_map, HashMap};
 use crate::sync::{Arc, Mutex, MutexGuard, RwLock};
 
+use lightning::chain::chaininterface::BroadcasterInterface;
 use lightning::events::HTLCHandlingFailureType;
 use lightning::ln::channelmanager::{AChannelManager, FailureCode, InterceptId};
 use lightning::ln::msgs::{ErrorAction, LightningError};
@@ -42,6 +43,7 @@ use lightning::util::logger::Level;
 use lightning_types::payment::PaymentHash;
 
 use bitcoin::secp256k1::PublicKey;
+use bitcoin::Transaction;
 
 use crate::lsps2::msgs::{
 	LSPS2BuyRequest, LSPS2BuyResponse, LSPS2GetInfoRequest, LSPS2GetInfoResponse, LSPS2Message,
@@ -107,6 +109,68 @@ struct ForwardPaymentAction(ChannelId, FeePayment);
 #[derive(Debug, PartialEq)]
 struct ForwardHTLCsAction(ChannelId, Vec<InterceptedHTLC>);
 
+#[derive(Debug, Clone)]
+enum TrustModel {
+	ClientTrustsLsp { funding_tx_broadcast_safe: bool, funding_tx: Option<Transaction> },
+	LspTrustsClient,
+}
+
+impl TrustModel {
+	fn should_manually_broadcast(&self, state_is_payment_forward: bool) -> bool {
+		match self {
+			TrustModel::ClientTrustsLsp { funding_tx_broadcast_safe, funding_tx } => {
+				*funding_tx_broadcast_safe && state_is_payment_forward && funding_tx.is_some()
+			},
+			// in lsp-trusts-client, the broadcast is automatic, so we never need to manually broadcast.
+			TrustModel::LspTrustsClient => false,
+		}
+	}
+
+	fn new(client_trusts_lsp: bool) -> Self {
+		if client_trusts_lsp {
+			TrustModel::ClientTrustsLsp { funding_tx_broadcast_safe: false, funding_tx: None }
+		} else {
+			TrustModel::LspTrustsClient
+		}
+	}
+
+	fn set_funding_tx(&mut self, funding_tx: Transaction) {
+		match self {
+			TrustModel::ClientTrustsLsp { funding_tx: tx, .. } => {
+				*tx = Some(funding_tx);
+			},
+			TrustModel::LspTrustsClient => {
+				// No-op
+			},
+		}
+	}
+
+	fn set_funding_tx_broadcast_safe(&mut self, funding_tx_broadcast_safe: bool) {
+		match self {
+			TrustModel::ClientTrustsLsp { funding_tx_broadcast_safe: safe, .. } => {
+				*safe = funding_tx_broadcast_safe;
+			},
+			TrustModel::LspTrustsClient => {
+				// No-op
+			},
+		}
+	}
+
+	fn get_funding_tx(&self) -> Option<Transaction> {
+		match self {
+			TrustModel::ClientTrustsLsp { funding_tx, .. } => funding_tx.clone(),
+			_ => None,
+		}
+	}
+
+	fn is_client_trusts_lsp(&self) -> bool {
+		match self {
+			TrustModel::ClientTrustsLsp { .. } => true,
+			TrustModel::LspTrustsClient => false,
+		}
+	}
+}
+
 /// The different states a requested JIT channel can be in.
 #[derive(Debug)]
 enum OutboundJITChannelState {
@@ -350,15 +414,29 @@ impl OutboundJITChannelState {
 		}
 	}
 
-	fn payment_forwarded(&mut self) -> Result<Option<ForwardHTLCsAction>, ChannelStateError> {
+	fn payment_forwarded(
+		&mut self, skimmed_fee_msat: Option<u64>,
+	) -> Result<Option<ForwardHTLCsAction>, ChannelStateError> {
 		match self {
 			OutboundJITChannelState::PendingPaymentForward {
-				payment_queue, channel_id, ..
-			} => {
-				let mut payment_queue = core::mem::take(payment_queue);
-				let forward_htlcs = ForwardHTLCsAction(*channel_id, payment_queue.clear());
-				*self = OutboundJITChannelState::PaymentForwarded { channel_id: *channel_id };
-				Ok(Some(forward_htlcs))
+				payment_queue,
+				channel_id,
+				opening_fee_msat,
+			} => match skimmed_fee_msat {
+				Some(skimmed) if skimmed >= *opening_fee_msat => {
+					let mut pq = core::mem::take(payment_queue);
+					let forward_htlcs = ForwardHTLCsAction(*channel_id, pq.clear());
+					*self = OutboundJITChannelState::PaymentForwarded { channel_id: *channel_id };
+					Ok(Some(forward_htlcs))
+				},
+				Some(_) | None => {
+					*self = OutboundJITChannelState::PendingPaymentForward {
+						payment_queue: core::mem::take(payment_queue),
+						opening_fee_msat: *opening_fee_msat,
+						channel_id: *channel_id,
+					};
+					Ok(None)
+				},
 			},
 			OutboundJITChannelState::PaymentForwarded { channel_id } => {
 				*self = OutboundJITChannelState::PaymentForwarded { channel_id: *channel_id };
@@ -377,18 +455,20 @@ struct OutboundJITChannel {
 	user_channel_id: u128,
 	opening_fee_params: LSPS2OpeningFeeParams,
 	payment_size_msat: Option<u64>,
+	trust_model: TrustModel,
 }
 
 impl OutboundJITChannel {
 	fn new(
 		payment_size_msat: Option<u64>, opening_fee_params: LSPS2OpeningFeeParams,
-		user_channel_id: u128,
+		user_channel_id: u128, client_trusts_lsp: bool,
 	) -> Self {
 		Self {
 			user_channel_id,
 			state: OutboundJITChannelState::new(),
 			opening_fee_params,
 			payment_size_msat,
+			trust_model: TrustModel::new(client_trusts_lsp),
 		}
 	}
 
@@ -412,8 +492,10 @@ impl OutboundJITChannel {
 		Ok(action)
 	}
 
-	fn payment_forwarded(&mut self) -> Result<Option<ForwardHTLCsAction>, LightningError> {
-		let action = self.state.payment_forwarded()?;
+	fn payment_forwarded(
+		&mut self, skimmed_fee_msat: Option<u64>,
+	) -> Result<Option<ForwardHTLCsAction>, LightningError> {
+		let action = self.state.payment_forwarded(skimmed_fee_msat)?;
 		Ok(action)
 	}
 
@@ -427,6 +509,29 @@ impl OutboundJITChannel {
 		let is_expired = is_expired_opening_fee_params(&self.opening_fee_params);
 		self.is_pending_initial_payment() && is_expired
 	}
+
+	fn set_funding_tx(&mut self, funding_tx: Transaction) {
+		self.trust_model.set_funding_tx(funding_tx);
+	}
+
+	fn set_funding_tx_broadcast_safe(&mut self, funding_tx_broadcast_safe: bool) {
+		self.trust_model.set_funding_tx_broadcast_safe(funding_tx_broadcast_safe);
+	}
+
+	fn should_broadcast_funding_transaction(&self) -> bool {
+		self.trust_model.should_manually_broadcast(matches!(
+			self.state,
+			OutboundJITChannelState::PaymentForwarded { .. }
+		))
+	}
+
+	fn get_funding_tx(&self) -> Option<Transaction> {
+		self.trust_model.get_funding_tx()
+	}
+
+	fn is_client_trusts_lsp(&self) -> bool {
+		self.trust_model.is_client_trusts_lsp()
+	}
 }
 
 struct PeerState {
@@ -526,11 +631,13 @@ macro_rules! get_or_insert_peer_state_entry {
 }
 
 /// The main object allowing to send and receive bLIP-52 / LSPS2 messages.
-pub struct LSPS2ServiceHandler<CM: Deref>
+pub struct LSPS2ServiceHandler<CM: Deref, T: Deref>
 where
 	CM::Target: AChannelManager,
+	T::Target: BroadcasterInterface,
 {
 	channel_manager: CM,
+	tx_broadcaster: T,
 	pending_messages: Arc<MessageQueue>,
 	pending_events: Arc<EventQueue>,
 	per_peer_state: RwLock<HashMap<PublicKey, Mutex<PeerState>>>,
@@ -540,14 +647,15 @@ where
 	config: LSPS2ServiceConfig,
 }
 
-impl<CM: Deref> LSPS2ServiceHandler<CM>
+impl<CM: Deref, T: Deref> LSPS2ServiceHandler<CM, T>
 where
 	CM::Target: AChannelManager,
+	T::Target: BroadcasterInterface,
 {
 	/// Constructs a `LSPS2ServiceHandler`.
 	pub(crate) fn new(
 		pending_messages: Arc<MessageQueue>, pending_events: Arc<EventQueue>, channel_manager: CM,
-		config: LSPS2ServiceConfig,
+		tx_broadcaster: T, config: LSPS2ServiceConfig,
 	) -> Self {
 		Self {
 			pending_messages,
@@ -557,6 +665,7 @@ where
 			peer_by_channel_id: RwLock::new(new_hash_map()),
 			total_pending_requests: AtomicUsize::new(0),
 			channel_manager,
+			tx_broadcaster,
 			config,
 		}
 	}
@@ -666,6 +775,12 @@ where
 	///
 	/// Should be called in response to receiving a [`LSPS2ServiceEvent::BuyRequest`] event.
 	///
+	/// `client_trusts_lsp`:
+	/// * false (default) => "LSP trusts client": LSP broadcasts the funding
+	///   transaction as soon as it is safe and forwards the payment normally.
+	/// * true => "Client trusts LSP": LSP may defer broadcasting the funding
+	///   transaction until after the client claims the forwarded HTLC(s).
+	///
 	/// [`ChannelManager::get_intercept_scid`]: lightning::ln::channelmanager::ChannelManager::get_intercept_scid
 	/// [`LSPS2ServiceEvent::BuyRequest`]: crate::lsps2::event::LSPS2ServiceEvent::BuyRequest
 	pub fn invoice_parameters_generated(
@@ -692,6 +807,7 @@ where
 							buy_request.payment_size_msat,
 							buy_request.opening_fee_params,
 							user_channel_id,
+							client_trusts_lsp,
 						);
 
 						peer_state_lock
@@ -883,15 +999,22 @@ where
 	/// Forward [`Event::PaymentForwarded`] event parameter into this function.
 	///
 	/// Will register the forwarded payment as having paid the JIT channel fee, and forward any held
-	/// and future HTLCs for the SCID of the initial invoice. In the future, this will verify the
-	/// `skimmed_fee_msat` in [`Event::PaymentForwarded`].
+	/// and future HTLCs for the SCID of the initial invoice.
+	///
+	/// When the reported skimmed fee equals or exceeds the promised opening fee, any HTLCs that
+	/// were being held for that JIT channel are forwarded. In a `client_trusts_lsp` flow, once
+	/// the fee has been fully paid a [`LSPS2ServiceEvent::BroadcastFundingTransaction`] will be emitted so the
+	/// caller can broadcast it.
 	///
 	/// Note that `next_channel_id` is required to be provided. Therefore, the corresponding
 	/// [`Event::PaymentForwarded`] events need to be generated and serialized by LDK versions
 	/// greater or equal to 0.0.107.
 	///
 	/// [`Event::PaymentForwarded`]: lightning::events::Event::PaymentForwarded
-	pub fn payment_forwarded(&self, next_channel_id: ChannelId) -> Result<(), APIError> {
+	/// [`Event::BroadcastFundingTransaction`]: crate::lsps2::event::LSPS2ServiceEvent::BroadcastFundingTransaction
+	pub fn payment_forwarded(
+		&self, next_channel_id: ChannelId, skimmed_fee_msat: Option<u64>,
+	) -> Result<(), APIError> {
 		if let Some(counterparty_node_id) =
 			self.peer_by_channel_id.read().unwrap().get(&next_channel_id)
 		{
@@ -905,7 +1028,7 @@ where
 						if let Some(jit_channel) =
 							peer_state.outbound_channels_by_intercept_scid.get_mut(&intercept_scid)
 						{
-							match jit_channel.payment_forwarded() {
+							match jit_channel.payment_forwarded(skimmed_fee_msat) {
 								Ok(Some(ForwardHTLCsAction(channel_id, htlcs))) => {
 									for htlc in htlcs {
 										self.channel_manager.get_cm().forward_intercepted_htlc(
@@ -926,6 +1049,11 @@ where
 									})
 								},
 							}
+
+							self.emit_broadcast_funding_transaction_event_if_applies(
+								jit_channel,
+								counterparty_node_id,
+							);
 						}
 					} else {
 						return Err(APIError::APIMisuseError {
@@ -1412,11 +1540,157 @@ where
 			peer_state_lock.is_prunable() == false
 		});
 	}
+
+	/// Checks if the JIT channel with the given `user_channel_id` needs manual broadcast.
+	/// Will be true if client_trusts_lsp is set to true
+	pub fn channel_needs_manual_broadcast(
+		&self, user_channel_id: u128, counterparty_node_id: &PublicKey,
+	) -> Result<bool, APIError> {
+		let outer_state_lock = self.per_peer_state.read().unwrap();
+		let inner_state_lock =
+			outer_state_lock.get(counterparty_node_id).ok_or_else(|| APIError::APIMisuseError {
+				err: format!("No counterparty state for: {}", counterparty_node_id),
+			})?;
+		let peer_state = inner_state_lock.lock().unwrap();
+
+		let intercept_scid = peer_state
+			.intercept_scid_by_user_channel_id
+			.get(&user_channel_id)
+			.copied()
+			.ok_or_else(|| APIError::APIMisuseError {
+				err: format!("Could not find a channel with user_channel_id {}", user_channel_id),
+			})?;
+
+		let jit_channel = peer_state
+			.outbound_channels_by_intercept_scid
+			.get(&intercept_scid)
+			.ok_or_else(|| APIError::APIMisuseError {
+				err: format!(
+					"Failed to map intercept_scid {} for user_channel_id {} to a channel.",
+					intercept_scid, user_channel_id,
+				),
+			})?;
+
+		Ok(jit_channel.is_client_trusts_lsp())
+	}
+
+	/// Called to store the funding transaction for a JIT channel.
+	/// This should be called when the funding transaction is created but before it's broadcast.
+	pub fn store_funding_transaction(
+		&self, user_channel_id: u128, counterparty_node_id: &PublicKey, funding_tx: Transaction,
+	) -> Result<(), APIError> {
+		let outer_state_lock = self.per_peer_state.read().unwrap();
+		let inner_state_lock =
+			outer_state_lock.get(counterparty_node_id).ok_or_else(|| APIError::APIMisuseError {
+				err: format!("No counterparty state for: {}", counterparty_node_id),
+			})?;
+		let mut peer_state = inner_state_lock.lock().unwrap();
+
+		let intercept_scid = peer_state
+			.intercept_scid_by_user_channel_id
+			.get(&user_channel_id)
+			.copied()
+			.ok_or_else(|| APIError::APIMisuseError {
+				err: format!("Could not find a channel with user_channel_id {}", user_channel_id),
+			})?;
+
+		let jit_channel = peer_state
+			.outbound_channels_by_intercept_scid
+			.get_mut(&intercept_scid)
+			.ok_or_else(|| APIError::APIMisuseError {
+			err: format!(
+				"Failed to map intercept_scid {} for user_channel_id {} to a channel.",
+				intercept_scid, user_channel_id,
+			),
+		})?;
+
+		jit_channel.set_funding_tx(funding_tx);
+
+		self.emit_broadcast_funding_transaction_event_if_applies(jit_channel, counterparty_node_id);
+		Ok(())
+	}
+
+	/// Marks that the funding transaction for the JIT channel identified by `user_channel_id`
+	/// is now safe to broadcast.
+	///
+	/// In LDK call this when you receive [`Event::FundingTxBroadcastSafe`]. In other Lightning
+	/// backends call it once the funding transaction is fully negotiated and signed (all
+	/// signatures verified), your channel state machine will now proceed assuming the funding
+	/// transaction will confirm, and you are intentionally deferring the actual broadcast so
+	/// the LSPS2 flow (when `client_trusts_lsp = true`) can first collect the opening fee from
+	/// the intercepted payment.
+	///
+	/// After this is set, in a `client_trusts_lsp` flow the handler will emit
+	/// [`LSPS2ServiceEvent::BroadcastFundingTransaction`] once the opening fee has been fully
+	/// skimmed.
+	///
+	/// [`Event::FundingTxBroadcastSafe`]: lightning::events::Event::FundingTxBroadcastSafe
+	/// [`LSPS2ServiceEvent::BroadcastFundingTransaction`]: crate::lsps2::event::LSPS2ServiceEvent::BroadcastFundingTransaction
+	pub fn set_funding_tx_broadcast_safe(
+		&self, user_channel_id: u128, counterparty_node_id: &PublicKey,
+	) -> Result<(), APIError> {
+		let outer_state_lock = self.per_peer_state.read().unwrap();
+		let inner_state_lock =
+			outer_state_lock.get(counterparty_node_id).ok_or_else(|| APIError::APIMisuseError {
+				err: format!("No counterparty state for: {}", counterparty_node_id),
+			})?;
+		let mut peer_state = inner_state_lock.lock().unwrap();
+
+		let intercept_scid = peer_state
+			.intercept_scid_by_user_channel_id
+			.get(&user_channel_id)
+			.copied()
+			.ok_or_else(|| APIError::APIMisuseError {
+				err: format!("Could not find a channel with user_channel_id {}", user_channel_id),
+			})?;
+
+		let jit_channel = peer_state
+			.outbound_channels_by_intercept_scid
+			.get_mut(&intercept_scid)
+			.ok_or_else(|| APIError::APIMisuseError {
+			err: format!(
+				"Failed to map intercept_scid {} for user_channel_id {} to a channel.",
+				intercept_scid, user_channel_id,
+			),
+		})?;
+
+		jit_channel.set_funding_tx_broadcast_safe(true);
+
+		self.emit_broadcast_funding_transaction_event_if_applies(jit_channel, counterparty_node_id);
+		Ok(())
+	}
+
+	fn emit_broadcast_funding_transaction_event_if_applies(
+		&self, jit_channel: &OutboundJITChannel, counterparty_node_id: &PublicKey,
+	) {
+		if jit_channel.should_broadcast_funding_transaction() {
+			let funding_tx = jit_channel.get_funding_tx();
+
+			if let Some(funding_tx) = funding_tx {
+				let event_queue_notifier = self.pending_events.notifier();
+				let event = LSPS2ServiceEvent::BroadcastFundingTransaction {
+					counterparty_node_id: *counterparty_node_id,
+					user_channel_id: jit_channel.user_channel_id,
+					funding_tx,
+				};
+				event_queue_notifier.enqueue(event);
+			}
+		}
+	}
+
+	/// Manually broadcast a transaction.
+	///
+	/// This method should only be used when manual control over transaction
+	/// broadcast timing is required (e.g. client_trusts_lsp=true)
+	pub fn broadcast_transaction(&self, tx: &Transaction) {
+		self.tx_broadcaster.broadcast_transactions(&[tx]);
+	}
 }
 
-impl<CM: Deref> LSPSProtocolMessageHandler for LSPS2ServiceHandler<CM>
+impl<CM: Deref, T: Deref> LSPSProtocolMessageHandler for LSPS2ServiceHandler<CM, T>
 where
 	CM::Target: AChannelManager,
+	T::Target: BroadcasterInterface,
 {
 	type ProtocolMessage = LSPS2Message;
 	const PROTOCOL_NUMBER: Option<u16> = Some(2);
@@ -1492,6 +1766,7 @@ mod tests {
 
 	use proptest::prelude::*;
 
+	use bitcoin::{absolute::LockTime, transaction::Version};
 	use core::str::FromStr;
 
 	const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
@@ -1728,7 +2003,7 @@ mod tests {
 		}
 		// Payment completes, queued payments get forwarded.
 		{
-			let action = state.payment_forwarded().unwrap();
+			let action = state.payment_forwarded(Some(100000000000)).unwrap();
 			assert!(matches!(state, OutboundJITChannelState::PaymentForwarded { .. }));
 			match action {
 				Some(ForwardHTLCsAction(channel_id, htlcs)) => {
@@ -1863,7 +2138,7 @@ mod tests {
 		}
 		// Payment completes, queued payments get forwarded.
 		{
-			let action = state.payment_forwarded().unwrap();
+			let action = state.payment_forwarded(Some(10000000000)).unwrap();
 			assert!(matches!(state, OutboundJITChannelState::PaymentForwarded { .. }));
 			match action {
 				Some(ForwardHTLCsAction(channel_id, htlcs)) => {
@@ -1899,4 +2174,105 @@ mod tests {
 			);
 		}
 	}
+
+	#[test]
+	fn broadcast_not_allowed_after_non_paying_fee_payment_claimed() {
+		let min_fee_msat: u64 = 12345;
+		let opening_fee_params = LSPS2OpeningFeeParams {
+			min_fee_msat,
+			proportional: 0,
+			valid_until: LSPSDateTime::from_str("2035-05-20T08:30:45Z").unwrap(),
+			min_lifetime: 144,
+			max_client_to_self_delay: 128,
+			min_payment_size_msat: 1,
+			max_payment_size_msat: 10_000_000_000,
+			promise: "ignore".to_string(),
+		};
+
+		let payment_size_msat = Some(1_000_000);
+		let user_channel_id = 4242u128;
+		let mut jit_channel = OutboundJITChannel::new(
+			payment_size_msat,
+			opening_fee_params.clone(),
+			user_channel_id,
+			true,
+		);
+
+		let opening_payment_hash = PaymentHash([42; 32]);
+		let htlcs_for_opening = [
+			InterceptedHTLC {
+				intercept_id: InterceptId([0; 32]),
+				expected_outbound_amount_msat: 400_000,
+				payment_hash: opening_payment_hash,
+			},
+			InterceptedHTLC {
+				intercept_id: InterceptId([1; 32]),
+				expected_outbound_amount_msat: 600_000,
+				payment_hash: opening_payment_hash,
+			},
+		];
+
+		assert!(jit_channel.htlc_intercepted(htlcs_for_opening[0].clone()).unwrap().is_none());
+		let action = jit_channel.htlc_intercepted(htlcs_for_opening[1].clone()).unwrap();
+		match action {
+			Some(HTLCInterceptedAction::OpenChannel(_)) => {},
+			other => panic!("Expected OpenChannel action, got {:?}", other),
+		}
+
+		let channel_id = ChannelId([7; 32]);
+		let ForwardPaymentAction(_, fee_payment) = jit_channel.channel_ready(channel_id).unwrap();
+		assert_eq!(fee_payment.opening_fee_msat, min_fee_msat);
+
+		let followup = jit_channel.htlc_handling_failed().unwrap();
+		assert!(followup.is_none());
+
+		let dummy_tx = Transaction {
+			version: Version(2),
+			lock_time: LockTime::ZERO,
+			input: vec![],
+			output: vec![],
+		};
+		jit_channel.set_funding_tx(dummy_tx);
+		jit_channel.set_funding_tx_broadcast_safe(true);
+		assert!(
+			!jit_channel.should_broadcast_funding_transaction(),
+			"Should not broadcast before any successful payment is claimed"
+		);
+
+		let second_payment_hash = PaymentHash([99; 32]);
+		let second_htlc = InterceptedHTLC {
+			intercept_id: InterceptId([2; 32]),
+			expected_outbound_amount_msat: min_fee_msat,
+			payment_hash: second_payment_hash,
+		};
+		let action2 = jit_channel.htlc_intercepted(second_htlc).unwrap();
+		let (forwarded_channel_id, fee_payment2) = match action2 {
+			Some(HTLCInterceptedAction::ForwardPayment(cid, fp)) => (cid, fp),
+			other => panic!("Expected ForwardPayment for second HTLC, got {:?}", other),
+		};
+		assert_eq!(forwarded_channel_id, channel_id);
+		assert_eq!(fee_payment2.opening_fee_msat, min_fee_msat);
+
+		assert!(
+			!jit_channel.should_broadcast_funding_transaction(),
+			"Should not broadcast before any successful payment is claimed"
+		);
+
+		// Forward a payment that is not enough to cover the fees
+		let _ = jit_channel.payment_forwarded(Some(min_fee_msat - 1)).unwrap();
+
+		assert!(
+			!jit_channel.should_broadcast_funding_transaction(),
+			"Should not broadcast before all the fees are collected"
+		);
+
+		let _ = jit_channel.payment_forwarded(Some(min_fee_msat)).unwrap();
+
+		let broadcast_allowed = jit_channel.should_broadcast_funding_transaction();
+
+		assert!(
+			broadcast_allowed,
+			"Broadcast was not allowed even though all the skimmed fees were collected"
+		);
+	}
 }
diff --git a/lightning-liquidity/src/manager.rs b/lightning-liquidity/src/manager.rs
index 4cf97786d02..56b4b573c6f 100644
--- a/lightning-liquidity/src/manager.rs
+++ b/lightning-liquidity/src/manager.rs
@@ -38,6 +38,7 @@ use crate::sync::{Arc, Mutex, RwLock};
 use crate::utils::time::DefaultTimeProvider;
 use crate::utils::time::TimeProvider;
 
+use lightning::chain::chaininterface::BroadcasterInterface;
 use lightning::chain::{self, BestBlock, Confirm, Filter, Listen};
 use lightning::ln::channelmanager::{AChannelManager, ChainParameters};
 use lightning::ln::msgs::{ErrorAction, LightningError};
@@ -112,8 +113,13 @@ pub trait ALiquidityManager {
 	type TimeProvider: TimeProvider + ?Sized;
 	/// A type that may be dereferenced to [`Self::TimeProvider`].
 	type TP: Deref<Target = Self::TimeProvider> + Clone;
+	/// A type implementing [`BroadcasterInterface`].
+	type BroadcasterInterface: BroadcasterInterface + ?Sized;
+	/// A type that may be dereferenced to [`Self::BroadcasterInterface`].
+	type T: Deref<Target = Self::BroadcasterInterface> + Clone;
 	/// Returns a reference to the actual [`LiquidityManager`] object.
-	fn get_lm(&self) -> &LiquidityManager<Self::ES, Self::NS, Self::CM, Self::C, Self::TP>;
+	fn get_lm(&self)
+		-> &LiquidityManager<Self::ES, Self::NS, Self::CM, Self::C, Self::TP, Self::T>;
 }
 
 impl<
@@ -122,13 +128,15 @@ impl<
 		CM: Deref + Clone,
 		C: Deref + Clone,
 		TP: Deref + Clone,
-	> ALiquidityManager for LiquidityManager<ES, NS, CM, C, TP>
+		T: Deref + Clone,
+	> ALiquidityManager for LiquidityManager<ES, NS, CM, C, TP, T>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	CM::Target: AChannelManager,
 	C::Target: Filter,
 	TP::Target: TimeProvider,
+	T::Target: BroadcasterInterface,
 {
 	type EntropySource = ES::Target;
 	type ES = ES;
@@ -140,7 +148,9 @@ where
 	type C = C;
 	type TimeProvider = TP::Target;
 	type TP = TP;
-	fn get_lm(&self) -> &LiquidityManager<ES, NS, CM, C, TP> {
+	type BroadcasterInterface = T::Target;
+	type T = T;
+	fn get_lm(&self) -> &LiquidityManager<ES, NS, CM, C, TP, T> {
 		self
 	}
 }
@@ -170,12 +180,14 @@ pub struct LiquidityManager<
 	CM: Deref + Clone,
 	C: Deref + Clone,
 	TP: Deref + Clone,
+	T: Deref + Clone,
 > where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	CM::Target: AChannelManager,
 	C::Target: Filter,
 	TP::Target: TimeProvider,
+	T::Target: BroadcasterInterface,
 {
 	pending_messages: Arc<MessageQueue>,
 	pending_events: Arc<EventQueue>,
@@ -187,7 +199,7 @@ pub struct LiquidityManager<
 	#[cfg(lsps1_service)]
 	lsps1_service_handler: Option<LSPS1ServiceHandler<ES, CM, C>>,
 	lsps1_client_handler: Option<LSPS1ClientHandler<ES>>,
-	lsps2_service_handler: Option<LSPS2ServiceHandler<CM>>,
+	lsps2_service_handler: Option<LSPS2ServiceHandler<CM, T>>,
 	lsps2_client_handler: Option<LSPS2ClientHandler<ES>>,
 	lsps5_service_handler: Option<LSPS5ServiceHandler<CM, NS, TP>>,
 	lsps5_client_handler: Option<LSPS5ClientHandler<ES>>,
@@ -198,18 +210,25 @@ pub struct LiquidityManager<
 }
 
 #[cfg(feature = "time")]
-impl<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone>
-	LiquidityManager<ES, NS, CM, C, Arc<DefaultTimeProvider>>
+impl<
+		ES: Deref + Clone,
+		NS: Deref + Clone,
+		CM: Deref + Clone,
+		C: Deref + Clone,
+		T: Deref + Clone,
+	> LiquidityManager<ES, NS, CM, C, Arc<DefaultTimeProvider>, T>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	CM::Target: AChannelManager,
 	C::Target: Filter,
+	T::Target: BroadcasterInterface,
 {
 	/// Constructor for the [`LiquidityManager`] using the default system clock
 	pub fn new(
 		entropy_source: ES, node_signer: NS, channel_manager: CM, chain_source: Option<C>,
-		chain_params: Option<ChainParameters>, service_config: Option<LiquidityServiceConfig>,
+		transaction_broadcaster: T, chain_params: Option<ChainParameters>,
+		service_config: Option<LiquidityServiceConfig>,
 		client_config: Option<LiquidityClientConfig>,
 	) -> Self {
 		let time_provider = Arc::new(DefaultTimeProvider);
@@ -217,6 +236,7 @@ where
 			entropy_source,
 			node_signer,
 			channel_manager,
+			transaction_broadcaster,
 			chain_source,
 			chain_params,
 			service_config,
@@ -232,13 +252,15 @@ impl<
 		CM: Deref + Clone,
 		C: Deref + Clone,
 		TP: Deref + Clone,
-	> LiquidityManager<ES, NS, CM, C, TP>
+		T: Deref + Clone,
+	> LiquidityManager<ES, NS, CM, C, TP, T>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	CM::Target: AChannelManager,
 	C::Target: Filter,
 	TP::Target: TimeProvider,
+	T::Target: BroadcasterInterface,
 {
 	/// Constructor for the [`LiquidityManager`] with a custom time provider.
 	///
@@ -247,8 +269,9 @@ where
 	/// Sets up the required protocol message handlers based on the given
 	/// [`LiquidityClientConfig`] and [`LiquidityServiceConfig`].
 	pub fn new_with_custom_time_provider(
-		entropy_source: ES, node_signer: NS, channel_manager: CM, chain_source: Option<C>,
-		chain_params: Option<ChainParameters>, service_config: Option<LiquidityServiceConfig>,
+		entropy_source: ES, node_signer: NS, channel_manager: CM, transaction_broadcaster: T,
+		chain_source: Option<C>, chain_params: Option<ChainParameters>,
+		service_config: Option<LiquidityServiceConfig>,
 		client_config: Option<LiquidityClientConfig>, time_provider: TP,
 	) -> Self {
 		let pending_messages = Arc::new(MessageQueue::new());
@@ -270,7 +293,7 @@ where
 		let lsps2_service_handler = service_config.as_ref().and_then(|config| {
 			config.lsps2_service_config.as_ref().map(|config| {
 				if let Some(number) =
-					<LSPS2ServiceHandler<CM> as LSPSProtocolMessageHandler>::PROTOCOL_NUMBER
+					<LSPS2ServiceHandler<CM, T> as LSPSProtocolMessageHandler>::PROTOCOL_NUMBER
 				{
 					supported_protocols.push(number);
 				}
@@ -278,6 +301,7 @@ where
 					Arc::clone(&pending_messages),
 					Arc::clone(&pending_events),
 					channel_manager.clone(),
+					transaction_broadcaster,
 					config.clone(),
 				)
 			})
@@ -412,7 +436,7 @@ where
 	/// Returns a reference to the LSPS2 server-side handler.
 	///
 	/// The returned hendler allows to initiate the LSPS2 service-side flow.
-	pub fn lsps2_service_handler(&self) -> Option<&LSPS2ServiceHandler<CM>> {
+	pub fn lsps2_service_handler(&self) -> Option<&LSPS2ServiceHandler<CM, T>> {
 		self.lsps2_service_handler.as_ref()
 	}
 
@@ -586,13 +610,15 @@ impl<
 		CM: Deref + Clone,
 		C: Deref + Clone,
 		TP: Deref + Clone,
-	> CustomMessageReader for LiquidityManager<ES, NS, CM, C, TP>
+		T: Deref + Clone,
+	> CustomMessageReader for LiquidityManager<ES, NS, CM, C, TP, T>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	CM::Target: AChannelManager,
 	C::Target: Filter,
 	TP::Target: TimeProvider,
+	T::Target: BroadcasterInterface,
 {
 	type CustomMessage = RawLSPSMessage;
 
@@ -614,13 +640,15 @@ impl<
 		CM: Deref + Clone,
 		C: Deref + Clone,
 		TP: Deref + Clone,
-	> CustomMessageHandler for LiquidityManager<ES, NS, CM, C, TP>
+		T: Deref + Clone,
+	> CustomMessageHandler for LiquidityManager<ES, NS, CM, C, TP, T>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	CM::Target: AChannelManager,
 	C::Target: Filter,
 	TP::Target: TimeProvider,
+	T::Target: BroadcasterInterface,
 {
 	fn handle_custom_message(
 		&self, msg: Self::CustomMessage, sender_node_id: PublicKey,
@@ -744,13 +772,15 @@ impl<
 		CM: Deref + Clone,
 		C: Deref + Clone,
 		TP: Deref + Clone,
-	> Listen for LiquidityManager<ES, NS, CM, C, TP>
+		T: Deref + Clone,
+	> Listen for LiquidityManager<ES, NS, CM, C, TP, T>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	CM::Target: AChannelManager,
 	C::Target: Filter,
 	TP::Target: TimeProvider,
+	T::Target: BroadcasterInterface,
 {
 	fn filtered_block_connected(
 		&self, header: &bitcoin::block::Header, txdata: &chain::transaction::TransactionData,
@@ -789,13 +819,15 @@ impl<
 		CM: Deref + Clone,
 		C: Deref + Clone,
 		TP: Deref + Clone,
-	> Confirm for LiquidityManager<ES, NS, CM, C, TP>
+		T: Deref + Clone,
+	> Confirm for LiquidityManager<ES, NS, CM, C, TP, T>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	CM::Target: AChannelManager,
 	C::Target: Filter,
 	TP::Target: TimeProvider,
+	T::Target: BroadcasterInterface,
 {
 	fn transactions_confirmed(
 		&self, _header: &bitcoin::block::Header, _txdata: &chain::transaction::TransactionData,
diff --git a/lightning-liquidity/tests/common/mod.rs b/lightning-liquidity/tests/common/mod.rs
index 013378f2cb0..540efe3f2a6 100644
--- a/lightning-liquidity/tests/common/mod.rs
+++ b/lightning-liquidity/tests/common/mod.rs
@@ -6,7 +6,7 @@ use lightning_liquidity::{LiquidityClientConfig, LiquidityManager, LiquidityServ
 use lightning::chain::{BestBlock, Filter};
 use lightning::ln::channelmanager::ChainParameters;
 use lightning::ln::functional_test_utils::{Node, TestChannelManager};
-use lightning::util::test_utils::TestKeysInterface;
+use lightning::util::test_utils::{TestBroadcaster, TestKeysInterface};
 
 use bitcoin::Network;
 
@@ -19,10 +19,19 @@ pub(crate) struct LSPSNodes<'a, 'b, 'c> {
 	pub client_node: LiquidityNode<'a, 'b, 'c>,
 }
 
-pub(crate) fn create_service_and_client_nodes<'a, 'b, 'c>(
-	nodes: Vec<Node<'a, 'b, 'c>>, service_config: LiquidityServiceConfig,
+// this is ONLY used on LSPS2 so it says it's not used but it is
+#[allow(dead_code)]
+pub(crate) struct LSPSNodesWithPayer<'a, 'b, 'c> {
+	pub service_node: LiquidityNode<'a, 'b, 'c>,
+	pub client_node: LiquidityNode<'a, 'b, 'c>,
+	pub payer_node: Node<'a, 'b, 'c>,
+}
+
+fn build_service_and_client<'a, 'b, 'c>(
+	mut nodes: Vec<Node<'a, 'b, 'c>>, service_config: LiquidityServiceConfig,
 	client_config: LiquidityClientConfig, time_provider: Arc<dyn TimeProvider + Send + Sync>,
-) -> LSPSNodes<'a, 'b, 'c> {
+) -> (LiquidityNode<'a, 'b, 'c>, LiquidityNode<'a, 'b, 'c>, Option<Node<'a, 'b, 'c>>) {
+	assert!(nodes.len() >= 2, "Need at least two nodes (service, client)");
 	let chain_params = ChainParameters {
 		network: Network::Testnet,
 		best_block: BestBlock::from_network(Network::Testnet),
@@ -31,6 +40,7 @@ pub(crate) fn create_service_and_client_nodes<'a, 'b, 'c>(
 		nodes[0].keys_manager,
 		nodes[0].keys_manager,
 		nodes[0].node,
+		nodes[0].tx_broadcaster,
 		None::<Arc<dyn Filter + Send + Sync>>,
 		Some(chain_params.clone()),
 		Some(service_config),
@@ -42,6 +52,7 @@ pub(crate) fn create_service_and_client_nodes<'a, 'b, 'c>(
 		nodes[1].keys_manager,
 		nodes[1].keys_manager,
 		nodes[1].node,
+		nodes[1].tx_broadcaster,
 		None::<Arc<dyn Filter + Send + Sync>>,
 		Some(chain_params),
 		None,
@@ -49,13 +60,35 @@ pub(crate) fn create_service_and_client_nodes<'a, 'b, 'c>(
 		time_provider,
 	);
 
-	let mut iter = nodes.into_iter();
+	let mut iter = nodes.drain(..);
 	let service_node = LiquidityNode::new(iter.next().unwrap(), service_lm);
 	let client_node = LiquidityNode::new(iter.next().unwrap(), client_lm);
+	let leftover = iter.next(); // payer if present
+	(service_node, client_node, leftover)
+}
 
+pub(crate) fn create_service_and_client_nodes<'a, 'b, 'c>(
+	nodes: Vec<Node<'a, 'b, 'c>>, service_config: LiquidityServiceConfig,
+	client_config: LiquidityClientConfig, time_provider: Arc<dyn TimeProvider + Send + Sync>,
+) -> LSPSNodes<'a, 'b, 'c> {
+	let (service_node, client_node, _extra) =
+		build_service_and_client(nodes, service_config, client_config, time_provider);
 	LSPSNodes { service_node, client_node }
 }
 
+// this is ONLY used on LSPS2 so it says it's not used but it is
+#[allow(dead_code)]
+pub(crate) fn create_service_client_and_payer_nodes<'a, 'b, 'c>(
+	nodes: Vec<Node<'a, 'b, 'c>>, service_config: LiquidityServiceConfig,
+	client_config: LiquidityClientConfig, time_provider: Arc<dyn TimeProvider + Send + Sync>,
+) -> LSPSNodesWithPayer<'a, 'b, 'c> {
+	assert!(nodes.len() >= 3, "Need three nodes (service, client, payer)");
+	let (service_node, client_node, payer_opt) =
+		build_service_and_client(nodes, service_config, client_config, time_provider);
+	let payer_node = payer_opt.expect("payer node missing");
+	LSPSNodesWithPayer { service_node, client_node, payer_node }
+}
+
 pub(crate) struct LiquidityNode<'a, 'b, 'c> {
 	pub inner: Node<'a, 'b, 'c>,
 	pub liquidity_manager: LiquidityManager<
@@ -64,6 +97,7 @@ pub(crate) struct LiquidityNode<'a, 'b, 'c> {
 		&'a TestChannelManager<'b, 'c>,
 		Arc<dyn Filter + Send + Sync>,
 		Arc<dyn TimeProvider + Send + Sync>,
+		&'c TestBroadcaster,
 	>,
 }
 
@@ -76,6 +110,7 @@ impl<'a, 'b, 'c> LiquidityNode<'a, 'b, 'c> {
 			&'a TestChannelManager<'b, 'c>,
 			Arc<dyn Filter + Send + Sync>,
 			Arc<dyn TimeProvider + Send + Sync>,
+			&'c TestBroadcaster,
 		>,
 	) -> Self {
 		Self { inner: node, liquidity_manager }
diff --git a/lightning-liquidity/tests/lsps2_integration_tests.rs b/lightning-liquidity/tests/lsps2_integration_tests.rs
index 6ea42e17532..c754ef5ca46 100644
--- a/lightning-liquidity/tests/lsps2_integration_tests.rs
+++ b/lightning-liquidity/tests/lsps2_integration_tests.rs
@@ -2,7 +2,28 @@
 
 mod common;
 
-use common::{create_service_and_client_nodes, get_lsps_message, LSPSNodes, LiquidityNode};
+use common::{
+	create_service_and_client_nodes, create_service_client_and_payer_nodes, get_lsps_message,
+	LSPSNodes, LSPSNodesWithPayer, LiquidityNode,
+};
+
+use lightning::check_added_monitors;
+use lightning::events::Event;
+use lightning::get_event_msg;
+use lightning::ln::channelmanager::PaymentId;
+use lightning::ln::channelmanager::Retry;
+use lightning::ln::functional_test_utils::create_chan_between_nodes_with_value;
+use lightning::ln::functional_test_utils::create_funding_transaction;
+use lightning::ln::functional_test_utils::do_commitment_signed_dance;
+use lightning::ln::functional_test_utils::expect_channel_pending_event;
+use lightning::ln::functional_test_utils::expect_channel_ready_event;
+use lightning::ln::functional_test_utils::expect_payment_sent;
+use lightning::ln::functional_test_utils::test_default_channel_config;
+use lightning::ln::functional_test_utils::SendEvent;
+use lightning::ln::msgs::BaseMessageHandler;
+use lightning::ln::msgs::ChannelMessageHandler;
+use lightning::ln::msgs::MessageSendEvent;
+use lightning::ln::types::ChannelId;
 
 use lightning_liquidity::events::LiquidityEvent;
 use lightning_liquidity::lsps0::ser::LSPSDateTime;
@@ -34,6 +55,7 @@ use lightning_types::payment::PaymentHash;
 use bitcoin::hashes::{sha256, Hash};
 use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
 use bitcoin::Network;
+use lightning_types::payment::PaymentPreimage;
 
 use std::str::FromStr;
 use std::sync::Arc;
@@ -42,9 +64,7 @@ use std::time::Duration;
 const MAX_PENDING_REQUESTS_PER_PEER: usize = 10;
 const MAX_TOTAL_PENDING_REQUESTS: usize = 1000;
 
-fn setup_test_lsps2_nodes<'a, 'b, 'c>(
-	nodes: Vec<Node<'a, 'b, 'c>>,
-) -> (LSPSNodes<'a, 'b, 'c>, [u8; 32]) {
+fn build_lsps2_configs() -> ([u8; 32], LiquidityServiceConfig, LiquidityClientConfig) {
 	let promise_secret = [42; 32];
 	let lsps2_service_config = LSPS2ServiceConfig { promise_secret };
 	let service_config = LiquidityServiceConfig {
@@ -61,13 +81,32 @@ fn setup_test_lsps2_nodes<'a, 'b, 'c>(
 		lsps2_client_config: Some(lsps2_client_config),
 		lsps5_client_config: None,
 	};
-	let lsps_nodes = create_service_and_client_nodes(
+	(promise_secret, service_config, client_config)
+}
+
+fn setup_test_lsps2_nodes_with_payer<'a, 'b, 'c>(
+	nodes: Vec<Node<'a, 'b, 'c>>,
+) -> (LSPSNodesWithPayer<'a, 'b, 'c>, [u8; 32]) {
+	let (promise_secret, service_config, client_config) = build_lsps2_configs();
+	let lsps_nodes = create_service_client_and_payer_nodes(
 		nodes,
 		service_config,
 		client_config,
 		Arc::new(DefaultTimeProvider),
 	);
+	(lsps_nodes, promise_secret)
+}
 
+fn setup_test_lsps2_nodes<'a, 'b, 'c>(
+	nodes: Vec<Node<'a, 'b, 'c>>,
+) -> (LSPSNodes<'a, 'b, 'c>, [u8; 32]) {
+	let (promise_secret, service_config, client_config) = build_lsps2_configs();
+	let lsps_nodes = create_service_and_client_nodes(
+		nodes,
+		service_config,
+		client_config,
+		Arc::new(DefaultTimeProvider),
+	);
 	(lsps_nodes, promise_secret)
 }
 
@@ -118,11 +157,13 @@ fn create_jit_invoice(
 	let sign_fn =
 		node.inner.keys_manager.sign_invoice(&raw_invoice, lightning::sign::Recipient::Node);
 
-	raw_invoice.sign(|_| sign_fn).and_then(|signed_raw| {
+	let invoice = raw_invoice.sign(|_| sign_fn).and_then(|signed_raw| {
 		Bolt11Invoice::from_signed(signed_raw).map_err(|e| {
 			log_error!(node.inner.logger, "Failed to create invoice from signed raw: {:?}", e);
 		})
-	})
+	})?;
+
+	Ok(invoice)
 }
 
 #[test]
@@ -883,3 +924,816 @@ fn opening_fee_params_menu_is_sorted_by_spec() {
 		panic!("Unexpected event");
 	}
 }
+
+#[test]
+fn client_trusts_lsp_end_to_end_test() {
+	// There are 3 nodes. Payer, service and client.
+	// client_trusts_lsp=true, that means that funding transaction broadcast will need to happen manually
+	// after the client claims the HTLC.
+	//
+	// 1. Create a channel between payer and service
+	// 2. Do the LSPS2 ceremony between client and service, to prepare the service to intercept an htlc and eventually create a JIT channel
+	// 3. Make the client create a JIT invoice and make the payer pay it
+	// 4. Assert that the service intercepts the HTLC
+	// 5. Assert that the service emits a LiquidityEvent::OpenChannel. This means that the intercepted HTLC was enough
+	// and that it's ready to proceed with channel creation.
+	// 6. Proceed with the JIT channel creation (we create it with funding_transaction_generated_manual_broadcast because
+	// client_trusts_lsp=true).
+	// 7. Call the service's channel_ready function
+	// 8. The service will now forward the intercepted HTLC to the client on the new JIT channel
+	// 9. The client will see the PaymentClaimable event
+	// 10. Assert that the service has not broadcasted the funding transaction yet, because the client has not claimed the HTLC yet
+	// 11. Make the client claim the HTLC
+	// 12. Assert that the service has now received the BroadcastTransaction event, and we broadcast it
+	// 13. Assert that the payer received the PaymentSent event
+	let chanmon_cfgs = create_chanmon_cfgs(3);
+	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+	let mut service_node_config = test_default_channel_config();
+	service_node_config.accept_intercept_htlcs = true;
+
+	let mut client_node_config = test_default_channel_config();
+	client_node_config.manually_accept_inbound_channels = true;
+	client_node_config.channel_config.accept_underpaying_htlcs = true;
+	let node_chanmgrs = create_node_chanmgrs(
+		3,
+		&node_cfgs,
+		&[Some(service_node_config), Some(client_node_config), None],
+	);
+	let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+	let (lsps_nodes, promise_secret) = setup_test_lsps2_nodes_with_payer(nodes);
+	let LSPSNodesWithPayer { ref service_node, ref client_node, ref payer_node } = lsps_nodes;
+
+	let payer_node_id = payer_node.node.get_our_node_id();
+	let service_node_id = service_node.inner.node.get_our_node_id();
+	let client_node_id = client_node.inner.node.get_our_node_id();
+
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
+
+	create_chan_between_nodes_with_value(&payer_node, &service_node.inner, 2000000, 100000);
+
+	let intercept_scid = service_node.node.get_intercept_scid();
+	let user_channel_id = 42;
+	let cltv_expiry_delta: u32 = 144;
+	let payment_size_msat = Some(1_000_000);
+
+	let fee_base_msat = 1000;
+
+	execute_lsps2_dance(
+		&lsps_nodes,
+		intercept_scid,
+		user_channel_id,
+		cltv_expiry_delta,
+		promise_secret,
+		payment_size_msat,
+		fee_base_msat,
+	);
+
+	let invoice = create_jit_invoice(
+		&client_node,
+		service_node_id,
+		intercept_scid,
+		cltv_expiry_delta,
+		payment_size_msat,
+		"asdf",
+		3600,
+	)
+	.unwrap();
+
+	payer_node
+		.node
+		.pay_for_bolt11_invoice(
+			&invoice,
+			PaymentId(invoice.payment_hash().to_byte_array()),
+			None,
+			Default::default(),
+			Retry::Attempts(3),
+		)
+		.unwrap();
+
+	check_added_monitors!(payer_node, 1);
+	let events = payer_node.node.get_and_clear_pending_msg_events();
+	let ev = SendEvent::from_event(events[0].clone());
+	service_node.inner.node.handle_update_add_htlc(payer_node_id, &ev.msgs[0]);
+	do_commitment_signed_dance(&service_node.inner, &payer_node, &ev.commitment_msg, false, true);
+	service_node.inner.node.process_pending_htlc_forwards();
+
+	let events = service_node.inner.node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	let (payment_hash, expected_outbound_amount_msat) = match &events[0] {
+		Event::HTLCIntercepted {
+			intercept_id,
+			requested_next_hop_scid,
+			payment_hash,
+			expected_outbound_amount_msat,
+			..
+		} => {
+			assert_eq!(*requested_next_hop_scid, intercept_scid);
+
+			service_handler
+				.htlc_intercepted(
+					*requested_next_hop_scid,
+					*intercept_id,
+					*expected_outbound_amount_msat,
+					*payment_hash,
+				)
+				.unwrap();
+			(*payment_hash, expected_outbound_amount_msat)
+		},
+		other => panic!("Expected HTLCIntercepted event, got: {:?}", other),
+	};
+
+	let open_channel_event = service_node.liquidity_manager.next_event().unwrap();
+
+	match open_channel_event {
+		LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::OpenChannel {
+			their_network_key,
+			amt_to_forward_msat,
+			opening_fee_msat,
+			user_channel_id,
+			intercept_scid: iscd,
+		}) => {
+			assert_eq!(their_network_key, client_node_id);
+			assert_eq!(amt_to_forward_msat, payment_size_msat.unwrap() - fee_base_msat);
+			assert_eq!(opening_fee_msat, fee_base_msat);
+			assert_eq!(user_channel_id, 42);
+			assert_eq!(iscd, intercept_scid);
+		},
+		other => panic!("Expected OpenChannel event, got: {:?}", other),
+	};
+
+	let result =
+		service_handler.channel_needs_manual_broadcast(user_channel_id, &client_node_id).unwrap();
+	assert!(result, "Channel should require manual broadcast");
+
+	let channel_id = create_channel_with_manual_broadcast(
+		&service_node_id,
+		&client_node_id,
+		&service_node,
+		&client_node,
+		user_channel_id,
+		expected_outbound_amount_msat,
+	);
+
+	service_handler.channel_ready(user_channel_id, &channel_id, &client_node_id).unwrap();
+
+	service_node.inner.node.process_pending_htlc_forwards();
+
+	let pay_event = {
+		{
+			let mut added_monitors =
+				service_node.inner.chain_monitor.added_monitors.lock().unwrap();
+			assert_eq!(added_monitors.len(), 1);
+			added_monitors.clear();
+		}
+		let mut events = service_node.inner.node.get_and_clear_pending_msg_events();
+		assert_eq!(events.len(), 1);
+		SendEvent::from_event(events.remove(0))
+	};
+
+	client_node.inner.node.handle_update_add_htlc(service_node_id, &pay_event.msgs[0]);
+	do_commitment_signed_dance(
+		&client_node.inner,
+		&service_node.inner,
+		&pay_event.commitment_msg,
+		false,
+		true,
+	);
+	client_node.inner.node.process_pending_htlc_forwards();
+
+	let client_events = client_node.inner.node.get_and_clear_pending_events();
+	assert_eq!(client_events.len(), 1);
+	let preimage = match &client_events[0] {
+		Event::PaymentClaimable { payment_hash: ph, purpose, .. } => {
+			assert_eq!(*ph, payment_hash);
+			purpose.preimage()
+		},
+		other => panic!("Expected PaymentClaimable event on client, got: {:?}", other),
+	};
+
+	// Check that before the client claims, the service node has not broadcasted anything
+	let events = service_node.liquidity_manager.get_and_clear_pending_events();
+	assert!(events.is_empty(), "Expected no events from service node, got: {:?}", events);
+
+	client_node.inner.node.claim_funds(preimage.unwrap());
+
+	claim_and_assert_forwarded_only(
+		&payer_node,
+		&service_node.inner,
+		&client_node.inner,
+		preimage.unwrap(),
+	);
+
+	let service_events = service_node.node.get_and_clear_pending_events();
+	assert_eq!(service_events.len(), 1);
+
+	let total_fee_msat = match service_events[0].clone() {
+		Event::PaymentForwarded {
+			prev_node_id,
+			next_node_id,
+			skimmed_fee_msat,
+			total_fee_earned_msat,
+			..
+		} => {
+			assert_eq!(prev_node_id, Some(payer_node_id));
+			assert_eq!(next_node_id, Some(client_node_id));
+			service_handler.payment_forwarded(channel_id, skimmed_fee_msat).unwrap();
+			Some(total_fee_earned_msat.unwrap() - skimmed_fee_msat.unwrap())
+		},
+		_ => panic!("Expected PaymentForwarded event, got: {:?}", service_events[0]),
+	};
+
+	match service_node.liquidity_manager.next_event().unwrap() {
+		LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::BroadcastFundingTransaction {
+			counterparty_node_id,
+			user_channel_id: uid,
+			funding_tx,
+		}) => {
+			assert_eq!(counterparty_node_id, client_node_id);
+			assert_eq!(uid, user_channel_id);
+
+			service_handler.broadcast_transaction(&funding_tx);
+
+			let broadcasted = service_node.inner.tx_broadcaster.txn_broadcasted.lock().unwrap();
+			assert!(broadcasted.iter().any(|b| b.compute_txid() == funding_tx.compute_txid()));
+		},
+		other => panic!("Unexpected event: {:?}", other),
+	}
+
+	expect_payment_sent(&payer_node, preimage.unwrap(), Some(total_fee_msat), true, true);
+}
+
+fn execute_lsps2_dance(
+	lsps_nodes: &LSPSNodesWithPayer, intercept_scid: u64, user_channel_id: u128,
+	cltv_expiry_delta: u32, promise_secret: [u8; 32], payment_size_msat: Option<u64>,
+	fee_base_msat: u64,
+) {
+	let service_node = &lsps_nodes.service_node;
+	let client_node = &lsps_nodes.client_node;
+
+	let service_node_id = service_node.inner.node.get_our_node_id();
+	let client_node_id = client_node.inner.node.get_our_node_id();
+
+	let client_handler = client_node.liquidity_manager.lsps2_client_handler().unwrap();
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
+
+	let get_info_request_id = client_handler.request_opening_params(service_node_id, None);
+	let get_info_request = get_lsps_message!(client_node, service_node_id);
+
+	service_node.liquidity_manager.handle_custom_message(get_info_request, client_node_id).unwrap();
+
+	let get_info_event = service_node.liquidity_manager.next_event().unwrap();
+	if let LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo {
+		request_id,
+		counterparty_node_id,
+		token,
+	}) = get_info_event
+	{
+		assert_eq!(request_id, get_info_request_id);
+		assert_eq!(counterparty_node_id, client_node_id);
+		assert_eq!(token, None);
+	} else {
+		panic!("Unexpected event");
+	}
+
+	let raw_opening_params = LSPS2RawOpeningFeeParams {
+		min_fee_msat: fee_base_msat,
+		proportional: 0,
+		valid_until: LSPSDateTime::from_str("2035-05-20T08:30:45Z").unwrap(),
+		min_lifetime: 144,
+		max_client_to_self_delay: 128,
+		min_payment_size_msat: 1,
+		max_payment_size_msat: 100_000_000,
+	};
+
+	service_handler
+		.opening_fee_params_generated(
+			&client_node_id,
+			get_info_request_id.clone(),
+			vec![raw_opening_params],
+		)
+		.unwrap();
+	let get_info_response = get_lsps_message!(service_node, client_node_id);
+
+	client_node
+		.liquidity_manager
+		.handle_custom_message(get_info_response, service_node_id)
+		.unwrap();
+
+	let opening_params_event = client_node.liquidity_manager.next_event().unwrap();
+	let opening_fee_params = match opening_params_event {
+		LiquidityEvent::LSPS2Client(LSPS2ClientEvent::OpeningParametersReady {
+			request_id,
+			counterparty_node_id,
+			opening_fee_params_menu,
+		}) => {
+			assert_eq!(request_id, get_info_request_id);
+			assert_eq!(counterparty_node_id, service_node_id);
+			let opening_fee_params = opening_fee_params_menu.first().unwrap().clone();
+			assert!(is_valid_opening_fee_params(&opening_fee_params, &promise_secret));
+			opening_fee_params
+		},
+		_ => panic!("Unexpected event"),
+	};
+
+	let buy_request_id = client_handler
+		.select_opening_params(service_node_id, payment_size_msat, opening_fee_params.clone())
+		.unwrap();
+
+	let buy_request = get_lsps_message!(client_node, service_node_id);
+	service_node.liquidity_manager.handle_custom_message(buy_request, client_node_id).unwrap();
+
+	let buy_event = service_node.liquidity_manager.next_event().unwrap();
+	if let LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::BuyRequest {
+		request_id,
+		counterparty_node_id,
+		opening_fee_params: ofp,
+		payment_size_msat: psm,
+	}) = buy_event
+	{
+		assert_eq!(request_id, buy_request_id);
+		assert_eq!(counterparty_node_id, client_node_id);
+		assert_eq!(opening_fee_params, ofp);
+		assert_eq!(payment_size_msat, psm);
+	} else {
+		panic!("Unexpected event");
+	}
+
+	let client_trusts_lsp = true;
+
+	service_handler
+		.invoice_parameters_generated(
+			&client_node_id,
+			buy_request_id.clone(),
+			intercept_scid,
+			cltv_expiry_delta,
+			client_trusts_lsp,
+			user_channel_id,
+		)
+		.unwrap();
+
+	let buy_response = get_lsps_message!(service_node, client_node_id);
+	client_node.liquidity_manager.handle_custom_message(buy_response, service_node_id).unwrap();
+
+	let invoice_params_event = client_node.liquidity_manager.next_event().unwrap();
+	if let LiquidityEvent::LSPS2Client(LSPS2ClientEvent::InvoiceParametersReady {
+		request_id,
+		counterparty_node_id,
+		intercept_scid: iscid,
+		cltv_expiry_delta: ced,
+		payment_size_msat: psm,
+	}) = invoice_params_event
+	{
+		assert_eq!(request_id, buy_request_id);
+		assert_eq!(counterparty_node_id, service_node_id);
+		assert_eq!(intercept_scid, iscid);
+		assert_eq!(cltv_expiry_delta, ced);
+		assert_eq!(payment_size_msat, psm);
+	} else {
+		panic!("Unexpected event");
+	}
+}
+
+fn create_channel_with_manual_broadcast(
+	service_node_id: &PublicKey, client_node_id: &PublicKey, service_node: &LiquidityNode,
+	client_node: &LiquidityNode, user_channel_id: u128, expected_outbound_amount_msat: &u64,
+) -> ChannelId {
+	assert!(service_node
+		.node
+		.create_channel(
+			*client_node_id,
+			*expected_outbound_amount_msat,
+			0,
+			user_channel_id,
+			None,
+			None
+		)
+		.is_ok());
+	let open_channel =
+		get_event_msg!(service_node, MessageSendEvent::SendOpenChannel, *client_node_id);
+
+	client_node.node.handle_open_channel(*service_node_id, &open_channel);
+
+	let events = client_node.node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	match events[0] {
+		Event::OpenChannelRequest { temporary_channel_id, .. } => {
+			client_node
+				.node
+				.accept_inbound_channel_from_trusted_peer_0conf(
+					&temporary_channel_id,
+					&service_node_id,
+					user_channel_id,
+					None,
+				)
+				.unwrap();
+		},
+		_ => panic!("Unexpected event"),
+	};
+
+	let accept_channel =
+		get_event_msg!(client_node, MessageSendEvent::SendAcceptChannel, *service_node_id);
+	assert_eq!(accept_channel.common_fields.minimum_depth, 0);
+
+	service_node.node.handle_accept_channel(*client_node_id, &accept_channel);
+	let (temp_channel_id, tx, funding_outpoint) = create_funding_transaction(
+		&service_node,
+		&client_node_id,
+		*expected_outbound_amount_msat,
+		42,
+	);
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
+	service_handler
+		.store_funding_transaction(user_channel_id, &client_node_id, tx.clone())
+		.unwrap();
+	service_node
+		.node
+		.funding_transaction_generated_manual_broadcast(temp_channel_id, *client_node_id, tx)
+		.unwrap();
+
+	let funding_created =
+		get_event_msg!(service_node, MessageSendEvent::SendFundingCreated, *client_node_id);
+	client_node.node.handle_funding_created(*service_node_id, &funding_created);
+	check_added_monitors!(client_node.inner, 1);
+
+	let bs_signed_locked = client_node.node.get_and_clear_pending_msg_events();
+	assert_eq!(bs_signed_locked.len(), 2);
+
+	let as_channel_ready;
+	match &bs_signed_locked[0] {
+		MessageSendEvent::SendFundingSigned { node_id, msg } => {
+			assert_eq!(*node_id, *service_node_id);
+			service_node.node.handle_funding_signed(*client_node_id, &msg);
+			let events = &service_node.node.get_and_clear_pending_events();
+			assert_eq!(events.len(), 2);
+			match &events[0] {
+				Event::FundingTxBroadcastSafe {
+					funding_txo,
+					user_channel_id,
+					counterparty_node_id,
+					..
+				} => {
+					assert_eq!(funding_txo.txid, funding_outpoint.txid);
+					assert_eq!(funding_txo.vout, funding_outpoint.index as u32);
+
+					service_handler
+						.set_funding_tx_broadcast_safe(*user_channel_id, counterparty_node_id)
+						.unwrap();
+				},
+				_ => panic!("Unexpected event"),
+			};
+			match &events[1] {
+				Event::ChannelPending { counterparty_node_id, .. } => {
+					assert_eq!(counterparty_node_id, client_node_id);
+				},
+				_ => panic!("Unexpected event"),
+			}
+			expect_channel_pending_event(&client_node, &service_node_id);
+			check_added_monitors!(service_node.inner, 1);
+
+			as_channel_ready =
+				get_event_msg!(service_node, MessageSendEvent::SendChannelReady, *client_node_id);
+		},
+		_ => panic!("Unexpected event"),
+	}
+
+	match &bs_signed_locked[1] {
+		MessageSendEvent::SendChannelReady { node_id, msg } => {
+			assert_eq!(*node_id, *service_node_id);
+			service_node.node.handle_channel_ready(*client_node_id, &msg);
+			expect_channel_ready_event(&service_node, &client_node_id);
+		},
+		_ => panic!("Unexpected event"),
+	}
+
+	client_node.node.handle_channel_ready(*service_node_id, &as_channel_ready);
+	expect_channel_ready_event(&client_node, &service_node_id);
+
+	let as_channel_update =
+		get_event_msg!(service_node, MessageSendEvent::SendChannelUpdate, *client_node_id);
+	let bs_channel_update =
+		get_event_msg!(client_node, MessageSendEvent::SendChannelUpdate, *service_node_id);
+
+	service_node.node.handle_channel_update(*client_node_id, &bs_channel_update);
+	client_node.node.handle_channel_update(*service_node_id, &as_channel_update);
+
+	as_channel_ready.channel_id
+}
+
+fn claim_and_assert_forwarded_only<'a, 'b, 'c>(
+	payer_node: &lightning::ln::functional_test_utils::Node<'a, 'b, 'c>,
+	service_node: &lightning::ln::functional_test_utils::Node<'a, 'b, 'c>,
+	client_node: &lightning::ln::functional_test_utils::Node<'a, 'b, 'c>,
+	preimage: PaymentPreimage,
+) {
+	let payer_node_id = payer_node.node.get_our_node_id();
+	let service_node_id = service_node.node.get_our_node_id();
+	let client_node_id = client_node.node.get_our_node_id();
+
+	let client_events = client_node.node.get_and_clear_pending_events();
+	assert_eq!(client_events.len(), 1);
+	match &client_events[0] {
+		Event::PaymentClaimed { purpose, .. } => {
+			assert_eq!(purpose.preimage().unwrap(), preimage);
+		},
+		other => panic!("Expected PaymentClaimed, got {:?}", other),
+	}
+
+	let mut client_msg_events = client_node.node.get_and_clear_pending_msg_events();
+	assert_eq!(client_msg_events.len(), 1);
+	let (fulfill_msg, client_commitment_signed) = match client_msg_events.remove(0) {
+		MessageSendEvent::UpdateHTLCs { node_id, updates, .. } => {
+			assert_eq!(node_id, service_node_id);
+			assert_eq!(updates.update_fulfill_htlcs.len(), 1);
+			(updates.update_fulfill_htlcs[0].clone(), updates.commitment_signed.clone())
+		},
+		other => panic!("Unexpected client msg event: {:?}", other),
+	};
+
+	service_node.node.handle_update_fulfill_htlc(client_node_id, fulfill_msg);
+	service_node
+		.node
+		.handle_commitment_signed_batch_test(client_node_id, &client_commitment_signed);
+	service_node.chain_monitor.added_monitors.lock().unwrap().clear();
+
+	let service_msg_events = service_node.node.get_and_clear_pending_msg_events();
+	assert!(
+		service_msg_events.len() >= 2 && service_msg_events.len() <= 3,
+		"Unexpected service msg events len = {}",
+		service_msg_events.len()
+	);
+
+	let mut revoke_and_ack_to_client = None;
+	let mut upstream_updates = None;
+	let mut client_commitment_update = None;
+
+	for ev in service_msg_events {
+		match ev {
+			MessageSendEvent::SendRevokeAndACK { node_id, msg } => {
+				assert_eq!(node_id, client_node_id);
+				revoke_and_ack_to_client = Some(msg);
+			},
+			MessageSendEvent::UpdateHTLCs { node_id, updates, .. } => {
+				if node_id == payer_node_id {
+					assert_eq!(updates.update_fulfill_htlcs.len(), 1, "Expected upstream fulfill");
+					upstream_updates = Some(updates);
+				} else if node_id == client_node_id {
+					assert!(updates.update_fulfill_htlcs.is_empty());
+					client_commitment_update = Some(updates);
+				} else {
+					panic!("Unexpected UpdateHTLCs destination");
+				}
+			},
+			other => panic!("Unexpected service msg event: {:?}", other),
+		}
+	}
+
+	let revoke_and_ack_to_client =
+		revoke_and_ack_to_client.expect("Missing RevokeAndACK to client");
+	let upstream_updates = upstream_updates.expect("Missing upstream fulfill updates");
+
+	client_node.node.handle_revoke_and_ack(service_node_id, &revoke_and_ack_to_client);
+	client_node.chain_monitor.added_monitors.lock().unwrap().clear();
+
+	if let Some(cu) = client_commitment_update {
+		client_node
+			.node
+			.handle_commitment_signed_batch_test(service_node_id, &cu.commitment_signed);
+		client_node.chain_monitor.added_monitors.lock().unwrap().clear();
+
+		let raa_back =
+			get_event_msg!(client_node, MessageSendEvent::SendRevokeAndACK, service_node_id);
+		service_node.node.handle_revoke_and_ack(client_node_id, &raa_back);
+		service_node.chain_monitor.added_monitors.lock().unwrap().clear();
+	}
+
+	payer_node.node.handle_update_fulfill_htlc(
+		service_node_id,
+		upstream_updates.update_fulfill_htlcs[0].clone(),
+	);
+	payer_node
+		.node
+		.handle_commitment_signed_batch_test(service_node_id, &upstream_updates.commitment_signed);
+	payer_node.chain_monitor.added_monitors.lock().unwrap().clear();
+
+	let payer_msg_events = payer_node.node.get_and_clear_pending_msg_events();
+
+	for ev in payer_msg_events {
+		match ev {
+			MessageSendEvent::SendRevokeAndACK { node_id, msg } => {
+				assert_eq!(node_id, service_node_id);
+				service_node.node.handle_revoke_and_ack(payer_node_id, &msg);
+				service_node.chain_monitor.added_monitors.lock().unwrap().clear();
+			},
+			MessageSendEvent::UpdateHTLCs { updates, .. } => {
+				service_node
+					.node
+					.handle_commitment_signed_batch_test(payer_node_id, &updates.commitment_signed);
+				service_node.chain_monitor.added_monitors.lock().unwrap().clear();
+				let mut svc_resp = service_node.node.get_and_clear_pending_msg_events();
+				for resp in svc_resp.drain(..) {
+					match resp {
+						MessageSendEvent::SendRevokeAndACK { msg, .. } => {
+							payer_node.node.handle_revoke_and_ack(service_node_id, &msg);
+							payer_node.chain_monitor.added_monitors.lock().unwrap().clear();
+						},
+						MessageSendEvent::UpdateHTLCs { updates, .. } => {
+							payer_node.node.handle_commitment_signed_batch_test(
+								service_node_id,
+								&updates.commitment_signed,
+							);
+							payer_node.chain_monitor.added_monitors.lock().unwrap().clear();
+							let maybe_final = payer_node.node.get_and_clear_pending_msg_events();
+							for final_ev in maybe_final {
+								if let MessageSendEvent::SendRevokeAndACK { msg, .. } = final_ev {
+									service_node.node.handle_revoke_and_ack(payer_node_id, &msg);
+									service_node
+										.chain_monitor
+										.added_monitors
+										.lock()
+										.unwrap()
+										.clear();
+								}
+							}
+						},
+						_ => {},
+					}
+				}
+			},
+			other => panic!("Unexpected payer msg event: {:?}", other),
+		}
+	}
+}
+
+#[test]
+fn client_trusts_lsp_partial_fee_does_not_trigger_broadcast() {
+	let chanmon_cfgs = create_chanmon_cfgs(3);
+	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+	let mut service_node_config = test_default_channel_config();
+	service_node_config.accept_intercept_htlcs = true;
+
+	let mut client_node_config = test_default_channel_config();
+	client_node_config.manually_accept_inbound_channels = true;
+	client_node_config.channel_config.accept_underpaying_htlcs = true;
+
+	let node_chanmgrs = create_node_chanmgrs(
+		3,
+		&node_cfgs,
+		&[Some(service_node_config), Some(client_node_config), None],
+	);
+	let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+	let (lsps_nodes, promise_secret) = setup_test_lsps2_nodes_with_payer(nodes);
+	let LSPSNodesWithPayer { ref service_node, ref client_node, ref payer_node } = lsps_nodes;
+
+	let payer_node_id = payer_node.node.get_our_node_id();
+	let service_node_id = service_node.inner.node.get_our_node_id();
+	let client_node_id = client_node.inner.node.get_our_node_id();
+
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
+
+	create_chan_between_nodes_with_value(&payer_node, &service_node.inner, 2_000_000, 100_000);
+
+	let intercept_scid = service_node.node.get_intercept_scid();
+	let user_channel_id = 42;
+	let cltv_expiry_delta: u32 = 144;
+	let payment_size_msat = Some(1_000_000);
+
+	let fee_base_msat: u64 = 10_000;
+
+	execute_lsps2_dance(
+		&lsps_nodes,
+		intercept_scid,
+		user_channel_id,
+		cltv_expiry_delta,
+		promise_secret,
+		payment_size_msat,
+		fee_base_msat,
+	);
+
+	let invoice = create_jit_invoice(
+		&client_node,
+		service_node_id,
+		intercept_scid,
+		cltv_expiry_delta,
+		payment_size_msat,
+		"test partial fee",
+		3600,
+	)
+	.unwrap();
+
+	payer_node
+		.node
+		.pay_for_bolt11_invoice(
+			&invoice,
+			PaymentId(invoice.payment_hash().to_byte_array()),
+			None,
+			Default::default(),
+			Retry::Attempts(3),
+		)
+		.unwrap();
+
+	check_added_monitors!(payer_node, 1);
+	let events = payer_node.node.get_and_clear_pending_msg_events();
+	let ev = SendEvent::from_event(events[0].clone());
+	service_node.inner.node.handle_update_add_htlc(payer_node_id, &ev.msgs[0]);
+	do_commitment_signed_dance(&service_node.inner, &payer_node, &ev.commitment_msg, false, true);
+	service_node.inner.node.process_pending_htlc_forwards();
+
+	let events = service_node.inner.node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	let (payment_hash, expected_outbound_amount_msat) = match &events[0] {
+		Event::HTLCIntercepted {
+			intercept_id,
+			requested_next_hop_scid,
+			payment_hash,
+			expected_outbound_amount_msat,
+			..
+		} => {
+			assert_eq!(*requested_next_hop_scid, intercept_scid);
+			service_handler
+				.htlc_intercepted(
+					*requested_next_hop_scid,
+					*intercept_id,
+					*expected_outbound_amount_msat,
+					*payment_hash,
+				)
+				.unwrap();
+			(*payment_hash, expected_outbound_amount_msat)
+		},
+		other => panic!("Expected HTLCIntercepted, got {:?}", other),
+	};
+
+	match service_node.liquidity_manager.next_event().unwrap() {
+		LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::OpenChannel {
+			their_network_key,
+			amt_to_forward_msat,
+			opening_fee_msat,
+			user_channel_id: u,
+			intercept_scid: sc,
+		}) => {
+			assert_eq!(their_network_key, client_node_id);
+			assert_eq!(u, user_channel_id);
+			assert_eq!(sc, intercept_scid);
+			assert_eq!(opening_fee_msat, fee_base_msat);
+			assert_eq!(amt_to_forward_msat, payment_size_msat.unwrap() - fee_base_msat);
+		},
+		other => panic!("Unexpected event: {:?}", other),
+	};
+
+	assert!(service_handler
+		.channel_needs_manual_broadcast(user_channel_id, &client_node_id)
+		.unwrap());
+
+	let channel_id = create_channel_with_manual_broadcast(
+		&service_node_id,
+		&client_node_id,
+		&service_node,
+		&client_node,
+		user_channel_id,
+		expected_outbound_amount_msat,
+	);
+
+	service_handler.channel_ready(user_channel_id, &channel_id, &client_node_id).unwrap();
+
+	service_node.inner.node.process_pending_htlc_forwards();
+
+	let pay_event = {
+		{
+			let mut added_monitors =
+				service_node.inner.chain_monitor.added_monitors.lock().unwrap();
+			assert_eq!(added_monitors.len(), 1);
+			added_monitors.clear();
+		}
+		let mut msg_events = service_node.inner.node.get_and_clear_pending_msg_events();
+		assert_eq!(msg_events.len(), 1);
+		SendEvent::from_event(msg_events.remove(0))
+	};
+
+	client_node.inner.node.handle_update_add_htlc(service_node_id, &pay_event.msgs[0]);
+	do_commitment_signed_dance(
+		&client_node.inner,
+		&service_node.inner,
+		&pay_event.commitment_msg,
+		false,
+		true,
+	);
+	client_node.inner.node.process_pending_htlc_forwards();
+
+	let client_events = client_node.inner.node.get_and_clear_pending_events();
+	assert_eq!(client_events.len(), 1);
+	match &client_events[0] {
+		Event::PaymentClaimable { payment_hash: ph, .. } => assert_eq!(*ph, payment_hash),
+		other => panic!("Expected PaymentClaimable, got {:?}", other),
+	};
+
+	assert!(service_node.liquidity_manager.get_and_clear_pending_events().is_empty());
+
+	let partial_skim_msat = fee_base_msat - 1; // less than promised fee
+	service_handler.payment_forwarded(channel_id, Some(partial_skim_msat)).unwrap();
+
+	let events_after_partial = service_node.liquidity_manager.get_and_clear_pending_events();
+	assert!(
+		events_after_partial.is_empty(),
+		"Funding tx broadcast event emitted prematurely: {:?}",
+		events_after_partial
+	);
+}
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index cc2110a9785..db8217727a6 100644
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -980,6 +980,11 @@ enum FundingType {
 	///
 	/// This is the normal flow.
 	Checked(Transaction),
+	/// This variant is useful when we want LDK to validate the funding transaction and
+	/// broadcast it manually.
+	///
+	/// Used in LSPS2 on a client_trusts_lsp model
+	CheckedManualBroadcast(Transaction),
 	/// This variant is useful when we want to loosen the validation checks and allow to
 	/// manually broadcast the funding transaction, leaving the responsibility to the caller.
 	///
@@ -994,6 +999,7 @@ impl FundingType {
 	fn txid(&self) -> Txid {
 		match self {
 			FundingType::Checked(tx) => tx.compute_txid(),
+			FundingType::CheckedManualBroadcast(tx) => tx.compute_txid(),
 			FundingType::Unchecked(outp) => outp.txid,
 		}
 	}
@@ -1001,6 +1007,7 @@ impl FundingType {
 	fn transaction_or_dummy(&self) -> Transaction {
 		match self {
 			FundingType::Checked(tx) => tx.clone(),
+			FundingType::CheckedManualBroadcast(tx) => tx.clone(),
 			FundingType::Unchecked(_) => Transaction {
 				version: bitcoin::transaction::Version::TWO,
 				lock_time: bitcoin::absolute::LockTime::ZERO,
@@ -1013,6 +1020,7 @@ impl FundingType {
 	fn is_manual_broadcast(&self) -> bool {
 		match self {
 			FundingType::Checked(_) => false,
+			FundingType::CheckedManualBroadcast(_) => true,
 			FundingType::Unchecked(_) => true,
 		}
 	}
@@ -5767,6 +5775,27 @@ where
 		self.batch_funding_transaction_generated_intern(temporary_chans, funding_type)
 	}
 
+	/// Call this upon creation of a funding transaction for the given channel.
+	///
+	/// This method executes the same checks as [`ChannelManager::funding_transaction_generated`],
+	/// but it does not automatically broadcast the funding transaction.
+	///
+	/// Call this in response to a [`Event::FundingGenerationReady`] event, only in a context where you want to manually
+	/// control the broadcast of the funding transaction.
+	///
+	/// [`ChannelManager::funding_transaction_generated`]: crate::ln::channelmanager::ChannelManager::funding_transaction_generated
+	/// [`Event::FundingGenerationReady`]: crate::events::Event::FundingGenerationReady
+	pub fn funding_transaction_generated_manual_broadcast(
+		&self, temporary_channel_id: ChannelId, counterparty_node_id: PublicKey,
+		funding_transaction: Transaction,
+	) -> Result<(), APIError> {
+		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
+		self.batch_funding_transaction_generated_intern(
+			&[(&temporary_channel_id, &counterparty_node_id)],
+			FundingType::CheckedManualBroadcast(funding_transaction),
+		)
+	}
+
 	/// Call this upon creation of a batch funding transaction for the given channels.
 	///
 	/// Return values are identical to [`Self::funding_transaction_generated`], respective to
@@ -5788,7 +5817,9 @@ where
 	#[rustfmt::skip]
 	fn batch_funding_transaction_generated_intern(&self, temporary_channels: &[(&ChannelId, &PublicKey)], funding: FundingType) -> Result<(), APIError> {
 		let mut result = Ok(());
-		if let FundingType::Checked(funding_transaction) = &funding {
+		if let FundingType::Checked(funding_transaction) |
+			FundingType::CheckedManualBroadcast(funding_transaction) = &funding
+		{
 			if !funding_transaction.is_coinbase() {
 				for inp in funding_transaction.input.iter() {
 					if inp.witness.is_empty() {
@@ -5848,7 +5879,7 @@ where
 					let mut output_index = None;
 					let expected_spk = chan.funding.get_funding_redeemscript().to_p2wsh();
 					let outpoint = match &funding {
-						FundingType::Checked(tx) => {
+						FundingType::Checked(tx) | FundingType::CheckedManualBroadcast(tx) => {
 							for (idx, outp) in tx.output.iter().enumerate() {
 								if outp.script_pubkey == expected_spk && outp.value.to_sat() == chan.funding.get_value_satoshis() {
 									if output_index.is_some() {