chainmonitor: Add persistence logic for StubChannelMonitor and appropriate helpers to reload it.

Author: Aditya Sharma

fuzz/src/chanmon_consistency.rs

@@ -48,7 +48,7 @@ use lightning::ln::channel::FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE;
 use lightning::ln::channel_state::ChannelDetails;
 use lightning::ln::channelmanager::{
 	ChainParameters, ChannelManager, ChannelManagerReadArgs, PaymentId, PaymentSendFailure,
-	RecipientOnionFields,
+	RecipientOnionFields, StubChannel,
 };
 use lightning::ln::functional_test_utils::*;
 use lightning::ln::msgs::{
@@ -287,6 +287,10 @@ impl chain::Watch<TestChannelSigner> for TestChainMonitor {
 	) -> Vec<(OutPoint, ChannelId, Vec<MonitorEvent>, Option<PublicKey>)> {
 		return self.chain_monitor.release_pending_monitor_events();
 	}
+
+	fn get_stub_cids_with_counterparty(&self, counterparty_node_id: PublicKey) -> Vec<ChannelId> {
+		return self.chain_monitor.get_stub_cids_with_counterparty(counterparty_node_id);
+	}
 }
 
 struct KeyProvider {

lightning/src/chain/chainmonitor.rs

@@ -230,6 +230,7 @@ pub struct ChainMonitor<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F
         P::Target: Persist<ChannelSigner>,
 {
 	monitors: RwLock<HashMap<OutPoint, MonitorHolder<ChannelSigner>>>,
+
 	chain_source: Option<C>,
 	broadcaster: T,
 	logger: L,
@@ -266,7 +267,7 @@ where C::Target: chain::Filter,
 	/// Calls which represent a new blockchain tip height should set `best_height`.
 	fn process_chain_data<FN>(&self, header: &Header, best_height: Option<u32>, txdata: &TransactionData, process: FN)
 	where
-		FN: Fn(&ChannelMonitor<ChannelSigner>, &TransactionData) -> Vec<TransactionOutputs>
+		FN: Fn(&ChannelMonitor<ChannelSigner>, &TransactionData) -> Vec<TransactionOutputs>,
 	{
 		let err_str = "ChannelMonitor[Update] persistence failed unrecoverably. This indicates we cannot continue normal operation and must shut down.";
 		let funding_outpoints = hash_set_from_iter(self.monitors.read().unwrap().keys().cloned());
@@ -749,6 +750,17 @@ 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

@@ -3727,6 +3727,15 @@ 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();
+	}
+
 	/// Attempts to claim a counterparty commitment transaction's outputs using the revocation key and
 	/// data in counterparty_claimable_outpoints. Will directly claim any HTLC outputs which expire at a
 	/// height > height + CLTV_SHARED_CLAIM_BUFFER. In any case, will install monitoring for

lightning/src/chain/mod.rs

@@ -16,7 +16,7 @@ use bitcoin::hash_types::{BlockHash, Txid};
 use bitcoin::network::Network;
 use bitcoin::secp256k1::PublicKey;
 
-use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, MonitorEvent};
+use crate::chain::channelmonitor::{ChannelMonitor, StubChannel, ChannelMonitorUpdate, MonitorEvent};
 use crate::ln::types::ChannelId;
 use crate::sign::ecdsa::EcdsaChannelSigner;
 use crate::chain::transaction::{OutPoint, TransactionData};
@@ -305,6 +305,15 @@ 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

lightning/src/ln/blinded_payment_tests.rs

@@ -1466,6 +1466,7 @@ fn route_blinding_spec_test_vector() {
 		fn sign_invoice(
 			&self, _invoice: &RawBolt11Invoice, _recipient: Recipient,
 		) -> Result<RecoverableSignature, ()> { unreachable!() }
+		fn get_peer_storage_key(&self) -> [u8;32] { unreachable!() }
 		fn sign_bolt12_invoice_request(
 			&self, _invoice_request: &UnsignedInvoiceRequest,
 		) -> Result<schnorr::Signature, ()> { unreachable!() }

lightning/src/ln/functional_test_utils.rs

@@ -715,6 +715,7 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 					panic!();
 				}
 			}
+
 			assert_eq!(*chain_source.watched_txn.unsafe_well_ordered_double_lock_self(), *self.chain_source.watched_txn.unsafe_well_ordered_double_lock_self());
 			assert_eq!(*chain_source.watched_outputs.unsafe_well_ordered_double_lock_self(), *self.chain_source.watched_outputs.unsafe_well_ordered_double_lock_self());
 		}
@@ -2033,6 +2034,16 @@ pub fn do_main_commitment_signed_dance(node_a: &Node<'_, '_, '_>, node_b: &Node<
 	check_added_monitors!(node_b, 0);
 	assert!(node_b.node.get_and_clear_pending_msg_events().is_empty());
 	node_b.node.handle_revoke_and_ack(node_a.node.get_our_node_id(), &as_revoke_and_ack);
+	let events = node_b.node.get_and_clear_pending_msg_events();
+	assert!(events.len() == 1);
+
+	match events.get(0).unwrap() {
+		MessageSendEvent::SendPeerStorageMessage { ref node_id, ref msg } => {
+			assert_eq!(*node_id, node_a.node.get_our_node_id());
+			node_a.node.handle_peer_storage(node_b.node.get_our_node_id(), msg);
+		},
+		_ =>panic!("Unexpected event"),
+	}
 	assert!(node_b.node.get_and_clear_pending_msg_events().is_empty());
 	check_added_monitors!(node_b, 1);
 	node_b.node.handle_commitment_signed(node_a.node.get_our_node_id(), &as_commitment_signed);
@@ -2094,6 +2105,15 @@ pub fn do_commitment_signed_dance(node_a: &Node<'_, '_, '_>, node_b: &Node<'_, '
 		// Expecting the failure backwards event to the previous hop (not `node_b`)
 		assert_eq!(number_of_msg_events, 1);
 	} else {
+		let events = node_a.node.get_and_clear_pending_msg_events();
+		assert!(events.len() == 1);
+		match events.get(0).unwrap() {
+			MessageSendEvent::SendPeerStorageMessage { ref node_id, ref msg } => {
+				assert_eq!(*node_id, node_b.node.get_our_node_id());
+				node_b.node.handle_peer_storage(node_b.node.get_our_node_id(), msg);
+			},
+			_ =>panic!("Unexpected event"),
+		}
 		assert!(node_a.node.get_and_clear_pending_msg_events().is_empty());
 	}
 }
@@ -3572,6 +3592,12 @@ macro_rules! get_chan_reestablish_msgs {
 				} else if let MessageSendEvent::SendChannelAnnouncement { ref node_id, ref msg, .. } = msg {
 					assert_eq!(*node_id, $dst_node.node.get_our_node_id());
 					announcements.insert(msg.contents.short_channel_id);
+				} else if let MessageSendEvent::SendPeerStorageMessage { ref node_id, ref msg } = msg {
+					$dst_node.node.handle_peer_storage($src_node.node.get_our_node_id(), msg);
+					assert_eq!(*node_id, $dst_node.node.get_our_node_id());
+				} else if let MessageSendEvent::SendYourPeerStorageMessage { ref node_id, ref msg } = msg {
+					$dst_node.node.handle_your_peer_storage($src_node.node.get_our_node_id(), msg);
+					assert_eq!(*node_id, $dst_node.node.get_our_node_id());
 				} else {
 					panic!("Unexpected event")
 				}

lightning/src/util/test_utils.rs

@@ -18,7 +18,7 @@ use crate::chain::chaininterface::ConfirmationTarget;
 use crate::chain::chaininterface::FEERATE_FLOOR_SATS_PER_KW;
 use crate::chain::chainmonitor;
 use crate::chain::channelmonitor;
-use crate::chain::channelmonitor::MonitorEvent;
+use crate::chain::channelmonitor::{MonitorEvent, StubChannel};
 use crate::chain::transaction::OutPoint;
 use crate::routing::router::{CandidateRouteHop, FirstHopCandidate, PublicHopCandidate, PrivateHopCandidate};
 use crate::sign;
@@ -423,6 +423,10 @@ impl<'a> chain::Watch<TestChannelSigner> for TestChainMonitor<'a> {
 	fn release_pending_monitor_events(&self) -> Vec<(OutPoint, ChannelId, Vec<MonitorEvent>, Option<PublicKey>)> {
 		return self.chain_monitor.release_pending_monitor_events();
 	}
+
+	fn get_stub_cids_with_counterparty(&self, counterparty_node_id: PublicKey) -> Vec<ChannelId> {
+		return self.chain_monitor.get_stub_cids_with_counterparty(counterparty_node_id);
+	}
 }
 
 #[cfg(test)]
@@ -1195,6 +1199,10 @@ impl NodeSigner for TestNodeSigner {
 		unreachable!()
 	}
 
+	fn get_peer_storage_key(&self) -> [u8;32] {
+		unreachable!()
+	}
+
 	fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
 		let node_secret = match recipient {
 			Recipient::Node => Ok(&self.node_secret),
@@ -1271,6 +1279,10 @@ impl NodeSigner for TestKeysInterface {
 		self.backing.sign_invoice(invoice, recipient)
 	}
 
+	fn get_peer_storage_key(&self) -> [u8;32] {
+		self.backing.get_peer_storage_key()
+	}
+
 	fn sign_bolt12_invoice_request(
 		&self, invoice_request: &UnsignedInvoiceRequest
 	) -> Result<schnorr::Signature, ()> {