Add ChannelClosed generation at cooperative/force-close/error processing

When we detect a channel `is_shutdown()` or call on it
`force_shutdown()`, we notify the user with a Event::ChannelClosed
informing about the id and closure reason in a best effort.

Author: Antoine Riard

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -53,7 +53,7 @@ use ln::onion_utils;
 use ln::msgs::{ChannelMessageHandler, DecodeError, LightningError, OptionalField};
 use chain::keysinterface::{Sign, KeysInterface, KeysManager, InMemorySigner};
 use util::config::UserConfig;
-use util::events::{EventHandler, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
+use util::events::{EventHandler, EventsProvider, MessageSendEvent, MessageSendEventsProvider, ClosureDescriptor};
 use util::{byte_utils, events};
 use util::ser::{Readable, ReadableArgs, MaybeReadable, Writeable, Writer};
 use util::chacha20::{ChaCha20, ChaChaReader};
@@ -778,6 +778,9 @@ macro_rules! handle_error {
 							msg: update
 						});
 					}
+					if let Some(channel_id) = chan_id {
+						$self.pending_events.lock().unwrap().push(events::Event::ChannelClosed { channel_id,  err: ClosureDescriptor::ProcessingError });
+					}
 				}
 
 				log_error!($self.logger, "{}", err.err);
@@ -1279,6 +1282,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 				msg: update
 			});
 		}
+		// We don't generate a ChannelClosed here as we'll generate oen at `ClosingSigned` handling.
 
 		Ok(())
 	}
@@ -1325,6 +1329,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 				msg: update
 			});
 		}
+		self.pending_events.lock().unwrap().push(events::Event::ChannelClosed { channel_id: *channel_id,  err: ClosureDescriptor::ForceClosed });
 
 		Ok(chan.get_counterparty_node_id())
 	}
@@ -2220,6 +2225,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 											if let Some(short_id) = channel.get_short_channel_id() {
 												channel_state.short_to_id.remove(&short_id);
 											}
+											// ChannelClosed event is generated by handle_errors for us.
 											Err(MsgHandleErrInternal::from_finish_shutdown(msg, channel_id, channel.force_shutdown(true), self.get_channel_update_for_broadcast(&channel).ok()))
 										},
 										ChannelError::CloseDelayBroadcast(_) => { panic!("Wait is only generated on receipt of channel_reestablish, which is handled by try_chan_entry, we don't bother to support it here"); }
@@ -3091,6 +3097,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 					msg: update
 				});
 			}
+			self.pending_events.lock().unwrap().push(events::Event::ChannelClosed { channel_id: msg.channel_id,  err: ClosureDescriptor::CounterpartyInitiated });
 		}
 		Ok(())
 	}
@@ -3137,6 +3144,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 					msg: update
 				});
 			}
+			self.pending_events.lock().unwrap().push(events::Event::ChannelClosed { channel_id: msg.channel_id,  err: ClosureDescriptor::CooperativeClosure });
 		}
 		Ok(())
 	}
@@ -3615,6 +3623,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 								msg: update
 							});
 						}
+						self.pending_events.lock().unwrap().push(events::Event::ChannelClosed { channel_id: chan.channel_id(),  err: ClosureDescriptor::UnknownOnchainCommitment });
 						pending_msg_events.push(events::MessageSendEvent::HandleError {
 							node_id: chan.get_counterparty_node_id(),
 							action: msgs::ErrorAction::SendErrorMessage {
@@ -3676,6 +3685,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 					Err(e) => {
 						let (close_channel, res) = convert_chan_err!(self, e, short_to_id, chan, channel_id);
 						handle_errors.push((chan.get_counterparty_node_id(), Err(res)));
+						// ChannelClosed event is generated by handle_error for us
 						!close_channel
 					}
 				}
@@ -4089,6 +4099,7 @@ where
 							msg: update
 						});
 					}
+					self.pending_events.lock().unwrap().push(events::Event::ChannelClosed { channel_id: channel.channel_id(),  err: ClosureDescriptor::UnknownOnchainCommitment });
 					pending_msg_events.push(events::MessageSendEvent::HandleError {
 						node_id: channel.get_counterparty_node_id(),
 						action: msgs::ErrorAction::SendErrorMessage { msg: e },
@@ -4279,6 +4290,7 @@ impl<Signer: Sign, M: Deref , T: Deref , K: Deref , F: Deref , L: Deref >
 								msg: update
 							});
 						}
+						self.pending_events.lock().unwrap().push(events::Event::ChannelClosed { channel_id: chan.channel_id(),  err: ClosureDescriptor::DisconnectedPeer });
 						false
 					} else {
 						true
@@ -4293,6 +4305,7 @@ impl<Signer: Sign, M: Deref , T: Deref , K: Deref , F: Deref , L: Deref >
 							if let Some(short_id) = chan.get_short_channel_id() {
 								short_to_id.remove(&short_id);
 							}
+							self.pending_events.lock().unwrap().push(events::Event::ChannelClosed { channel_id: chan.channel_id(),  err: ClosureDescriptor::ProcessingError });
 							return false;
 						} else {
 							no_channels_remain = false;

lightning/src/ln/channelmanager.rs

@@ -731,16 +731,16 @@ macro_rules! get_closing_signed_broadcast {
 #[macro_export]
 macro_rules! check_closed_broadcast {
 	($node: expr, $with_error_msg: expr) => {{
-		let events = $node.node.get_and_clear_pending_msg_events();
-		assert_eq!(events.len(), if $with_error_msg { 2 } else { 1 });
-		match events[0] {
+		let msg_events = $node.node.get_and_clear_pending_msg_events();
+		assert_eq!(msg_events.len(), if $with_error_msg { 2 } else { 1 });
+		match msg_events[0] {
 			MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
 				assert_eq!(msg.contents.flags & 2, 2);
 			},
 			_ => panic!("Unexpected event"),
 		}
 		if $with_error_msg {
-			match events[1] {
+			match msg_events[1] {
 				MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id: _ } => {
 					// TODO: Check node_id
 					Some(msg.clone())
@@ -751,6 +751,19 @@ macro_rules! check_closed_broadcast {
 	}}
 }
 
+/// Check that a channel's closing channel event has been issued
+#[macro_export]
+macro_rules! check_closed_event {
+	($node: expr, $events: expr) => {{
+		let events = $node.node.get_and_clear_pending_events();
+		assert_eq!(events.len(), $events);
+		match events[0] {
+			Event::ChannelClosed { .. } => {}
+			_ => panic!("Unexpected event"),
+		}
+	}}
+}
+
 pub fn close_channel<'a, 'b, 'c>(outbound_node: &Node<'a, 'b, 'c>, inbound_node: &Node<'a, 'b, 'c>, channel_id: &[u8; 32], funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, Transaction) {
 	let (node_a, broadcaster_a, struct_a) = if close_inbound_first { (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) } else { (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) };
 	let (node_b, broadcaster_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster) } else { (&inbound_node.node, &inbound_node.tx_broadcaster) };
@@ -911,7 +924,8 @@ macro_rules! commitment_signed_dance {
 		{
 			commitment_signed_dance!($node_a, $node_b, $commitment_signed, $fail_backwards, true);
 			if $fail_backwards {
-				expect_pending_htlcs_forwardable!($node_a);
+				let events = $node_a.node.get_and_clear_pending_events();
+				expect_pending_htlcs_forwardable!($node_a, events);
 				check_added_monitors!($node_a, 1);
 
 				let channel_state = $node_a.node.channel_state.lock().unwrap();
@@ -953,19 +967,18 @@ macro_rules! get_route_and_payment_hash {
 }
 
 macro_rules! expect_pending_htlcs_forwardable_ignore {
-	($node: expr) => {{
-		let events = $node.node.get_and_clear_pending_events();
-		assert_eq!(events.len(), 1);
-		match events[0] {
+	($node: expr, $events: expr) => {{
+		assert_eq!($events.len(), 1);
+		match $events[0] {
 			Event::PendingHTLCsForwardable { .. } => { },
 			_ => panic!("Unexpected event"),
 		};
 	}}
 }
 
 macro_rules! expect_pending_htlcs_forwardable {
-	($node: expr) => {{
-		expect_pending_htlcs_forwardable_ignore!($node);
+	($node: expr, $events: expr) => {{
+		expect_pending_htlcs_forwardable_ignore!($node, $events);
 		$node.node.process_pending_htlc_forwards();
 	}}
 }
@@ -988,10 +1001,9 @@ macro_rules! expect_payment_received {
 }
 
 macro_rules! expect_payment_sent {
-	($node: expr, $expected_payment_preimage: expr) => {
-		let events = $node.node.get_and_clear_pending_events();
-		assert_eq!(events.len(), 1);
-		match events[0] {
+	($node: expr, $expected_payment_preimage: expr, $events: expr) => {
+		assert_eq!($events.len(), 1);
+		match $events[0] {
 			Event::PaymentSent { ref payment_preimage } => {
 				assert_eq!($expected_payment_preimage, *payment_preimage);
 			},
@@ -1026,8 +1038,8 @@ macro_rules! expect_payment_failure_chan_update {
 
 #[cfg(test)]
 macro_rules! expect_payment_failed {
-	($node: expr, $expected_payment_hash: expr, $rejected_by_dest: expr $(, $expected_error_code: expr, $expected_error_data: expr)*) => {
-		let events = $node.node.get_and_clear_pending_events();
+	($node: expr, $events: expr, $expected_payment_hash: expr, $rejected_by_dest: expr $(, $expected_error_code: expr, $expected_error_data: expr)*) => {
+		let events: Vec<Event> = $events;
 		assert_eq!(events.len(), 1);
 		match events[0] {
 			Event::PaymentFailed { ref payment_hash, rejected_by_dest, ref error_code, ref error_data } => {
@@ -1062,7 +1074,8 @@ pub fn pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path
 		check_added_monitors!(node, 0);
 		commitment_signed_dance!(node, prev_node, payment_event.commitment_msg, false);
 
-		expect_pending_htlcs_forwardable!(node);
+		let events = node.node.get_and_clear_pending_events();
+		expect_pending_htlcs_forwardable!(node, events);
 
 		if idx == expected_path.len() - 1 {
 			let events_2 = node.node.get_and_clear_pending_events();
@@ -1192,7 +1205,14 @@ pub fn claim_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, exp
 
 		if !skip_last {
 			last_update_fulfill_dance!(origin_node, expected_route.first().unwrap());
-			expect_payment_sent!(origin_node, our_payment_preimage);
+			let mut events = origin_node.node.get_and_clear_pending_events();
+			let payment_sent: Vec<Event>;
+			if events.len() == 2 {
+				payment_sent = events.drain(1..2).collect();
+			} else {
+				payment_sent = events;
+			}
+			expect_payment_sent!(origin_node, our_payment_preimage, payment_sent);
 		}
 	}
 }
@@ -1241,7 +1261,8 @@ pub fn send_payment<'a, 'b, 'c>(origin: &Node<'a, 'b, 'c>, expected_route: &[&No
 
 pub fn fail_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], skip_last: bool, our_payment_hash: PaymentHash)  {
 	assert!(expected_route.last().unwrap().node.fail_htlc_backwards(&our_payment_hash));
-	expect_pending_htlcs_forwardable!(expected_route.last().unwrap());
+	let events = expected_route.last().unwrap().node.get_and_clear_pending_events();
+	expect_pending_htlcs_forwardable!(expected_route.last().unwrap(), events);
 	check_added_monitors!(expected_route.last().unwrap(), 1);
 
 	let mut next_msgs: Option<(msgs::UpdateFailHTLC, msgs::CommitmentSigned)> = None;
@@ -1251,7 +1272,8 @@ pub fn fail_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe
 				$node.node.handle_update_fail_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
 				commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, !$last_node);
 				if skip_last && $last_node {
-					expect_pending_htlcs_forwardable!($node);
+					let events = $node.node.get_and_clear_pending_events();
+					expect_pending_htlcs_forwardable!($node, events);
 				}
 			}
 		}