Unparameterize HashMap from InFlightHtlcs initializer

Author: jurvis

lightning-invoice/src/payment.rs

@@ -145,7 +145,6 @@ use crate::prelude::*;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
-use lightning::routing::gossip::NodeId;
 use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
@@ -712,38 +711,15 @@ where
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
 	fn create_inflight_map(&self) -> InFlightHtlcs {
-		let mut total_inflight_map: HashMap<(u64, bool), u64> = HashMap::new();
-		// Make an attempt at finding existing payment information from `payment_cache`. If it
-		// does not exist, it probably is a fresh payment and we can just return an empty
-		// HashMap.
+		let mut total_inflight_map = InFlightHtlcs::new();
+		// Make an attempt at finding existing payment information from `payment_cache`.
 		for payment_info in self.payment_cache.lock().unwrap().values() {
 			for path in &payment_info.paths {
-				if path.is_empty() { break };
-				// total_inflight_map needs to be direction-sensitive when keeping track of the HTLC value
-				// that is held up. However, the `hops` array, which is a path returned by `find_route` in
-				// the router excludes the payer node. In the following lines, the payer's information is
-				// hardcoded with an inflight value of 0 so that we can correctly represent the first hop
-				// in our sliding window of two.
-				let our_node_id: PublicKey = self.payer.node_id();
-				let reversed_hops_with_payer = path.iter().rev().skip(1)
-					.map(|hop| hop.pubkey)
-					.chain(core::iter::once(our_node_id));
-				let mut cumulative_msat = 0;
-
-				// Taking the reversed vector from above, we zip it with just the reversed hops list to
-				// work "backwards" of the given path, since the last hop's `fee_msat` actually represents
-				// the total amount sent.
-				for (next_hop, prev_hop) in path.iter().rev().zip(reversed_hops_with_payer) {
-					cumulative_msat += next_hop.fee_msat;
-					total_inflight_map
-						.entry((next_hop.short_channel_id, NodeId::from_pubkey(&prev_hop) < NodeId::from_pubkey(&next_hop.pubkey)))
-						.and_modify(|used_liquidity_msat| *used_liquidity_msat += cumulative_msat)
-						.or_insert(cumulative_msat);
-				}
+				total_inflight_map.process_path(path, self.payer.node_id());
 			}
 		}
 
-		InFlightHtlcs::new(total_inflight_map)
+		total_inflight_map
 	}
 }
 

lightning/src/routing/router.rs

@@ -48,10 +48,32 @@ pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
 pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
 
 impl InFlightHtlcs {
-	/// Create a new `InFlightHtlcs` via a mapping from:
-	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
-	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
-		InFlightHtlcs(inflight_map)
+	/// Constructs an empty `InFlightHtlcs`.
+	pub fn new() -> Self { InFlightHtlcs(HashMap::new()) }
+
+	/// Takes in a path with payer's node id and adds the path's details to `InFlightHtlcs`.
+	pub fn process_path(&mut self, path: &[RouteHop], payer_node_id: PublicKey) {
+		if path.is_empty() { return };
+		// total_inflight_map needs to be direction-sensitive when keeping track of the HTLC value
+		// that is held up. However, the `hops` array, which is a path returned by `find_route` in
+		// the router excludes the payer node. In the following lines, the payer's information is
+		// hardcoded with an inflight value of 0 so that we can correctly represent the first hop
+		// in our sliding window of two.
+		let reversed_hops_with_payer = path.iter().rev().skip(1)
+			.map(|hop| hop.pubkey)
+			.chain(core::iter::once(payer_node_id));
+		let mut cumulative_msat = 0;
+
+		// Taking the reversed vector from above, we zip it with just the reversed hops list to
+		// work "backwards" of the given path, since the last hop's `fee_msat` actually represents
+		// the total amount sent.
+		for (next_hop, prev_hop) in path.iter().rev().zip(reversed_hops_with_payer) {
+			cumulative_msat += next_hop.fee_msat;
+			self.0
+				.entry((next_hop.short_channel_id, NodeId::from_pubkey(&prev_hop) < NodeId::from_pubkey(&next_hop.pubkey)))
+				.and_modify(|used_liquidity_msat| *used_liquidity_msat += cumulative_msat)
+				.or_insert(cumulative_msat);
+		}
 	}
 
 	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel