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

@@ -1217,6 +1217,7 @@ pub(super) struct ReestablishResponses {
 	pub tx_signatures: Option<msgs::TxSignatures>,
 	pub tx_abort: Option<msgs::TxAbort>,
 	pub splice_locked: Option<msgs::SpliceLocked>,
+	pub implicit_splice_locked: Option<msgs::SpliceLocked>,
 }
 
 /// The first message we send to our peer after connection
@@ -8357,6 +8358,7 @@ where
 					tx_signatures: None,
 					tx_abort: None,
 					splice_locked: None,
+					implicit_splice_locked: None,
 				});
 			}
 
@@ -8369,6 +8371,7 @@ where
 				tx_signatures: None,
 				tx_abort: None,
 				splice_locked: None,
+				implicit_splice_locked: None,
 			});
 		}
 
@@ -8480,6 +8483,30 @@ where
 				splice_txid,
 			});
 
+		// 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 implicit_splice_locked = msg.my_current_funding_locked_txid.and_then(|funding_txid| {
+			self.pending_funding
+				.iter()
+				.find(|funding| funding.get_funding_txid() == Some(funding_txid))
+				.and_then(|_| {
+					self.pending_splice.as_ref().and_then(|pending_splice| {
+						(Some(funding_txid) != pending_splice.received_funding_txid)
+							.then(|| funding_txid)
+					})
+				})
+				.map(|splice_txid| msgs::SpliceLocked {
+					channel_id: self.context.channel_id,
+					splice_txid,
+				})
+		});
+		#[cfg(not(splicing))]
+		let implicit_splice_locked = None;
+
 		let mut commitment_update = None;
 		let mut tx_signatures = None;
 		let mut tx_abort = None;
@@ -8593,6 +8620,7 @@ where
 				tx_signatures,
 				tx_abort,
 				splice_locked,
+				implicit_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
@@ -8615,6 +8643,7 @@ where
 					tx_signatures,
 					tx_abort,
 					splice_locked,
+					implicit_splice_locked,
 				})
 			} else {
 				let commitment_update = if self.context.resend_order == RAACommitmentOrder::RevokeAndACKFirst
@@ -8640,6 +8669,7 @@ where
 					tx_signatures,
 					tx_abort,
 					splice_locked,
+					implicit_splice_locked,
 				})
 			}
 		} else if msg.next_local_commitment_number < next_counterparty_commitment_number {

lightning/src/ln/channelmanager.rs

@@ -10046,7 +10046,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 (implicit_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)
@@ -10099,7 +10099,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.implicit_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);
@@ -10146,6 +10147,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 _ = implicit_splice_locked;
+		#[cfg(splicing)]
+		if let Some(splice_locked) = implicit_splice_locked {
+			self.internal_splice_locked(counterparty_node_id, &splice_locked)?;
+			return Ok(NotifyOption::DoPersist);
+		}
+
 		Ok(NotifyOption::SkipPersistHandleEvents)
 	}