lightning: Add struct for building OurPeerStorage, it gets updated everytime a LatestCounterpartyCommitmentTxn update is sent. It would be encrypted and sent to our peers.

Aditya Sharma · Aditya Sharma · commit c2ee14283c4b · 2024-09-07T16:27:53.000+05:30
diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs
@@ -832,6 +832,208 @@ impl Readable for IrrevocablyResolvedHTLC {
 	}
 }
 
+/// [StubChannel] is the smallest unit of [OurPeerStorage], it contains
+/// information about a single channel using which we can recover on-chain funds.
+#[derive(Clone, PartialEq, Eq)]
+pub struct StubChannel {
+	pub(crate) channel_id: ChannelId,
+	pub(crate) funding_outpoint: OutPoint,
+	pub(crate) channel_value_stoshis: u64,
+	pub(crate) channel_keys_id: [u8;32],
+	pub(crate) commitment_secrets: CounterpartyCommitmentSecrets,
+	pub(crate) counterparty_node_id: PublicKey,
+	pub(crate) counterparty_delayed_payment_base_key: DelayedPaymentBasepoint,
+	pub(crate) counterparty_htlc_base_key: HtlcBasepoint,
+	pub(crate) on_counterparty_tx_csv: u16,
+	pub(crate) obscure_factor: u64,
+	pub(crate) latest_state: HashMap<Txid, Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)>>,
+	pub(crate) their_cur_per_commitment_points: Option<(u64, PublicKey, Option<PublicKey>)>,
+	pub(crate) features: ChannelTypeFeatures,
+}
+
+impl StubChannel {
+    pub(crate) fn new(channel_id: ChannelId, funding_outpoint: OutPoint, channel_value_stoshis: u64, channel_keys_id: [u8; 32],
+		       commitment_secrets: CounterpartyCommitmentSecrets, counterparty_node_id: PublicKey, counterparty_delayed_payment_base_key: DelayedPaymentBasepoint, counterparty_htlc_base_key: HtlcBasepoint, on_counterparty_tx_csv: u16,
+			   obscure_factor: u64, latest_state: HashMap<Txid, Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)>>, their_cur_per_commitment_points: Option<(u64, PublicKey, Option<PublicKey>)>,
+			   features: ChannelTypeFeatures) -> Self {
+        StubChannel {
+            channel_id,
+			funding_outpoint,
+			channel_value_stoshis,
+            channel_keys_id,
+            commitment_secrets,
+			counterparty_node_id,
+			counterparty_delayed_payment_base_key,
+			counterparty_htlc_base_key,
+			on_counterparty_tx_csv,
+			obscure_factor,
+			latest_state,
+			their_cur_per_commitment_points,
+			features,
+        }
+    }
+
+	/// Get the min seen secret from the commitment secrets.
+	pub fn get_min_seen_secret(&self) -> u64 {
+		return self.commitment_secrets.get_min_seen_secret();
+	}
+}
+
+impl_writeable_tlv_based!(StubChannel, {
+	(0, channel_id, required),
+	(2, channel_keys_id, required),
+	(4, channel_value_stoshis, required),
+	(6, funding_outpoint, required),
+	(8, commitment_secrets, required),
+	(10, counterparty_node_id, required),
+	(12, counterparty_delayed_payment_base_key, required),
+	(14, counterparty_htlc_base_key, required),
+	(16, on_counterparty_tx_csv, required),
+	(18, obscure_factor, required),
+	(20, latest_state, required),
+	(22, their_cur_per_commitment_points, option),
+	(24, features, required),
+});
+
+/// [`OurPeerStorage`] is used to store our channels using which we
+/// can create our PeerStorage Backup.
+/// This includes timestamp to compare between two given 
+/// [`OurPeerStorage`] and version defines the structure.
+#[derive(Clone, PartialEq, Eq)]
+pub struct OurPeerStorage {
+    version: u32,
+    timestamp: u32,
+    channels: Vec<StubChannel>,
+}
+
+impl OurPeerStorage {
+	/// Returns a [`OurPeerStorage`] with version 1 and current timestamp.
+    pub fn new() -> Self {
+        let duration_since_epoch = std::time::SystemTime::now()
+            .duration_since(std::time::SystemTime::UNIX_EPOCH)
+            .expect("Time must be > 1970");
+
+        Self {
+            version: 1,
+            timestamp: duration_since_epoch.as_secs() as u32,
+            channels: Vec::new(),
+        }
+    }
+
+	/// Stubs a channel inside [`OurPeerStorage`]
+    pub fn stub_channel(&mut self, chan: StubChannel) {
+        self.channels.push(chan);
+    }
+
+	/// Get a reference of `channels` array from [`StubChannel::channels`]
+	pub fn get_channels(&self) -> &Vec<StubChannel> {
+		self.channels.as_ref()
+	}
+
+	pub(crate) fn update_latest_state(&mut self, cid: ChannelId, txid: Txid, htlc_data: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)>, their_cur_per_commitment_points: Option<(u64, PublicKey, Option<PublicKey>)>) {
+        for stub_channel in &mut self.channels {
+            if stub_channel.channel_id == cid {
+                let mut latest_state = HashMap::new();
+                latest_state.insert(txid, htlc_data);
+                stub_channel.latest_state = latest_state;
+				stub_channel.their_cur_per_commitment_points = their_cur_per_commitment_points;
+                return;
+            }
+        }
+	}
+
+	pub(crate) fn provide_secret(&mut self, cid: ChannelId, idx:u64, secret: [u8; 32]) -> Result<(), ()> {
+		for stub_channel in &mut self.channels {
+            if stub_channel.channel_id == cid {
+                return stub_channel.commitment_secrets.provide_secret(idx, secret);
+            }
+        }
+		return Err(());
+	}
+
+	/// This is called to update the data of the latest state inside [`OurPeerStorage`] using
+	/// [`ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo`]
+	pub(crate) fn update_state_from_monitor_update(&mut self, cid: ChannelId, monitor_update: ChannelMonitorUpdate) -> Result<(),()> {
+		for update in monitor_update.updates.iter() {
+			match update {
+				ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo { commitment_txid, htlc_outputs, commitment_number, 
+					their_per_commitment_point, .. } => {
+						let stub_channels = &self.channels;
+						let mut cur_per_commitment_points = None;
+						for stub_channel in stub_channels {
+							if stub_channel.channel_id == cid {
+								match stub_channel.their_cur_per_commitment_points {
+									Some(old_points) => {
+										if old_points.0 == commitment_number + 1 {
+											cur_per_commitment_points = Some((old_points.0, old_points.1, Some(*their_per_commitment_point)));
+										} else if old_points.0 == commitment_number + 2 {
+											if let Some(old_second_point) = old_points.2 {
+												cur_per_commitment_points = Some((old_points.0 - 1, old_second_point, Some(*their_per_commitment_point)));
+											} else {
+												cur_per_commitment_points = Some((*commitment_number, *their_per_commitment_point, None));
+											}
+										} else {
+											cur_per_commitment_points = Some((*commitment_number, *their_per_commitment_point, None));
+										}
+									},
+									None => {
+										cur_per_commitment_points = Some((*commitment_number, *their_per_commitment_point, None));
+									}
+								}
+							}
+						}
+						let mut htlc_data = htlc_outputs.clone();
+						for htlc in &mut htlc_data {
+							htlc.1 = None;
+						}
+						self.update_latest_state(cid, *commitment_txid, htlc_data, cur_per_commitment_points);
+						return Ok(());
+					}
+					_ => {}
+			}
+		}
+		Err(())
+	}
+
+	/// Encrypt [`OurPeerStorage`] using the `key` and return a Vec<u8> containing the result.
+    pub fn encrypt_our_peer_storage(&self, key: [u8; 32]) -> Vec<u8> {
+        let n = 0u64;
+        let mut peer_storage = VecWriter(Vec::new());
+        self.write(&mut peer_storage).unwrap();
+        let mut res = vec![0;peer_storage.0.len() + 16];
+
+        let plaintext = &peer_storage.0[..];
+		let mut nonce = [0; 12];
+		nonce[4..].copy_from_slice(&n.to_le_bytes()[..]);
+
+		let mut chacha = ChaCha20Poly1305RFC::new(&key, &nonce, b"");
+		let mut tag = [0; 16];
+		chacha.encrypt(plaintext, &mut res[0..plaintext.len()], &mut tag);
+		res[plaintext.len()..].copy_from_slice(&tag);
+        res
+	}
+
+	/// Decrypt `OurPeerStorage` using the `key`, result is stored inside the `res`.
+	/// Returns an error if the the `cyphertext` is not correct.
+    pub fn decrypt_our_peer_storage(&self, res: &mut[u8], cyphertext: &[u8], key: [u8; 32]) -> Result<(), ()> {
+		let n = 0u64;
+        let mut nonce = [0; 12];
+		nonce[4..].copy_from_slice(&n.to_le_bytes()[..]);
+
+		let mut chacha = ChaCha20Poly1305RFC::new(&key, &nonce, b"");
+		if chacha.variable_time_decrypt(&cyphertext[0..cyphertext.len() - 16], res, &cyphertext[cyphertext.len() - 16..]).is_err() {
+			return Err(());
+		}
+		Ok(())
+	}
+}
+
+impl_writeable_tlv_based!(OurPeerStorage, {
+	(0, version, (default_value, 1)),
+	(2, timestamp, required),
+	(4, channels, optional_vec),
+});
+
 /// A ChannelMonitor handles chain events (blocks connected and disconnected) and generates
 /// on-chain transactions to ensure no loss of funds occurs.
 ///
@@ -1532,6 +1734,19 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 		self.inner.lock().unwrap().get_latest_update_id()
 	}
 
+	/// Gets the latest claiming info from the ChannelMonitor to update our PeerStorageBackup.
+	pub(crate) fn get_latest_commitment_txn_and_its_claiming_info(&self) -> Option<(Txid, Vec<(HTLCOutputInCommitment, Option<std::boxed::Box<HTLCSource>>)>, Option<(u64, PublicKey, Option<PublicKey>)>)> {
+		let lock = self.inner.lock().unwrap();
+		if let Some(latest_txid) = lock.current_counterparty_commitment_txid {
+			return Some((
+				latest_txid, lock.counterparty_claimable_outpoints.get(&latest_txid).unwrap().clone(),
+				lock.their_cur_per_commitment_points
+			))
+		}
+ 
+		None
+	}
+
 	/// Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for.
 	pub fn get_funding_txo(&self) -> (OutPoint, ScriptBuf) {
 		self.inner.lock().unwrap().get_funding_txo().clone()
diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
@@ -2073,6 +2073,18 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider  {
 		self.update_time_counter
 	}
 
+	pub fn get_commitment_secret(&self) -> CounterpartyCommitmentSecrets {
+		self.commitment_secrets.clone()
+	}
+
+	pub fn get_channel_keys_id(&self) -> [u8;32] {
+		self.channel_keys_id
+	}
+
+	pub fn get_commitment_txn_number_obscure_factor(&self) -> u64 {
+		get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound())
+	}
+
 	pub fn get_latest_monitor_update_id(&self) -> u64 {
 		self.latest_monitor_update_id
 	}
@@ -2371,7 +2383,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider  {
 		height.checked_sub(self.funding_tx_confirmation_height).map_or(0, |c| c + 1)
 	}
 
-	fn get_holder_selected_contest_delay(&self) -> u16 {
+	pub fn get_holder_selected_contest_delay(&self) -> u16 {
 		self.channel_transaction_parameters.holder_selected_contest_delay
 	}
 
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
@@ -40,7 +40,7 @@ use crate::blinded_path::payment::{BlindedPaymentPath, Bolt12OfferContext, Bolt1
 use crate::chain;
 use crate::chain::{Confirm, ChannelMonitorUpdateStatus, Watch, BestBlock};
 use crate::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator, LowerBoundedFeeEstimator};
-use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, WithChannelMonitor, ChannelMonitorUpdateStep, HTLC_FAIL_BACK_BUFFER, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ANTI_REORG_DELAY, MonitorEvent, CLOSED_CHANNEL_UPDATE_ID};
+use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, StubChannelMonitor, StubChannel, OurPeerStorage, WithChannelMonitor, ChannelMonitorUpdateStep, HTLC_FAIL_BACK_BUFFER, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ANTI_REORG_DELAY, MonitorEvent, CLOSED_CHANNEL_UPDATE_ID};
 use crate::chain::transaction::{OutPoint, TransactionData};
 use crate::events;
 use crate::events::{Event, EventHandler, EventsProvider, MessageSendEvent, MessageSendEventsProvider, ClosureReason, HTLCDestination, PaymentFailureReason, ReplayEvent};
@@ -2303,6 +2303,7 @@ where
 	entropy_source: ES,
 	node_signer: NS,
 	signer_provider: SP,
+	our_peer_storage: FairRwLock<OurPeerStorage>,
 	peer_storage: Mutex<HashMap<PublicKey, Vec<u8>>>,
 	logger: L,
 }
@@ -3108,6 +3109,7 @@ where
 			entropy_source,
 			node_signer,
 			signer_provider,
+			our_peer_storage: FairRwLock::new(OurPeerStorage::new()),
 			peer_storage: Mutex::new(new_hash_map()),
 			logger,
 		}
@@ -6624,6 +6626,8 @@ where
 								if let Some(raa_blocker) = raa_blocker_opt {
 									peer_state.actions_blocking_raa_monitor_updates.entry(chan_id).or_insert_with(Vec::new).push(raa_blocker);
 								}
+
+								let _ = self.our_peer_storage.write().unwrap().update_state_from_monitor_update(chan.context.channel_id(), monitor_update.clone());
 								if !during_init {
 									handle_new_monitor_update!(self, prev_hop.outpoint, monitor_update, peer_state_lock,
 										peer_state, per_peer_state, chan);
@@ -7744,7 +7748,17 @@ where
 						let mut pending_events = self.pending_events.lock().unwrap();
 						emit_channel_ready_event!(pending_events, chan);
 					}
-
+					// Update Peer Storage.
+					let counterparty_channel_parameters = chan.context.channel_transaction_parameters.counterparty_parameters.as_ref().unwrap();
+					let counterparty_delayed_payment_base_key = counterparty_channel_parameters.pubkeys.delayed_payment_basepoint;
+					let counterparty_htlc_base_key = counterparty_channel_parameters.pubkeys.htlc_basepoint;
+					let stub_chan = StubChannel::new(chan.context.channel_id(), chan.context.get_funding_txo().unwrap(), chan.context.get_value_satoshis(),
+																chan.context.get_channel_keys_id(), chan.context.get_commitment_secret(),
+																chan.context.get_counterparty_node_id(), counterparty_delayed_payment_base_key, counterparty_htlc_base_key,
+																chan.context.get_holder_selected_contest_delay(),
+																chan.context.get_commitment_txn_number_obscure_factor(), new_hash_map(),
+																None, chan.context.channel_transaction_parameters.channel_type_features.clone());
+					self.our_peer_storage.write().unwrap().stub_channel(stub_chan);
 					Ok(())
 				} else {
 					try_chan_phase_entry!(self, Err(ChannelError::close(
@@ -8092,6 +8106,7 @@ where
 					let funding_txo = chan.context.get_funding_txo();
 					let monitor_update_opt = try_chan_phase_entry!(self, chan.commitment_signed(&msg, &&logger), chan_phase_entry);
 					if let Some(monitor_update) = monitor_update_opt {
+						let _ = self.our_peer_storage.write().unwrap().update_state_from_monitor_update(chan.context.channel_id(), monitor_update.clone());
 						handle_new_monitor_update!(self, funding_txo.unwrap(), monitor_update, peer_state_lock,
 							peer_state, per_peer_state, chan);
 					}
@@ -8292,9 +8307,15 @@ where
 						} else { false };
 						let (htlcs_to_fail, monitor_update_opt) = try_chan_phase_entry!(self,
 							chan.revoke_and_ack(&msg, &self.fee_estimator, &&logger, mon_update_blocked), chan_phase_entry);
+
+						let mut our_peer_storage = self.our_peer_storage.write().unwrap();
+						let _ = our_peer_storage.provide_secret(chan.context.channel_id(), chan.get_cur_counterparty_commitment_transaction_number() + 1, msg.per_commitment_secret);
 						if let Some(monitor_update) = monitor_update_opt {
 							let funding_txo = funding_txo_opt
 								.expect("Funding outpoint must have been set for RAA handling to succeed");
+
+							let _ = our_peer_storage.update_state_from_monitor_update(chan.context.channel_id(), monitor_update.clone());
+
 							handle_new_monitor_update!(self, funding_txo, monitor_update,
 								peer_state_lock, peer_state, per_peer_state, chan);
 						}
@@ -8638,6 +8659,7 @@ where
 						}
 						if let Some(monitor_update) = monitor_opt {
 							has_monitor_update = true;
+							let _ = self.our_peer_storage.write().unwrap().update_state_from_monitor_update(chan.context.channel_id(), monitor_update.clone());
 
 							handle_new_monitor_update!(self, funding_txo.unwrap(), monitor_update,
 								peer_state_lock, peer_state, per_peer_state, chan);
@@ -11944,6 +11966,8 @@ where
 		let mut channel_closures = VecDeque::new();
 		let mut close_background_events = Vec::new();
 		let mut funding_txo_to_channel_id = hash_map_with_capacity(channel_count as usize);
+		let mut our_peer_storage: OurPeerStorage = OurPeerStorage::new();
+
 		for _ in 0..channel_count {
 			let mut channel: Channel<SP> = Channel::read(reader, (
 				&args.entropy_source, &args.signer_provider, best_block_height, &provided_channel_type_features(&args.default_config)
@@ -11952,7 +11976,39 @@ where
 			let funding_txo = channel.context.get_funding_txo().ok_or(DecodeError::InvalidValue)?;
 			funding_txo_to_channel_id.insert(funding_txo, channel.context.channel_id());
 			funding_txo_set.insert(funding_txo.clone());
+			let counterparty_channel_parameters = channel.context.channel_transaction_parameters.counterparty_parameters.as_ref().unwrap();
+			let counterparty_delayed_payment_base_key = counterparty_channel_parameters.pubkeys.delayed_payment_basepoint;
+			let counterparty_htlc_base_key = counterparty_channel_parameters.pubkeys.htlc_basepoint;
+
+			let stub_chan = StubChannel::new(
+				channel.context.channel_id(),
+				funding_txo,
+				channel.context.get_value_satoshis(),
+				channel.context.get_channel_keys_id(),
+				channel.context.get_commitment_secret(),
+				channel.context.get_counterparty_node_id(),
+				counterparty_delayed_payment_base_key,
+				counterparty_htlc_base_key,
+				channel.context.get_holder_selected_contest_delay(),
+				channel.context.get_commitment_txn_number_obscure_factor(),
+				new_hash_map(),
+				None,
+				channel.context.channel_transaction_parameters.channel_type_features.clone(),
+			);
+			our_peer_storage.stub_channel(stub_chan);
 			if let Some(ref mut monitor) = args.channel_monitors.get_mut(&funding_txo) {
+				if let Some(latest_commitment_txn_info) = monitor.get_latest_commitment_txn_and_its_claiming_info() {
+
+					let mut htlc_data = latest_commitment_txn_info.1;
+
+					// We do not need HTLCSource to be backed up.
+					for htlc in &mut htlc_data {
+						htlc.1 = None;
+					}
+
+					our_peer_storage.update_latest_state(monitor.channel_id(), latest_commitment_txn_info.0, htlc_data, latest_commitment_txn_info.2);
+				}
+
 				if channel.get_cur_holder_commitment_transaction_number() > monitor.get_cur_holder_commitment_number() ||
 						channel.get_revoked_counterparty_commitment_transaction_number() > monitor.get_min_seen_secret() ||
 						channel.get_cur_counterparty_commitment_transaction_number() > monitor.get_cur_counterparty_commitment_number() ||
@@ -12796,6 +12852,7 @@ where
 
 			last_days_feerates: Mutex::new(VecDeque::new()),
 
+			our_peer_storage: FairRwLock::new(our_peer_storage),
 			peer_storage: Mutex::new(peer_storage),
 			logger: args.logger,
 			default_configuration: args.default_config,

Original file line number	Diff line number	Diff line change
`@@ -2073,6 +2073,18 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {`
`2073`	`2073`	`self.update_time_counter`
`2074`	`2074`	`}`
`2075`	`2075`
	`2076`	`+ pub fn get_commitment_secret(&self) -> CounterpartyCommitmentSecrets {`
	`2077`	`+ self.commitment_secrets.clone()`
	`2078`	`+ }`
	`2079`	`+`
	`2080`	`+ pub fn get_channel_keys_id(&self) -> [u8;32] {`
	`2081`	`+ self.channel_keys_id`
	`2082`	`+ }`
	`2083`	`+`
	`2084`	`+ pub fn get_commitment_txn_number_obscure_factor(&self) -> u64 {`
	`2085`	`+ get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound())`
	`2086`	`+ }`
	`2087`	`+`
`2076`	`2088`	`pub fn get_latest_monitor_update_id(&self) -> u64 {`
`2077`	`2089`	`self.latest_monitor_update_id`
`2078`	`2090`	`}`
`@@ -2371,7 +2383,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {`
`2371`	`2383`	`height.checked_sub(self.funding_tx_confirmation_height).map_or(0, \|c\| c + 1)`
`2372`	`2384`	`}`
`2373`	`2385`
`2374`		`- fn get_holder_selected_contest_delay(&self) -> u16 {`
	`2386`	`+ pub fn get_holder_selected_contest_delay(&self) -> u16 {`
`2375`	`2387`	`self.channel_transaction_parameters.holder_selected_contest_delay`
`2376`	`2388`	`}`
`2377`	`2389`