pass through prev_htlc_amount

Author: johncantrell97

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)>,
+	pub accepted_htlcs: Vec<(PendingHTLCInfo, u64, Option<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)>,
+	pub accepted_htlcs: Vec<(PendingHTLCInfo, u64, Option<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)>,
+	monitor_pending_forwards: Vec<(PendingHTLCInfo, u64, Option<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));
+								to_forward_infos.push((forward_info, htlc.htlc_id, Some(htlc.amount_msat)));
 								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)>,
+		resend_channel_ready: bool, mut pending_forwards: Vec<(PendingHTLCInfo, u64, Option<u64>)>,
 		mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
 		mut pending_finalized_claimed_htlcs: Vec<HTLCSource>
 	) {
@@ -6007,9 +6007,10 @@ 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) in self.monitor_pending_forwards.iter() {
+		for &(ref pending_forward, ref htlc_id, ref htlc_amount) 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)?;
@@ -6270,7 +6271,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)?));
+			monitor_pending_forwards.push((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?));
 		}
 
 		let monitor_pending_failures_count: u64 = Readable::read(reader)?;

lightning/src/ln/channelmanager.rs

@@ -144,6 +144,7 @@ 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,
@@ -1454,7 +1455,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)> = $pending_forwards; // Force type-checking to resolve
+			let forwards: Vec<(PendingHTLCInfo, u64, Option<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));
@@ -3108,7 +3109,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 			None => Err(APIError::APIMisuseError { err: "Payment with that InterceptId not found".to_string() }),
 			Some(payment) => {
 				match payment {
-					HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_htlc_id, forward_info, prev_funding_outpoint } => {
+					HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_htlc_id, forward_info, prev_funding_outpoint, prev_htlc_amount } => {
 
 						let routing = match forward_info.routing {
 								PendingHTLCRouting::Forward { onion_packet, .. } => {
@@ -3123,7 +3124,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 								..forward_info
 							};
 
-							let mut per_source_pending_forward = vec![(prev_short_channel_id, prev_funding_outpoint, vec![(pending_htlc_info, prev_htlc_id)])];
+							let mut per_source_pending_forward = vec![(prev_short_channel_id, prev_funding_outpoint, vec![(pending_htlc_info, prev_htlc_id, prev_htlc_amount)])];
 
 							self.forward_htlcs(&mut per_source_pending_forward);
 
@@ -3144,7 +3145,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)>)> = Vec::new();
+		let mut phantom_receives: Vec<(u64, OutPoint, Vec<(PendingHTLCInfo, u64, Option<u64>)>)> = Vec::new();
 		let mut handle_errors = Vec::new();
 		{
 			let mut channel_state_lock = self.channel_state.lock().unwrap();
@@ -3159,7 +3160,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 								match forward_info {
 									HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_htlc_id, forward_info: PendingHTLCInfo {
 										ref routing, incoming_shared_secret, payment_hash, amt_to_forward, outgoing_cltv_value },
-										prev_funding_outpoint } => {
+										prev_funding_outpoint, prev_htlc_amount } => {
 											macro_rules! fail_forward {
 												($msg: expr, $err_code: expr, $err_data: expr, $phantom_ss: expr) => {
 													{
@@ -3199,13 +3200,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, incoming_shared_secret, payment_hash, amt_to_forward, outgoing_cltv_value, Some(phantom_shared_secret)) {
-																Ok(info) => phantom_receives.push((prev_short_channel_id, prev_funding_outpoint, vec![(info, prev_htlc_id)])),
+																Ok(info) => phantom_receives.push((prev_short_channel_id, prev_funding_outpoint, vec![(info, prev_htlc_id, prev_htlc_amount)])),
 																Err(ReceiveError { err_code, err_data, msg }) => fail_forward!(msg, err_code, err_data, Some(phantom_shared_secret))
 															}
 														},
 														_ => panic!(),
 													}
-												} else if fake_scid::is_valid_intercept(&self.fake_scid_rand_bytes, short_chan_id) {
+												} else if prev_htlc_amount.is_some() && fake_scid::is_valid_intercept(&self.fake_scid_rand_bytes, short_chan_id) {
 													let intercept_id = InterceptId(Sha256::hash(&incoming_shared_secret).into_inner());
 													let mut pending_intercepts = self.pending_intercepted_payments.lock().unwrap();
 													match pending_intercepts.entry(intercept_id) {
@@ -3214,7 +3215,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 															new_events.push(events::Event::PaymentIntercepted {
 																short_channel_id: short_chan_id,
 																payment_hash,
-																inbound_amount_msats: 0,
+																inbound_amount_msats: prev_htlc_amount.unwrap(),
 																expected_outbound_amount_msats: amt_to_forward,
 																intercept_id
 															});
@@ -3250,7 +3251,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 										routing: PendingHTLCRouting::Forward {
 											onion_packet, ..
 										}, incoming_shared_secret, payment_hash, amt_to_forward, outgoing_cltv_value },
-										prev_funding_outpoint } => {
+										prev_funding_outpoint, prev_htlc_amount } => {
 									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 {
 										short_channel_id: prev_short_channel_id,
@@ -3370,7 +3371,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 						match forward_info {
 							HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_htlc_id, forward_info: PendingHTLCInfo {
 									routing, incoming_shared_secret, payment_hash, amt_to_forward, .. },
-									prev_funding_outpoint } => {
+									prev_funding_outpoint, prev_htlc_amount } => {
 								let (cltv_expiry, onion_payload, payment_data, phantom_shared_secret) = match routing {
 									PendingHTLCRouting::Receive { payment_data, incoming_cltv_expiry, phantom_shared_secret } => {
 										let _legacy_hop_data = Some(payment_data.clone());
@@ -5002,27 +5003,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)>)]) {
+	fn forward_htlcs(&self, per_source_pending_forwards: &mut [(u64, OutPoint, Vec<(PendingHTLCInfo, u64, Option<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) in pending_forwards.drain(..) {
+				for (forward_info, prev_htlc_id, prev_htlc_amount) 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, forward_info });
+							                                                prev_htlc_id, prev_htlc_amount, forward_info });
 						},
 						hash_map::Entry::Vacant(entry) => {
 							entry.insert(vec!(HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_funding_outpoint,
-							                                             prev_htlc_id, forward_info }));
+							                                             prev_htlc_id, prev_htlc_amount, forward_info }));
 						}
 					}
 				}
@@ -6640,6 +6641,7 @@ 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),