f - Attempt to handle channel monitor update error at shutdown

Author: jkczyz

lightning/src/ln/channelmanager.rs

@@ -1258,7 +1258,8 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 	pub fn close_channel(&self, channel_id: &[u8; 32]) -> Result<(), APIError> {
 		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(&self.total_consistency_lock, &self.persistence_notifier);
 
-		let (mut failed_htlcs, chan_option) = {
+		let mut error_to_handle = None;
+		let (counterparty_node_id, shutdown_msg, mut failed_htlcs, chan_option) = {
 			let mut channel_state_lock = self.channel_state.lock().unwrap();
 			let channel_state = &mut *channel_state_lock;
 			match channel_state.by_id.entry(channel_id.clone()) {
@@ -1272,35 +1273,58 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 						}
 					};
 					let (shutdown_msg, monitor_update, failed_htlcs) = chan_entry.get_mut().get_shutdown(&self.keys_manager, &their_features)?;
-					channel_state.pending_msg_events.push(events::MessageSendEvent::SendShutdown {
-						node_id: counterparty_node_id,
-						msg: shutdown_msg
-					});
+
+					// Update the monitor with the shutdown script if necessary.
 					if let Some(monitor_update) = monitor_update {
-						if let Err(_) = self.chain_monitor.update_channel(chan_entry.get().get_funding_txo().unwrap(), monitor_update) {
+						if let Err(e) = self.chain_monitor.update_channel(chan_entry.get().get_funding_txo().unwrap(), monitor_update) {
 							// TODO: How should this be handled?
-							unimplemented!();
+							error_to_handle = Some(handle_monitor_err!(self, e, channel_state.short_to_id, chan_entry.get_mut(), RAACommitmentOrder::CommitmentFirst, false, false, Vec::new(), Vec::new(), chan_entry.key()));
 						}
 					}
-					if chan_entry.get().is_shutdown() {
+
+					// Clean up the channel mappings if necessary.
+					let remove_chan_entry = {
+						if chan_entry.get().is_shutdown() { true }
+						else if let Some((_, is_permanent)) = error_to_handle { is_permanent }
+						else { false }
+					};
+					let chan_option = if remove_chan_entry {
 						if let Some(short_id) = chan_entry.get().get_short_channel_id() {
 							channel_state.short_to_id.remove(&short_id);
 						}
-						(failed_htlcs, Some(chan_entry.remove_entry().1))
-					} else { (failed_htlcs, None) }
+						Some(chan_entry.remove_entry().1)
+					} else { None };
+
+					(counterparty_node_id, shutdown_msg, failed_htlcs, chan_option)
 				},
 				hash_map::Entry::Vacant(_) => return Err(APIError::ChannelUnavailable{err: "No such channel".to_owned()})
 			}
 		};
+
 		for htlc_source in failed_htlcs.drain(..) {
 			self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), htlc_source.0, &htlc_source.1, HTLCFailReason::Reason { failure_code: 0x4000 | 8, data: Vec::new() });
 		}
+
+		// Handle any channel monitor update error, exiting early if it resulted in a force close.
+		if let Some((error, is_permanent)) = error_to_handle {
+			let _ = handle_error!(self, error, counterparty_node_id);
+			if is_permanent {
+				return Ok(());
+			}
+		}
+
+		// Send the shutdown message since any channel monitor update error would be temporary.
+		let mut channel_state = self.channel_state.lock().unwrap();
+		channel_state.pending_msg_events.push(events::MessageSendEvent::SendShutdown {
+			node_id: counterparty_node_id,
+			msg: shutdown_msg
+		});
+
 		let chan_update = if let Some(chan) = chan_option {
 			self.get_channel_update_for_broadcast(&chan).ok()
 		} else { None };
 
 		if let Some(update) = chan_update {
-			let mut channel_state = self.channel_state.lock().unwrap();
 			channel_state.pending_msg_events.push(events::MessageSendEvent::BroadcastChannelUpdate {
 				msg: update
 			});