Fix InflightHtlcs::process_path to process the whole Path

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -5698,7 +5698,7 @@ where
 			for chan in peer_state.channel_by_id.values() {
 				for (htlc_source, _) in chan.inflight_htlc_sources() {
 					if let HTLCSource::OutboundRoute { path, .. } = htlc_source {
-						inflight_htlcs.process_path(&path.hops, self.get_our_node_id()); // fixed in upcoming commit
+						inflight_htlcs.process_path(path, self.get_our_node_id());
 					}
 				}
 			}

lightning/src/routing/router.rs

@@ -170,22 +170,33 @@ impl 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 };
+	pub fn process_path(&mut self, path: &Path, payer_node_id: PublicKey) {
+		if path.len() == 0 { return };
+
+		let mut cumulative_msat = 0;
+		if let Some(tail) = &path.blinded_tail {
+			cumulative_msat += tail.final_value_msat + tail.fee_msat;
+			self.0
+				.entry((tail.intro_node_scid,
+						NodeId::from_pubkey(&path.hops.last().map_or(payer_node_id, |hop| hop.pubkey)) <
+						NodeId::from_pubkey(&tail.path.introduction_node_id)))
+				.and_modify(|used_liquidity_msat| *used_liquidity_msat += cumulative_msat)
+				.or_insert(cumulative_msat);
+		}
+
 		// 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)
+		let reversed_hops_with_payer = path.hops.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) {
+		for (next_hop, prev_hop) in path.hops.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)))
@@ -2274,11 +2285,12 @@ fn build_route_from_hops_internal<L: Deref>(
 
 #[cfg(test)]
 mod tests {
+	use crate::blinded_path::BlindedPath;
 	use crate::routing::gossip::{NetworkGraph, P2PGossipSync, NodeId, EffectiveCapacity};
 	use crate::routing::utxo::UtxoResult;
 	use crate::routing::router::{get_route, build_route_from_hops_internal, add_random_cltv_offset, default_node_features,
-		Path, PaymentParameters, Route, RouteHint, RouteHintHop, RouteHop, RoutingFees,
-		DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE};
+		BlindedTail, InFlightHtlcs, Path, PaymentParameters, Route, RouteHint, RouteHintHop, RouteHop,
+		RoutingFees, DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE};
 	use crate::routing::scoring::{ChannelUsage, FixedPenaltyScorer, Score, ProbabilisticScorer, ProbabilisticScoringParameters};
 	use crate::routing::test_utils::{add_channel, add_or_update_node, build_graph, build_line_graph, id_to_feature_flags, get_nodes, update_channel};
 	use crate::chain::transaction::OutPoint;
@@ -5244,6 +5256,36 @@ mod tests {
 		assert_eq!(path, vec![2, 4, 7, 10]);
 	}
 
+	#[test]
+	fn blinded_path_inflight_processing() {
+		// Ensure we'll score the channel that's inbound to a blinded path's introduction node.
+		let mut inflight_htlcs = InFlightHtlcs::new();
+		let path = Path {
+			hops: vec![RouteHop {
+				pubkey: ln_test_utils::pubkey(42),
+				node_features: NodeFeatures::empty(),
+				short_channel_id: 42,
+				channel_features: ChannelFeatures::empty(),
+				fee_msat: 100,
+				cltv_expiry_delta: 0,
+			}],
+			blinded_tail: Some(BlindedTail {
+				path: BlindedPath {
+					introduction_node_id: ln_test_utils::pubkey(43),
+					blinding_point: ln_test_utils::pubkey(44),
+					blinded_hops: Vec::new(),
+				},
+				intro_node_scid: 43,
+				fee_msat: 1,
+				cltv_expiry_delta: 0,
+				final_value_msat: 200,
+			}),
+		};
+		inflight_htlcs.process_path(&path, ln_test_utils::pubkey(44));
+		assert_eq!(*inflight_htlcs.0.get(&(42, true)).unwrap(), 301);
+		assert_eq!(*inflight_htlcs.0.get(&(43, false)).unwrap(), 201);
+	}
+
 	struct BadChannelScorer {
 		short_channel_id: u64,
 	}

lightning/src/util/test_utils.rs

@@ -60,6 +60,15 @@ use crate::chain::keysinterface::{InMemorySigner, Recipient, EntropySource, Node
 use std::time::{SystemTime, UNIX_EPOCH};
 use bitcoin::Sequence;
 
+pub fn pubkey(byte: u8) -> PublicKey {
+	let secp_ctx = Secp256k1::new();
+	PublicKey::from_secret_key(&secp_ctx, &privkey(byte))
+}
+
+pub fn privkey(byte: u8) -> SecretKey {
+	SecretKey::from_slice(&[byte; 32]).unwrap()
+}
+
 pub struct TestVecWriter(pub Vec<u8>);
 impl Writer for TestVecWriter {
 	fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error> {