rustfmt chainmonitor selectively

Author: joostjager

lightning/src/chain/chainmonitor.rs

@@ -126,8 +126,9 @@ pub trait Persist<ChannelSigner: EcdsaChannelSigner> {
 	///
 	/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 	/// [`Writeable::write`]: crate::util::ser::Writeable::write
-	#[rustfmt::skip]
-	fn persist_new_channel(&self, monitor_name: MonitorName, monitor: &ChannelMonitor<ChannelSigner>) -> ChannelMonitorUpdateStatus;
+	fn persist_new_channel(
+		&self, monitor_name: MonitorName, monitor: &ChannelMonitor<ChannelSigner>,
+	) -> ChannelMonitorUpdateStatus;
 
 	/// Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
 	/// update.
@@ -166,8 +167,10 @@ pub trait Persist<ChannelSigner: EcdsaChannelSigner> {
 	/// [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
 	///
 	/// [`Writeable::write`]: crate::util::ser::Writeable::write
-	#[rustfmt::skip]
-	fn update_persisted_channel(&self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>, monitor: &ChannelMonitor<ChannelSigner>) -> ChannelMonitorUpdateStatus;
+	fn update_persisted_channel(
+		&self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>,
+		monitor: &ChannelMonitor<ChannelSigner>,
+	) -> ChannelMonitorUpdateStatus;
 	/// Prevents the channel monitor from being loaded on startup.
 	///
 	/// Archiving the data in a backup location (rather than deleting it fully) is useful for
@@ -350,19 +353,26 @@ where
 		}
 	}
 
-	#[rustfmt::skip]
 	fn update_monitor_with_chain_data<FN>(
-		&self, header: &Header, best_height: Option<u32>, txdata: &TransactionData, process: FN, channel_id: &ChannelId,
-		monitor_state: &MonitorHolder<ChannelSigner>, channel_count: usize,
-	) -> Result<(), ()> where FN: Fn(&ChannelMonitor<ChannelSigner>, &TransactionData) -> Vec<TransactionOutputs> {
+		&self, header: &Header, best_height: Option<u32>, txdata: &TransactionData, process: FN,
+		channel_id: &ChannelId, monitor_state: &MonitorHolder<ChannelSigner>, channel_count: usize,
+	) -> Result<(), ()>
+	where
+		FN: Fn(&ChannelMonitor<ChannelSigner>, &TransactionData) -> Vec<TransactionOutputs>,
+	{
 		let monitor = &monitor_state.monitor;
 		let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
 
 		let mut txn_outputs = process(monitor, txdata);
 
 		let get_partition_key = |channel_id: &ChannelId| {
 			let channel_id_bytes = channel_id.0;
-			let channel_id_u32 = u32::from_be_bytes([channel_id_bytes[0], channel_id_bytes[1], channel_id_bytes[2], channel_id_bytes[3]]);
+			let channel_id_u32 = u32::from_be_bytes([
+				channel_id_bytes[0],
+				channel_id_bytes[1],
+				channel_id_bytes[2],
+				channel_id_bytes[3],
+			]);
 			channel_id_u32.wrapping_add(best_height.unwrap_or_default())
 		};
 
@@ -374,23 +384,33 @@ where
 
 		let has_pending_claims = monitor_state.monitor.has_pending_claims();
 		if has_pending_claims || get_partition_key(channel_id) % partition_factor == 0 {
-			log_trace!(logger, "Syncing Channel Monitor for channel {}", log_funding_info!(monitor));
+			log_trace!(
+				logger,
+				"Syncing Channel Monitor for channel {}",
+				log_funding_info!(monitor)
+			);
 			// Even though we don't track monitor updates from chain-sync as pending, we still want
 			// updates per-channel to be well-ordered so that users don't see a
 			// `ChannelMonitorUpdate` after a channel persist for a channel with the same
 			// `latest_update_id`.
 			let _pending_monitor_updates = monitor_state.pending_monitor_updates.lock().unwrap();
-			match self.persister.update_persisted_channel(monitor.persistence_key(), None, monitor) {
-				ChannelMonitorUpdateStatus::Completed =>
-					log_trace!(logger, "Finished syncing Channel Monitor for channel {} for block-data",
-						log_funding_info!(monitor)
-					),
+			match self.persister.update_persisted_channel(monitor.persistence_key(), None, monitor)
+			{
+				ChannelMonitorUpdateStatus::Completed => log_trace!(
+					logger,
+					"Finished syncing Channel Monitor for channel {} for block-data",
+					log_funding_info!(monitor)
+				),
 				ChannelMonitorUpdateStatus::InProgress => {
-					log_trace!(logger, "Channel Monitor sync for channel {} in progress.", log_funding_info!(monitor));
-				}
+					log_trace!(
+						logger,
+						"Channel Monitor sync for channel {} in progress.",
+						log_funding_info!(monitor)
+					);
+				},
 				ChannelMonitorUpdateStatus::UnrecoverableError => {
 					return Err(());
-				}
+				},
 			}
 		}
 
@@ -406,7 +426,11 @@ where
 						outpoint: OutPoint { txid, index: idx as u16 },
 						script_pubkey: output.script_pubkey,
 					};
-					log_trace!(logger, "Adding monitoring for spends of outpoint {} to the filter", output.outpoint);
+					log_trace!(
+						logger,
+						"Adding monitoring for spends of outpoint {} to the filter",
+						output.outpoint
+					);
 					chain_source.register_output(output);
 				}
 			}
@@ -433,8 +457,10 @@ where
 	/// [`NodeSigner`]: crate::sign::NodeSigner
 	/// [`NodeSigner::get_peer_storage_key`]: crate::sign::NodeSigner::get_peer_storage_key
 	/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
-	#[rustfmt::skip]
-	pub fn new(chain_source: Option<C>, broadcaster: T, logger: L, feeest: F, persister: P, entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey) -> Self {
+	pub fn new(
+		chain_source: Option<C>, broadcaster: T, logger: L, feeest: F, persister: P,
+		entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey,
+	) -> Self {
 		Self {
 			monitors: RwLock::new(new_hash_map()),
 			chain_source,
@@ -447,7 +473,7 @@ where
 			highest_chain_height: AtomicUsize::new(0),
 			event_notifier: Notifier::new(),
 			pending_send_only_events: Mutex::new(Vec::new()),
-			our_peerstorage_encryption_key
+			our_peerstorage_encryption_key,
 		}
 	}
 
@@ -547,37 +573,50 @@ where
 	///
 	/// Returns an [`APIError::APIMisuseError`] if `funding_txo` does not match any currently
 	/// registered [`ChannelMonitor`]s.
-	#[rustfmt::skip]
-	pub fn channel_monitor_updated(&self, channel_id: ChannelId, completed_update_id: u64) -> Result<(), APIError> {
+	pub fn channel_monitor_updated(
+		&self, channel_id: ChannelId, completed_update_id: u64,
+	) -> Result<(), APIError> {
 		let monitors = self.monitors.read().unwrap();
-		let monitor_data = if let Some(mon) = monitors.get(&channel_id) { mon } else {
-			return Err(APIError::APIMisuseError { err: format!("No ChannelMonitor matching channel ID {} found", channel_id) });
+		let monitor_data = if let Some(mon) = monitors.get(&channel_id) {
+			mon
+		} else {
+			return Err(APIError::APIMisuseError {
+				err: format!("No ChannelMonitor matching channel ID {} found", channel_id),
+			});
 		};
 		let mut pending_monitor_updates = monitor_data.pending_monitor_updates.lock().unwrap();
 		pending_monitor_updates.retain(|update_id| *update_id != completed_update_id);
 
 		// Note that we only check for pending non-chainsync monitor updates and we don't track monitor
 		// updates resulting from chainsync in `pending_monitor_updates`.
 		let monitor_is_pending_updates = monitor_data.has_pending_updates(&pending_monitor_updates);
-		log_debug!(self.logger, "Completed off-chain monitor update {} for channel with channel ID {}, {}",
+		log_debug!(
+			self.logger,
+			"Completed off-chain monitor update {} for channel with channel ID {}, {}",
 			completed_update_id,
 			channel_id,
 			if monitor_is_pending_updates {
 				"still have pending off-chain updates"
 			} else {
 				"all off-chain updates complete, returning a MonitorEvent"
-			});
+			}
+		);
 		if monitor_is_pending_updates {
 			// If there are still monitor updates pending, we cannot yet construct a
 			// Completed event.
 			return Ok(());
 		}
 		let funding_txo = monitor_data.monitor.get_funding_txo();
-		self.pending_monitor_events.lock().unwrap().push((funding_txo, channel_id, vec![MonitorEvent::Completed {
+		self.pending_monitor_events.lock().unwrap().push((
 			funding_txo,
 			channel_id,
-			monitor_update_id: monitor_data.monitor.get_latest_update_id(),
-		}], monitor_data.monitor.get_counterparty_node_id()));
+			vec![MonitorEvent::Completed {
+				funding_txo,
+				channel_id,
+				monitor_update_id: monitor_data.monitor.get_latest_update_id(),
+			}],
+			monitor_data.monitor.get_counterparty_node_id(),
+		));
 
 		self.event_notifier.notify();
 		Ok(())
@@ -693,30 +732,37 @@ where
 	///
 	/// Depending on the implementation of [`Persist::archive_persisted_channel`] the monitor
 	/// data could be moved to an archive location or removed entirely.
-	#[rustfmt::skip]
 	pub fn archive_fully_resolved_channel_monitors(&self) {
 		let mut have_monitors_to_prune = false;
 		for monitor_holder in self.monitors.read().unwrap().values() {
 			let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor, None);
-			let (is_fully_resolved, needs_persistence) = monitor_holder.monitor.check_and_update_full_resolution_status(&logger);
+			let (is_fully_resolved, needs_persistence) =
+				monitor_holder.monitor.check_and_update_full_resolution_status(&logger);
 			if is_fully_resolved {
 				have_monitors_to_prune = true;
 			}
 			if needs_persistence {
-				self.persister.update_persisted_channel(monitor_holder.monitor.persistence_key(), None, &monitor_holder.monitor);
+				self.persister.update_persisted_channel(
+					monitor_holder.monitor.persistence_key(),
+					None,
+					&monitor_holder.monitor,
+				);
 			}
 		}
 		if have_monitors_to_prune {
 			let mut monitors = self.monitors.write().unwrap();
 			monitors.retain(|channel_id, monitor_holder| {
 				let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor, None);
-				let (is_fully_resolved, _) = monitor_holder.monitor.check_and_update_full_resolution_status(&logger);
+				let (is_fully_resolved, _) =
+					monitor_holder.monitor.check_and_update_full_resolution_status(&logger);
 				if is_fully_resolved {
-					log_info!(logger,
+					log_info!(
+						logger,
 						"Archiving fully resolved ChannelMonitor for channel ID {}",
 						channel_id
 					);
-					self.persister.archive_persisted_channel(monitor_holder.monitor.persistence_key());
+					self.persister
+						.archive_persisted_channel(monitor_holder.monitor.persistence_key());
 					false
 				} else {
 					true
@@ -786,8 +832,11 @@ where
 		InitFeatures::empty()
 	}
 
-	#[rustfmt::skip]
-	fn peer_connected(&self, _their_node_id: PublicKey, _msg: &Init, _inbound: bool) -> Result<(), ()> { Ok(()) }
+	fn peer_connected(
+		&self, _their_node_id: PublicKey, _msg: &Init, _inbound: bool,
+	) -> Result<(), ()> {
+		Ok(())
+	}
 }
 
 impl<
@@ -923,8 +972,9 @@ where
 	P::Target: Persist<ChannelSigner>,
 	ES::Target: EntropySource,
 {
-	#[rustfmt::skip]
-	fn watch_channel(&self, channel_id: ChannelId, monitor: ChannelMonitor<ChannelSigner>) -> Result<ChannelMonitorUpdateStatus, ()> {
+	fn watch_channel(
+		&self, channel_id: ChannelId, monitor: ChannelMonitor<ChannelSigner>,
+	) -> Result<ChannelMonitorUpdateStatus, ()> {
 		let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
 		let mut monitors = self.monitors.write().unwrap();
 		let entry = match monitors.entry(channel_id) {
@@ -940,11 +990,19 @@ where
 		let persist_res = self.persister.persist_new_channel(monitor.persistence_key(), &monitor);
 		match persist_res {
 			ChannelMonitorUpdateStatus::InProgress => {
-				log_info!(logger, "Persistence of new ChannelMonitor for channel {} in progress", log_funding_info!(monitor));
+				log_info!(
+					logger,
+					"Persistence of new ChannelMonitor for channel {} in progress",
+					log_funding_info!(monitor)
+				);
 				pending_monitor_updates.push(update_id);
 			},
 			ChannelMonitorUpdateStatus::Completed => {
-				log_info!(logger, "Persistence of new ChannelMonitor for channel {} completed", log_funding_info!(monitor));
+				log_info!(
+					logger,
+					"Persistence of new ChannelMonitor for channel {} completed",
+					log_funding_info!(monitor)
+				);
 			},
 			ChannelMonitorUpdateStatus::UnrecoverableError => {
 				let err_str = "ChannelMonitor[Update] persistence failed unrecoverably. This indicates we cannot continue normal operation and must shut down.";
@@ -953,7 +1011,7 @@ where
 			},
 		}
 		if let Some(ref chain_source) = self.chain_source {
-			monitor.load_outputs_to_watch(chain_source , &self.logger);
+			monitor.load_outputs_to_watch(chain_source, &self.logger);
 		}
 		entry.insert(MonitorHolder {
 			monitor,
@@ -962,8 +1020,9 @@ where
 		Ok(persist_res)
 	}
 
-	#[rustfmt::skip]
-	fn update_channel(&self, channel_id: ChannelId, update: &ChannelMonitorUpdate) -> ChannelMonitorUpdateStatus {
+	fn update_channel(
+		&self, channel_id: ChannelId, update: &ChannelMonitorUpdate,
+	) -> ChannelMonitorUpdateStatus {
 		// `ChannelMonitorUpdate`'s `channel_id` is `None` prior to 0.0.121 and all channels in those
 		// versions are V1-established. For 0.0.121+ the `channel_id` fields is always `Some`.
 		debug_assert_eq!(update.channel_id.unwrap(), channel_id);
@@ -985,13 +1044,24 @@ where
 			Some(monitor_state) => {
 				let monitor = &monitor_state.monitor;
 				let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
-				log_trace!(logger, "Updating ChannelMonitor to id {} for channel {}", update.update_id, log_funding_info!(monitor));
+				log_trace!(
+					logger,
+					"Updating ChannelMonitor to id {} for channel {}",
+					update.update_id,
+					log_funding_info!(monitor)
+				);
 
 				// We hold a `pending_monitor_updates` lock through `update_monitor` to ensure we
 				// have well-ordered updates from the users' point of view. See the
 				// `pending_monitor_updates` docs for more.
-				let mut pending_monitor_updates = monitor_state.pending_monitor_updates.lock().unwrap();
-				let update_res = monitor.update_monitor(update, &self.broadcaster, &self.fee_estimator, &self.logger);
+				let mut pending_monitor_updates =
+					monitor_state.pending_monitor_updates.lock().unwrap();
+				let update_res = monitor.update_monitor(
+					update,
+					&self.broadcaster,
+					&self.fee_estimator,
+					&self.logger,
+				);
 
 				let update_id = update.update_id;
 				let persist_res = if update_res.is_err() {
@@ -1001,9 +1071,17 @@ where
 					// while reading `channel_monitor` with updates from storage. Instead, we should persist
 					// the entire `channel_monitor` here.
 					log_warn!(logger, "Failed to update ChannelMonitor for channel {}. Going ahead and persisting the entire ChannelMonitor", log_funding_info!(monitor));
-					self.persister.update_persisted_channel(monitor.persistence_key(), None, monitor)
+					self.persister.update_persisted_channel(
+						monitor.persistence_key(),
+						None,
+						monitor,
+					)
 				} else {
-					self.persister.update_persisted_channel(monitor.persistence_key(), Some(update), monitor)
+					self.persister.update_persisted_channel(
+						monitor.persistence_key(),
+						Some(update),
+						monitor,
+					)
 				};
 				match persist_res {
 					ChannelMonitorUpdateStatus::InProgress => {
@@ -1015,7 +1093,8 @@ where
 						);
 					},
 					ChannelMonitorUpdateStatus::Completed => {
-						log_debug!(logger,
+						log_debug!(
+							logger,
 							"Persistence of ChannelMonitorUpdate id {:?} for channel {} completed",
 							update_id,
 							log_funding_info!(monitor)
@@ -1037,7 +1116,7 @@ where
 				} else {
 					persist_res
 				}
-			}
+			},
 		}
 	}
 
@@ -1087,14 +1166,16 @@ where
 	///
 	/// [`SpendableOutputs`]: events::Event::SpendableOutputs
 	/// [`BumpTransaction`]: events::Event::BumpTransaction
-	#[rustfmt::skip]
-	fn process_pending_events<H: Deref>(&self, handler: H) where H::Target: EventHandler {
+	fn process_pending_events<H: Deref>(&self, handler: H)
+	where
+		H::Target: EventHandler,
+	{
 		for monitor_state in self.monitors.read().unwrap().values() {
 			match monitor_state.monitor.process_pending_events(&handler, &self.logger) {
 				Ok(()) => {},
-				Err(ReplayEvent ()) => {
+				Err(ReplayEvent()) => {
 					self.event_notifier.notify();
-				}
+				},
 			}
 		}
 	}