Emit SplicePending event when splice funding is negotiated

Add Event::SplicePending emission whenever a FundingScope is pushed
into PendingSplice::negotiated_candidates. This allows applications
to be notified when a splice transaction has been constructed and
signed but is not yet confirmed on-chain.

Creates SpliceFundingNegotiated struct to carry event data from
channel operations to ChannelManager, where it's converted to the
appropriate Event. Updates function signatures in the channel layer
to return this information and modifies all callers in ChannelManager
to handle the new return values and emit the events.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: jkczyz

lightning/src/ln/channel.rs

@@ -111,6 +111,21 @@ pub struct ChannelValueStat {
 	pub counterparty_dust_limit_msat: u64,
 }
 
+/// Information about a splice funding negotiation that has been completed.
+/// This is returned from channel operations and converted to an Event::SplicePending in ChannelManager.
+pub struct SpliceFundingNegotiated {
+	/// The channel_id of the channel being spliced.
+	pub channel_id: ChannelId,
+	/// The counterparty's node_id.
+	pub counterparty_node_id: PublicKey,
+	/// The user_channel_id value.
+	pub user_channel_id: u128,
+	/// The outpoint of the channel's splice funding transaction.
+	pub funding_txo: bitcoin::OutPoint,
+	/// The features that this channel will operate with.
+	pub channel_type: ChannelTypeFeatures,
+}
+
 pub struct AvailableBalances {
 	/// Total amount available for our counterparty to send to us.
 	pub inbound_capacity_msat: u64,
@@ -8579,30 +8594,46 @@ where
 		}
 	}
 
-	fn on_tx_signatures_exchange(&mut self, funding_tx: Transaction) {
+	fn on_tx_signatures_exchange(&mut self, funding_tx: Transaction) -> Option<SpliceFundingNegotiated> {
 		debug_assert!(!self.context.channel_state.is_monitor_update_in_progress());
 		debug_assert!(!self.context.channel_state.is_awaiting_remote_revoke());
 
 		if let Some(pending_splice) = self.pending_splice.as_mut() {
+			self.context.channel_state.clear_quiescent();
 			if let Some(FundingNegotiation::AwaitingSignatures { mut funding }) =
 				pending_splice.funding_negotiation.take()
 			{
 				funding.funding_transaction = Some(funding_tx);
+
+				let funding_txo = funding.get_funding_txo().expect("funding outpoint should be set");
+				let channel_type = funding.get_channel_type().clone();
+
 				pending_splice.negotiated_candidates.push(funding);
+
+				let splice_negotiated = SpliceFundingNegotiated {
+					channel_id: self.context.channel_id,
+					counterparty_node_id: self.context.counterparty_node_id,
+					user_channel_id: self.context.user_id,
+					funding_txo: funding_txo.into_bitcoin_outpoint(),
+					channel_type,
+				};
+
+				Some(splice_negotiated)
 			} else {
 				debug_assert!(false);
+				None
 			}
-			self.context.channel_state.clear_quiescent();
 		} else {
 			self.funding.funding_transaction = Some(funding_tx);
 			self.context.channel_state =
 				ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
+			None
 		}
 	}
 
 	pub fn funding_transaction_signed(
 		&mut self, funding_txid_signed: Txid, witnesses: Vec<Witness>,
-	) -> Result<(Option<msgs::TxSignatures>, Option<Transaction>), APIError> {
+	) -> Result<(Option<msgs::TxSignatures>, Option<Transaction>, Option<SpliceFundingNegotiated>), APIError> {
 		let signing_session =
 			if let Some(signing_session) = self.context.interactive_tx_signing_session.as_mut() {
 				if let Some(pending_splice) = self.pending_splice.as_ref() {
@@ -8658,17 +8689,19 @@ where
 			.provide_holder_witnesses(tx_signatures, &self.context.secp_ctx)
 			.map_err(|err| APIError::APIMisuseError { err })?;
 
-		if let Some(funding_tx) = funding_tx_opt.clone() {
+		let splice_negotiated = if let Some(funding_tx) = funding_tx_opt.clone() {
 			debug_assert!(tx_signatures_opt.is_some());
-			self.on_tx_signatures_exchange(funding_tx);
-		}
+			self.on_tx_signatures_exchange(funding_tx)
+		} else {
+			None
+		};
 
-		Ok((tx_signatures_opt, funding_tx_opt))
+		Ok((tx_signatures_opt, funding_tx_opt, splice_negotiated))
 	}
 
 	pub fn tx_signatures(
 		&mut self, msg: &msgs::TxSignatures,
-	) -> Result<(Option<msgs::TxSignatures>, Option<Transaction>), ChannelError> {
+	) -> Result<(Option<msgs::TxSignatures>, Option<Transaction>, Option<SpliceFundingNegotiated>), ChannelError> {
 		let signing_session = if let Some(signing_session) =
 			self.context.interactive_tx_signing_session.as_mut()
 		{
@@ -8714,11 +8747,13 @@ where
 		let (holder_tx_signatures_opt, funding_tx_opt) =
 			signing_session.received_tx_signatures(msg).map_err(|msg| ChannelError::Warn(msg))?;
 
-		if let Some(funding_tx) = funding_tx_opt.clone() {
-			self.on_tx_signatures_exchange(funding_tx);
-		}
+		let splice_negotiated = if let Some(funding_tx) = funding_tx_opt.clone() {
+			self.on_tx_signatures_exchange(funding_tx)
+		} else {
+			None
+		};
 
-		Ok((holder_tx_signatures_opt, funding_tx_opt))
+		Ok((holder_tx_signatures_opt, funding_tx_opt, splice_negotiated))
 	}
 
 	/// Queues up an outbound update fee by placing it in the holding cell. You should call

lightning/src/ln/channelmanager.rs

@@ -61,7 +61,7 @@ use crate::ln::channel::QuiescentAction;
 use crate::ln::channel::{
 	self, hold_time_since, Channel, ChannelError, ChannelUpdateStatus, FundedChannel,
 	InboundV1Channel, OutboundV1Channel, PendingV2Channel, ReconnectionMsg, ShutdownResult,
-	StfuResponse, UpdateFulfillCommitFetch, WithChannelContext,
+	SpliceFundingNegotiated, StfuResponse, UpdateFulfillCommitFetch, WithChannelContext,
 };
 use crate::ln::channel_state::ChannelDetails;
 use crate::ln::funding::SpliceContribution;
@@ -6098,10 +6098,22 @@ where
 							.filter(|witness| !witness.is_empty())
 							.collect();
 						match chan.funding_transaction_signed(txid, witnesses) {
-							Ok((Some(tx_signatures), funding_tx_opt)) => {
+							Ok((Some(tx_signatures), funding_tx_opt, splice_negotiated)) => {
 								if let Some(funding_tx) = funding_tx_opt {
 									self.broadcast_interactive_funding(chan, &funding_tx);
 								}
+								if let Some(splice_negotiated) = splice_negotiated {
+									self.pending_events.lock().unwrap().push_back((
+										events::Event::SplicePending {
+											channel_id: splice_negotiated.channel_id,
+											counterparty_node_id: splice_negotiated.counterparty_node_id,
+											user_channel_id: splice_negotiated.user_channel_id,
+											funding_txo: splice_negotiated.funding_txo,
+											channel_type: splice_negotiated.channel_type,
+										},
+										None,
+									));
+								}
 								peer_state.pending_msg_events.push(
 									MessageSendEvent::SendTxSignatures {
 										node_id: *counterparty_node_id,
@@ -9154,16 +9166,28 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 			} else {
 				let txid = signing_session.unsigned_tx().compute_txid();
 				match channel.funding_transaction_signed(txid, vec![]) {
-					Ok((Some(tx_signatures), funding_tx_opt)) => {
+					Ok((Some(tx_signatures), funding_tx_opt, splice_negotiated)) => {
 						if let Some(funding_tx) = funding_tx_opt {
 							self.broadcast_interactive_funding(channel, &funding_tx);
 						}
+						if let Some(splice_negotiated) = splice_negotiated {
+							self.pending_events.lock().unwrap().push_back((
+								events::Event::SplicePending {
+									channel_id: splice_negotiated.channel_id,
+									counterparty_node_id: splice_negotiated.counterparty_node_id,
+									user_channel_id: splice_negotiated.user_channel_id,
+									funding_txo: splice_negotiated.funding_txo,
+									channel_type: splice_negotiated.channel_type,
+								},
+								None,
+							));
+						}
 						pending_msg_events.push(MessageSendEvent::SendTxSignatures {
 							node_id: counterparty_node_id,
 							msg: tx_signatures,
 						});
 					},
-					Ok((None, _)) => {
+					Ok((None, _, _)) => {
 						debug_assert!(false, "If our tx_signatures is empty, then we should send it first!");
 					},
 					Err(err) => {
@@ -10109,7 +10133,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 			hash_map::Entry::Occupied(mut chan_entry) => {
 				match chan_entry.get_mut().as_funded_mut() {
 					Some(chan) => {
-						let (tx_signatures_opt, funding_tx_opt) = try_channel_entry!(self, peer_state, chan.tx_signatures(msg), chan_entry);
+						let (tx_signatures_opt, funding_tx_opt, splice_negotiated) = try_channel_entry!(self, peer_state, chan.tx_signatures(msg), chan_entry);
 						if let Some(tx_signatures) = tx_signatures_opt {
 							peer_state.pending_msg_events.push(MessageSendEvent::SendTxSignatures {
 								node_id: *counterparty_node_id,
@@ -10123,6 +10147,18 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 								emit_channel_pending_event!(pending_events, chan);
 							}
 						}
+						if let Some(splice_negotiated) = splice_negotiated {
+							self.pending_events.lock().unwrap().push_back((
+								events::Event::SplicePending {
+									channel_id: splice_negotiated.channel_id,
+									counterparty_node_id: splice_negotiated.counterparty_node_id,
+									user_channel_id: splice_negotiated.user_channel_id,
+									funding_txo: splice_negotiated.funding_txo,
+									channel_type: splice_negotiated.channel_type,
+								},
+								None,
+							));
+						}
 					},
 					None => {
 						let msg = "Got an unexpected tx_signatures message";