Test generated-route valididty in fuzzing

While our router fuzzer is pretty good at hitting internal
assertions in our pathfinder, it doesn't actually do anything to
check that the returned route is valid (or meets the requirements
given to the pathfinder).

Here we add some initial checks covering the feerates of the hops
taken in the returned route.

Author: TheBlueMatt

fuzz/src/router.rs

@@ -19,9 +19,9 @@ use lightning::ln::channel_state::{ChannelCounterparty, ChannelDetails, ChannelS
 use lightning::ln::channelmanager;
 use lightning::ln::msgs;
 use lightning::ln::types::ChannelId;
-use lightning::routing::gossip::{NetworkGraph, RoutingFees};
+use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
 use lightning::routing::router::{
-	find_route, PaymentParameters, RouteHint, RouteHintHop, RouteParameters,
+	find_route, Payee, PaymentParameters, RouteHint, RouteHintHop, RouteParameters,
 };
 use lightning::routing::scoring::{
 	ProbabilisticScorer, ProbabilisticScoringDecayParameters, ProbabilisticScoringFeeParameters,
@@ -296,19 +296,97 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 				let final_value_msat = slice_to_be64(get_slice!(8));
 				let final_cltv_expiry_delta = slice_to_be32(get_slice!(4));
 				let route_params = $route_params(final_value_msat, final_cltv_expiry_delta, target);
-				let _ = find_route(
+				let route = find_route(
 					&our_pubkey,
 					&route_params,
 					&net_graph,
-					$first_hops
-						.map(|c| c.iter().collect::<Vec<_>>())
+					$first_hops.map(|c| c.iter().collect::<Vec<_>>())
 						.as_ref()
 						.map(|a| a.as_slice()),
 					&logger,
 					&scorer,
 					&ProbabilisticScoringFeeParameters::default(),
 					&random_seed_bytes,
 				);
+				if let Ok(route) = route {
+					// If we generated a route, check that it is valid
+					// TODO: Check CLTV deltas
+					assert_eq!(route.route_params.as_ref(), Some(&route_params));
+					let graph = net_graph.read_only();
+					let mut blinded_path_payment_amts = new_hash_map();
+					let mut total_fee = 0;
+					let mut total_sent = 0;
+					for path in &route.paths {
+						total_fee += path.fee_msat();
+						total_sent += path.final_value_msat();
+						let unblinded_recipient = path.hops.last().expect("No hops").pubkey;
+						let mut hops = path.hops.iter().peekable();
+						'path_check: while let Some(hop) = hops.next() {
+							if let Some(next_hop) = hops.peek().cloned() {
+								let amt_to_send: u64 = hops.clone().map(|hop| hop.fee_msat).sum();
+								if let Payee::Clear { route_hints, .. } = &route_params.payment_params.payee {
+									// If we paid to an invoice with clear route hints, check
+									// whether we pulled from a route hint first, and if not fall
+									// back to searching through the public network graph.
+									for hint in route_hints.iter() {
+										let mut hint_hops = hint.0.iter().peekable();
+										while let Some(hint_hop) = hint_hops.next() {
+											let next_hint_hop_key = hint_hops.peek()
+												.map(|hint_hop| hint_hop.src_node_id)
+												.unwrap_or(unblinded_recipient);
+
+											let matches_hint = hint_hop.src_node_id == hop.pubkey
+												&& hint_hop.short_channel_id == next_hop.short_channel_id
+												&& next_hint_hop_key == next_hop.pubkey;
+											if matches_hint {
+												let min_fee = amt_to_send
+													* (hint_hop.fees.proportional_millionths as u64) / 1_000_000
+													+ hint_hop.fees.base_msat as u64;
+												assert!(min_fee <= hop.fee_msat);
+												continue 'path_check;
+											}
+										}
+									}
+								}
+								let chan = graph.channel(hop.short_channel_id).expect("No chan");
+								assert!(chan.one_to_two.is_some() && chan.two_to_one.is_some());
+								let fees = if chan.node_one == NodeId::from_pubkey(&hop.pubkey) {
+									chan.one_to_two.as_ref().unwrap().fees
+								} else {
+									chan.two_to_one.as_ref().unwrap().fees
+								};
+								let min_fee = amt_to_send * (fees.proportional_millionths as u64) / 1_000_000 + fees.base_msat as u64;
+								assert!(min_fee <= hop.fee_msat);
+							} else {
+								if let Payee::Blinded { route_hints, .. } = &route_params.payment_params.payee {
+									let tail = path.blinded_tail.as_ref().expect("No blinded path");
+									if tail.hops.len() == 1 {
+										// We don't consider the payinfo for one-hop blinded paths
+										// since they're not "real" blinded paths.
+										continue;
+									}
+									let blinded_intro_amt = tail.final_value_msat + hop.fee_msat;
+									// TODO: We should add some kind of coverage of trampoline hops
+									assert!(tail.trampoline_hops.is_empty());
+									let hint_filter = |hint: &&BlindedPaymentPath| {
+										hint.blinded_hops()[0].encrypted_payload == tail.hops[0].encrypted_payload
+									};
+									let mut matching_hints = route_hints.iter().filter(hint_filter);
+									let matching_hint = matching_hints.next().unwrap();
+									assert!(matching_hints.next().is_none());
+									let key = &tail.hops[0].encrypted_payload;
+									let used = blinded_path_payment_amts.entry(key).or_insert(0u64);
+									*used += blinded_intro_amt;
+									assert!(*used <= matching_hint.payinfo.htlc_maximum_msat);
+									assert!(blinded_intro_amt >= matching_hint.payinfo.htlc_minimum_msat);
+								}
+								break;
+							}
+						}
+					}
+					assert!(total_sent >= final_value_msat);
+					assert!(total_fee <= route_params.max_total_routing_fee_msat.unwrap_or(u64::MAX));
+				}
 			}
 		};
 	}
@@ -383,7 +461,8 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 				let dummy_pk = PublicKey::from_slice(&[2; 33]).unwrap();
 				let last_hops: Vec<BlindedPaymentPath> = last_hops_unblinded
 					.into_iter()
-					.map(|hint| {
+					.enumerate()
+					.map(|(hint_idx, hint)| {
 						let hop = &hint.0[0];
 						let payinfo = BlindedPayInfo {
 							fee_base_msat: hop.fees.base_msat,
@@ -398,7 +477,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 						for _ in 0..num_blinded_hops {
 							blinded_hops.push(BlindedHop {
 								blinded_node_id: dummy_pk,
-								encrypted_payload: Vec::new(),
+								encrypted_payload: hint_idx.to_ne_bytes().to_vec(),
 							});
 						}
 						BlindedPaymentPath::from_raw(