Account for Path::blinded_tail in scoring

Author: valentinewallace

lightning/src/routing/router.rs

@@ -295,6 +295,14 @@ pub struct Path {
 }
 
 impl Path {
+	/// Returns the total amount paid on this [`Path`], excluding the fees.
+	pub fn final_value_msat(&self) -> u64 {
+		match &self.blinded_tail {
+			Some(blinded_tail) => blinded_tail.final_value_msat,
+			None => self.hops.last().map_or(0, |hop| hop.fee_msat)
+		}
+	}
+
 	/// 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.hops.len().saturating_sub(1)) // Don't double count the intro node

lightning/src/routing/scoring.rs

@@ -1234,66 +1234,74 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Score for Probabilis
 	}
 
 	fn payment_path_failed(&mut self, path: &Path, short_channel_id: u64) {
-		let amount_msat = path.hops.split_last().map(|(hop, _)| hop.fee_msat).unwrap_or(0);
+		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, hop) in path.hops.iter().enumerate() {
-			let target = NodeId::from_pubkey(&hop.pubkey);
+		for (hop_idx, (pubkey, scid)) in path.hops.iter().map(|hop| (hop.pubkey, hop.short_channel_id))
+			.chain(path.blinded_tail.as_ref().map(|tail| (tail.path.introduction_node_id, tail.intro_node_scid)))
+			.enumerate()
+		{
+			let target = NodeId::from_pubkey(&pubkey);
 			let channel_directed_from_source = network_graph.channels()
-				.get(&hop.short_channel_id)
+				.get(&scid)
 				.and_then(|channel| channel.as_directed_to(&target));
 
-			let at_failed_channel = hop.short_channel_id == short_channel_id;
+			let at_failed_channel = scid == 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.", hop.short_channel_id);
+				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);
 			}
 
 			// 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(hop.short_channel_id)
+						.entry(scid)
 						.or_insert_with(ChannelLiquidity::new)
 						.as_directed_mut(source, &target, 0, capacity_msat, &self.params)
-						.failed_at_channel(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger);
+						.failed_at_channel(amount_msat, format_args!("SCID {}, towards {:?}", scid, target), &self.logger);
 				} else {
 					self.channel_liquidities
-						.entry(hop.short_channel_id)
+						.entry(scid)
 						.or_insert_with(ChannelLiquidity::new)
 						.as_directed_mut(source, &target, 0, capacity_msat, &self.params)
-						.failed_downstream(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger);
+						.failed_downstream(amount_msat, format_args!("SCID {}, towards {:?}", scid, 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).",
-					hop.short_channel_id);
+					scid);
 			}
 			if at_failed_channel { break; }
 		}
 	}
 
 	fn payment_path_successful(&mut self, path: &Path) {
-		let amount_msat = path.hops.split_last().map(|(hop, _)| hop.fee_msat).unwrap_or(0);
+		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.",
-			path.hops.split_last().map(|(hop, _)| hop.short_channel_id).unwrap_or(0), amount_msat);
+			final_scid, amount_msat);
 		let network_graph = self.network_graph.read_only();
-		for hop in &path.hops {
-			let target = NodeId::from_pubkey(&hop.pubkey);
+		for (pubkey, scid) in path.hops.iter().map(|hop| (hop.pubkey, hop.short_channel_id))
+			.chain(path.blinded_tail.as_ref().map(|tail| (tail.path.introduction_node_id, tail.intro_node_scid)))
+		{
+			let target = NodeId::from_pubkey(&pubkey);
 			let channel_directed_from_source = network_graph.channels()
-				.get(&hop.short_channel_id)
+				.get(&scid)
 				.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(hop.short_channel_id)
+					.entry(scid)
 					.or_insert_with(ChannelLiquidity::new)
 					.as_directed_mut(source, &target, 0, capacity_msat, &self.params)
-					.successful(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger);
+					.successful(amount_msat, format_args!("SCID {}, towards {:?}", scid, 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).",
-					hop.short_channel_id);
+					scid);
 			}
 		}
 	}
@@ -1702,17 +1710,18 @@ impl<T: Time> Readable for ChannelLiquidity<T> {
 #[cfg(test)]
 mod tests {
 	use super::{ChannelLiquidity, HistoricalBucketRangeTracker, ProbabilisticScoringParameters, ProbabilisticScorerUsingTime};
+	use crate::blinded_path::BlindedPath;
 	use crate::util::config::UserConfig;
 	use crate::util::time::Time;
 	use crate::util::time::tests::SinceEpoch;
 
 	use crate::ln::channelmanager;
 	use crate::ln::msgs::{ChannelAnnouncement, ChannelUpdate, UnsignedChannelAnnouncement, UnsignedChannelUpdate};
 	use crate::routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId};
-	use crate::routing::router::{Path, RouteHop};
+	use crate::routing::router::{BlindedTail, Path, RouteHop};
 	use crate::routing::scoring::{ChannelUsage, Score};
 	use crate::util::ser::{ReadableArgs, Writeable};
-	use crate::util::test_utils::TestLogger;
+	use crate::util::test_utils::{self, TestLogger};
 
 	use bitcoin::blockdata::constants::genesis_block;
 	use bitcoin::hashes::Hash;
@@ -2870,4 +2879,45 @@ mod tests {
 		};
 		assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0);
 	}
+
+	#[test]
+	fn scores_intro_node_scid() {
+		// Make sure we'll score the scid contained in the blinded portion of a path
+		let logger = TestLogger::new();
+		let network_graph = network_graph(&logger);
+		let params = ProbabilisticScoringParameters {
+			liquidity_penalty_multiplier_msat: 1_000,
+			liquidity_offset_half_life: Duration::from_secs(10),
+			..ProbabilisticScoringParameters::zero_penalty()
+		};
+		let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+		let source = source_node_id();
+		let target = target_node_id();
+		let usage = ChannelUsage {
+			amount_msat: 512,
+			inflight_htlc_msat: 0,
+			effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: 1_000 },
+		};
+		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();
+		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,
+		});
+
+		scorer.payment_path_failed(&path, 42);
+		path.blinded_tail.as_mut().unwrap().final_value_msat = 256;
+		scorer.payment_path_failed(&path, 43);
+		assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 281);
+	}
 }