Send splice_locked on channel_reestablish

The channel_reestablish protocol supports retransmitting splice_locked
messages as needed. Add support for doing such when handling
channel_reestablish messages.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1213,6 +1213,7 @@ pub(super) struct ReestablishResponses {
 	pub shutdown_msg: Option<msgs::Shutdown>,
 	pub tx_signatures: Option<msgs::TxSignatures>,
 	pub tx_abort: Option<msgs::TxAbort>,
+	pub splice_locked: Option<msgs::SpliceLocked>,
 }
 
 /// The first message we send to our peer after connection
@@ -2169,6 +2170,10 @@ impl FundingScope {
 	pub fn get_short_channel_id(&self) -> Option<u64> {
 		self.short_channel_id
 	}
+
+	fn is_splice(&self) -> bool {
+		self.channel_transaction_parameters.splice_parent_funding_txid.is_some()
+	}
 }
 
 /// Info about a pending splice, used in the pre-splice channel
@@ -8389,6 +8394,7 @@ where
 					shutdown_msg, announcement_sigs,
 					tx_signatures: None,
 					tx_abort: None,
+					splice_locked: None,
 				});
 			}
 
@@ -8400,6 +8406,7 @@ where
 				shutdown_msg, announcement_sigs,
 				tx_signatures: None,
 				tx_abort: None,
+				splice_locked: None,
 			});
 		}
 
@@ -8445,6 +8452,25 @@ where
 				.and_then(|_| self.get_channel_ready(logger))
 		} else { None };
 
+		// A receiving node:
+		//   - if `your_last_funding_locked` is set and it does not match the most recent
+		//     `splice_locked` it has sent:
+		//     - MUST retransmit `splice_locked`.
+		let sent_splice_txid = self
+			.maybe_get_my_current_funding_locked(features)
+			.filter(|funding| funding.is_splice())
+			.map(|funding| {
+				funding.get_funding_txid().expect("Splice funding_txid should always be set")
+			});
+		let splice_locked = msg.your_last_funding_locked_txid.and_then(|last_funding_txid| {
+			sent_splice_txid
+				.filter(|sent_splice_txid| last_funding_txid != *sent_splice_txid)
+				.map(|splice_txid| msgs::SpliceLocked {
+					channel_id: self.context.channel_id,
+					splice_txid,
+				})
+		});
+
 		let mut commitment_update = None;
 		let mut tx_signatures = None;
 		let mut tx_abort = None;
@@ -8551,6 +8577,7 @@ where
 				order: self.context.resend_order.clone(),
 				tx_signatures,
 				tx_abort,
+				splice_locked,
 			})
 		} else if msg.next_local_commitment_number == next_counterparty_commitment_number - 1 {
 			// We've made an update so we must have exchanged `tx_signatures`, implying that
@@ -8572,6 +8599,7 @@ where
 					order: self.context.resend_order.clone(),
 					tx_signatures,
 					tx_abort,
+					splice_locked,
 				})
 			} else {
 				let commitment_update = if self.context.resend_order == RAACommitmentOrder::RevokeAndACKFirst
@@ -8596,6 +8624,7 @@ where
 					order: self.context.resend_order.clone(),
 					tx_signatures,
 					tx_abort,
+					splice_locked,
 				})
 			}
 		} else if msg.next_local_commitment_number < next_counterparty_commitment_number {
@@ -10219,6 +10248,32 @@ where
 		None
 	}
 
+	#[cfg(splicing)]
+	fn maybe_get_my_current_funding_locked(
+		&self, features: &InitFeatures,
+	) -> Option<&FundingScope> {
+		if !features.supports_splicing() {
+			return None;
+		}
+
+		self.pending_splice
+			.as_ref()
+			.and_then(|pending_splice| pending_splice.sent_funding_txid)
+			.and_then(|funding_txid| {
+				self.pending_funding
+					.iter()
+					.find(|funding| funding.get_funding_txid() == Some(funding_txid))
+			})
+			.or_else(|| self.is_our_channel_ready().then(|| &self.funding))
+	}
+
+	#[cfg(not(splicing))]
+	fn maybe_get_my_current_funding_locked(
+		&self, _features: &InitFeatures,
+	) -> Option<&FundingScope> {
+		None
+	}
+
 	#[cfg(splicing)]
 	fn maybe_get_my_current_funding_locked_txid(&self, features: &InitFeatures) -> Option<Txid> {
 		if !features.supports_splicing() {

lightning/src/ln/channelmanager.rs

@@ -3406,7 +3406,8 @@ macro_rules! handle_monitor_update_completion {
 			&mut $peer_state.pending_msg_events, $chan, updates.raa,
 			updates.commitment_update, updates.order, updates.accepted_htlcs, updates.pending_update_adds,
 			updates.funding_broadcastable, updates.channel_ready,
-			updates.announcement_sigs, updates.tx_signatures, None);
+			updates.announcement_sigs, updates.tx_signatures, None, None,
+		);
 		if let Some(upd) = channel_update {
 			$peer_state.pending_msg_events.push(upd);
 		}
@@ -8059,9 +8060,10 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		funding_broadcastable: Option<Transaction>,
 		channel_ready: Option<msgs::ChannelReady>, announcement_sigs: Option<msgs::AnnouncementSignatures>,
 		tx_signatures: Option<msgs::TxSignatures>, tx_abort: Option<msgs::TxAbort>,
+		splice_locked: Option<msgs::SpliceLocked>,
 	) -> (Option<(u64, Option<PublicKey>, OutPoint, ChannelId, u128, Vec<(PendingHTLCInfo, u64)>)>, Option<(u64, Vec<msgs::UpdateAddHTLC>)>) {
 		let logger = WithChannelContext::from(&self.logger, &channel.context, None);
-		log_trace!(logger, "Handling channel resumption for channel {} with {} RAA, {} commitment update, {} pending forwards, {} pending update_add_htlcs, {}broadcasting funding, {} channel ready, {} announcement, {} tx_signatures, {} tx_abort",
+		log_trace!(logger, "Handling channel resumption for channel {} with {} RAA, {} commitment update, {} pending forwards, {} pending update_add_htlcs, {}broadcasting funding, {} channel ready, {} announcement, {} tx_signatures, {} tx_abort, {} splice_locked",
 			&channel.context.channel_id(),
 			if raa.is_some() { "an" } else { "no" },
 			if commitment_update.is_some() { "a" } else { "no" },
@@ -8071,6 +8073,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 			if announcement_sigs.is_some() { "sending" } else { "without" },
 			if tx_signatures.is_some() { "sending" } else { "without" },
 			if tx_abort.is_some() { "sending" } else { "without" },
+			if splice_locked.is_some() { "sending" } else { "without" },
 		);
 
 		let counterparty_node_id = channel.context.get_counterparty_node_id();
@@ -8110,6 +8113,12 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 				msg,
 			});
 		}
+		if let Some(msg) = splice_locked {
+			pending_msg_events.push(MessageSendEvent::SendSpliceLocked {
+				node_id: counterparty_node_id,
+				msg,
+			});
+		}
 
 		macro_rules! handle_cs { () => {
 			if let Some(update) = commitment_update {
@@ -10054,7 +10063,8 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 						let (htlc_forwards, decode_update_add_htlcs) = self.handle_channel_resumption(
 							&mut peer_state.pending_msg_events, chan, responses.raa, responses.commitment_update, responses.order,
 							Vec::new(), Vec::new(), None, responses.channel_ready, responses.announcement_sigs,
-							responses.tx_signatures, responses.tx_abort);
+							responses.tx_signatures, responses.tx_abort, responses.splice_locked,
+						);
 						debug_assert!(htlc_forwards.is_none());
 						debug_assert!(decode_update_add_htlcs.is_none());
 						if let Some(upd) = channel_update {