Add phantom invoice route hints filtering tests

Author: ViktorT-11

lightning-invoice/src/utils.rs

@@ -338,7 +338,7 @@ mod test {
 	use bitcoin_hashes::sha256::Hash as Sha256;
 	use lightning::chain::keysinterface::PhantomKeysManager;
 	use lightning::ln::{PaymentPreimage, PaymentHash};
-	use lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY;
+	use lightning::ln::channelmanager::{PhantomRouteHints, MIN_FINAL_CLTV_EXPIRY};
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::features::InitFeatures;
 	use lightning::ln::msgs::ChannelMessageHandler;
@@ -661,4 +661,256 @@ mod test {
 			_ => panic!("Unexpected event")
 		}
 	}
+
+	#[test]
+	#[cfg(feature = "std")]
+	fn test_multi_node_hints_includes_single_public_channels_to_participating_nodes() {
+		let mut chanmon_cfgs = create_chanmon_cfgs(3);
+		let seed_1 = [42 as u8; 32];
+		let seed_2 = [43 as u8; 32];
+		let cross_node_seed = [44 as u8; 32];
+		chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed);
+		chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed);
+		let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+		let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
+		let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+		let chan_0_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_0_1.1);
+		nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_1.0);
+		let chan_0_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_0_2.1);
+		nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_2.0);
+
+		let mut short_chan_ids = HashSet::new();
+		short_chan_ids.insert(chan_0_1.0.contents.short_channel_id.clone());
+		short_chan_ids.insert(chan_0_2.0.contents.short_channel_id.clone());
+
+		match_multi_node_invoice_routes(
+			Some(10_000),
+			&nodes[1],
+			vec![&nodes[1], &nodes[2],],
+			short_chan_ids.clone(),
+			false
+		);
+	}
+
+	#[test]
+	#[cfg(feature = "std")]
+	fn test_multi_node_hints_includes_one_channel_of_each_counterparty_nodes_per_participating_node() {
+		let mut chanmon_cfgs = create_chanmon_cfgs(4);
+		let seed_1 = [42 as u8; 32];
+		let seed_2 = [43 as u8; 32];
+		let cross_node_seed = [44 as u8; 32];
+		chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed);
+		chanmon_cfgs[3].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed);
+		let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
+		let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
+		let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
+		let chan_0_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_0_2.1);
+		nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_2.0);
+		let chan_0_3 = create_announced_chan_between_nodes_with_value(&nodes, 0, 3, 1000000, 10001, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[3].node.get_our_node_id(), &chan_0_3.1);
+		nodes[3].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_3.0);
+		let chan_1_3 = create_announced_chan_between_nodes_with_value(&nodes, 1, 3, 3_000_000, 10005, InitFeatures::known(), InitFeatures::known());
+		nodes[1].node.handle_channel_update(&nodes[3].node.get_our_node_id(), &chan_1_3.1);
+		nodes[3].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_1_3.0);
+
+		let mut short_chan_ids = HashSet::new();
+		short_chan_ids.insert(chan_0_2.0.contents.short_channel_id.clone());
+		short_chan_ids.insert(chan_0_3.0.contents.short_channel_id.clone());
+		short_chan_ids.insert(chan_1_3.0.contents.short_channel_id.clone());
+
+		match_multi_node_invoice_routes(
+			Some(10_000),
+			&nodes[2],
+			vec![&nodes[2], &nodes[3],],
+			short_chan_ids.clone(),
+			false
+		);
+	}
+
+	#[test]
+	#[cfg(feature = "std")]
+	fn test_multi_node_with_private_channel_hints_includes_only_phantom_route() {
+		let mut chanmon_cfgs = create_chanmon_cfgs(3);
+		let seed_1 = [42 as u8; 32];
+		let seed_2 = [43 as u8; 32];
+		let cross_node_seed = [44 as u8; 32];
+		chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed);
+		chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed);
+		let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+		let mut nodes_2_priv_channels_conf = UserConfig::default();
+		nodes_2_priv_channels_conf.channel_options.announced_channel = false;
+		let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, Some(nodes_2_priv_channels_conf)]);
+		let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+		let chan_0_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_0_1.1);
+		nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_1.0);
+
+		let chan_2_0 = create_private_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+		nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_2_0.1);
+		nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_2_0.0);
+
+		// Hints should include `chan_0_1` from as `nodes[1]` only have public channels, and no
+		// channels for `nodes[2]` as it contains private channels.
+		let mut short_chan_ids = HashSet::new();
+		short_chan_ids.insert(chan_0_1.0.contents.short_channel_id.clone());
+
+		match_multi_node_invoice_routes(
+			Some(10_000),
+			&nodes[1],
+			vec![&nodes[1], &nodes[2],],
+			short_chan_ids.clone(),
+			true
+		);
+	}
+
+	#[test]
+	#[cfg(feature = "std")]
+	fn test_multi_node_hints_has_only_highest_inbound_capacity_channel() {
+		let mut chanmon_cfgs = create_chanmon_cfgs(3);
+		let seed_1 = [42 as u8; 32];
+		let seed_2 = [43 as u8; 32];
+		let cross_node_seed = [44 as u8; 32];
+		chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed);
+		chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed);
+		let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+		let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
+		let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+		let chan_0_1_low_inbound_capacity = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_0_1_low_inbound_capacity.1);
+		nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_1_low_inbound_capacity.0);
+		let chan_0_1_high_inbound_capacity = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_0_1_high_inbound_capacity.1);
+		nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_1_high_inbound_capacity.0);
+		let chan_0_1_medium_inbound_capacity = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_0_1_medium_inbound_capacity.1);
+		nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_1_medium_inbound_capacity.0);
+		let chan_0_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_0_2.1);
+		nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_2.0);
+
+		let mut short_chan_ids = HashSet::new();
+		short_chan_ids.insert(chan_0_1_high_inbound_capacity.0.contents.short_channel_id.clone());
+		short_chan_ids.insert(chan_0_2.0.contents.short_channel_id.clone());
+
+		match_multi_node_invoice_routes(
+			Some(10_000),
+			&nodes[1],
+			vec![&nodes[1], &nodes[2],],
+			short_chan_ids.clone(),
+			false
+		);
+	}
+
+	#[test]
+	#[cfg(feature = "std")]
+	fn test_multi_node_hints_has_no_channels_with_lower_inbound_capacity_than_invoice_amt() {
+		let mut chanmon_cfgs = create_chanmon_cfgs(3);
+		let seed_1 = [42 as u8; 32];
+		let seed_2 = [43 as u8; 32];
+		let cross_node_seed = [44 as u8; 32];
+		chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed);
+		chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed);
+		let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+		let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
+		let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+		let chan_0_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_0_1.1);
+		nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_1.0);
+		let chan_0_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
+		nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_0_2.1);
+		nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_2.0);
+
+		// 1 msat above chan_0_1's inbound capacity
+		let mut short_chan_ids_99_000_001_msat = HashSet::new();
+		short_chan_ids_99_000_001_msat.insert(chan_0_2.0.contents.short_channel_id.clone());
+
+		match_multi_node_invoice_routes(
+			Some(99_000_001),
+			&nodes[1],
+			vec![&nodes[1], &nodes[2],],
+			short_chan_ids_99_000_001_msat.clone(),
+			false
+		);
+
+		// Exactly at chan_0_1's inbound capacity
+		let mut short_chan_ids_99_000_000_msat = HashSet::new();
+		short_chan_ids_99_000_000_msat.insert(chan_0_1.0.contents.short_channel_id.clone());
+		short_chan_ids_99_000_000_msat.insert(chan_0_2.0.contents.short_channel_id.clone());
+
+
+		match_multi_node_invoice_routes(
+			Some(99_000_000),
+			&nodes[1],
+			vec![&nodes[1], &nodes[2],],
+			short_chan_ids_99_000_000_msat.clone(),
+			false
+		);
+
+		// Invoices with a higher amount than any of our channels' inbound capacity should result
+		// in no hints.
+		match_multi_node_invoice_routes(
+			Some(99_000_000_1),
+			&nodes[1],
+			vec![&nodes[1], &nodes[2],],
+			HashSet::new(),
+			false
+		);
+
+		// An invoice with no specified amount should include all participating nodes in the hints.
+		let mut short_chan_ids_no_specified_amount = HashSet::new();
+		short_chan_ids_no_specified_amount.insert(chan_0_1.0.contents.short_channel_id.clone());
+		short_chan_ids_no_specified_amount.insert(chan_0_2.0.contents.short_channel_id.clone());
+
+		match_multi_node_invoice_routes(
+			None,
+			&nodes[1],
+			vec![&nodes[1], &nodes[2],],
+			short_chan_ids_no_specified_amount.clone(),
+			false
+		);
+	}
+
+	#[cfg(feature = "std")]
+	fn match_multi_node_invoice_routes<'a, 'b: 'a, 'c: 'b>(
+		invoice_amt: Option<u64>,
+		invoice_node: &Node<'a, 'b, 'c>,
+		network_multi_nodes: Vec<&Node<'a, 'b, 'c>>,
+		mut chan_ids_to_match: HashSet<u64>,
+		nodes_contains_private_channels: bool
+	){
+		let (payment_hash, payment_secret) = invoice_node.node.create_inbound_payment(invoice_amt, 3600).unwrap();
+		let phantom_route_hints = network_multi_nodes.iter()
+			.map(|node| node.node.get_phantom_route_hints())
+			.collect::<Vec<PhantomRouteHints>>();
+		let phantom_scids = phantom_route_hints.iter()
+			.map(|route_hint| route_hint.phantom_scid)
+			.collect::<HashSet<u64>>();
+
+		let invoice = ::utils::create_phantom_invoice::<EnforcingSigner, &test_utils::TestKeysInterface>(invoice_amt, "test".to_string(), payment_hash, payment_secret, phantom_route_hints, &invoice_node.keys_manager, Currency::BitcoinTestnet).unwrap();
+
+		let invoice_hints = invoice.private_routes();
+
+		for hint in invoice_hints {
+			let hints = &(hint.0).0;
+			match hints.len() {
+				1 => {
+					assert!(nodes_contains_private_channels);
+					let phantom_scid = hints[0].short_channel_id;
+					assert!(phantom_scids.contains(&phantom_scid));
+				},
+				2 => {
+					let hint_short_chan_id = hints[0].short_channel_id;
+					assert!(chan_ids_to_match.contains(&hint_short_chan_id));
+					chan_ids_to_match.remove(&hint_short_chan_id);
+					let phantom_scid = hints[1].short_channel_id;
+					assert!(phantom_scids.contains(&phantom_scid));
+				},
+				_ => panic!("Incorrect hint length generated")
+			}
+		}
+		assert!(chan_ids_to_match.is_empty());
+	}
 }