move prev_htlc_amount into PendingHTLCInfo

johncantrell97 · johncantrell97 · commit d9e0c4549658 · 2022-07-11T07:13:20.000-04:00
diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
@@ -413,7 +413,7 @@ pub enum UpdateFulfillCommitFetch {
 /// state.
 pub(super) struct RAAUpdates {
 	pub commitment_update: Option<msgs::CommitmentUpdate>,
-	pub accepted_htlcs: Vec<(PendingHTLCInfo, u64, Option<u64>)>,
+	pub accepted_htlcs: Vec<(PendingHTLCInfo, u64)>,
 	pub failed_htlcs: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
 	pub finalized_claimed_htlcs: Vec<HTLCSource>,
 	pub monitor_update: ChannelMonitorUpdate,
@@ -425,7 +425,7 @@ pub(super) struct MonitorRestoreUpdates {
 	pub raa: Option<msgs::RevokeAndACK>,
 	pub commitment_update: Option<msgs::CommitmentUpdate>,
 	pub order: RAACommitmentOrder,
-	pub accepted_htlcs: Vec<(PendingHTLCInfo, u64, Option<u64>)>,
+	pub accepted_htlcs: Vec<(PendingHTLCInfo, u64)>,
 	pub failed_htlcs: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
 	pub finalized_claimed_htlcs: Vec<HTLCSource>,
 	pub funding_broadcastable: Option<Transaction>,
@@ -558,7 +558,7 @@ pub(super) struct Channel<Signer: Sign> {
 	monitor_pending_channel_ready: bool,
 	monitor_pending_revoke_and_ack: bool,
 	monitor_pending_commitment_signed: bool,
-	monitor_pending_forwards: Vec<(PendingHTLCInfo, u64, Option<u64>)>,
+	monitor_pending_forwards: Vec<(PendingHTLCInfo, u64)>,
 	monitor_pending_failures: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
 	monitor_pending_finalized_fulfills: Vec<HTLCSource>,
 
@@ -3326,7 +3326,7 @@ impl<Signer: Sign> Channel<Signer> {
 							},
 							PendingHTLCStatus::Forward(forward_info) => {
 								log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to Committed", log_bytes!(htlc.payment_hash.0));
-								to_forward_infos.push((forward_info, htlc.htlc_id, Some(htlc.amount_msat)));
+								to_forward_infos.push((forward_info, htlc.htlc_id));
 								htlc.state = InboundHTLCState::Committed;
 							}
 						}
@@ -3599,7 +3599,7 @@ impl<Signer: Sign> Channel<Signer> {
 	/// monitor update failure must *not* have been sent to the remote end, and must instead
 	/// have been dropped. They will be regenerated when monitor_updating_restored is called.
 	pub fn monitor_update_failed(&mut self, resend_raa: bool, resend_commitment: bool,
-		resend_channel_ready: bool, mut pending_forwards: Vec<(PendingHTLCInfo, u64, Option<u64>)>,
+		resend_channel_ready: bool, mut pending_forwards: Vec<(PendingHTLCInfo, u64)>,
 		mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
 		mut pending_finalized_claimed_htlcs: Vec<HTLCSource>
 	) {
@@ -6007,10 +6007,9 @@ impl<Signer: Sign> Writeable for Channel<Signer> {
 		self.monitor_pending_commitment_signed.write(writer)?;
 
 		(self.monitor_pending_forwards.len() as u64).write(writer)?;
-		for &(ref pending_forward, ref htlc_id, ref htlc_amount) in self.monitor_pending_forwards.iter() {
+		for &(ref pending_forward, ref htlc_id) in self.monitor_pending_forwards.iter() {
 			pending_forward.write(writer)?;
 			htlc_id.write(writer)?;
-			htlc_amount.write(writer)?;
 		}
 
 		(self.monitor_pending_failures.len() as u64).write(writer)?;
@@ -6271,7 +6270,7 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 		let monitor_pending_forwards_count: u64 = Readable::read(reader)?;
 		let mut monitor_pending_forwards = Vec::with_capacity(cmp::min(monitor_pending_forwards_count as usize, OUR_MAX_HTLCS as usize));
 		for _ in 0..monitor_pending_forwards_count {
-			monitor_pending_forwards.push((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?));
+			monitor_pending_forwards.push((Readable::read(reader)?, Readable::read(reader)?));
 		}
 
 		let monitor_pending_failures_count: u64 = Readable::read(reader)?;
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
@@ -116,6 +116,7 @@ pub(super) struct PendingHTLCInfo {
 	payment_hash: PaymentHash,
 	pub(super) amt_to_forward: u64,
 	pub(super) outgoing_cltv_value: u32,
+	pub(super) amt_incoming: Option<u64>
 }
 
 #[derive(Clone)] // See Channel::revoke_and_ack for why, tl;dr: Rust bug
@@ -136,7 +137,6 @@ pub(super) struct PendingInterceptedHTLC {
 	prev_short_channel_id: u64,
 	prev_htlc_id: u64,
 	prev_funding_outpoint: OutPoint,
-	prev_htlc_amount: u64
 }
 
 pub(super) enum HTLCForwardInfo {
@@ -152,7 +152,6 @@ pub(super) enum HTLCForwardInfo {
 		prev_short_channel_id: u64,
 		prev_htlc_id: u64,
 		prev_funding_outpoint: OutPoint,
-		prev_htlc_amount: Option<u64>
 	},
 	FailHTLC {
 		htlc_id: u64,
@@ -1374,7 +1373,7 @@ macro_rules! handle_monitor_err {
 							} else if $resend_commitment { "commitment" }
 							else if $resend_raa { "RAA" }
 							else { "nothing" },
-						(&$failed_forwards as &Vec<(PendingHTLCInfo, u64, Option<u64>)>).len(),
+						(&$failed_forwards as &Vec<(PendingHTLCInfo, u64)>).len(),
 						(&$failed_fails as &Vec<(HTLCSource, PaymentHash, HTLCFailReason)>).len(),
 						(&$failed_finalized_fulfills as &Vec<HTLCSource>).len());
 				if !$resend_commitment {
@@ -1463,7 +1462,7 @@ macro_rules! handle_chan_restoration_locked {
 		let chanmon_update_is_none = chanmon_update.is_none();
 		let counterparty_node_id = $channel_entry.get().get_counterparty_node_id();
 		let res = loop {
-			let forwards: Vec<(PendingHTLCInfo, u64, Option<u64>)> = $pending_forwards; // Force type-checking to resolve
+			let forwards: Vec<(PendingHTLCInfo, u64)> = $pending_forwards; // Force type-checking to resolve
 			if !forwards.is_empty() {
 				htlc_forwards = Some(($channel_entry.get().get_short_channel_id().unwrap_or($channel_entry.get().outbound_scid_alias()),
 					$channel_entry.get().get_funding_txo().unwrap(), forwards));
@@ -2145,7 +2144,8 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 			routing,
 			payment_hash,
 			incoming_shared_secret: shared_secret,
-			amt_to_forward: amt_msat,
+			amt_to_forward: 0,
+			amt_incoming: Some(amt_msat),
 			outgoing_cltv_value: hop_data.outgoing_cltv_value,
 		})
 	}
@@ -2248,6 +2248,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 					incoming_shared_secret: shared_secret,
 					amt_to_forward: next_hop_data.amt_to_forward,
 					outgoing_cltv_value: next_hop_data.outgoing_cltv_value,
+					amt_incoming: Some(msg.amount_msat)
 				})
 			}
 		};
@@ -3137,7 +3138,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 						..payment.forward_info
 					};
 
-					let mut per_source_pending_forward = vec![(payment.prev_short_channel_id, payment.prev_funding_outpoint, vec![(pending_htlc_info, payment.prev_htlc_id, Some(payment.prev_htlc_amount))])];
+					let mut per_source_pending_forward = vec![(payment.prev_short_channel_id, payment.prev_funding_outpoint, vec![(pending_htlc_info, payment.prev_htlc_id)])];
 					self.forward_htlcs(&mut per_source_pending_forward);
 					Ok(())
 			}
@@ -3153,7 +3154,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 
 		let mut new_events = Vec::new();
 		let mut failed_forwards = Vec::new();
-		let mut phantom_receives: Vec<(u64, OutPoint, Vec<(PendingHTLCInfo, u64, Option<u64>)>)> = Vec::new();
+		let mut phantom_receives: Vec<(u64, OutPoint, Vec<(PendingHTLCInfo, u64)>)> = Vec::new();
 		let mut handle_errors = Vec::new();
 		{
 			let mut channel_state_lock = self.channel_state.lock().unwrap();
@@ -3166,7 +3167,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 						None => {
 							for forward_info in pending_forwards.drain(..) {
 								match forward_info {
-									HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_htlc_id, forward_info, prev_funding_outpoint, prev_htlc_amount } => {
+									HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_htlc_id, forward_info, prev_funding_outpoint } => {
 											macro_rules! fail_forward {
 												($msg: expr, $err_code: expr, $err_data: expr, $phantom_ss: expr) => {
 													{
@@ -3206,13 +3207,13 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 													match next_hop {
 														onion_utils::Hop::Receive(hop_data) => {
 															match self.construct_recv_pending_htlc_info(hop_data, forward_info.incoming_shared_secret, forward_info.payment_hash, forward_info.amt_to_forward, forward_info.outgoing_cltv_value, Some(phantom_shared_secret)) {
-																Ok(info) => phantom_receives.push((prev_short_channel_id, prev_funding_outpoint, vec![(info, prev_htlc_id, prev_htlc_amount)])),
+																Ok(info) => phantom_receives.push((prev_short_channel_id, prev_funding_outpoint, vec![(info, prev_htlc_id)])),
 																Err(ReceiveError { err_code, err_data, msg }) => fail_forward!(msg, err_code, err_data, Some(phantom_shared_secret))
 															}
 														},
 														_ => panic!(),
 													}
-												} else if prev_htlc_amount.is_some() && fake_scid::is_valid_intercept(&self.fake_scid_rand_bytes, short_chan_id) {
+												} else if forward_info.amt_incoming.is_some() && fake_scid::is_valid_intercept(&self.fake_scid_rand_bytes, short_chan_id) {
 													let intercept_id = InterceptId(Sha256::hash(&forward_info.incoming_shared_secret).into_inner());
 													let mut pending_intercepts = self.pending_intercepted_payments.lock().unwrap();
 													match pending_intercepts.entry(intercept_id) {
@@ -3222,13 +3223,12 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 																prev_short_channel_id,
 																prev_htlc_id,
 																prev_funding_outpoint,
-																prev_htlc_amount: prev_htlc_amount.unwrap()
 															};
 															entry.insert(pending_intercepted_payment);
 															new_events.push(events::Event::PaymentIntercepted {
 																short_channel_id: short_chan_id,
 																payment_hash: forward_info.payment_hash,
-																inbound_amount_msats: prev_htlc_amount.unwrap(),
+																inbound_amount_msats: forward_info.amt_incoming.unwrap(),
 																expected_outbound_amount_msats: forward_info.amt_to_forward,
 																intercept_id
 															});
@@ -3263,7 +3263,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 								HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_htlc_id, forward_info: PendingHTLCInfo {
 										routing: PendingHTLCRouting::Forward {
 											onion_packet, ..
-										}, incoming_shared_secret, payment_hash, amt_to_forward, outgoing_cltv_value },
+										}, incoming_shared_secret, payment_hash, amt_to_forward, outgoing_cltv_value, .. },
 										prev_funding_outpoint, .. } => {
 									log_trace!(self.logger, "Adding HTLC from short id {} with payment_hash {} to channel with short id {} after delay", prev_short_channel_id, log_bytes!(payment_hash.0), short_chan_id);
 									let htlc_source = HTLCSource::PreviousHopData(HTLCPreviousHopData {
@@ -5016,27 +5016,27 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 	}
 
 	#[inline]
-	fn forward_htlcs(&self, per_source_pending_forwards: &mut [(u64, OutPoint, Vec<(PendingHTLCInfo, u64, Option<u64>)>)]) {
+	fn forward_htlcs(&self, per_source_pending_forwards: &mut [(u64, OutPoint, Vec<(PendingHTLCInfo, u64)>)]) {
 		for &mut (prev_short_channel_id, prev_funding_outpoint, ref mut pending_forwards) in per_source_pending_forwards {
 			let mut forward_event = None;
 			if !pending_forwards.is_empty() {
 				let mut channel_state = self.channel_state.lock().unwrap();
 				if channel_state.forward_htlcs.is_empty() {
 					forward_event = Some(Duration::from_millis(MIN_HTLC_RELAY_HOLDING_CELL_MILLIS))
 				}
-				for (forward_info, prev_htlc_id, prev_htlc_amount) in pending_forwards.drain(..) {
+				for (forward_info, prev_htlc_id) in pending_forwards.drain(..) {
 					match channel_state.forward_htlcs.entry(match forward_info.routing {
 							PendingHTLCRouting::Forward { short_channel_id, .. } => short_channel_id,
 							PendingHTLCRouting::Receive { .. } => 0,
 							PendingHTLCRouting::ReceiveKeysend { .. } => 0,
 					}) {
 						hash_map::Entry::Occupied(mut entry) => {
 							entry.get_mut().push(HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_funding_outpoint,
-							                                                prev_htlc_id, prev_htlc_amount, forward_info });
+							                                                prev_htlc_id, forward_info });
 						},
 						hash_map::Entry::Vacant(entry) => {
 							entry.insert(vec!(HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_funding_outpoint,
-							                                             prev_htlc_id, prev_htlc_amount, forward_info }));
+							                                             prev_htlc_id, forward_info }));
 						}
 					}
 				}
@@ -6426,7 +6426,8 @@ impl_writeable_tlv_based!(PendingHTLCInfo, {
 	(2, incoming_shared_secret, required),
 	(4, payment_hash, required),
 	(6, amt_to_forward, required),
-	(8, outgoing_cltv_value, required)
+	(8, outgoing_cltv_value, required),
+	(9, amt_incoming, option),
 });
 
 
@@ -6654,7 +6655,6 @@ impl_writeable_tlv_based_enum!(HTLCForwardInfo,
 		(2, prev_short_channel_id, required),
 		(4, prev_htlc_id, required),
 		(6, prev_funding_outpoint, required),
-		(8, prev_htlc_amount, option)
 	},
 	(1, FailHTLC) => {
 		(0, htlc_id, required),
