Add ClosingComplete and ClosingSig message types + serialization

Author: tnull

lightning-net-tokio/src/lib.rs

@@ -716,6 +716,10 @@ mod tests {
 		fn handle_channel_ready(&self, _their_node_id: PublicKey, _msg: &ChannelReady) {}
 		fn handle_shutdown(&self, _their_node_id: PublicKey, _msg: &Shutdown) {}
 		fn handle_closing_signed(&self, _their_node_id: PublicKey, _msg: &ClosingSigned) {}
+		#[cfg(simple_close)]
+		fn handle_closing_complete(&self, _their_node_id: PublicKey, _msg: ClosingComplete) {}
+		#[cfg(simple_close)]
+		fn handle_closing_sig(&self, _their_node_id: PublicKey, _msg: ClosingSig) {}
 		fn handle_update_add_htlc(&self, _their_node_id: PublicKey, _msg: &UpdateAddHTLC) {}
 		fn handle_update_fulfill_htlc(&self, _their_node_id: PublicKey, _msg: &UpdateFulfillHTLC) {}
 		fn handle_update_fail_htlc(&self, _their_node_id: PublicKey, _msg: &UpdateFailHTLC) {}

lightning/src/ln/channelmanager.rs

@@ -9352,6 +9352,20 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		Ok(())
 	}
 
+	#[cfg(simple_close)]
+	fn internal_closing_complete(
+		&self, _counterparty_node_id: PublicKey, _msg: msgs::ClosingComplete,
+	) -> Result<(), MsgHandleErrInternal> {
+		unimplemented!("Handling ClosingComplete is not implemented");
+	}
+
+	#[cfg(simple_close)]
+	fn internal_closing_sig(
+		&self, _counterparty_node_id: PublicKey, _msg: msgs::ClosingSig,
+	) -> Result<(), MsgHandleErrInternal> {
+		unimplemented!("Handling ClosingSig is not implemented");
+	}
+
 	#[rustfmt::skip]
 	fn internal_update_add_htlc(&self, counterparty_node_id: &PublicKey, msg: &msgs::UpdateAddHTLC) -> Result<(), MsgHandleErrInternal> {
 		//TODO: BOLT 4 points out a specific attack where a peer may re-send an onion packet and
@@ -12650,6 +12664,26 @@ where
 		let _ = handle_error!(self, res, counterparty_node_id);
 	}
 
+	#[cfg(simple_close)]
+	fn handle_closing_complete(&self, counterparty_node_id: PublicKey, msg: msgs::ClosingComplete) {
+		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
+		let _ = handle_error!(
+			self,
+			self.internal_closing_complete(counterparty_node_id, msg),
+			counterparty_node_id
+		);
+	}
+
+	#[cfg(simple_close)]
+	fn handle_closing_sig(&self, counterparty_node_id: PublicKey, msg: msgs::ClosingSig) {
+		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
+		let _ = handle_error!(
+			self,
+			self.internal_closing_sig(counterparty_node_id, msg),
+			counterparty_node_id
+		);
+	}
+
 	fn handle_update_add_htlc(&self, counterparty_node_id: PublicKey, msg: &msgs::UpdateAddHTLC) {
 		// Note that we never need to persist the updated ChannelManager for an inbound
 		// update_add_htlc message - the message itself doesn't change our channel state only the

lightning/src/ln/msgs.rs

@@ -684,6 +684,48 @@ pub struct ClosingSigned {
 	pub fee_range: Option<ClosingSignedFeeRange>,
 }
 
+/// A [`closing_complete`] message to be sent to or received from a peer.
+///
+/// [`closing_complete`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_complete-and-closing_sig
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct ClosingComplete {
+	/// The channel ID.
+	pub channel_id: ChannelId,
+	/// The destination of the closer's funds on closing.
+	pub closer_scriptpubkey: ScriptBuf,
+	/// The destination of the closee's funds on closing.
+	pub closee_scriptpubkey: ScriptBuf,
+	/// The proposed total fee for the closing transaction.
+	pub fee_satoshis: u64,
+	/// The locktime of the closing transaction.
+	pub locktime: u32,
+	/// A signature on the closing transaction omitting the `closee` output.
+	pub closer_output_only: Option<Signature>,
+	/// A signature on the closing transaction omitting the `closer` output.
+	pub closee_output_only: Option<Signature>,
+	/// A signature on the closing transaction covering both `closer` and `closee` outputs.
+	pub closer_and_closee_outputs: Option<Signature>,
+}
+
+/// A [`closing_sig`] message to be sent to or received from a peer.
+///
+/// [`closing_sig`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_complete-and-closing_sig
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct ClosingSig {
+	/// The channel ID.
+	pub channel_id: ChannelId,
+	/// The destination of the closer's funds on closing.
+	pub closer_scriptpubkey: ScriptBuf,
+	/// The destination of the closee's funds on closing.
+	pub closee_scriptpubkey: ScriptBuf,
+	/// A signature on the closing transaction omitting the `closee` output.
+	pub closer_output_only: Option<Signature>,
+	/// A signature on the closing transaction omitting the `closer` output.
+	pub closee_output_only: Option<Signature>,
+	/// A signature on the closing transaction covering both `closer` and `closee` outputs.
+	pub closer_and_closee_outputs: Option<Signature>,
+}
+
 /// A [`start_batch`] message to be sent to group together multiple channel messages as a single
 /// logical message.
 ///
@@ -1914,6 +1956,12 @@ pub trait ChannelMessageHandler: BaseMessageHandler {
 	fn handle_shutdown(&self, their_node_id: PublicKey, msg: &Shutdown);
 	/// Handle an incoming `closing_signed` message from the given peer.
 	fn handle_closing_signed(&self, their_node_id: PublicKey, msg: &ClosingSigned);
+	/// Handle an incoming `closing_complete` message from the given peer.
+	#[cfg(simple_close)]
+	fn handle_closing_complete(&self, their_node_id: PublicKey, msg: ClosingComplete);
+	/// Handle an incoming `closing_sig` message from the given peer.
+	#[cfg(simple_close)]
+	fn handle_closing_sig(&self, their_node_id: PublicKey, msg: ClosingSig);
 
 	// Quiescence
 	/// Handle an incoming `stfu` message from the given peer.
@@ -2744,6 +2792,24 @@ impl_writeable_msg!(ClosingSigned,
 	{ (1, fee_range, option) }
 );
 
+impl_writeable_msg!(ClosingComplete,
+	{ channel_id, closer_scriptpubkey, closee_scriptpubkey, fee_satoshis, locktime },
+	{
+		(1, closer_output_only, option),
+		(2, closee_output_only, option),
+		(3, closer_and_closee_outputs, option)
+	}
+);
+
+impl_writeable_msg!(ClosingSig,
+	{ channel_id, closer_scriptpubkey, closee_scriptpubkey },
+	{
+		(1, closer_output_only, option),
+		(2, closee_output_only, option),
+		(3, closer_and_closee_outputs, option)
+	}
+);
+
 impl_writeable!(ClosingSignedFeeRange, {
 	min_fee_satoshis,
 	max_fee_satoshis

lightning/src/ln/peer_handler.rs

@@ -304,6 +304,14 @@ impl ChannelMessageHandler for ErroringMessageHandler {
 	fn handle_closing_signed(&self, their_node_id: PublicKey, msg: &msgs::ClosingSigned) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
+	#[cfg(simple_close)]
+	fn handle_closing_complete(&self, their_node_id: PublicKey, msg: msgs::ClosingComplete) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+	#[cfg(simple_close)]
+	fn handle_closing_sig(&self, their_node_id: PublicKey, msg: msgs::ClosingSig) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
 	fn handle_stfu(&self, their_node_id: PublicKey, msg: &msgs::Stfu) {
 		ErroringMessageHandler::push_error(&self, their_node_id, msg.channel_id);
 	}
@@ -449,7 +457,7 @@ pub struct MessageHandler<CM: Deref, RM: Deref, OM: Deref, CustomM: Deref, SM: D
 
 	/// A message handler which only allows sending messages. This should generally be a
 	/// [`ChainMonitor`].
-	/// 
+	///
 	/// [`ChainMonitor`]: crate::chain::chainmonitor::ChainMonitor
 	pub send_only_message_handler: SM,
 }
@@ -2097,6 +2105,14 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 			wire::Message::ClosingSigned(msg) => {
 				self.message_handler.chan_handler.handle_closing_signed(their_node_id, &msg);
 			},
+			#[cfg(simple_close)]
+			wire::Message::ClosingComplete(msg) => {
+				self.message_handler.chan_handler.handle_closing_complete(their_node_id, msg);
+			},
+			#[cfg(simple_close)]
+			wire::Message::ClosingSig(msg) => {
+				self.message_handler.chan_handler.handle_closing_sig(their_node_id, msg);
+			},
 
 			// Commitment messages:
 			wire::Message::UpdateAddHTLC(msg) => {

lightning/src/ln/wire.rs

@@ -81,6 +81,10 @@ pub(crate) enum Message<T: core::fmt::Debug + Type + TestEq> {
 	ChannelReady(msgs::ChannelReady),
 	Shutdown(msgs::Shutdown),
 	ClosingSigned(msgs::ClosingSigned),
+	#[cfg(simple_close)]
+	ClosingComplete(msgs::ClosingComplete),
+	#[cfg(simple_close)]
+	ClosingSig(msgs::ClosingSig),
 	OnionMessage(msgs::OnionMessage),
 	StartBatch(msgs::StartBatch),
 	UpdateAddHTLC(msgs::UpdateAddHTLC),
@@ -142,6 +146,10 @@ impl<T: core::fmt::Debug + Type + TestEq> Writeable for Message<T> {
 			&Message::ChannelReady(ref msg) => msg.write(writer),
 			&Message::Shutdown(ref msg) => msg.write(writer),
 			&Message::ClosingSigned(ref msg) => msg.write(writer),
+			#[cfg(simple_close)]
+			&Message::ClosingComplete(ref msg) => msg.write(writer),
+			#[cfg(simple_close)]
+			&Message::ClosingSig(ref msg) => msg.write(writer),
 			&Message::OnionMessage(ref msg) => msg.write(writer),
 			&Message::StartBatch(ref msg) => msg.write(writer),
 			&Message::UpdateAddHTLC(ref msg) => msg.write(writer),
@@ -203,6 +211,10 @@ impl<T: core::fmt::Debug + Type + TestEq> Type for Message<T> {
 			&Message::ChannelReady(ref msg) => msg.type_id(),
 			&Message::Shutdown(ref msg) => msg.type_id(),
 			&Message::ClosingSigned(ref msg) => msg.type_id(),
+			#[cfg(simple_close)]
+			&Message::ClosingComplete(ref msg) => msg.type_id(),
+			#[cfg(simple_close)]
+			&Message::ClosingSig(ref msg) => msg.type_id(),
 			&Message::OnionMessage(ref msg) => msg.type_id(),
 			&Message::StartBatch(ref msg) => msg.type_id(),
 			&Message::UpdateAddHTLC(ref msg) => msg.type_id(),
@@ -350,6 +362,14 @@ where
 		msgs::ClosingSigned::TYPE => {
 			Ok(Message::ClosingSigned(LengthReadable::read_from_fixed_length_buffer(buffer)?))
 		},
+		#[cfg(simple_close)]
+		msgs::ClosingComplete::TYPE => {
+			Ok(Message::ClosingComplete(LengthReadable::read_from_fixed_length_buffer(buffer)?))
+		},
+		#[cfg(simple_close)]
+		msgs::ClosingSig::TYPE => {
+			Ok(Message::ClosingSig(LengthReadable::read_from_fixed_length_buffer(buffer)?))
+		},
 		msgs::OnionMessage::TYPE => {
 			Ok(Message::OnionMessage(LengthReadable::read_from_fixed_length_buffer(buffer)?))
 		},
@@ -535,6 +555,14 @@ impl Encode for msgs::ClosingSigned {
 	const TYPE: u16 = 39;
 }
 
+impl Encode for msgs::ClosingComplete {
+	const TYPE: u16 = 40;
+}
+
+impl Encode for msgs::ClosingSig {
+	const TYPE: u16 = 41;
+}
+
 impl Encode for msgs::OpenChannelV2 {
 	const TYPE: u16 = 64;
 }

lightning/src/util/test_utils.rs

@@ -1024,6 +1024,14 @@ impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
 	fn handle_closing_signed(&self, _their_node_id: PublicKey, msg: &msgs::ClosingSigned) {
 		self.received_msg(wire::Message::ClosingSigned(msg.clone()));
 	}
+	#[cfg(simple_close)]
+	fn handle_closing_complete(&self, _their_node_id: PublicKey, msg: msgs::ClosingComplete) {
+		self.received_msg(wire::Message::ClosingComplete(msg.clone()));
+	}
+	#[cfg(simple_close)]
+	fn handle_closing_sig(&self, _their_node_id: PublicKey, msg: msgs::ClosingSig) {
+		self.received_msg(wire::Message::ClosingSig(msg.clone()));
+	}
 	fn handle_stfu(&self, _their_node_id: PublicKey, msg: &msgs::Stfu) {
 		self.received_msg(wire::Message::Stfu(msg.clone()));
 	}