Emit SpliceLocked event

Once both parties have exchanged splice_locked messages, the splice
funding is ready for use. Emit an event to the user indicating as much.

Author: jkczyz

lightning/src/events/mod.rs

@@ -1318,6 +1318,29 @@ pub enum Event {
 		/// The features that this channel will operate with.
 		channel_type: ChannelTypeFeatures,
 	},
+	/// Used to indicate that a channel with the given `channel_id` has had its funding spliced.
+	/// This event is emitted when the splice transaction has been confirmed on-chain to a
+	/// sufficient depth by both parties, or, in case of a 0-conf channel, when both parties have
+	/// completed negotiation of the splice transaction.
+	///
+	/// # Failure Behavior and Persistence
+	/// This event will eventually be replayed after failures-to-handle (i.e., the event handler
+	/// returning `Err(ReplayEvent ())`) and will be persisted across restarts.
+	SpliceLocked {
+		/// The `channel_id` of the channel that had its funding spliced.
+		channel_id: ChannelId,
+		/// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound
+		/// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if
+		/// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
+		/// `user_channel_id` will be randomized for an inbound channel.
+		///
+		/// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
+		/// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
+		/// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
+		user_channel_id: u128,
+		/// The `node_id` of the channel counterparty.
+		counterparty_node_id: PublicKey,
+	},
 	/// Used to indicate that a channel that got past the initial handshake with the given `channel_id` is in the
 	/// process of closure. This includes previously opened channels, and channels that time out from not being funded.
 	///
@@ -1842,6 +1865,14 @@ impl Writeable for Event {
 					(8, former_temporary_channel_id, required),
 				});
 			},
+			&Event::SpliceLocked { ref channel_id, ref user_channel_id, ref counterparty_node_id } => {
+				45u8.write(writer)?;
+				write_tlv_fields!(writer, {
+					(0, channel_id, required),
+					(2, user_channel_id, required),
+					(4, counterparty_node_id, required),
+				});
+			},
 			// Note that, going forward, all new events must only write data inside of
 			// `write_tlv_fields`. Versions 0.0.101+ will ignore odd-numbered events that write
 			// data via `write_tlv_fields`.
@@ -2358,6 +2389,25 @@ impl MaybeReadable for Event {
 					former_temporary_channel_id: former_temporary_channel_id.0.unwrap(),
 				}))
 			},
+			45u8 => {
+				let mut f = || {
+					let mut channel_id = ChannelId::new_zero();
+					let mut user_channel_id: u128 = 0;
+					let mut counterparty_node_id = RequiredWrapper(None);
+					read_tlv_fields!(reader, {
+						(0, channel_id, required),
+						(2, user_channel_id, required),
+						(4, counterparty_node_id, required),
+					});
+
+					Ok(Some(Event::SpliceLocked {
+						channel_id,
+						user_channel_id,
+						counterparty_node_id: counterparty_node_id.0.unwrap(),
+					}))
+				};
+				f()
+			},
 			// Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
 			// Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt
 			// reads.

lightning/src/ln/channelmanager.rs

@@ -9640,6 +9640,13 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 						let mut short_to_chan_info = self.short_to_chan_info.write().unwrap();
 						insert_short_channel_id!(short_to_chan_info, chan);
 
+						let mut pending_events = self.pending_events.lock().unwrap();
+						pending_events.push_back((events::Event::SpliceLocked {
+							channel_id: chan.context.channel_id(),
+							user_channel_id: chan.context.get_user_id(),
+							counterparty_node_id: chan.context.get_counterparty_node_id(),
+						}, None));
+
 						log_trace!(logger, "Sending announcement_signatures for channel {}", chan.context.channel_id());
 						peer_state.pending_msg_events.push(MessageSendEvent::SendAnnouncementSignatures {
 							node_id: counterparty_node_id.clone(),
@@ -11784,6 +11791,13 @@ where
 										if announcement_sigs.is_some() {
 											let mut short_to_chan_info = self.short_to_chan_info.write().unwrap();
 											insert_short_channel_id!(short_to_chan_info, funded_channel);
+
+											let mut pending_events = self.pending_events.lock().unwrap();
+											pending_events.push_back((events::Event::SpliceLocked {
+												channel_id: funded_channel.context.channel_id(),
+												user_channel_id: funded_channel.context.get_user_id(),
+												counterparty_node_id: funded_channel.context.get_counterparty_node_id(),
+											}, None));
 										}
 
 										pending_msg_events.push(MessageSendEvent::SendSpliceLocked {