channelmanager: Create FundRecoverer to take our node in offline mode so that we can just send a BogusChannelReestablish and close all the StubChannelMonitors and sweep the funds from the events.

Author: Aditya Sharma

lightning/src/chain/chainmonitor.rs

@@ -165,8 +165,8 @@ pub trait Persist<ChannelSigner: EcdsaChannelSigner> {
 	fn archive_persisted_channel(&self, channel_funding_outpoint: OutPoint);
 }
 
-struct MonitorHolder<ChannelSigner: EcdsaChannelSigner> {
-	monitor: ChannelMonitor<ChannelSigner>,
+pub(crate) struct MonitorHolder<ChannelSigner: EcdsaChannelSigner> {
+	pub(crate) monitor: ChannelMonitor<ChannelSigner>,
 	/// The full set of pending monitor updates for this Channel.
 	///
 	/// Note that this lock must be held from [`ChannelMonitor::update_monitor`] through to
@@ -181,7 +181,7 @@ struct MonitorHolder<ChannelSigner: EcdsaChannelSigner> {
 	/// could cause users to have a full [`ChannelMonitor`] on disk as well as a
 	/// [`ChannelMonitorUpdate`] which was already applied. While this isn't an issue for the
 	/// LDK-provided update-based [`Persist`], it is somewhat surprising for users so we avoid it.
-	pending_monitor_updates: Mutex<Vec<u64>>,
+	pub(crate) pending_monitor_updates: Mutex<Vec<u64>>,
 }
 
 impl<ChannelSigner: EcdsaChannelSigner> MonitorHolder<ChannelSigner> {
@@ -195,8 +195,8 @@ impl<ChannelSigner: EcdsaChannelSigner> MonitorHolder<ChannelSigner> {
 /// Note that this holds a mutex in [`ChainMonitor`] and may block other events until it is
 /// released.
 pub struct LockedChannelMonitor<'a, ChannelSigner: EcdsaChannelSigner> {
-	lock: RwLockReadGuard<'a, HashMap<OutPoint, MonitorHolder<ChannelSigner>>>,
-	funding_txo: OutPoint,
+	pub(crate) lock: RwLockReadGuard<'a, HashMap<OutPoint, MonitorHolder<ChannelSigner>>>,
+	pub(crate) funding_txo: OutPoint,
 }
 
 impl<ChannelSigner: EcdsaChannelSigner> Deref for LockedChannelMonitor<'_, ChannelSigner> {
@@ -750,17 +750,6 @@ where C::Target: chain::Filter,
 	    L::Target: Logger,
 	    P::Target: Persist<ChannelSigner>,
 {
-	fn get_stub_cids_with_counterparty(&self, counterparty_node_id: PublicKey) -> Vec<ChannelId> {
-		let stub_monitors = self.stub_monitors.read().unwrap();
-		let mut stubs = vec![];
-		for (_, mon) in stub_monitors.iter() {
-			if mon.get_counterparty_node_id() == Some(counterparty_node_id) {
-				stubs.push(mon.channel_id());
-			}
-		}
-		stubs
-	}
-
 	fn watch_channel(&self, funding_outpoint: OutPoint, monitor: ChannelMonitor<ChannelSigner>) -> Result<ChannelMonitorUpdateStatus, ()> {
 		let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
 		let mut monitors = self.monitors.write().unwrap();

lightning/src/chain/channelmonitor.rs

@@ -1884,6 +1884,10 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 		}
 	}
 
+	pub fn update_latest_state_from_new_stubmonitor(&self, stub: &StubChannel) {
+		self.inner.lock().unwrap().update_latest_state_from_new_stubmonitor(stub);
+	}
+
 	/// Get the list of HTLCs who's status has been updated on chain. This should be called by
 	/// ChannelManager via [`chain::Watch::release_pending_monitor_events`].
 	pub fn get_and_clear_pending_monitor_events(&self) -> Vec<MonitorEvent> {
@@ -3727,13 +3731,14 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 		self.current_holder_commitment_number
 	}
 
-	/// Updates the [`StubChannelMonitor`] when we receive a new more recent
-	/// peer storage from our peer. This souldn't be called through [`ChannelMonitor`].
-	fn update_latest_state_from_new_stubchannelmonitor(&mut self, stub: &StubChannelMonitor<Signer>) {
-		let inner = stub.inner.lock().unwrap();
-		self.commitment_secrets = inner.commitment_secrets.clone();
-		self.counterparty_claimable_outpoints = inner.counterparty_claimable_outpoints.clone();
-		self.their_cur_per_commitment_points = inner.their_cur_per_commitment_points.clone();
+	/// Updates the [`ChannelMonitor`] when we receive a new more recent
+	/// peer storage from our peer.
+	fn update_latest_state_from_new_stubmonitor(&mut self, stub: &StubChannel) {
+		let mut latest_state = new_hash_map();
+		latest_state.insert(stub.latest_state.unwrap(), Vec::new());
+		self.commitment_secrets = stub.commitment_secrets.clone();
+		self.counterparty_claimable_outpoints = latest_state;
+		self.their_cur_per_commitment_points = stub.their_cur_per_commitment_points.clone();
 	}
 
 	/// Attempts to claim a counterparty commitment transaction's outputs using the revocation key and

lightning/src/chain/mod.rs

@@ -305,15 +305,6 @@ pub trait Watch<ChannelSigner: EcdsaChannelSigner> {
 	/// For details on asynchronous [`ChannelMonitor`] updating and returning
 	/// [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
 	fn release_pending_monitor_events(&self) -> Vec<(OutPoint, ChannelId, Vec<MonitorEvent>, Option<PublicKey>)>;
-
-	/// Retrieves a list of channel IDs for [`StubChannelMonitor`] associated with a specific counterparty node ID.
-	///
-	/// This function searches through the collection of [`StubChannelMonitor`] and collects the channel IDs
-	/// of those monitors that have the specified counterparty node ID.
-	///
-	/// This is used by [`FundRecoverer`] to fetch all the [`ChannelId`] with a peer that needs recovery so that we can send them
-	/// `BogusChannelReestablish`.
-	fn get_stub_cids_with_counterparty(&self, counterparty_node_id: PublicKey) -> Vec<ChannelId>;
 }
 
 /// The `Filter` trait defines behavior for indicating chain activity of interest pertaining to