f auto-detect if we need persistence

Author: TheBlueMatt

lightning/src/chain/chainmonitor.rs

@@ -837,11 +837,20 @@ where
 	/// changed due to a [`ChannelMonitorUpdate`] such that it may be different after another
 	/// restart).
 	///
-	/// This method is only safe for [`ChannelMonitor`]s which have been loaded (in conjunction
-	/// with a `ChannelManager`) at least once by LDK 0.1 or later.
-	pub fn load_post_0_1_existing_monitor(
+	/// For [`ChannelMonitor`]s which were last serialized by an LDK version prior to 0.1 this will
+	/// fall back to calling [`chain::Watch::watch_channel`] and persisting the [`ChannelMonitor`].
+	/// See the release notes for LDK 0.1 for more information on this requirement.
+	///
+	/// [`ChannelMonitor`]s which do not need to be persisted (i.e. were last written by LDK 0.1 or
+	/// later) will be loaded without persistence and this method will return
+	/// [`ChannelMonitorUpdateStatus::Completed`].
+	pub fn load_existing_monitor(
 		&self, channel_id: ChannelId, monitor: ChannelMonitor<ChannelSigner>,
-	) -> Result<(), ()> {
+	) -> Result<ChannelMonitorUpdateStatus, ()> {
+		if !monitor.written_by_0_1_or_later() {
+			return chain::Watch::watch_channel(self, channel_id, monitor);
+		}
+
 		let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
 		let mut monitors = self.monitors.write().unwrap();
 		let entry = match monitors.entry(channel_id) {
@@ -860,7 +869,8 @@ where
 			monitor.load_outputs_to_watch(chain_source, &self.logger);
 		}
 		entry.insert(MonitorHolder { monitor, pending_monitor_updates: Mutex::new(Vec::new()) });
-		Ok(())
+
+		Ok(ChannelMonitorUpdateStatus::Completed)
 	}
 }
 

lightning/src/chain/channelmonitor.rs

@@ -1300,6 +1300,11 @@ pub(crate) struct ChannelMonitorImpl<Signer: EcdsaChannelSigner> {
 	// found at `Self::funding`. We don't use the term "renegotiated", as the currently locked
 	// `FundingScope` could be one that was renegotiated.
 	alternative_funding_confirmed: Option<(Txid, u32)>,
+
+	/// [`ChannelMonitor`]s written by LDK prior to 0.1 need to be re-persisted after startup. To
+	/// make deciding whether to do so simple, here we track whether this monitor was last written
+	/// prior to 0.1.
+	written_by_0_1_or_later: bool,
 }
 
 // Macro helper to access holder commitment HTLC data (including both non-dust and dust) while
@@ -1803,6 +1808,8 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 			prev_holder_htlc_data: None,
 
 			alternative_funding_confirmed: None,
+
+			written_by_0_1_or_later: true,
 		})
 	}
 
@@ -1936,6 +1943,10 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 		self.inner.lock().unwrap().get_funding_txo()
 	}
 
+	pub(crate) fn written_by_0_1_or_later(&self) -> bool {
+		self.inner.lock().unwrap().written_by_0_1_or_later
+	}
+
 	/// Gets the funding script of the channel this ChannelMonitor is monitoring for.
 	pub fn get_funding_script(&self) -> ScriptBuf {
 		self.inner.lock().unwrap().get_funding_script()
@@ -6080,6 +6091,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 			(32, pending_funding, optional_vec),
 			(34, alternative_funding_confirmed, option),
 		});
+		let written_by_0_1_or_later = payment_preimages_with_info.is_some();
 		if let Some(payment_preimages_with_info) = payment_preimages_with_info {
 			if payment_preimages_with_info.len() != payment_preimages.len() {
 				return Err(DecodeError::InvalidValue);
@@ -6250,6 +6262,8 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 			prev_holder_htlc_data,
 
 			alternative_funding_confirmed,
+
+			written_by_0_1_or_later,
 		})))
 	}
 }

lightning/src/ln/channelmanager.rs

@@ -15402,7 +15402,7 @@ impl Readable for VecDeque<(Event, Option<EventCompletionAction>)> {
 ///    the next step.
 ///
 ///    If you wish to avoid this for performance reasons, use
-///    [`ChainMonitor::load_post_0_1_existing_monitor`].
+///    [`ChainMonitor::load_existing_monitor`].
 /// 7) Move the [`ChannelMonitor`]s into your local [`chain::Watch`]. If you're using a
 ///    [`ChainMonitor`], this is done by calling [`chain::Watch::watch_channel`].
 ///
@@ -15417,7 +15417,7 @@ impl Readable for VecDeque<(Event, Option<EventCompletionAction>)> {
 /// which you've already broadcasted the transaction.
 ///
 /// [`ChainMonitor`]: crate::chain::chainmonitor::ChainMonitor
-/// [`ChainMonitor::load_post_0_1_existing_monitor`]: crate::chain::chainmonitor::ChainMonitor::load_post_0_1_existing_monitor
+/// [`ChainMonitor::load_existing_monitor`]: crate::chain::chainmonitor::ChainMonitor::load_existing_monitor
 pub struct ChannelManagerReadArgs<
 	'a,
 	M: Deref,

lightning/src/ln/functional_test_utils.rs

@@ -1323,7 +1323,10 @@ pub fn _reload_node<'a, 'b, 'c>(
 
 	for monitor in monitors_read.drain(..) {
 		let channel_id = monitor.channel_id();
-		assert_eq!(node.chain_monitor.load_post_0_1_existing_monitor(channel_id, monitor), Ok(()));
+		assert_eq!(
+			node.chain_monitor.load_existing_monitor(channel_id, monitor),
+			Ok(ChannelMonitorUpdateStatus::Completed),
+		);
 		check_added_monitors!(node, 1);
 	}
 

lightning/src/util/test_utils.rs

@@ -516,9 +516,9 @@ impl<'a> TestChainMonitor<'a> {
 		self.chain_monitor.channel_monitor_updated(*channel_id, latest_update).unwrap();
 	}
 
-	pub fn load_post_0_1_existing_monitor(
+	pub fn load_existing_monitor(
 		&self, channel_id: ChannelId, monitor: ChannelMonitor<TestChannelSigner>,
-	) -> Result<(), ()> {
+	) -> Result<chain::ChannelMonitorUpdateStatus, ()> {
 		#[cfg(feature = "std")]
 		if let Some(blocker) = &*self.write_blocker.lock().unwrap() {
 			blocker.recv().unwrap();
@@ -534,13 +534,15 @@ impl<'a> TestChainMonitor<'a> {
 		)
 		.unwrap()
 		.1;
-		assert!(new_monitor == monitor);
+		// Note that a ChannelMonitor might not round-trip exactly here as we have tests that were
+		// serialized prior to LDK 0.1 and re-serializing them will flip the "written after LDK
+		// 0.1" flag.
 		self.latest_monitor_update_id
 			.lock()
 			.unwrap()
 			.insert(channel_id, (monitor.get_latest_update_id(), monitor.get_latest_update_id()));
 		self.added_monitors.lock().unwrap().push((channel_id, monitor));
-		self.chain_monitor.load_post_0_1_existing_monitor(channel_id, new_monitor)
+		self.chain_monitor.load_existing_monitor(channel_id, new_monitor)
 	}
 }
 impl<'a> chain::Watch<TestChannelSigner> for TestChainMonitor<'a> {