Send 0conf splice_locked upon tx_signatures exchange

Splices negotiated with 0 confirmations require that we immediately lock
it after exchanging `tx_signatures`.

Author: wpaulino

lightning/src/ln/channel.rs

@@ -8636,16 +8636,38 @@ where
 		}
 	}
 
-	fn on_tx_signatures_exchange(&mut self, funding_tx: Transaction) {
+	fn on_tx_signatures_exchange<'a, L: Deref>(
+		&mut self, funding_tx: Transaction, best_block_height: u32,
+		logger: &WithChannelContext<'a, L>,
+	) -> Option<msgs::SpliceLocked>
+	where
+		L::Target: Logger,
+	{
 		debug_assert!(!self.context.channel_state.is_monitor_update_in_progress());
 		debug_assert!(!self.context.channel_state.is_awaiting_remote_revoke());
 
+		let mut splice_locked = None;
 		if let Some(pending_splice) = self.pending_splice.as_mut() {
 			if let Some(FundingNegotiation::AwaitingSignatures { mut funding }) =
 				pending_splice.funding_negotiation.take()
 			{
 				funding.funding_transaction = Some(funding_tx);
 				pending_splice.negotiated_candidates.push(funding);
+				splice_locked = pending_splice.check_get_splice_locked(
+					&self.context,
+					pending_splice.negotiated_candidates.len() - 1,
+					best_block_height,
+				);
+				if let Some(splice_txid) =
+					splice_locked.as_ref().map(|splice_locked| splice_locked.splice_txid)
+				{
+					log_info!(
+						logger,
+						"Sending 0conf splice_locked txid {} to our peer for channel {}",
+						splice_txid,
+						&self.context.channel_id
+					);
+				}
 			} else {
 				debug_assert!(false);
 			}
@@ -8655,11 +8677,20 @@ where
 			self.context.channel_state =
 				ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
 		}
+
+		splice_locked
 	}
 
-	pub fn funding_transaction_signed(
-		&mut self, funding_txid_signed: Txid, witnesses: Vec<Witness>,
-	) -> Result<(Option<msgs::TxSignatures>, Option<Transaction>), APIError> {
+	pub fn funding_transaction_signed<L: Deref>(
+		&mut self, funding_txid_signed: Txid, witnesses: Vec<Witness>, best_block_height: u32,
+		logger: &L,
+	) -> Result<
+		(Option<msgs::TxSignatures>, Option<msgs::SpliceLocked>, Option<Transaction>),
+		APIError,
+	>
+	where
+		L::Target: Logger,
+	{
 		let signing_session =
 			if let Some(signing_session) = self.context.interactive_tx_signing_session.as_mut() {
 				if let Some(pending_splice) = self.pending_splice.as_ref() {
@@ -8674,17 +8705,17 @@ where
 				}
 
 				if signing_session.holder_tx_signatures().is_some() {
-					// Our `tx_signatures` either should've been the first time we processed them,
-					// or we're waiting for our counterparty to send theirs first.
-					return Ok((None, None));
+					// Our `tx_signatures` either should've been sent the first time we processed
+					// them, or we're waiting for our counterparty to send theirs first.
+					return Ok((None, None, None));
 				}
 
 				signing_session
 			} else {
 				if Some(funding_txid_signed) == self.funding.get_funding_txid() {
 					// We may be handling a duplicate call and the funding was already locked so we
 					// no longer have the signing session present.
-					return Ok((None, None));
+					return Ok((None, None, None));
 				}
 				let err =
 					format!("Channel {} not expecting funding signatures", self.context.channel_id);
@@ -8726,17 +8757,31 @@ where
 			.provide_holder_witnesses(tx_signatures, &self.context.secp_ctx)
 			.map_err(|err| APIError::APIMisuseError { err })?;
 
-		if let Some(funding_tx) = funding_tx_opt.clone() {
-			debug_assert!(tx_signatures_opt.is_some());
-			self.on_tx_signatures_exchange(funding_tx);
+		let logger = WithChannelContext::from(logger, &self.context, None);
+		if tx_signatures_opt.is_some() {
+			log_info!(
+				logger,
+				"Sending tx_signatures for interactive funding transaction {funding_txid_signed}"
+			);
 		}
 
-		Ok((tx_signatures_opt, funding_tx_opt))
+		let splice_locked_opt = funding_tx_opt.clone().and_then(|funding_tx| {
+			debug_assert!(tx_signatures_opt.is_some());
+			self.on_tx_signatures_exchange(funding_tx, best_block_height, &logger)
+		});
+
+		Ok((tx_signatures_opt, splice_locked_opt, funding_tx_opt))
 	}
 
-	pub fn tx_signatures(
-		&mut self, msg: &msgs::TxSignatures,
-	) -> Result<(Option<msgs::TxSignatures>, Option<Transaction>), ChannelError> {
+	pub fn tx_signatures<L: Deref>(
+		&mut self, msg: &msgs::TxSignatures, best_block_height: u32, logger: &L,
+	) -> Result<
+		(Option<msgs::TxSignatures>, Option<msgs::SpliceLocked>, Option<Transaction>),
+		ChannelError,
+	>
+	where
+		L::Target: Logger,
+	{
 		let signing_session = if let Some(signing_session) =
 			self.context.interactive_tx_signing_session.as_mut()
 		{
@@ -8782,11 +8827,18 @@ where
 		let (holder_tx_signatures_opt, funding_tx_opt) =
 			signing_session.received_tx_signatures(msg).map_err(|msg| ChannelError::Warn(msg))?;
 
-		if let Some(funding_tx) = funding_tx_opt.clone() {
-			self.on_tx_signatures_exchange(funding_tx);
-		}
+		let logger = WithChannelContext::from(logger, &self.context, None);
+		log_info!(
+			logger,
+			"Received tx_signatures for interactive funding transaction {}",
+			msg.tx_hash
+		);
+
+		let splice_locked_opt = funding_tx_opt.clone().and_then(|funding_tx| {
+			self.on_tx_signatures_exchange(funding_tx, best_block_height, &logger)
+		});
 
-		Ok((holder_tx_signatures_opt, funding_tx_opt))
+		Ok((holder_tx_signatures_opt, splice_locked_opt, funding_tx_opt))
 	}
 
 	/// Queues up an outbound update fee by placing it in the holding cell. You should call
@@ -11113,7 +11165,11 @@ where
 					confirmed_funding_index,
 					height,
 				) {
-					log_info!(logger, "Sending a splice_locked to our peer for channel {}", &self.context.channel_id);
+					log_info!(
+						logger, "Sending splice_locked txid {} to our peer for channel {}",
+						splice_locked.splice_txid,
+						&self.context.channel_id
+					);
 
 					let (funding_txo, monitor_update, announcement_sigs, discarded_funding) = chain_node_signer
 						.and_then(|(chain_hash, node_signer, user_config)| {

lightning/src/ln/channelmanager.rs

@@ -6297,8 +6297,14 @@ where
 							.map(|input| input.witness)
 							.filter(|witness| !witness.is_empty())
 							.collect();
-						match chan.funding_transaction_signed(txid, witnesses) {
-							Ok((Some(tx_signatures), funding_tx_opt)) => {
+						let best_block_height = self.best_block.read().unwrap().height;
+						match chan.funding_transaction_signed(
+							txid,
+							witnesses,
+							best_block_height,
+							&self.logger,
+						) {
+							Ok((Some(tx_signatures), splice_locked_opt, funding_tx_opt)) => {
 								if let Some(funding_tx) = funding_tx_opt {
 									self.broadcast_interactive_funding(
 										chan,
@@ -6312,6 +6318,14 @@ where
 										msg: tx_signatures,
 									},
 								);
+								if let Some(splice_locked) = splice_locked_opt {
+									peer_state.pending_msg_events.push(
+										MessageSendEvent::SendSpliceLocked {
+											node_id: *counterparty_node_id,
+											msg: splice_locked,
+										},
+									);
+								}
 								return NotifyOption::DoPersist;
 							},
 							Err(err) => {
@@ -9422,21 +9436,27 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 				}
 			} else {
 				let txid = signing_session.unsigned_tx().compute_txid();
-				match channel.funding_transaction_signed(txid, vec![]) {
-					Ok((Some(tx_signatures), funding_tx_opt)) => {
+				let best_block_height = self.best_block.read().unwrap().height;
+				match channel.funding_transaction_signed(txid, vec![], best_block_height, &self.logger) {
+					Ok((tx_signatures_opt, splice_locked_opt, funding_tx_opt)) => {
 						if let Some(funding_tx) = funding_tx_opt {
 							self.broadcast_interactive_funding(channel, &funding_tx, &self.logger);
 						}
 						if channel.context.is_connected() {
-							pending_msg_events.push(MessageSendEvent::SendTxSignatures {
-								node_id: counterparty_node_id,
-								msg: tx_signatures,
-							});
+							if let Some(tx_signatures) = tx_signatures_opt {
+								pending_msg_events.push(MessageSendEvent::SendTxSignatures {
+									node_id: counterparty_node_id,
+									msg: tx_signatures,
+								});
+							}
+							if let Some(splice_locked) = splice_locked_opt {
+								pending_msg_events.push(MessageSendEvent::SendSpliceLocked {
+									node_id: counterparty_node_id,
+									msg: splice_locked,
+								});
+							}
 						}
 					},
-					Ok((None, _)) => {
-						debug_assert!(false, "If our tx_signatures is empty, then we should send it first!");
-					},
 					Err(err) => {
 						log_warn!(logger, "Failed signing interactive funding transaction: {err:?}");
 					},
@@ -10383,13 +10403,20 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 			hash_map::Entry::Occupied(mut chan_entry) => {
 				match chan_entry.get_mut().as_funded_mut() {
 					Some(chan) => {
-						let (tx_signatures_opt, funding_tx_opt) = try_channel_entry!(self, peer_state, chan.tx_signatures(msg), chan_entry);
+						let best_block_height = self.best_block.read().unwrap().height;
+						let (tx_signatures_opt, splice_locked_opt, funding_tx_opt) = try_channel_entry!(self, peer_state, chan.tx_signatures(msg, best_block_height, &self.logger), chan_entry);
 						if let Some(tx_signatures) = tx_signatures_opt {
 							peer_state.pending_msg_events.push(MessageSendEvent::SendTxSignatures {
 								node_id: *counterparty_node_id,
 								msg: tx_signatures,
 							});
 						}
+						if let Some(splice_locked) = splice_locked_opt {
+							peer_state.pending_msg_events.push(MessageSendEvent::SendSpliceLocked {
+								node_id: *counterparty_node_id,
+								msg: splice_locked,
+							});
+						}
 						if let Some(ref funding_tx) = funding_tx_opt {
 							self.broadcast_interactive_funding(chan, funding_tx, &self.logger);
 						}