Account for Path::blinded_tail in InflightHtlcs::process_path

Author: valentinewallace

lightning/src/routing/router.rs

@@ -171,7 +171,19 @@ impl InFlightHtlcs {
 
 	/// Takes in a path with payer's node id and adds the path's details to `InFlightHtlcs`.
 	pub fn process_path(&mut self, path: &Path, payer_node_id: PublicKey) {
-		if path.hops.is_empty() { return };
+		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
@@ -180,7 +192,6 @@ impl InFlightHtlcs {
 		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
@@ -290,6 +301,13 @@ pub struct Path {
 	pub blinded_tail: Option<BlindedTail>,
 }
 
+impl Path {
+	/// The length of this path, including the hops of its [`Path::blinded_tail`], if any.
+	pub fn len(&self) -> usize {
+		self.hops.len() + self.blinded_tail.as_ref().map_or(0, |tail| tail.path.blinded_hops.len())
+	}
+}
+
 /// A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP,
 /// it can take multiple paths. Each path is composed of one or more hops through the network.
 #[derive(Clone, Hash, PartialEq, Eq)]
@@ -2247,10 +2265,11 @@ 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,
+		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};
@@ -5747,6 +5766,36 @@ mod tests {
 		let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, 42, Arc::clone(&logger), &scorer, &random_seed_bytes);
 		assert!(route.is_ok());
 	}
+
+	#[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);
+	}
 }
 
 #[cfg(all(test, not(feature = "no-std")))]

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> {