Add tests for defaulting to creating tlv onions

lightning/src/ln/onion_route_tests.rs

@@ -16,9 +16,9 @@ use chain::keysinterface::{KeysInterface, Recipient};
 use ln::{PaymentHash, PaymentSecret};
 use ln::channelmanager::{HTLCForwardInfo, CLTV_FAR_FAR_AWAY, MIN_CLTV_EXPIRY_DELTA, PendingHTLCInfo, PendingHTLCRouting};
 use ln::onion_utils;
-use routing::network_graph::{NetworkUpdate, RoutingFees};
+use routing::network_graph::{NetworkUpdate, RoutingFees, NodeId};
 use routing::router::{get_route, PaymentParameters, Route, RouteHint, RouteHintHop};
-use ln::features::{InitFeatures, InvoiceFeatures};
+use ln::features::{InitFeatures, InvoiceFeatures, NodeFeatures};
 use ln::msgs;
 use ln::msgs::{ChannelMessageHandler, ChannelUpdate, OptionalField};
 use util::events::{Event, MessageSendEvent, MessageSendEventsProvider};
@@ -34,6 +34,7 @@ use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::secp256k1;
 use bitcoin::secp256k1::Secp256k1;
 use bitcoin::secp256k1::key::{PublicKey, SecretKey};
+use bitcoin::network::constants::Network;
 
 use io;
 use prelude::*;
@@ -577,6 +578,185 @@ fn test_onion_failure() {
 	}, true, Some(23), None, None);
 }
 
+#[test]
+fn test_default_to_onion_payload_tlv_format() {
+	// Tests that we default to creating tlv format onion payloads when no `NodeAnnouncementInfo`
+	// `features` for a node in the `network_graph` exists, or when the node isn't in the
+	// `network_graph`, and no other known `features` for the node exists.
+	let mut priv_channels_conf = UserConfig::default();
+	priv_channels_conf.channel_options.announced_channel = false;
+	let chanmon_cfgs = create_chanmon_cfgs(5);
+	let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, Some(priv_channels_conf)]);
+	let mut nodes = create_network(5, &node_cfgs, &node_chanmgrs);
+
+	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+	create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
+	create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
+	create_unannounced_chan_between_nodes_with_value(&nodes, 3, 4, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+
+	let payment_params = PaymentParameters::from_node_id(nodes[3].node.get_our_node_id());
+	let origin_node = &nodes[0];
+	let network_graph = origin_node.network_graph;
+
+	// Clears all the `NodeAnnouncementInfo` for all nodes of `nodes[0]`'s `network_graph`, so that
+	// their `features` aren't used when creating the `route`.
+	network_graph.clear_nodes_announcement_info();
+
+	let scorer = test_utils::TestScorer::with_penalty(0);
+	let seed = [0u8; 32];
+	let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
+	let random_seed_bytes = keys_manager.get_secure_random_bytes();
+	let read_only_network_graph = &network_graph.read_only();
+	let announced_route = get_route(
+		&origin_node.node.get_our_node_id(), &payment_params, read_only_network_graph,
+		Some(&origin_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
+		1000000, TEST_FINAL_CLTV, origin_node.logger, &scorer, &random_seed_bytes).unwrap();
+
+	let hops = &announced_route.paths[0];
+	// Assert that the hop between `nodes[1]` and `nodes[2]` defaults to supporting variable length
+	// onions, as `nodes[0]` has no `NodeAnnouncementInfo` `features` for `node[2]`
+	assert!(hops[1].node_features.supports_variable_length_onion());
+	// Assert that the hop between `nodes[2]` and `nodes[3]` defaults to supporting variable length
+	// onions, as `nodes[0]` has no `NodeAnnouncementInfo` `features` for `node[3]`, and no `InvoiceFeatures`
+	// for the `payment_params`, which would otherwise have been used.
+	assert!(hops[2].node_features.supports_variable_length_onion());
+	// Note that we do not asset that `hops[0]` (the channel between `nodes[0]` and `nodes[1]`)
+	// supports variable length onions, as the `InitFeatures` exchanged in the init message when
+	// between the nodes will be used when creating the route. We therefore do not default to
+	// supporting variable length onions for that hop, as the `InitFeatures` in this case are
+	// `InitFeatures::known()`.
+
+	let unannounced_chan = &nodes[4].node.list_usable_channels()[0];
+
+	let last_hop = RouteHint(vec![RouteHintHop {
+		src_node_id: nodes[3].node.get_our_node_id(),
+		short_channel_id: unannounced_chan.short_channel_id.unwrap(),
+		fees: RoutingFees {
+			base_msat: 0,
+			proportional_millionths: 0,
+		},
+		cltv_expiry_delta: 42,
+		htlc_minimum_msat: None,
+		htlc_maximum_msat: None,
+	}]);
+
+	let unannounced_chan_params = PaymentParameters::from_node_id(nodes[4].node.get_our_node_id()).with_route_hints(vec![last_hop]);
+	let unannounced_route = get_route(
+		&origin_node.node.get_our_node_id(), &unannounced_chan_params, read_only_network_graph,
+		Some(&origin_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
+		10000, TEST_FINAL_CLTV, origin_node.logger, &scorer, &random_seed_bytes).unwrap();
+
+	let unannounced_chan_hop = &unannounced_route.paths[0][3];
+	// Ensure that `nodes[4]` doesn't exist in `nodes[0]`'s `network_graph`, as it's not public.
+	assert!(read_only_network_graph.nodes().get(&NodeId::from_pubkey(&nodes[4].node.get_our_node_id())).is_none());
+	// Assert that the hop between `nodes[3]` and `nodes[4]` defaults to supporting variable length
+	// onions, even though `nodes[4]` as `nodes[0]` doesn't exists in `nodes[0]`'s `network_graph`,
+	// and no `InvoiceFeatures` for the `payment_params` exists, which would otherwise have been
+	// used.
+	assert!(unannounced_chan_hop.node_features.supports_variable_length_onion());
+
+	let cur_height = nodes[0].best_block_info().1 + 1;
+	let (announced_route_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&announced_route.paths[0], 40000, &None, cur_height, &None).unwrap();
+	let (unannounced_route_paylods, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&unannounced_route.paths[0], 40000, &None, cur_height, &None).unwrap();
+
+	for onion_payloads in vec![announced_route_payloads, unannounced_route_paylods] {
+		for onion_payload in onion_payloads.iter() {
+			match onion_payload.format {
+				msgs::OnionHopDataFormat::Legacy {..} => {
+					panic!("Generated a `msgs::OnionHopDataFormat::Legacy` payload, even though that shouldn't have happend.");
+				}
+				_ => {}
+			}
+		}
+	}
+}
+
+#[test]
+fn test_do_not_use_default_to_tlv_onions_if_other_features_not_supporting_them_exists() {
+	// Tests that we do not default to creating tlv onions if any of these features exists when
+	// creating the specific hop in the route:
+	// 1. `InitFeatures` to the counterparty node exchanged with the init message to the node, which
+	// doesn't support variable length onions.
+	// 2. `NodeFeatures` in the `NodeAnnouncementInfo` of a node in sender node's the
+	// `network_graph`, which doesn't support variable length onions.
+	// 3. `InvoiceFeatures` specified by the receiving node, which doesn't support variable length
+	// onions, when no `NodeAnnouncementInfo` `features` exists for the receiver in the sender's
+	// `network_graph`.
+	let chanmon_cfgs = create_chanmon_cfgs(4);
+	let mut node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
+
+	// Set `node[1]` config to `InitFeatures::empty()` which return `false` for
+	// `supports_variable_length_onion()`
+	let mut node_1_cfg = &mut node_cfgs[1];
+	node_1_cfg.features = InitFeatures::empty();
+
+	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
+	let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
+
+	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+	create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
+	create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
+
+	let payment_params = PaymentParameters::from_node_id(nodes[3].node.get_our_node_id())
+		.with_features(InvoiceFeatures::empty());
+	let origin_node = &nodes[0];
+	let network_graph = origin_node.network_graph;
+	network_graph.clear_nodes_announcement_info();
+	let scorer = test_utils::TestScorer::with_penalty(0);
+	let seed = [0u8; 32];
+	let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
+	let random_seed_bytes = keys_manager.get_secure_random_bytes();
+
+	// Set `NodeAnnouncementInfo` `features` which do not support variable length onions for
+	// `nodes[2]` in `nodes[0]`'s `network_graph`.
+	let nodes_2_unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
+		features: NodeFeatures::empty(),
+		timestamp: 0,
+		node_id: nodes[2].node.get_our_node_id(),
+		rgb: [32; 3],
+		alias: [16;32],
+		addresses: Vec::new(),
+		excess_address_data: Vec::new(),
+		excess_data: Vec::new(),
+	};
+	let _res = network_graph.update_node_from_unsigned_announcement(&nodes_2_unsigned_node_announcement);
+
+	let route = get_route(
+		&origin_node.node.get_our_node_id(), &payment_params, &network_graph.read_only(),
+		Some(&origin_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
+		1000000, TEST_FINAL_CLTV, origin_node.logger, &scorer, &random_seed_bytes).unwrap();
+
+	let hops = &route.paths[0];
+
+	// Assert that the hop between `nodes[0]` and `nodes[1]` doesn't support variable length
+	// onions, as as the `InitFeatures` exchanged (`InitFeatures::empty()`) in the init message
+	// between the nodes when setting up the channel is used when creating the `route` and that we
+	// therefore do not default to supporting variable length onions. Despite `nodes[0]` having no
+	// `NodeAnnouncementInfo` `features` for `node[1]`.
+	assert!(!hops[0].node_features.supports_variable_length_onion());
+	// Assert that the hop between `nodes[1]` and `nodes[2]` uses the `features` from
+	// `nodes_2_unsigned_node_announcement` that doesn't support variable length onions.
+	assert!(!hops[1].node_features.supports_variable_length_onion());
+	// Assert that the hop between `nodes[2]` and `nodes[3]` uses the `InvoiceFeatures` set to the
+	// `payment_params`, that doesn't support variable length onions. We therefore do not end up
+	// defaulting to supporting variable length onions, despite `nodes[0]` having no
+	// `NodeAnnouncementInfo` `features` for `node[3]`.
+	assert!(!hops[2].node_features.supports_variable_length_onion());
+
+	let cur_height = nodes[0].best_block_info().1 + 1;
+	let (onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height, &None).unwrap();
+
+	for onion_payload in onion_payloads.iter() {
+		match onion_payload.format {
+			msgs::OnionHopDataFormat::Legacy {..} => {}
+			_ => {
+				panic!("Should have only have generated `msgs::OnionHopDataFormat::Legacy` payloads");
+			}
+		}
+	}
+}
+
 macro_rules! get_phantom_route {
 	($nodes: expr, $amt: expr, $channel: expr) => {{
 		let secp_ctx = Secp256k1::new();

lightning/src/routing/network_graph.rs

@@ -1033,6 +1033,15 @@ impl NetworkGraph {
 		}
 	}
 
+	/// Clears the `NodeAnnouncementInfo` field for all nodes in the `NetworkGraph` for testing
+	/// purposes.
+	#[cfg(test)]
+	pub fn clear_nodes_announcement_info(&self) {
+		for node in self.nodes.write().unwrap().iter_mut(){
+			node.1.announcement_info = None;
+		}
+	}
+
 	/// For an already known node (from channel announcements), update its stored properties from a
 	/// given node announcement.
 	///