Track HTLC on-chain value for HTLC-Success/-Timeout txn for balance

This adds tracking in the HTLC resolution of the
HTLC-Success/HTLC-Timeout amounts so that we can use them in the
coming commits for the `get_claimable_balance` amounts.

Author: TheBlueMatt

lightning/src/chain/channelmonitor.rs

@@ -361,6 +361,9 @@ enum OnchainEvent {
 	HTLCUpdate {
 		source: HTLCSource,
 		payment_hash: PaymentHash,
+		/// If the HTLC was claimed by an HTLC-Success or HTLC-Timeout transaction, this is the
+		/// amount of the output of that transaction (ie `htlc_value_satoshis` minus fees).
+		onchain_value_satoshis: Option<u64>,
 		htlc_value_satoshis: Option<u64>,
 		/// None in the second case, above, ie when there is no relevant output in the commitment
 		/// transaction which appeared on chain.
@@ -392,6 +395,9 @@ enum OnchainEvent {
 	///    signature.
 	HTLCSpendConfirmation {
 		commitment_tx_output_idx: u32,
+		/// If the HTLC was claimed by an HTLC-Success or HTLC-Timeout transaction, this is the
+		/// amount of the output of that transaction (ie `htlc_value_satoshis` minus fees).
+		onchain_value_satoshis: Option<u64>,
 		/// If the claim was made by either party with a preimage, this is filled in
 		preimage: Option<PaymentPreimage>,
 		/// If the claim was made by us on an inbound HTLC against a local commitment transaction,
@@ -439,6 +445,7 @@ impl_writeable_tlv_based_enum_upgradable!(OnchainEvent,
 		(1, htlc_value_satoshis, option),
 		(2, payment_hash, required),
 		(3, commitment_tx_output_idx, option),
+		(5, onchain_value_satoshis, option),
 	},
 	(1, MaturingOutput) => {
 		(0, descriptor, required),
@@ -449,6 +456,7 @@ impl_writeable_tlv_based_enum_upgradable!(OnchainEvent,
 	},
 	(5, HTLCSpendConfirmation) => {
 		(0, commitment_tx_output_idx, required),
+		(1, onchain_value_satoshis, option),
 		(2, preimage, option),
 		(4, on_to_local_output_csv, option),
 	},
@@ -1720,6 +1728,7 @@ macro_rules! fail_unbroadcast_htlcs {
 									source: (**source).clone(),
 									payment_hash: htlc.payment_hash.clone(),
 									htlc_value_satoshis: Some(htlc.amount_msat / 1000),
+									onchain_value_satoshis: None,
 									commitment_tx_output_idx: None,
 								},
 							};
@@ -2619,7 +2628,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		// Produce actionable events from on-chain events having reached their threshold.
 		for entry in onchain_events_reaching_threshold_conf.drain(..) {
 			match entry.event {
-				OnchainEvent::HTLCUpdate { ref source, payment_hash, htlc_value_satoshis, commitment_tx_output_idx } => {
+				OnchainEvent::HTLCUpdate { ref source, payment_hash, htlc_value_satoshis, commitment_tx_output_idx, .. } => {
 					// Check for duplicate HTLC resolutions.
 					#[cfg(debug_assertions)]
 					{
@@ -2850,6 +2859,14 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			#[cfg(not(fuzzing))]
 			let offered_timeout_claim = witness_items == 5 && htlctype == Some(HTLCType::OfferedHTLC);
 
+			let claim_via_htlc_tx = accepted_preimage_claim || offered_timeout_claim;
+			if claim_via_htlc_tx {
+				// If the claim was via an HTLC-Timeout/HTLC-Success transaction, it must be a
+				// 1-in-1-out transaction as its pre-signed.
+				debug_assert_eq!(tx.input.len(), 1);
+				debug_assert_eq!(tx.output.len(), 1); // If anchors are enabled this should be 2
+			}
+
 			let mut payment_preimage = PaymentPreimage([0; 32]);
 			if accepted_preimage_claim {
 				payment_preimage.0.copy_from_slice(input.witness.second_to_last().unwrap());
@@ -2888,13 +2905,14 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			}
 
 			macro_rules! check_htlc_valid_counterparty {
-				($counterparty_txid: expr, $htlc_output: expr) => {
+				($counterparty_txid: expr, $htlc_output: expr, $htlc_value_sats: expr) => {
 					if let Some(txid) = $counterparty_txid {
 						for &(ref pending_htlc, ref pending_source) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
 							if pending_htlc.payment_hash == $htlc_output.payment_hash && pending_htlc.amount_msat == $htlc_output.amount_msat {
 								if let &Some(ref source) = pending_source {
 									log_claim!("revoked counterparty commitment tx", false, pending_htlc, true);
-									payment_data = Some(((**source).clone(), $htlc_output.payment_hash, $htlc_output.amount_msat));
+									payment_data = Some(((**source).clone(), $htlc_output.payment_hash,
+										pending_htlc.amount_msat, $htlc_value_sats));
 									break;
 								}
 							}
@@ -2907,18 +2925,24 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 				($htlcs: expr, $tx_info: expr, $holder_tx: expr) => {
 					for (ref htlc_output, source_option) in $htlcs {
 						if Some(input.previous_output.vout) == htlc_output.transaction_output_index {
+							let htlc_value_sats = if claim_via_htlc_tx {
+								tx.output.iter().map(|txout| txout.value).sum::<u64>()
+							} else { htlc_output.amount_msat / 1000 };
 							if let Some(ref source) = source_option {
 								log_claim!($tx_info, $holder_tx, htlc_output, true);
 								// We have a resolution of an HTLC either from one of our latest
 								// holder commitment transactions or an unrevoked counterparty commitment
 								// transaction. This implies we either learned a preimage, the HTLC
 								// has timed out, or we screwed up. In any case, we should now
 								// resolve the source HTLC with the original sender.
-								payment_data = Some(((*source).clone(), htlc_output.payment_hash, htlc_output.amount_msat));
+								payment_data = Some(((*source).clone(), htlc_output.payment_hash,
+									htlc_output.amount_msat, htlc_value_sats));
 							} else if !$holder_tx {
-								check_htlc_valid_counterparty!(self.current_counterparty_commitment_txid, htlc_output);
+								check_htlc_valid_counterparty!(self.current_counterparty_commitment_txid,
+									htlc_output, htlc_value_sats);
 								if payment_data.is_none() {
-									check_htlc_valid_counterparty!(self.prev_counterparty_commitment_txid, htlc_output);
+									check_htlc_valid_counterparty!(self.prev_counterparty_commitment_txid,
+										htlc_output, htlc_value_sats);
 								}
 							}
 							if payment_data.is_none() {
@@ -2929,6 +2953,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 										txid: tx.txid(), height, transaction: Some(tx.clone()),
 										event: OnchainEvent::HTLCSpendConfirmation {
 											commitment_tx_output_idx: input.previous_output.vout,
+											onchain_value_satoshis: Some(htlc_value_sats),
 											preimage: if accepted_preimage_claim || offered_preimage_claim {
 												Some(payment_preimage) } else { None },
 											// If this is a payment to us (!outbound_htlc, above),
@@ -2971,7 +2996,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 
 			// Check that scan_commitment, above, decided there is some source worth relaying an
 			// HTLC resolution backwards to and figure out whether we learned a preimage from it.
-			if let Some((source, payment_hash, amount_msat)) = payment_data {
+			if let Some((source, payment_hash, amount_msat, onchain_amount_sat)) = payment_data {
 				if accepted_preimage_claim {
 					if !self.pending_monitor_events.iter().any(
 						|update| if let &MonitorEvent::HTLCEvent(ref upd) = update { upd.source == source } else { false }) {
@@ -2983,6 +3008,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 								commitment_tx_output_idx: input.previous_output.vout,
 								preimage: Some(payment_preimage),
 								on_to_local_output_csv: None,
+								onchain_value_satoshis: Some(onchain_amount_sat),
 							},
 						});
 						self.pending_monitor_events.push(MonitorEvent::HTLCEvent(HTLCUpdate {
@@ -3005,6 +3031,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 								commitment_tx_output_idx: input.previous_output.vout,
 								preimage: Some(payment_preimage),
 								on_to_local_output_csv: None,
+								onchain_value_satoshis: Some(onchain_amount_sat),
 							},
 						});
 						self.pending_monitor_events.push(MonitorEvent::HTLCEvent(HTLCUpdate {
@@ -3032,6 +3059,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 							source, payment_hash,
 							htlc_value_satoshis: Some(amount_msat / 1000),
 							commitment_tx_output_idx: Some(input.previous_output.vout),
+							onchain_value_satoshis: Some(onchain_amount_sat),
 						},
 					};
 					log_info!(logger, "Failing HTLC with payment_hash {} timeout by a spend tx, waiting for confirmation (at height {})", log_bytes!(payment_hash.0), entry.confirmation_threshold());