Clean up channel updating macro somewhat

This mostly swaps some Vecs that can only ever contain one element
for Options.

Author: TheBlueMatt

lightning/src/ln/channelmanager.rs

@@ -712,30 +712,29 @@ macro_rules! maybe_break_monitor_err {
 macro_rules! handle_chan_restoration_locked {
 	($self: expr, $channel_lock: expr, $channel_state: expr, $channel_entry: expr,
 	 $raa: expr, $commitment_update: expr, $order: expr,
-	 $pending_forwards: expr, $pending_failures: expr, $broadcast_safe: expr, $funding_locked: expr) => { {
-		let mut htlc_forwards = Vec::new();
-		let mut htlc_failures = Vec::new();
-		let mut pending_events = Vec::new();
+	 $pending_forwards: expr, $broadcast_safe: expr, $funding_locked: expr) => { {
+		let mut htlc_forwards = None;
+		let mut funding_broadcast_safe = None;
+		let counterparty_node_id = $channel_entry.get().get_counterparty_node_id();
 
 		{
 			if !$pending_forwards.is_empty() {
-				htlc_forwards.push(($channel_entry.get().get_short_channel_id().expect("We can't have pending forwards before funding confirmation"),
+				htlc_forwards = Some(($channel_entry.get().get_short_channel_id().expect("We can't have pending forwards before funding confirmation"),
 					$channel_entry.get().get_funding_txo().unwrap(), $pending_forwards));
 			}
-			htlc_failures.append(&mut $pending_failures);
 
 			macro_rules! handle_cs { () => {
 				if let Some(update) = $commitment_update {
 					$channel_state.pending_msg_events.push(events::MessageSendEvent::UpdateHTLCs {
-						node_id: $channel_entry.get().get_counterparty_node_id(),
+						node_id: counterparty_node_id,
 						updates: update,
 					});
 				}
 			} }
 			macro_rules! handle_raa { () => {
 				if let Some(revoke_and_ack) = $raa {
 					$channel_state.pending_msg_events.push(events::MessageSendEvent::SendRevokeAndACK {
-						node_id: $channel_entry.get().get_counterparty_node_id(),
+						node_id: counterparty_node_id,
 						msg: revoke_and_ack,
 					});
 				}
@@ -751,38 +750,43 @@ macro_rules! handle_chan_restoration_locked {
 				},
 			}
 			if $broadcast_safe {
-				pending_events.push(events::Event::FundingBroadcastSafe {
+				funding_broadcast_safe = Some(events::Event::FundingBroadcastSafe {
 					funding_txo: $channel_entry.get().get_funding_txo().unwrap(),
 					user_channel_id: $channel_entry.get().get_user_id(),
 				});
 			}
 			if let Some(msg) = $funding_locked {
 				$channel_state.pending_msg_events.push(events::MessageSendEvent::SendFundingLocked {
-					node_id: $channel_entry.get().get_counterparty_node_id(),
+					node_id: counterparty_node_id,
 					msg,
 				});
 				if let Some(announcement_sigs) = $self.get_announcement_sigs($channel_entry.get()) {
 					$channel_state.pending_msg_events.push(events::MessageSendEvent::SendAnnouncementSignatures {
-						node_id: $channel_entry.get().get_counterparty_node_id(),
+						node_id: counterparty_node_id,
 						msg: announcement_sigs,
 					});
 				}
 				$channel_state.short_to_id.insert($channel_entry.get().get_short_channel_id().unwrap(), $channel_entry.get().channel_id());
 			}
 		}
-		(htlc_forwards, htlc_failures, pending_events)
+		(htlc_forwards, funding_broadcast_safe)
 	} }
 }
 
 macro_rules! post_handle_chan_restoration {
-	($self: expr, $locked_res: expr) => { {
-		let (mut htlc_forwards, mut htlc_failures, mut pending_events) = $locked_res;
-		$self.pending_events.lock().unwrap().append(&mut pending_events);
+	($self: expr, $locked_res: expr, $pending_failures: expr) => { {
+		let (htlc_forwards, funding_broadcast_safe) = $locked_res;
 
-		for failure in htlc_failures.drain(..) {
+		if let Some(ev) = funding_broadcast_safe {
+			$self.pending_events.lock().unwrap().push(ev);
+		}
+
+		for failure in $pending_failures.drain(..) {
 			$self.fail_htlc_backwards_internal($self.channel_state.lock().unwrap(), failure.0, &failure.1, failure.2);
 		}
-		$self.forward_htlcs(&mut htlc_forwards[..]);
+		if let Some(forwards) = htlc_forwards {
+			$self.forward_htlcs(&mut [forwards][..]);
+		}
 	} }
 }
 
@@ -2287,7 +2291,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 	pub fn channel_monitor_updated(&self, funding_txo: &OutPoint, highest_applied_update_id: u64) {
 		let _consistency_lock = self.total_consistency_lock.read().unwrap();
 
-		let chan_restoration_res = {
+		let (mut pending_failures, chan_restoration_res) = {
 			let mut channel_lock = self.channel_state.lock().unwrap();
 			let channel_state = &mut *channel_lock;
 			let mut channel = match channel_state.by_id.entry(funding_txo.to_channel_id()) {
@@ -2298,10 +2302,10 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 				return;
 			}
 
-			let (raa, commitment_update, order, pending_forwards, mut pending_failures, needs_broadcast_safe, funding_locked) = channel.get_mut().monitor_updating_restored(&self.logger);
-			handle_chan_restoration_locked!(self, channel_lock, channel_state, channel, raa, commitment_update, order, pending_forwards, pending_failures, needs_broadcast_safe, funding_locked)
+			let (raa, commitment_update, order, pending_forwards, pending_failures, needs_broadcast_safe, funding_locked) = channel.get_mut().monitor_updating_restored(&self.logger);
+			(pending_failures, handle_chan_restoration_locked!(self, channel_lock, channel_state, channel, raa, commitment_update, order, pending_forwards, needs_broadcast_safe, funding_locked))
 		};
-		post_handle_chan_restoration!(self, chan_restoration_res);
+		post_handle_chan_restoration!(self, chan_restoration_res, pending_failures);
 	}
 
 	fn internal_open_channel(&self, counterparty_node_id: &PublicKey, their_features: InitFeatures, msg: &msgs::OpenChannel) -> Result<(), MsgHandleErrInternal> {