Harden test to include mpp

Author: sourabhmarathe

lightning/src/routing/network_graph.rs

@@ -281,11 +281,11 @@ pub struct ChannelInfo {
 	/// Protocol features of a channel communicated during its announcement
 	pub features: ChannelFeatures,
 	/// Source node of the first direction of a channel
-	pub node_one: PublicKey,
+	pub node_alice: PublicKey,
 	/// Details about the first direction of a channel
 	pub alice_to_bob: Option<DirectionalChannelInfo>,
 	/// Source node of the second direction of a channel
-	pub node_two: PublicKey,
+	pub node_bob: PublicKey,
 	/// Details about the second direction of a channel
 	pub bob_to_alice: Option<DirectionalChannelInfo>,
 	/// An initial announcement of the channel
@@ -297,17 +297,17 @@ pub struct ChannelInfo {
 
 impl std::fmt::Display for ChannelInfo {
 	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-		write!(f, "features: {}, node_one: {}, alice_to_bob: {:?}, node_two: {}, bob_to_alice: {:?}",
-		   log_bytes!(self.features.encode()), log_pubkey!(self.node_one), self.alice_to_bob, log_pubkey!(self.node_two), self.bob_to_alice)?;
+		write!(f, "features: {}, node_alice: {}, alice_to_bob: {:?}, node_bob: {}, bob_to_alice: {:?}",
+		   log_bytes!(self.features.encode()), log_pubkey!(self.node_alice), self.alice_to_bob, log_pubkey!(self.node_bob), self.bob_to_alice)?;
 		Ok(())
 	}
 }
 
 impl_writeable!(ChannelInfo, 0, {
 	features,
-	node_one,
+	node_alice,
 	alice_to_bob,
-	node_two,
+	node_bob,
 	bob_to_alice,
 	announcement_message
 });
@@ -577,16 +577,18 @@ impl NetworkGraph {
 			for route_hop in path {
 				let short_channel_id = route_hop.short_channel_id;
 				let channel = self.channels.get_mut(&short_channel_id).unwrap();
-				let directional_channel_info = if route_hop.pubkey == channel.node_one {
-					channel.alice_to_bob.as_mut().unwrap()
-				} else {
-					channel.bob_to_alice.as_mut().unwrap()
-				};
-				let channel_score = &mut directional_channel_info.channel_score;
 				if faultive_nodes.contains(&(route_hop.pubkey)) {
+					let directional_channel_info = if route_hop.pubkey == channel.node_alice {
+						channel.bob_to_alice.as_mut().unwrap()
+					} else {
+						channel.alice_to_bob.as_mut().unwrap()
+					};
+					let channel_score = &mut directional_channel_info.channel_score;
 					channel_score.payment_failed_score += 1;
+					break; // You don't want to reward channels past this point in the path, but you don't want to penalize either. So here we just move onto the next path in the route.
 				} else {
-					channel_score.payment_sent_score += 1;
+					channel.alice_to_bob.as_mut().unwrap().channel_score.payment_sent_score += 1;
+					channel.bob_to_alice.as_mut().unwrap().channel_score.payment_sent_score += 1;
 				}
 			}
 		}
@@ -644,9 +646,9 @@ impl NetworkGraph {
 
 		let chan_info = ChannelInfo {
 				features: msg.contents.features.clone(),
-				node_one: msg.contents.node_id_1.clone(),
+				node_alice: msg.contents.node_id_1.clone(),
 				alice_to_bob: None,
-				node_two: msg.contents.node_id_2.clone(),
+				node_bob: msg.contents.node_id_2.clone(),
 				bob_to_alice: None,
 				announcement_message: if should_relay { Some(msg.clone()) } else { None },
 			};
@@ -776,17 +778,17 @@ impl NetworkGraph {
 
 				let msg_hash = hash_to_message!(&Sha256dHash::hash(&msg.contents.encode()[..])[..]);
 				if msg.contents.flags & 1 == 1 {
-					dest_node_id = channel.node_one.clone();
+					dest_node_id = channel.node_alice.clone();
 					if let Some(sig_verifier) = secp_ctx {
-						secp_verify_sig!(sig_verifier, &msg_hash, &msg.signature, &channel.node_two);
+						secp_verify_sig!(sig_verifier, &msg_hash, &msg.signature, &channel.node_bob);
 					}
-					maybe_update_channel_info!(channel.bob_to_alice, channel.node_two);
+					maybe_update_channel_info!(channel.bob_to_alice, channel.node_bob);
 				} else {
-					dest_node_id = channel.node_two.clone();
+					dest_node_id = channel.node_bob.clone();
 					if let Some(sig_verifier) = secp_ctx {
-						secp_verify_sig!(sig_verifier, &msg_hash, &msg.signature, &channel.node_one);
+						secp_verify_sig!(sig_verifier, &msg_hash, &msg.signature, &channel.node_alice);
 					}
-					maybe_update_channel_info!(channel.alice_to_bob, channel.node_one);
+					maybe_update_channel_info!(channel.alice_to_bob, channel.node_alice);
 				}
 			}
 		}
@@ -810,7 +812,7 @@ impl NetworkGraph {
 			for chan_id in node.channels.iter() {
 				let chan = self.channels.get(chan_id).unwrap();
 				let chan_info_opt;
-				if chan.node_one == dest_node_id {
+				if chan.node_alice == dest_node_id {
 					chan_info_opt = chan.bob_to_alice.as_ref();
 				} else {
 					chan_info_opt = chan.alice_to_bob.as_ref();
@@ -847,8 +849,8 @@ impl NetworkGraph {
 			}
 		}
 
-		remove_from_node!(chan.node_one);
-		remove_from_node!(chan.node_two);
+		remove_from_node!(chan.node_alice);
+		remove_from_node!(chan.node_bob);
 	}
 }
 
@@ -1760,6 +1762,7 @@ mod tests {
 		// node_3 -> node_4
 		// We can use this to simulate a MPP from node_1 to node_4 via node_2 and node_3.
 		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let num_nodes = 4;
 		let node_0_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node_1_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
 		let node_2_privkey = &SecretKey::from_slice(&[40; 32]).unwrap();
@@ -1787,8 +1790,15 @@ mod tests {
 
 		{
 			// Create channels between each node
-			for i in 0..=3 {
-				for j in 0..=3 {
+			// The short channel IDs will be assigned as follows:
+			// 0 <-> 1 = 0
+			// 0 <-> 2 = 1
+			// 0 <-> 3 = 2
+			// 1 <-> 2 = 3
+			// 1 <-> 3 = 4
+			// 2 <-> 3 = 5
+			for i in 0..num_nodes {
+				for j in 0..num_nodes {
 					if i >= j {
 						continue;
 					} else {
@@ -1832,7 +1842,6 @@ mod tests {
 			// channel
 			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
 			for channel_id in 0..short_channel_id {
-				//let chan_id = network.get_nodes().get(&node_ids[0]).unwrap().channels[0];
 				let channel_info = network.channels.get_mut(&channel_id).unwrap();
 				// Assign a DirectionalChannelInfo and ChannelScore object to alice_to_bob of
 				// channel_info
@@ -1877,12 +1886,12 @@ mod tests {
 			}
 		}
 
-		// From here on out we simulate the network learning of payments.
+		// Network is now setup so we can proceed with testing the scoring function
 		{
 			// Assume a PaymentSent event is picked up and it consists of a simple payment from
 			// node_0 to node_1
 			let route_hop = RouteHop {
-				pubkey: node_ids[0],
+				pubkey: node_ids[1],
 				node_features: NodeFeatures::empty(),
 				short_channel_id: 0,
 				channel_features: ChannelFeatures::empty(),
@@ -1895,37 +1904,208 @@ mod tests {
 			let sent_res = network.score_payment_sent_for_route(sent_route);
 			assert!(sent_res.unwrap() == true);
 			// Check that score_payment_sent_for_route incremented the appropriate ChannelScore
-			let chan_id = network.get_nodes().get(&node_ids[0]).unwrap().channels[0];
+			let chan_id = 0;
 			let channel_info = network.channels.get_mut(&chan_id).unwrap();
 			let dir_alice_to_bob = &channel_info.alice_to_bob.as_ref();
 			assert_eq!(dir_alice_to_bob.unwrap().channel_score.payment_sent_score, 1);
 			assert_eq!(dir_alice_to_bob.unwrap().channel_score.payment_failed_score, 0);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
 		}
 
 		{
-			let route_hop = RouteHop {
-								pubkey: node_ids[0],
-								node_features: NodeFeatures::empty(),
-								short_channel_id: 0,
-								channel_features: ChannelFeatures::empty(),
-								fee_msat: 0,
-								cltv_expiry_delta: 0,
-							};
 			// Assume a payment fails due to node_1 (identified by its PublicKey), verify that its
-			// directional channel's score (node_1 -> node_2) has its PaymentFailed score
+			// directional channel's score (node_0 -> node_1) has its PaymentFailed score
 			// incremented.
-			let faultive_nodes: Vec<PublicKey> = vec![node_ids[0]];
+			let route_hop = RouteHop {
+				pubkey: node_ids[1],
+				node_features: NodeFeatures::empty(),
+				short_channel_id: 0,
+				channel_features: ChannelFeatures::empty(),
+				fee_msat: 0,
+				cltv_expiry_delta: 0,
+			};
+			let faultive_nodes: Vec<PublicKey> = vec![node_ids[1]];
 			let attempted_path: Vec<RouteHop> = vec![route_hop];
 			let failed_route: Vec<Vec<RouteHop>> = vec![attempted_path];
 			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
 			let failed_res = network.score_payment_failed_for_route(failed_route, faultive_nodes);
 			assert!(failed_res.unwrap() == true);
-			let chan_id = network.get_nodes().get(&node_ids[0]).unwrap().channels[0];
+			let chan_id = 0;
 			let channel_info = network.channels.get_mut(&chan_id).unwrap();
-			assert!(channel_info.node_two == node_ids[1]);
-			let dir_alice_to_bob = &channel_info.alice_to_bob.as_ref();
-			assert_eq!(dir_alice_to_bob.unwrap().channel_score.payment_sent_score, 1);
-			assert_eq!(dir_alice_to_bob.unwrap().channel_score.payment_failed_score, 1);
+			assert!(channel_info.node_bob == node_ids[1]);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+		}
+
+		{
+			// In this case, the route through node_1 succeeded, but the route through node_2
+			// failed. We expect the node_0 <-> node_2 channel to be penalized.
+			let mut route_hops: Vec<RouteHop> = vec![];
+			for i in 0..num_nodes {
+				let route_hop = RouteHop {
+					pubkey: node_ids[i],
+					node_features: NodeFeatures::empty(),
+					short_channel_id: 0,
+					channel_features: ChannelFeatures::empty(),
+					fee_msat: 0,
+					cltv_expiry_delta: 0,
+				};
+				route_hops.push(route_hop);
+			}
+			let faultive_nodes: Vec<PublicKey> = vec![node_ids[2]];
+			let mut success_path: Vec<RouteHop> = vec![route_hops[1].clone(), route_hops[3].clone()];
+			let mut failed_path: Vec<RouteHop> = vec![route_hops[2].clone(), route_hops[3].clone()];
+
+			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
+			success_path[0].short_channel_id = 0;
+			success_path[1].short_channel_id = 4;
+			failed_path[0].short_channel_id = 1;
+			failed_path[1].short_channel_id = 5;
+
+			let mpp_route: Vec<Vec<RouteHop>> = vec![success_path, failed_path];
+			let failed_res = network.score_payment_failed_for_route(mpp_route, faultive_nodes);
+			assert!(failed_res.unwrap() == true);
+		}
+
+		{
+			let network = net_graph_msg_handler.network_graph.read().unwrap();
+			let mut chan_id = 0; // Check on 0 <-> 1
+			let mut channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 2);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 2);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+
+			chan_id = 1; // Check on 0 <-> 2
+			channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 0);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 0);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+		}
+
+		{
+			// In this case, both routes succeed, so we will check that the payment_sent_score's
+			// for all channels are incremented.
+			let mut route_hops: Vec<RouteHop> = vec![];
+			for i in 0..num_nodes {
+				let route_hop = RouteHop {
+					pubkey: node_ids[i],
+					node_features: NodeFeatures::empty(),
+					short_channel_id: 0,
+					channel_features: ChannelFeatures::empty(),
+					fee_msat: 0,
+					cltv_expiry_delta: 0,
+				};
+				route_hops.push(route_hop);
+			}
+			let mut success_path_1: Vec<RouteHop> = vec![route_hops[1].clone(), route_hops[3].clone()];
+			let mut success_path_2: Vec<RouteHop> = vec![route_hops[2].clone(), route_hops[3].clone()];
+
+			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
+			success_path_1[0].short_channel_id = 0;
+			success_path_1[1].short_channel_id = 4;
+			success_path_2[0].short_channel_id = 1;
+			success_path_2[1].short_channel_id = 5;
+
+			let mpp_route: Vec<Vec<RouteHop>> = vec![success_path_1, success_path_2];
+			let failed_res = network.score_payment_sent_for_route(mpp_route);
+			assert!(failed_res.unwrap() == true);
+		}
+
+		{
+			let network = net_graph_msg_handler.network_graph.read().unwrap();
+			let mut chan_id = 0; // Check on 0 <-> 1
+			let mut channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 3);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 3);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+
+			chan_id = 1; // Check on 0 <-> 2
+			channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+
+			chan_id = 4; // Check on 1 <-> 3
+			channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 2);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 0);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 2);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+
+			chan_id = 5; // Check on 2 <-> 3
+			channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 0);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+		}
+
+		{
+			// In this case, both routes fail, so we will check that the payment_fail_score's
+			// for all 0 <-> 1 and 0 <-> 2 are incremented while 1 <->3 and 2 <-> 3 remain the
+			// same.
+			let mut route_hops: Vec<RouteHop> = vec![];
+			for i in 0..num_nodes {
+				let route_hop = RouteHop {
+					pubkey: node_ids[i],
+					node_features: NodeFeatures::empty(),
+					short_channel_id: 0,
+					channel_features: ChannelFeatures::empty(),
+					fee_msat: 0,
+					cltv_expiry_delta: 0,
+				};
+				route_hops.push(route_hop);
+			}
+			let faultive_nodes = vec![node_ids[1], node_ids[2]];
+			let mut fail_path_1: Vec<RouteHop> = vec![route_hops[1].clone(), route_hops[3].clone()];
+			let mut fail_path_2: Vec<RouteHop> = vec![route_hops[2].clone(), route_hops[3].clone()];
+
+			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
+			fail_path_1[0].short_channel_id = 0;
+			fail_path_1[1].short_channel_id = 4;
+			fail_path_2[0].short_channel_id = 1;
+			fail_path_2[1].short_channel_id = 5;
+
+			let mpp_route: Vec<Vec<RouteHop>> = vec![fail_path_1, fail_path_2];
+			let failed_res = network.score_payment_failed_for_route(mpp_route, faultive_nodes);
+			assert!(failed_res.unwrap() == true);
+		}
+		{
+			let network = net_graph_msg_handler.network_graph.read().unwrap();
+			let mut chan_id = 0; // Check on 0 <-> 1
+			let mut channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 3);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 2);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 3);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+
+			chan_id = 1; // Check on 0 <-> 2
+			channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 2);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+
+			chan_id = 4; // Check on 1 <-> 3
+			channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 2);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 0);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 2);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
+
+			chan_id = 5; // Check on 2 <-> 3
+			channel_info = network.channels.get(&chan_id).unwrap();
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().channel_score.payment_failed_score, 0);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(channel_info.bob_to_alice.as_ref().unwrap().channel_score.payment_failed_score, 0);
 		}
 	}
 }