WIP Implement closing_sig handler for option_simple_close

Implement the closer-side handling of the `closing_sig` message, which
is the response to our `closing_complete`. The new `closing_sig()` method
on `FundedChannel` validates that echoed fields match what we sent,
ensures exactly one signature is present in a TLV field we offered,
verifies the counterparty's signature, builds the signed closing
transaction, and transitions the channel to `ShutdownComplete`.

The `internal_closing_sig()` method in `ChannelManager` replaces the
previous `unimplemented!()` stub, following the same pattern as
`internal_closing_complete()` but without queuing a response message
since the closer simply broadcasts.

Co-Authored-By: HAL 9000
Signed-off-by: Elias Rohrer <dev@tnull.de>

Author: tnull

lightning/src/ln/channel.rs

@@ -11722,6 +11722,182 @@ where
 		Ok((Some(closing_sig), Some((signed_tx, shutdown_result))))
 	}
 
+	pub fn closing_sig<L: Logger>(
+		&mut self, msg: &msgs::ClosingSig, logger: &L,
+	) -> Result<Option<(Transaction, ShutdownResult)>, ChannelError> {
+		if !self.context.channel_state.is_both_sides_shutdown() {
+			return Err(ChannelError::close(
+				"Remote end sent us a closing_sig before both sides provided a shutdown".to_owned(),
+			));
+		}
+		if self.context.channel_state.is_peer_disconnected() {
+			return Err(ChannelError::close(
+				"Peer sent closing_sig when we needed a channel_reestablish".to_owned(),
+			));
+		}
+		if !self.context.pending_inbound_htlcs.is_empty()
+			|| !self.context.pending_outbound_htlcs.is_empty()
+		{
+			return Err(ChannelError::close(
+				"Remote end sent us a closing_sig while there were still pending HTLCs".to_owned(),
+			));
+		}
+
+		// Retrieve the closing_complete we sent that this closing_sig is responding to.
+		let v2_closing_negotiation =
+			self.context.v2_closing_negotiation.as_ref().ok_or_else(|| {
+				ChannelError::close(
+					"Received closing_sig without an active v2 closing negotiation".to_owned(),
+				)
+			})?;
+		let sent_closing_complete =
+			v2_closing_negotiation.last_sent_closing_complete.as_ref().ok_or_else(|| {
+				ChannelError::close(
+					"Received closing_sig without having sent closing_complete".to_owned(),
+				)
+			})?;
+
+		// Validate that the echoed fields match what we sent in closing_complete.
+		if msg.closer_scriptpubkey != sent_closing_complete.closer_scriptpubkey
+			|| msg.closee_scriptpubkey != sent_closing_complete.closee_scriptpubkey
+			|| msg.fee_satoshis != sent_closing_complete.fee_satoshis
+			|| msg.locktime != sent_closing_complete.locktime
+		{
+			return Err(ChannelError::WarnAndDisconnect(
+				"closing_sig fields do not match what was sent in closing_complete".to_owned(),
+			));
+		}
+
+		// Validate exactly one signature is present.
+		let sig_count = msg.closer_output_only.is_some() as u8
+			+ msg.closee_output_only.is_some() as u8
+			+ msg.closer_and_closee_outputs.is_some() as u8;
+		if sig_count != 1 {
+			return Err(ChannelError::WarnAndDisconnect(
+				"closing_sig must contain exactly one signature".to_owned(),
+			));
+		}
+
+		// Validate that the signature field corresponds to one we sent in closing_complete.
+		enum SelectedField {
+			CloserOutputOnly,
+			CloseeOutputOnly,
+			CloserAndCloseeOutputs,
+		}
+
+		let (selected_field, counterparty_sig) = if let Some(sig) = msg.closer_output_only {
+			if sent_closing_complete.closer_output_only.is_none() {
+				return Err(ChannelError::WarnAndDisconnect(
+					"closing_sig contains closer_output_only but we did not send it in \
+						 closing_complete"
+						.to_owned(),
+				));
+			}
+			(SelectedField::CloserOutputOnly, sig)
+		} else if let Some(sig) = msg.closee_output_only {
+			if sent_closing_complete.closee_output_only.is_none() {
+				return Err(ChannelError::WarnAndDisconnect(
+					"closing_sig contains closee_output_only but we did not send it in \
+						 closing_complete"
+						.to_owned(),
+				));
+			}
+			(SelectedField::CloseeOutputOnly, sig)
+		} else if let Some(sig) = msg.closer_and_closee_outputs {
+			if sent_closing_complete.closer_and_closee_outputs.is_none() {
+				return Err(ChannelError::WarnAndDisconnect(
+					"closing_sig contains closer_and_closee_outputs but we did not send it \
+						 in closing_complete"
+						.to_owned(),
+				));
+			}
+			(SelectedField::CloserAndCloseeOutputs, sig)
+		} else {
+			// Already checked sig_count == 1, so this is unreachable.
+			unreachable!()
+		};
+
+		// Extract our stored signature from the sent closing_complete.
+		let our_sig = match selected_field {
+			SelectedField::CloserOutputOnly => sent_closing_complete.closer_output_only.unwrap(),
+			SelectedField::CloseeOutputOnly => sent_closing_complete.closee_output_only.unwrap(),
+			SelectedField::CloserAndCloseeOutputs => {
+				sent_closing_complete.closer_and_closee_outputs.unwrap()
+			},
+		};
+
+		// Build the closing transaction for the selected variant.
+		// We are the closer, so fee comes from our balance.
+		let closer_balance_msat = self.funding.value_to_self_msat;
+		let closee_balance_msat =
+			(self.funding.get_value_satoshis() * 1000).saturating_sub(closer_balance_msat);
+
+		let closer_is_op_return = msg.closer_scriptpubkey.is_op_return();
+		let value_to_closer = if closer_is_op_return {
+			Amount::ZERO
+		} else {
+			Amount::from_sat(closer_balance_msat / 1000 - msg.fee_satoshis)
+		};
+		let value_to_closee = Amount::from_sat(closee_balance_msat / 1000);
+		let lock_time = LockTime::from_consensus(msg.locktime);
+
+		let funding_outpoint = self.funding_outpoint().into_bitcoin_outpoint();
+		let outputs = match selected_field {
+			SelectedField::CloserOutputOnly => ClosingTransactionV2Outputs::CloserOutputOnly {
+				value_to_closer,
+				to_closer_script: msg.closer_scriptpubkey.clone(),
+			},
+			SelectedField::CloseeOutputOnly => ClosingTransactionV2Outputs::CloseeOutputOnly {
+				value_to_closee,
+				to_closee_script: msg.closee_scriptpubkey.clone(),
+			},
+			SelectedField::CloserAndCloseeOutputs => {
+				ClosingTransactionV2Outputs::CloserAndCloseeOutputs {
+					value_to_closer,
+					to_closer_script: msg.closer_scriptpubkey.clone(),
+					value_to_closee,
+					to_closee_script: msg.closee_scriptpubkey.clone(),
+				}
+			},
+		};
+		let closing_tx = ClosingTransaction::new_v2(outputs, funding_outpoint, lock_time);
+
+		// Verify the counterparty's signature.
+		let funding_redeemscript = self.funding.get_funding_redeemscript();
+		let sighash = closing_tx
+			.trust()
+			.get_sighash_all(&funding_redeemscript, self.funding.get_value_satoshis());
+		secp_check!(
+			self.context.secp_ctx.verify_ecdsa(
+				&sighash,
+				&counterparty_sig,
+				self.funding.counterparty_funding_pubkey(),
+			),
+			"Invalid closing_sig signature from peer".to_owned()
+		);
+
+		// Build the signed closing transaction.
+		let signed_tx =
+			self.build_signed_closing_transaction(&closing_tx, &counterparty_sig, &our_sig);
+
+		// State transitions.
+		self.context.channel_state = ChannelState::ShutdownComplete;
+		self.context.update_time_counter += 1;
+
+		let v2_closing_negotiation = self.context.v2_closing_negotiation.as_mut().unwrap();
+		v2_closing_negotiation.last_sent_closing_complete = None;
+
+		let shutdown_result = self.shutdown_result_coop_close();
+
+		log_info!(
+			logger,
+			"Received closing_sig with fee {} sat, broadcasting closing tx",
+			msg.fee_satoshis,
+		);
+
+		Ok(Some((signed_tx, shutdown_result)))
+	}
+
 	#[rustfmt::skip]
 	fn internal_htlc_satisfies_config(
 		&self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32, config: &ChannelConfig,

lightning/src/ln/channelmanager.rs

@@ -12566,23 +12566,68 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 	}
 
 	fn internal_closing_sig(
-		&self, _counterparty_node_id: PublicKey, _msg: msgs::ClosingSig,
+		&self, counterparty_node_id: PublicKey, msg: msgs::ClosingSig,
 	) -> Result<(), MsgHandleErrInternal> {
-		// The receiver of `closing_sig`:
-		//   - If `closer_scriptpubkey`, `closee_scriptpubkey`, `fee_satoshis` or `locktime` don't match what was sent in `closing_complete`:
-		//     - MUST either send a `warning` and close the connection, or send an `error` and fail the channel.
-		//   - If `tlvs` does not contain exactly one signature:
-		//     - MUST either send a `warning` and close the connection, or send an `error` and fail the channel.
-		//   - If `tlvs` does not contain one of the TLV fields sent in `closing_complete`:
-		//     - MUST either send a `warning` and close the connection, or send an `error` and fail the channel.
-		//   - If the signature field is not valid for the corresponding closing transaction specified in [BOLT #3](03-transactions.md#closing-transaction):
-		//     - MUST either send a `warning` and close the connection, or send an `error` and fail the channel.
-		//   - If the signature field is non-compliant with LOW-S-standard rule<sup>[LOWS](https://github.com/bitcoin/bitcoin/pull/6769)</sup>:
-		//     - MUST either send a `warning` and close the connection, or send an `error` and fail the channel.
-		//   - otherwise:
-		//     - MUST broadcast the corresponding closing transaction.
-		//   - MAY send another `closing_complete` (e.g. with a different `fee_satoshis` or `closer_scriptpubkey`).
-		unimplemented!("Handling ClosingSig is not implemented");
+		let per_peer_state = self.per_peer_state.read().unwrap();
+		let peer_state_mutex = per_peer_state.get(&counterparty_node_id).ok_or_else(|| {
+			debug_assert!(false);
+			MsgHandleErrInternal::unreachable_no_such_peer(&counterparty_node_id, msg.channel_id)
+		})?;
+		let logger;
+		let tx_err: Option<(_, Result<Infallible, _>)> = {
+			let mut peer_state_lock = peer_state_mutex.lock().unwrap();
+			let peer_state = &mut *peer_state_lock;
+			match peer_state.channel_by_id.entry(msg.channel_id.clone()) {
+				hash_map::Entry::Occupied(mut chan_entry) => {
+					if let Some(chan) = chan_entry.get_mut().as_funded_mut() {
+						logger = WithChannelContext::from(&self.logger, &chan.context, None);
+						let res = chan.closing_sig(&msg, &&logger);
+						let tx_shutdown_result =
+							try_channel_entry!(self, peer_state, res, chan_entry);
+						if let Some((tx, close_res)) = tx_shutdown_result {
+							let err = self.locked_handle_funded_coop_close(
+								&mut peer_state.closed_channel_monitor_update_ids,
+								&mut peer_state.in_flight_monitor_updates,
+								close_res,
+								chan,
+							);
+							chan_entry.remove();
+							Some((tx, Err(err)))
+						} else {
+							None
+						}
+					} else {
+						return try_channel_entry!(
+							self,
+							peer_state,
+							Err(ChannelError::close(
+								"Got a closing_sig message for an unfunded channel!".into()
+							)),
+							chan_entry
+						);
+					}
+				},
+				hash_map::Entry::Vacant(_) => {
+					return Err(MsgHandleErrInternal::no_such_channel_for_peer(
+						&counterparty_node_id,
+						msg.channel_id,
+					))
+				},
+			}
+		};
+		mem::drop(per_peer_state);
+		if let Some((broadcast_tx, err)) = tx_err {
+			log_info!(logger, "Broadcasting {}", log_tx!(broadcast_tx));
+			self.tx_broadcaster.broadcast_transactions(&[(
+				&broadcast_tx,
+				TransactionType::CooperativeClose {
+					counterparty_node_id,
+					channel_id: msg.channel_id,
+				},
+			)]);
+			let _ = self.handle_error(err, counterparty_node_id);
+		}
+		Ok(())
 	}
 
 	#[rustfmt::skip]