extract PendingInterceptedPayment from HTLCForwardInfo::AddHTLC

Author: johncantrell97

lightning/src/ln/channelmanager.rs

@@ -131,6 +131,14 @@ pub(super) enum PendingHTLCStatus {
 	Fail(HTLCFailureMsg),
 }
 
+pub(super) struct PendingInterceptedHTLC {
+	forward_info: PendingHTLCInfo,
+	prev_short_channel_id: u64,
+	prev_htlc_id: u64,
+	prev_funding_outpoint: OutPoint,
+	prev_htlc_amount: u64
+}
+
 pub(super) enum HTLCForwardInfo {
 	AddHTLC {
 		forward_info: PendingHTLCInfo,
@@ -741,9 +749,9 @@ pub struct ChannelManager<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref,
 	/// Locked *after* channel_state.
 	pending_outbound_payments: Mutex<HashMap<PaymentId, PendingOutboundPayment>>,
 
-	/// Storage for HTLCForwardInfo's that have been intercepted and bubbled up to the user.
+	/// Storage for PendingInterceptedHTLC's that have been intercepted and bubbled up to the user.
 	/// We hold them here until the user tells us what we should to with them.
-	pending_intercepted_payments: Mutex<HashMap<InterceptId, HTLCForwardInfo>>,
+	pending_intercepted_payments: Mutex<HashMap<InterceptId, PendingInterceptedHTLC>>,
 
 	/// The set of outbound SCID aliases across all our channels, including unconfirmed channels
 	/// and some closed channels which reached a usable state prior to being closed. This is used
@@ -3090,19 +3098,16 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 		};
 
 		if let Some(payment) = pending_intercept {
-			if let HTLCForwardInfo::AddHTLC { forward_info, prev_short_channel_id, prev_htlc_id, prev_funding_outpoint, .. } = payment {
-
-				let htlc_source = HTLCSource::PreviousHopData(HTLCPreviousHopData {
-					short_channel_id: prev_short_channel_id,
-					outpoint: prev_funding_outpoint,
-					htlc_id: prev_htlc_id,
-					incoming_packet_shared_secret: forward_info.incoming_shared_secret,
-					phantom_shared_secret: None,
-				});
+			let htlc_source = HTLCSource::PreviousHopData(HTLCPreviousHopData {
+				short_channel_id: payment.prev_short_channel_id,
+				outpoint: payment.prev_funding_outpoint,
+				htlc_id: payment.prev_htlc_id,
+				incoming_packet_shared_secret: payment.forward_info.incoming_shared_secret,
+				phantom_shared_secret: None,
+			});
 
-				let failure_reason = HTLCFailReason::Reason { failure_code: 0x4000 | 10, data: Vec::new() };
-				self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), htlc_source, &forward_info.payment_hash, failure_reason);
-			}
+			let failure_reason = HTLCFailReason::Reason { failure_code: 0x4000 | 10, data: Vec::new() };
+			self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), htlc_source, &payment.forward_info.payment_hash, failure_reason);
 		}
 	}
 
@@ -3119,30 +3124,22 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 		match pending_intercept {
 			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, prev_htlc_amount } => {
-
-						let routing = match forward_info.routing {
-								PendingHTLCRouting::Forward { onion_packet, .. } => {
-									PendingHTLCRouting::Forward { onion_packet, short_channel_id: scid }
-								},
-								_ => forward_info.routing
-							};
-
-							let pending_htlc_info = PendingHTLCInfo {
-								amt_to_forward,
-								routing,
-								..forward_info
-							};
-
-							let mut per_source_pending_forward = vec![(prev_short_channel_id, prev_funding_outpoint, vec![(pending_htlc_info, prev_htlc_id, prev_htlc_amount)])];
+					let routing = match payment.forward_info.routing {
+						PendingHTLCRouting::Forward { onion_packet, .. } => {
+							PendingHTLCRouting::Forward { onion_packet, short_channel_id: scid }
+						},
+						_ => payment.forward_info.routing
+					};
 
-							self.forward_htlcs(&mut per_source_pending_forward);
+					let pending_htlc_info = PendingHTLCInfo {
+						amt_to_forward,
+						routing,
+						..payment.forward_info
+					};
 
-							Ok(())
-					},
-					_ => Err(APIError::APIMisuseError { err: "impossible".to_string() })
-				}
+					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))])];
+					self.forward_htlcs(&mut per_source_pending_forward);
+					Ok(())
 			}
 		}
 	}
@@ -3169,9 +3166,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: PendingHTLCInfo {
-										ref routing, incoming_shared_secret, payment_hash, amt_to_forward, outgoing_cltv_value },
-										prev_funding_outpoint, prev_htlc_amount } => {
+									HTLCForwardInfo::AddHTLC { prev_short_channel_id, prev_htlc_id, forward_info, prev_funding_outpoint, prev_htlc_amount } => {
 											macro_rules! fail_forward {
 												($msg: expr, $err_code: expr, $err_data: expr, $phantom_ss: expr) => {
 													{
@@ -3180,21 +3175,21 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 															short_channel_id: prev_short_channel_id,
 															outpoint: prev_funding_outpoint,
 															htlc_id: prev_htlc_id,
-															incoming_packet_shared_secret: incoming_shared_secret,
+															incoming_packet_shared_secret: forward_info.incoming_shared_secret,
 															phantom_shared_secret: $phantom_ss,
 														});
-														failed_forwards.push((htlc_source, payment_hash,
+														failed_forwards.push((htlc_source, forward_info.payment_hash,
 															HTLCFailReason::Reason { failure_code: $err_code, data: $err_data }
 														));
 														continue;
 													}
 												}
 											}
-											if let PendingHTLCRouting::Forward { onion_packet, .. } = routing {
+											if let PendingHTLCRouting::Forward { ref onion_packet, .. } = forward_info.routing {
 												let phantom_secret_res = self.keys_manager.get_node_secret(Recipient::PhantomNode);
 												if phantom_secret_res.is_ok() && fake_scid::is_valid_phantom(&self.fake_scid_rand_bytes, short_chan_id) {
 													let phantom_shared_secret = SharedSecret::new(&onion_packet.public_key.unwrap(), &phantom_secret_res.unwrap()).secret_bytes();
-													let next_hop = match onion_utils::decode_next_hop(phantom_shared_secret, &onion_packet.hop_data, onion_packet.hmac, payment_hash) {
+													let next_hop = match onion_utils::decode_next_hop(phantom_shared_secret, &onion_packet.hop_data, onion_packet.hmac, forward_info.payment_hash) {
 														Ok(res) => res,
 														Err(onion_utils::OnionDecodeErr::Malformed { err_msg, err_code }) => {
 															let sha256_of_onion = Sha256::hash(&onion_packet.hop_data).into_inner();
@@ -3210,24 +3205,31 @@ 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)) {
+															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)])),
 																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) {
-													let intercept_id = InterceptId(Sha256::hash(&incoming_shared_secret).into_inner());
+													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) {
 														hash_map::Entry::Vacant(entry) => {
-															entry.insert(forward_info);
+															let pending_intercepted_payment = PendingInterceptedHTLC {
+																forward_info: forward_info.clone(),
+																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,
+																payment_hash: forward_info.payment_hash,
 																inbound_amount_msats: prev_htlc_amount.unwrap(),
-																expected_outbound_amount_msats: amt_to_forward,
+																expected_outbound_amount_msats: forward_info.amt_to_forward,
 																intercept_id
 															});
 														},