f - Attempt to handle channel monitor update error at shutdown

Author: jkczyz

lightning/src/ln/channelmanager.rs

@@ -1259,7 +1259,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()) {
@@ -1273,35 +1274,57 @@ 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) {
-							// TODO: How should this be handled?
-							unimplemented!();
+						if let Err(e) = self.chain_monitor.update_channel(chan_entry.get().get_funding_txo().unwrap(), monitor_update) {
+							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 ChannelMonitorUpdateErr, 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 ChannelMonitorUpdateErr would have been 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
 			});
@@ -3172,7 +3195,8 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 	}
 
 	fn internal_shutdown(&self, counterparty_node_id: &PublicKey, their_features: &InitFeatures, msg: &msgs::Shutdown) -> Result<(), MsgHandleErrInternal> {
-		let (mut dropped_htlcs, chan_option) = {
+		let mut error_to_handle = None;
+		let (shutdown, closing_signed, mut dropped_htlcs, chan_option) = {
 			let mut channel_state_lock = self.channel_state.lock().unwrap();
 			let channel_state = &mut *channel_state_lock;
 
@@ -3181,41 +3205,62 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 					if chan_entry.get().get_counterparty_node_id() != *counterparty_node_id {
 						return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!".to_owned(), msg.channel_id));
 					}
+
 					let (shutdown, closing_signed, monitor_update, dropped_htlcs) = try_chan_entry!(self, chan_entry.get_mut().shutdown(&self.fee_estimator, &self.keys_manager, &their_features, &msg), channel_state, chan_entry);
-					if let Some(msg) = shutdown {
-						channel_state.pending_msg_events.push(events::MessageSendEvent::SendShutdown {
-							node_id: counterparty_node_id.clone(),
-							msg,
-						});
-					}
-					if let Some(msg) = closing_signed {
-						channel_state.pending_msg_events.push(events::MessageSendEvent::SendClosingSigned {
-							node_id: counterparty_node_id.clone(),
-							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) {
-							// TODO: How should this be handled?
-							unimplemented!();
+						if let Err(e) = self.chain_monitor.update_channel(chan_entry.get().get_funding_txo().unwrap(), monitor_update) {
+							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);
 						}
-						(dropped_htlcs, Some(chan_entry.remove_entry().1))
-					} else { (dropped_htlcs, None) }
+						Some(chan_entry.remove_entry().1)
+					} else { None };
+
+					(shutdown, closing_signed, dropped_htlcs, chan_option)
 				},
 				hash_map::Entry::Vacant(_) => return Err(MsgHandleErrInternal::send_err_msg_no_close("Failed to find corresponding channel".to_owned(), msg.channel_id))
 			}
 		};
 		for htlc_source in dropped_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 ChannelMonitorUpdateErr, 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 ChannelMonitorUpdateErr would have been temporary.
+		let mut channel_state = self.channel_state.lock().unwrap();
+		if let Some(msg) = shutdown {
+			channel_state.pending_msg_events.push(events::MessageSendEvent::SendShutdown {
+				node_id: *counterparty_node_id,
+				msg,
+			});
+		}
+		if let Some(msg) = closing_signed {
+			channel_state.pending_msg_events.push(events::MessageSendEvent::SendClosingSigned {
+				node_id: *counterparty_node_id,
+				msg,
+			});
+		}
 		if let Some(chan) = chan_option {
 			if let Ok(update) = self.get_channel_update_for_broadcast(&chan) {
-				let mut channel_state = self.channel_state.lock().unwrap();
 				channel_state.pending_msg_events.push(events::MessageSendEvent::BroadcastChannelUpdate {
 					msg: update
 				});