f adapt to adding RouteHop for intro node

Author: valentinewallace

lightning/src/routing/router.rs

@@ -308,11 +308,6 @@ impl Path {
 	pub fn len(&self) -> usize {
 		self.hops.len() + self.blinded_tail.as_ref().map_or(0, |tail| tail.hops.len().saturating_sub(1)) // Don't double count the intro node
 	}
-
-	pub(super) fn node_id_scid_iter(&self) -> impl Iterator<Item=(PublicKey, u64)> + '_ {
-		self.hops.iter().map(|hop| (hop.pubkey, hop.short_channel_id))
-			.chain(self.blinded_tail.as_ref().map(|tail| (tail.path.introduction_node_id, tail.intro_node_scid)))
-	}
 }
 
 /// A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP,

lightning/src/routing/scoring.rs

@@ -1237,66 +1237,63 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Score for Probabilis
 		let amount_msat = path.final_value_msat();
 		log_trace!(self.logger, "Scoring path through to SCID {} as having failed at {} msat", short_channel_id, amount_msat);
 		let network_graph = self.network_graph.read_only();
-		for (hop_idx, (pubkey, scid)) in path.node_id_scid_iter().enumerate() {
-			let target = NodeId::from_pubkey(&pubkey);
+		for (hop_idx, hop) in path.hops.iter().enumerate() {
+			let target = NodeId::from_pubkey(&hop.pubkey);
 			let channel_directed_from_source = network_graph.channels()
-				.get(&scid)
+				.get(&hop.short_channel_id)
 				.and_then(|channel| channel.as_directed_to(&target));
 
-			let at_failed_channel = scid == short_channel_id;
+			let at_failed_channel = hop.short_channel_id == short_channel_id;
 			if at_failed_channel && hop_idx == 0 {
-				log_warn!(self.logger, "Payment failed at the first hop - we do not attempt to learn channel info in such cases as we can directly observe local state.\n\tBecause we know the local state, we should generally not see failures here - this may be an indication that your channel peer on channel {} is broken and you may wish to close the channel.", scid);
+				log_warn!(self.logger, "Payment failed at the first hop - we do not attempt to learn channel info in such cases as we can directly observe local state.\n\tBecause we know the local state, we should generally not see failures here - this may be an indication that your channel peer on channel {} is broken and you may wish to close the channel.", hop.short_channel_id);
 			}
 
 			// Only score announced channels.
 			if let Some((channel, source)) = channel_directed_from_source {
 				let capacity_msat = channel.effective_capacity().as_msat();
 				if at_failed_channel {
 					self.channel_liquidities
-						.entry(scid)
+						.entry(hop.short_channel_id)
 						.or_insert_with(ChannelLiquidity::new)
 						.as_directed_mut(source, &target, 0, capacity_msat, &self.params)
-						.failed_at_channel(amount_msat, format_args!("SCID {}, towards {:?}", scid, target), &self.logger);
+						.failed_at_channel(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger);
 				} else {
 					self.channel_liquidities
-						.entry(scid)
+						.entry(hop.short_channel_id)
 						.or_insert_with(ChannelLiquidity::new)
 						.as_directed_mut(source, &target, 0, capacity_msat, &self.params)
-						.failed_downstream(amount_msat, format_args!("SCID {}, towards {:?}", scid, target), &self.logger);
+						.failed_downstream(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger);
 				}
 			} else {
 				log_debug!(self.logger, "Not able to penalize channel with SCID {} as we do not have graph info for it (likely a route-hint last-hop).",
-					scid);
+					hop.short_channel_id);
 			}
 			if at_failed_channel { break; }
 		}
 	}
 
 	fn payment_path_successful(&mut self, path: &Path) {
 		let amount_msat = path.final_value_msat();
-		let final_scid = path.blinded_tail.as_ref().map_or_else(
-			|| path.hops.last().map_or(0, |hop| hop.short_channel_id),
-			|tail| tail.intro_node_scid);
 		log_trace!(self.logger, "Scoring path through SCID {} as having succeeded at {} msat.",
-			final_scid, amount_msat);
+			path.hops.split_last().map(|(hop, _)| hop.short_channel_id).unwrap_or(0), amount_msat);
 		let network_graph = self.network_graph.read_only();
-		for (pubkey, scid) in path.node_id_scid_iter() {
-			let target = NodeId::from_pubkey(&pubkey);
+		for hop in &path.hops {
+			let target = NodeId::from_pubkey(&hop.pubkey);
 			let channel_directed_from_source = network_graph.channels()
-				.get(&scid)
+				.get(&hop.short_channel_id)
 				.and_then(|channel| channel.as_directed_to(&target));
 
 			// Only score announced channels.
 			if let Some((channel, source)) = channel_directed_from_source {
 				let capacity_msat = channel.effective_capacity().as_msat();
 				self.channel_liquidities
-					.entry(scid)
+					.entry(hop.short_channel_id)
 					.or_insert_with(ChannelLiquidity::new)
 					.as_directed_mut(source, &target, 0, capacity_msat, &self.params)
-					.successful(amount_msat, format_args!("SCID {}, towards {:?}", scid, target), &self.logger);
+					.successful(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger);
 			} else {
 				log_debug!(self.logger, "Not able to learn for channel with SCID {} as we do not have graph info for it (likely a route-hint last-hop).",
-					scid);
+					hop.short_channel_id);
 			}
 		}
 	}
@@ -1705,7 +1702,7 @@ impl<T: Time> Readable for ChannelLiquidity<T> {
 #[cfg(test)]
 mod tests {
 	use super::{ChannelLiquidity, HistoricalBucketRangeTracker, ProbabilisticScoringParameters, ProbabilisticScorerUsingTime};
-	use crate::blinded_path::BlindedPath;
+	use crate::blinded_path::{BlindedHop, BlindedPath};
 	use crate::util::config::UserConfig;
 	use crate::util::time::Time;
 	use crate::util::time::tests::SinceEpoch;
@@ -2876,8 +2873,8 @@ mod tests {
 	}
 
 	#[test]
-	fn scores_intro_node_scid() {
-		// Make sure we'll score the scid contained in the blinded portion of a path
+	fn scores_with_blinded_path() {
+		// Make sure we'll account for a blinded path's final_value_msat in scoring
 		let logger = TestLogger::new();
 		let network_graph = network_graph(&logger);
 		let params = ProbabilisticScoringParameters {
@@ -2896,18 +2893,19 @@ mod tests {
 		assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300);
 
 		let mut path = payment_path_for_amount(768);
-		let last_hop = path.hops.pop().unwrap();
-		let _intro_node_hop = path.hops.pop().unwrap();
+		let recipient_hop = path.hops.pop().unwrap();
+		let blinded_path = BlindedPath {
+			introduction_node_id: path.hops.last().as_ref().unwrap().pubkey,
+			blinding_point: test_utils::pubkey(42),
+			blinded_hops: vec![
+				BlindedHop { blinded_node_id: test_utils::pubkey(44), encrypted_payload: Vec::new() }
+			],
+		};
 		path.blinded_tail = Some(BlindedTail {
-			path: BlindedPath {
-				introduction_node_id: target_pubkey(),
-				blinding_point: test_utils::pubkey(42),
-				blinded_hops: Vec::new(),
-			},
-			fee_msat: 2,
-			cltv_expiry_delta: last_hop.cltv_expiry_delta,
-			final_value_msat: last_hop.fee_msat,
-			intro_node_scid: 42,
+			hops: blinded_path.blinded_hops,
+			blinding_point: blinded_path.blinding_point,
+			final_cltv_expiry_delta: recipient_hop.cltv_expiry_delta,
+			final_value_msat: recipient_hop.fee_msat,
 		});
 
 		scorer.payment_path_failed(&path, 42);