Handle implicit splice_locked during channel_reestablish

When handling a counterparties channel_reestablish, the spec dictates
that a splice_locked may be implied by my_current_funding_locked.
Compare that against any pending splices and handle an implicit
splice_locked message when applicable.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1215,6 +1215,7 @@ pub(super) struct ReestablishResponses {
 	pub shutdown_msg: Option<msgs::Shutdown>,
 	pub tx_signatures: Option<msgs::TxSignatures>,
 	pub tx_abort: Option<msgs::TxAbort>,
+	pub inferred_splice_locked: Option<msgs::SpliceLocked>,
 }
 
 /// The first message we send to our peer after connection
@@ -8734,6 +8735,7 @@ where
 					shutdown_msg, announcement_sigs,
 					tx_signatures: None,
 					tx_abort: None,
+					inferred_splice_locked: None,
 				});
 			}
 
@@ -8745,6 +8747,7 @@ where
 				shutdown_msg, announcement_sigs,
 				tx_signatures: None,
 				tx_abort: None,
+				inferred_splice_locked: None,
 			});
 		}
 
@@ -8780,6 +8783,30 @@ where
 			self.get_channel_ready(logger)
 		} else { None };
 
+		// A receiving node:
+		//   - if splice transactions are pending and `my_current_funding_locked` matches one of
+		//     those splice transactions, for which it hasn't received `splice_locked` yet:
+		//     - MUST process `my_current_funding_locked` as if it was receiving `splice_locked`
+		//       for this `txid`.
+		#[cfg(splicing)]
+		let inferred_splice_locked = msg.my_current_funding_locked.as_ref().and_then(|funding_locked| {
+			self.pending_funding
+				.iter()
+				.find(|funding| funding.get_funding_txid() == Some(funding_locked.txid))
+				.and_then(|_| {
+					self.pending_splice.as_ref().and_then(|pending_splice| {
+						(Some(funding_locked.txid) != pending_splice.received_funding_txid)
+							.then(|| funding_locked.txid)
+					})
+				})
+				.map(|splice_txid| msgs::SpliceLocked {
+					channel_id: self.context.channel_id,
+					splice_txid,
+				})
+		});
+		#[cfg(not(splicing))]
+		let inferred_splice_locked = None;
+
 		let mut commitment_update = None;
 		let mut tx_signatures = None;
 		let mut tx_abort = None;
@@ -8874,6 +8901,7 @@ where
 				order: self.context.resend_order.clone(),
 				tx_signatures,
 				tx_abort,
+				inferred_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
@@ -8895,6 +8923,7 @@ where
 					order: self.context.resend_order.clone(),
 					tx_signatures,
 					tx_abort,
+					inferred_splice_locked,
 				})
 			} else {
 				let commitment_update = if self.context.resend_order == RAACommitmentOrder::RevokeAndACKFirst
@@ -8919,6 +8948,7 @@ where
 					order: self.context.resend_order.clone(),
 					tx_signatures,
 					tx_abort,
+					inferred_splice_locked,
 				})
 			}
 		} else if msg.next_local_commitment_number < next_counterparty_commitment_number {

lightning/src/ln/channelmanager.rs

@@ -11002,7 +11002,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 
 	#[rustfmt::skip]
 	fn internal_channel_reestablish(&self, counterparty_node_id: &PublicKey, msg: &msgs::ChannelReestablish) -> Result<NotifyOption, MsgHandleErrInternal> {
-		let need_lnd_workaround = {
+		let (inferred_splice_locked, need_lnd_workaround) = {
 			let per_peer_state = self.per_peer_state.read().unwrap();
 
 			let peer_state_mutex = per_peer_state.get(counterparty_node_id)
@@ -11053,7 +11053,8 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 						if let Some(upd) = channel_update {
 							peer_state.pending_msg_events.push(upd);
 						}
-						need_lnd_workaround
+
+						(responses.inferred_splice_locked, need_lnd_workaround)
 					} else {
 						return try_channel_entry!(self, peer_state, Err(ChannelError::close(
 							"Got a channel_reestablish message for an unfunded channel!".into())), chan_entry);
@@ -11099,6 +11100,15 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		if let Some(channel_ready_msg) = need_lnd_workaround {
 			self.internal_channel_ready(counterparty_node_id, &channel_ready_msg)?;
 		}
+
+		#[cfg(not(splicing))]
+		let _ = inferred_splice_locked;
+		#[cfg(splicing)]
+		if let Some(splice_locked) = inferred_splice_locked {
+			self.internal_splice_locked(counterparty_node_id, &splice_locked)?;
+			return Ok(NotifyOption::DoPersist);
+		}
+
 		Ok(NotifyOption::SkipPersistHandleEvents)
 	}