Respect route hint max_htlc in pathfinding

Author: valentinewallace

lightning/src/routing/gossip.rs

@@ -1033,6 +1033,11 @@ pub enum EffectiveCapacity {
 	/// A capacity sufficient to route any payment, typically used for private channels provided by
 	/// an invoice.
 	Infinite,
+	/// The maximum HTLC amount as provided by an invoice route hint.
+	HintMaxHTLC {
+		/// The maximum HTLC amount denominated in millisatoshi.
+		amount_msat: u64,
+	},
 	/// A capacity that is unknown possibly because either the chain state is unavailable to know
 	/// the total capacity or the `htlc_maximum_msat` was not advertised on the gossip network.
 	Unknown,
@@ -1049,6 +1054,7 @@ impl EffectiveCapacity {
 			EffectiveCapacity::ExactLiquidity { liquidity_msat } => *liquidity_msat,
 			EffectiveCapacity::AdvertisedMaxHTLC { amount_msat } => *amount_msat,
 			EffectiveCapacity::Total { capacity_msat, .. } => *capacity_msat,
+			EffectiveCapacity::HintMaxHTLC { amount_msat } => *amount_msat,
 			EffectiveCapacity::Infinite => u64::max_value(),
 			EffectiveCapacity::Unknown => UNKNOWN_CHANNEL_CAPACITY_MSAT,
 		}

lightning/src/routing/router.rs

@@ -951,7 +951,10 @@ impl<'a> CandidateRouteHop<'a> {
 				liquidity_msat: details.next_outbound_htlc_limit_msat,
 			},
 			CandidateRouteHop::PublicHop { info, .. } => info.effective_capacity(),
-			CandidateRouteHop::PrivateHop { .. } => EffectiveCapacity::Infinite,
+			CandidateRouteHop::PrivateHop { hint } => {
+				hint.htlc_maximum_msat.map_or(EffectiveCapacity::Infinite,
+					|max| EffectiveCapacity::HintMaxHTLC { amount_msat: max })
+			},
 		}
 	}
 }
@@ -965,6 +968,7 @@ fn max_htlc_from_capacity(capacity: EffectiveCapacity, max_channel_saturation_po
 		EffectiveCapacity::Unknown => EffectiveCapacity::Unknown.as_msat(),
 		EffectiveCapacity::AdvertisedMaxHTLC { amount_msat } =>
 			amount_msat.checked_shr(saturation_shift).unwrap_or(0),
+		EffectiveCapacity::HintMaxHTLC { amount_msat } => amount_msat,
 		EffectiveCapacity::Total { capacity_msat, htlc_maximum_msat } =>
 			cmp::min(capacity_msat.checked_shr(saturation_shift).unwrap_or(0), htlc_maximum_msat),
 	}
@@ -6050,6 +6054,57 @@ mod tests {
 		assert_eq!(route.paths[0].blinded_tail.as_ref().unwrap().excess_final_cltv_expiry_delta, 40);
 		assert_eq!(route.paths[0].hops.last().unwrap().cltv_expiry_delta, 40);
 	}
+
+	#[test]
+	fn respect_route_hint_max_htlc() {
+		// Make sure that any max_htlc provided in the route hints of the payment params is respected in
+		// the final route.
+		let (secp_ctx, network_graph, _, _, logger) = build_graph();
+		let netgraph = network_graph.read_only();
+		let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
+		let scorer = ln_test_utils::TestScorer::new();
+		let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+		let random_seed_bytes = keys_manager.get_secure_random_bytes();
+		let config = UserConfig::default();
+
+		let max_htlc_msat = 50_000;
+		let route_hint_1 = RouteHint(vec![RouteHintHop {
+			src_node_id: nodes[2],
+			short_channel_id: 42,
+			fees: RoutingFees {
+				base_msat: 100,
+				proportional_millionths: 0,
+			},
+			cltv_expiry_delta: 10,
+			htlc_minimum_msat: None,
+			htlc_maximum_msat: Some(max_htlc_msat),
+		}]);
+		let dest_node_id = ln_test_utils::pubkey(42);
+		let payment_params = PaymentParameters::from_node_id(dest_node_id, 42)
+			.with_route_hints(vec![route_hint_1.clone()]).unwrap()
+			.with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap();
+
+		// Make sure we'll error if our route hints don't have enough liquidity according to their
+		// max_htlc.
+		if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id,
+			&payment_params, &netgraph, None, max_htlc_msat + 1, Arc::clone(&logger), &scorer, &(),
+			&random_seed_bytes)
+		{
+			assert_eq!(err, "Failed to find a sufficient route to the given destination");
+		} else { panic!(); }
+
+		// Make sure we'll split an MPP payment across route hints if their max_htlcs warrant it.
+		let mut route_hint_2 = route_hint_1.clone();
+		route_hint_2.0[0].short_channel_id = 43;
+		let payment_params = PaymentParameters::from_node_id(dest_node_id, 42)
+			.with_route_hints(vec![route_hint_1, route_hint_2]).unwrap()
+			.with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap();
+		let route  = get_route(&our_id, &payment_params, &netgraph, None, max_htlc_msat + 1,
+			Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap();
+		assert_eq!(route.paths.len(), 2);
+		assert!(route.paths[0].hops.last().unwrap().fee_msat <= max_htlc_msat);
+		assert!(route.paths[1].hops.last().unwrap().fee_msat <= max_htlc_msat);
+	}
 }
 
 #[cfg(all(test, not(feature = "no-std")))]

lightning/src/routing/scoring.rs

@@ -1243,8 +1243,10 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Score for Probabilis
 
 		let mut anti_probing_penalty_msat = 0;
 		match usage.effective_capacity {
-			EffectiveCapacity::ExactLiquidity { liquidity_msat } => {
-				if usage.amount_msat > liquidity_msat {
+			EffectiveCapacity::ExactLiquidity { liquidity_msat: amount_msat } |
+				EffectiveCapacity::HintMaxHTLC { amount_msat } =>
+			{
+				if usage.amount_msat > amount_msat {
 					return u64::max_value();
 				} else {
 					return base_penalty_msat;