Add offset plausibility test.

Author: tnull

lightning/src/routing/router.rs

@@ -1639,6 +1639,7 @@ mod tests {
 	   NodeAnnouncement, UnsignedNodeAnnouncement, ChannelUpdate, UnsignedChannelUpdate};
 	use ln::channelmanager;
 	use util::test_utils;
+	use util::chacha20::ChaCha20;
 	use util::ser::Writeable;
 	#[cfg(c_bindings)]
 	use util::ser::Writer;
@@ -5071,6 +5072,74 @@ mod tests {
 		assert_eq!(cltv_expiry_deltas_before, cltv_expiry_deltas_limited);
 	}
 
+	#[test]
+	fn adds_plausible_cltv_offset() {
+		let (secp_ctx, network, _, _, logger) = build_graph();
+		let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
+		let network_graph = network.read_only();
+		let network_nodes = network_graph.nodes();
+		let network_channels = network_graph.channels();
+		let scorer = test_utils::TestScorer::with_penalty(0);
+		let payment_params = PaymentParameters::from_node_id(nodes[3]);
+		let keys_manager = test_utils::TestKeysInterface::new(&[4u8; 32], Network::Testnet);
+		let random_seed_bytes = keys_manager.get_secure_random_bytes();
+
+		let mut route = get_route(&our_id, &payment_params, &network, None, 100, 0,
+								  Arc::clone(&logger), &scorer, &random_seed_bytes).unwrap();
+		add_random_cltv_offset(&mut route, &payment_params, &network, &random_seed_bytes);
+
+		let mut path_plausibility = vec![];
+
+		for p in route.paths {
+			// 1. Select random observation point
+			let mut prng = ChaCha20::new(&random_seed_bytes, &[0u8; 12]);
+			let mut random_bytes = [0u8; ::core::mem::size_of::<usize>()];
+
+			prng.process_in_place(&mut random_bytes);
+			let random_path_index = usize::from_be_bytes(random_bytes).wrapping_rem(p.len());
+			let observation_point = NodeId::from_pubkey(&p.get(random_path_index).unwrap().pubkey);
+
+			// 2. Calculate what CLTV expiry delta we would observe there
+			let observed_cltv_expiry_delta: u32 = p[random_path_index..].iter().map(|h| h.cltv_expiry_delta).sum();
+
+			// 3. Starting from the observation point, find candidate paths
+			let mut candidates: VecDeque<(NodeId, Vec<u32>)> = VecDeque::new();
+			candidates.push_back((observation_point, vec![]));
+
+			let mut found_plausible_candidate = false;
+
+			'candidate_loop: while let Some((cur_node_id, cur_path_cltv_deltas)) = candidates.pop_front() {
+				if let Some(remaining) = observed_cltv_expiry_delta.checked_sub(cur_path_cltv_deltas.iter().sum::<u32>()) {
+					if remaining == 0 || remaining.wrapping_rem(40) == 0 || remaining.wrapping_rem(144) == 0 {
+						found_plausible_candidate = true;
+						break 'candidate_loop;
+					}
+				}
+
+				if let Some(cur_node) = network_nodes.get(&cur_node_id) {
+					for channel_id in &cur_node.channels {
+						if let Some(channel_info) = network_channels.get(&channel_id) {
+							if let Some((dir_info, next_id)) = channel_info.as_directed_from(&cur_node_id) {
+								if let Some(channel_update_info) = dir_info.direction() {
+									let next_cltv_expiry_delta = channel_update_info.cltv_expiry_delta as u32;
+									if cur_path_cltv_deltas.iter().sum::<u32>()
+										.saturating_add(next_cltv_expiry_delta) <= observed_cltv_expiry_delta {
+										let mut new_path_cltv_deltas = cur_path_cltv_deltas.clone();
+										new_path_cltv_deltas.push(next_cltv_expiry_delta);
+										candidates.push_back((*next_id, new_path_cltv_deltas));
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+
+			path_plausibility.push(found_plausible_candidate);
+		}
+		assert!(path_plausibility.iter().all(|x| *x));
+	}
+
 	#[cfg(not(feature = "no-std"))]
 	pub(super) fn random_init_seed() -> u64 {
 		// Because the default HashMap in std pulls OS randomness, we can use it as a (bad) RNG.