Cache remote HTLC inside OnchainTxHandler::JusticeTxCache

As we can't predict if any and which revoked commitment tx is
going to appear onchain we have by design to cache all htlc information
to regenerate htlc script if needed.

Author: Antoine Riard

lightning/src/ln/channelmonitor.rs

@@ -1211,7 +1211,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 		log_trace!(self, "New potential remote commitment transaction: {}", encode::serialize_hex(unsigned_commitment_tx));
 		self.onchain_detection.prev_remote_commitment_txid = self.onchain_detection.current_remote_commitment_txid.take();
 		self.onchain_detection.current_remote_commitment_txid = Some(new_txid);
-		self.remote_claimable_outpoints.insert(new_txid, htlc_outputs);
+		self.remote_claimable_outpoints.insert(new_txid, htlc_outputs.clone());
 		self.current_remote_commitment_number = commitment_number;
 		//TODO: Merge this into the other per-remote-transaction output storage stuff
 		match self.their_cur_revocation_points {
@@ -1232,6 +1232,13 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 				self.their_cur_revocation_points = Some((commitment_number, their_revocation_point, None));
 			}
 		}
+		let mut htlcs = Vec::with_capacity(htlc_outputs.len());
+		for htlc in htlc_outputs {
+			if htlc.0.transaction_output_index.is_some() {
+				htlcs.push(htlc.0);
+			}
+		}
+		self.onchain_tx_handler.provide_latest_remote_tx(new_txid, htlcs);
 	}
 
 	pub(super) fn provide_rescue_remote_commitment_tx_info(&mut self, their_revocation_point: PublicKey) {

lightning/src/ln/onchaintx.rs

@@ -62,7 +62,8 @@ struct HTLCTxCache {
 /// Cache remote basepoint to compute any justice tx.
 struct JusticeTxCache {
 	remote_delayed_payment_base_key: PublicKey,
-	remote_htlc_base_key: PublicKey
+	remote_htlc_base_key: PublicKey,
+	per_htlc: HashMap<Sha256dHash, Vec<(HTLCOutputInCommitment)>>
 }
 
 /// Higher-level cache structure needed to re-generate bumped claim txn if needed
@@ -244,6 +245,14 @@ impl<ChanSigner: ChannelKeys + Writeable> OnchainTxHandler<ChanSigner> {
 
 		self.justice_tx_cache.remote_delayed_payment_base_key.write(writer)?;
 		self.justice_tx_cache.remote_htlc_base_key.write(writer)?;
+		writer.write_all(&byte_utils::be64_to_array(self.justice_tx_cache.per_htlc.len() as u64))?;
+		for (ref txid, ref htlcs) in self.justice_tx_cache.per_htlc.iter() {
+			writer.write_all(&txid[..])?;
+			writer.write_all(&byte_utils::be64_to_array(htlcs.len() as u64))?;
+			for &ref htlc in htlcs.iter() {
+				htlc.write(writer)?;
+			}
+		}
 		self.remote_csv.write(writer)?;
 
 		self.key_storage.write(writer)?;
@@ -335,9 +344,24 @@ impl<ChanSigner: ChannelKeys + Readable> ReadableArgs<Arc<Logger>> for OnchainTx
 		let justice_tx_cache = {
 			let remote_delayed_payment_base_key = Readable::read(reader)?;
 			let remote_htlc_base_key = Readable::read(reader)?;
+			let per_htlc_len: u64 = Readable::read(reader)?;
+			let mut per_htlc = HashMap::with_capacity(cmp::min(per_htlc_len as usize, MAX_ALLOC_SIZE / 64));
+			for _  in 0..per_htlc_len {
+				let txid: Sha256dHash = Readable::read(reader)?;
+				let htlcs_count: u64 = Readable::read(reader)?;
+				let mut htlcs = Vec::with_capacity(cmp::min(htlcs_count as usize, MAX_ALLOC_SIZE / 32));
+				for _ in 0..htlcs_count {
+					let htlc = Readable::read(reader)?;
+					htlcs.push(htlc);
+				}
+				if let Some(_) = per_htlc.insert(txid, htlcs) {
+					return Err(DecodeError::InvalidValue);
+				}
+			}
 			JusticeTxCache {
 				remote_delayed_payment_base_key,
 				remote_htlc_base_key,
+				per_htlc,
 			}
 		};
 		let remote_csv = Readable::read(reader)?;
@@ -415,6 +439,7 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 		let justice_tx_cache = JusticeTxCache {
 			remote_delayed_payment_base_key,
 			remote_htlc_base_key,
+			per_htlc: HashMap::new(),
 		};
 
 		OnchainTxHandler {
@@ -916,6 +941,10 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 		});
 	}
 
+	pub(super) fn provide_latest_remote_tx(&mut self, commitment_txid: Sha256dHash, htlcs: Vec<HTLCOutputInCommitment>) {
+		self.justice_tx_cache.per_htlc.insert(commitment_txid, htlcs);
+	}
+
 	pub(super) fn get_fully_signed_local_tx(&mut self, channel_value_satoshis: u64) -> Option<Transaction> {
 		if self.local_commitment.is_some() {
 			let mut tx = self.local_commitment.clone().unwrap();