Emit SpliceFailed events for splice_ack failures

When splice_ack validation or interactive transaction construction fails,
emit Event::SpliceFailed to notify users of the failure.

This reuses the SpliceFundingFailed struct introduced for interactive
transaction failures, providing consistent failure reporting across all
splice operations. The implementation handles two failure scenarios:

- Early validation failure: Sets funding_txo and channel_type to None
  since no splice funding was established
- Late construction failure: Includes actual funding information since
  validation passed but transaction construction failed

The SpliceFundingFailed struct provides placeholders for contributed
inputs/outputs that can be populated when access to interactive
transaction constructor internals becomes available.

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

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

Author: jkczyz

lightning/src/ln/channel.rs

@@ -11924,12 +11924,24 @@ where
 	pub(crate) fn splice_ack<ES: Deref, L: Deref>(
 		&mut self, msg: &msgs::SpliceAck, signer_provider: &SP, entropy_source: &ES,
 		holder_node_id: &PublicKey, logger: &L,
-	) -> Result<Option<InteractiveTxMessageSend>, ChannelError>
+	) -> Result<Option<InteractiveTxMessageSend>, (ChannelError, SpliceFundingFailed)>
 	where
 		ES::Target: EntropySource,
 		L::Target: Logger,
 	{
-		let splice_funding = self.validate_splice_ack(msg)?;
+		let splice_funding = self.validate_splice_ack(msg).map_err(|err| {
+			let splice_failed = SpliceFundingFailed {
+				channel_id: self.context.channel_id,
+				counterparty_node_id: self.context.counterparty_node_id,
+				user_channel_id: self.context.user_id,
+				funding_txo: None,
+				channel_type: None,
+				// FIXME: Populate these from funding_negotiation_context?
+				contributed_inputs: Vec::new(),
+				contributed_outputs: Vec::new(),
+			};
+			(err, splice_failed)
+		})?;
 
 		log_info!(
 			logger,
@@ -11959,10 +11971,20 @@ where
 				holder_node_id.clone(),
 			)
 			.map_err(|err| {
-				ChannelError::WarnAndDisconnect(format!(
+				let splice_failed = SpliceFundingFailed {
+					channel_id: self.context.channel_id,
+					counterparty_node_id: self.context.counterparty_node_id,
+					user_channel_id: self.context.user_id,
+					funding_txo: splice_funding.get_funding_txo().map(|txo| txo.into_bitcoin_outpoint()),
+					channel_type: Some(splice_funding.get_channel_type().clone()),
+					contributed_inputs: err.contributed_inputs,
+					contributed_outputs: err.contributed_outputs,
+				};
+				let channel_error = ChannelError::WarnAndDisconnect(format!(
 					"Failed to start interactive transaction construction, {:?}",
-					err
-				))
+					err.reason
+				));
+				(channel_error, splice_failed)
 			})?;
 		let tx_msg_opt = interactive_tx_constructor.take_initiator_first_message();
 

lightning/src/ln/channelmanager.rs

@@ -11526,7 +11526,26 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 						msg, &self.signer_provider, &self.entropy_source,
 						&self.get_our_node_id(), &self.logger
 					);
-					let tx_msg_opt = try_channel_entry!(self, peer_state, splice_ack_res, chan_entry);
+
+					// Handle splice_ack failure and emit SpliceFailed event if needed
+					let tx_msg_opt = match splice_ack_res {
+						Ok(tx_msg_opt) => Ok(tx_msg_opt),
+						Err((channel_error, splice_funding_failed)) => {
+							let pending_events = &mut self.pending_events.lock().unwrap();
+							pending_events.push_back((events::Event::SpliceFailed {
+								channel_id: splice_funding_failed.channel_id,
+								counterparty_node_id: splice_funding_failed.counterparty_node_id,
+								user_channel_id: splice_funding_failed.user_channel_id,
+								funding_txo: splice_funding_failed.funding_txo,
+								channel_type: splice_funding_failed.channel_type,
+								contributed_inputs: splice_funding_failed.contributed_inputs,
+								contributed_outputs: splice_funding_failed.contributed_outputs,
+							}, None));
+							Err(channel_error)
+						}
+					};
+
+					let tx_msg_opt = try_channel_entry!(self, peer_state, tx_msg_opt, chan_entry);
 					if let Some(tx_msg) = tx_msg_opt {
 						peer_state.pending_msg_events.push(tx_msg.into_msg_send_event(counterparty_node_id.clone()));
 					}