Add ChannelScore struct

Adds a ChannelScore field under DirectionalInfoStruct to measure the
performance of channels. Two methods were added to the NetworkGraph impl
to allow for scoring PaymentSent and PaymentFailed events.

Includes a test to ensure that NetworkGraph objects are properly updated
when their scoring functions are called.

Author: sourabhmarathe

lightning/src/ln/channelmanager.rs

@@ -1845,7 +1845,12 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 						// TODO: If we decided to blame ourselves (or one of our channels) in
 						// process_onion_failure we should close that channel as it implies our
 						// next-hop is needlessly blaming us!
+						let mut faultive_node = None;
 						if let Some(update) = channel_update {
+							faultive_node = match update.clone() {
+								msgs::HTLCFailChannelUpdate::NodeFailure {node_id, is_permanent: _} => Some(node_id),
+								_ => None,
+							};
 							self.channel_state.lock().unwrap().pending_msg_events.push(
 								events::MessageSendEvent::PaymentFailureNetworkUpdate {
 									update,
@@ -1856,6 +1861,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 							events::Event::PaymentFailed {
 								payment_hash: payment_hash.clone(),
 								rejected_by_dest: !payment_retryable,
+								faultive_node: faultive_node,
 #[cfg(test)]
 								error_code: onion_error_code,
 #[cfg(test)]
@@ -1880,6 +1886,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 							events::Event::PaymentFailed {
 								payment_hash: payment_hash.clone(),
 								rejected_by_dest: path.len() == 1,
+								faultive_node: None,
 #[cfg(test)]
 								error_code: Some(*failure_code),
 #[cfg(test)]

lightning/src/ln/functional_test_utils.rs

@@ -770,7 +770,7 @@ macro_rules! expect_payment_failed {
 		let events = $node.node.get_and_clear_pending_events();
 		assert_eq!(events.len(), 1);
 		match events[0] {
-			Event::PaymentFailed { ref payment_hash, rejected_by_dest, ref error_code, ref error_data } => {
+			Event::PaymentFailed { ref payment_hash, rejected_by_dest, faultive_node: _, ref error_code, ref error_data } => {
 				assert_eq!(*payment_hash, $expected_payment_hash);
 				assert_eq!(rejected_by_dest, $rejected_by_dest);
 				assert!(error_code.is_some());

lightning/src/ln/functional_tests.rs

@@ -5578,7 +5578,7 @@ fn run_onion_failure_test_with_fail_intercept<F1,F2,F3>(_name: &str, test_case:
 
 	let events = nodes[0].node.get_and_clear_pending_events();
 	assert_eq!(events.len(), 1);
-	if let &Event::PaymentFailed { payment_hash:_, ref rejected_by_dest, ref error_code, error_data: _ } = &events[0] {
+	if let &Event::PaymentFailed { payment_hash:_, ref rejected_by_dest, faultive_node: _, ref error_code, error_data: _ } = &events[0] {
 		assert_eq!(*rejected_by_dest, !expected_retryable);
 		assert_eq!(*error_code, expected_error_code);
 	} else {

lightning/src/routing/network_graph.rs

@@ -13,6 +13,7 @@ use chain::chaininterface::{ChainError, ChainWatchInterface};
 use ln::features::{ChannelFeatures, NodeFeatures};
 use ln::msgs::{DecodeError,ErrorAction,LightningError,RoutingMessageHandler,NetAddress};
 use ln::msgs;
+use routing::router::RouteHop;
 use util::ser::{Writeable, Readable, Writer};
 use util::logger::Logger;
 
@@ -202,6 +203,36 @@ impl<C: Deref + Sync + Send, L: Deref + Sync + Send> RoutingMessageHandler for N
 	}
 }
 
+#[derive(PartialEq, Debug)]
+/// Tracks the score of a payment by holding onto certain metadata about
+/// the channel. Right now it stores a count of PaymentSent and PaymentFailed
+/// occurances for a given channel, but there's a lot more that could be
+/// added down the road (eg uptime, fee rates, variation, floppiness...)
+pub struct ChannelScore {
+	/// Count of occurances of PaymentSent events
+	pub payment_sent_score: u64,
+	/// Count of occurances of PaymentFailed events
+	pub payment_failed_score: u64,
+}
+
+impl Readable for ChannelScore {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<ChannelScore, DecodeError> {
+		let payment_sent_score: u64 = Readable::read(reader)?;
+		let payment_failed_score: u64 = Readable::read(reader)?;
+		Ok(ChannelScore {
+			payment_sent_score,
+			payment_failed_score,
+		})
+	}
+}
+
+impl Writeable for ChannelScore {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+		self.payment_sent_score.write(writer)?;
+		self.payment_failed_score.write(writer)?;
+		Ok(())
+	}
+}
 #[derive(PartialEq, Debug)]
 /// Details about one direction of a channel. Received
 /// within a channel update.
@@ -222,6 +253,8 @@ pub struct DirectionalChannelInfo {
 	/// Everything else is useful only for sending out for initial routing sync.
 	/// Not stored if contains excess data to prevent DoS.
 	pub last_update_message: Option<msgs::ChannelUpdate>,
+	/// A structure that tracks the reliablity of a channel.
+	pub channel_score: ChannelScore,
 }
 
 impl std::fmt::Display for DirectionalChannelInfo {
@@ -237,7 +270,8 @@ impl_writeable!(DirectionalChannelInfo, 0, {
 	cltv_expiry_delta,
 	htlc_minimum_msat,
 	fees,
-	last_update_message
+	last_update_message,
+	channel_score
 });
 
 #[derive(PartialEq)]
@@ -506,6 +540,56 @@ impl NetworkGraph {
 		None
 	}
 
+	/// Increments payment_sent_score for appropriate DirectionalChannelInfos on the network graph.
+	/// The appropriate directional channel is indentified by the RouteHop, which includes a
+	/// PublicKey field. This is matched against the two PublicKey fields in ChannelInfo and is
+	/// used to increment the score.
+	pub fn score_payment_sent_for_route(&mut self, route: Vec<Vec<RouteHop>>) -> Result<bool, LightningError> {
+		for path in route {
+			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.one_to_two.as_mut().unwrap()
+				} else {
+					channel.two_to_one.as_mut().unwrap()
+				};
+				let channel_score = &mut directional_channel_info.channel_score;
+				channel_score.payment_sent_score += 1;
+			}
+		}
+		Ok(true)
+	}
+
+	/// Increments payment_failed_score for approriate DirectionalChannelInfos on the network
+	/// graph. Like the case for scoring PaymentSent events, this method uses the node's PublicKey
+	/// to identify the appropriate DirectionalChannelInfo to score. From there, there is a check
+	/// against a list of at fault nodes that determines whether the node's channel score should be
+	/// penalized for failing to execute or rewarded for executing properly.
+	pub fn score_payment_failed_for_route(&mut self, route: Vec<Vec<RouteHop>>, faultive_nodes: Vec<PublicKey>) -> Result<bool, LightningError> {
+		if faultive_nodes.len() == 0 {
+			return self.score_payment_sent_for_route(route)
+		}
+		for path in route {
+			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.one_to_two.as_mut().unwrap()
+				} else {
+					channel.two_to_one.as_mut().unwrap()
+				};
+				let channel_score = &mut directional_channel_info.channel_score;
+				if faultive_nodes.contains(&(route_hop.pubkey)) {
+					channel_score.payment_failed_score += 1;
+				} else {
+					channel_score.payment_sent_score += 1;
+				}
+			}
+		}
+		Ok(true)
+	}
+
 	/// For an already known node (from channel announcements), update its stored properties from a given node announcement
 	/// Announcement signatures are checked here only if Secp256k1 object is provided.
 	fn update_node_from_announcement(&mut self, msg: &msgs::NodeAnnouncement, secp_ctx: Option<&Secp256k1<secp256k1::VerifyOnly>>) -> Result<bool, LightningError> {
@@ -677,7 +761,11 @@ impl NetworkGraph {
 								base_msat: msg.contents.fee_base_msat,
 								proportional_millionths: msg.contents.fee_proportional_millionths,
 							},
-							last_update_message
+							last_update_message,
+							channel_score: ChannelScore {
+								payment_sent_score: 0,
+								payment_failed_score: 0,
+							}
 						};
 						$target = Some(updated_channel_dir_info);
 					}
@@ -765,12 +853,13 @@ impl NetworkGraph {
 mod tests {
 	use chain::chaininterface;
 	use ln::features::{ChannelFeatures, NodeFeatures};
-	use routing::network_graph::{NetGraphMsgHandler, NetworkGraph};
+	use routing::network_graph::{NetGraphMsgHandler, NetworkGraph, DirectionalChannelInfo, ChannelScore, RoutingFees};
 	use ln::msgs::{RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement,
 		UnsignedChannelAnnouncement, ChannelAnnouncement, UnsignedChannelUpdate, ChannelUpdate, HTLCFailChannelUpdate};
 	use util::test_utils;
 	use util::logger::Logger;
 	use util::ser::{Readable, Writeable};
+	use routing::router::RouteHop;
 
 	use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 	use bitcoin::hashes::Hash;
@@ -1658,4 +1747,132 @@ mod tests {
 		network.write(&mut w).unwrap();
 		assert!(<NetworkGraph>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap() == *network);
 	}
+
+	#[test]
+	fn network_graph_score_payment() {
+		// Set up a network that consists of just a channel between node_1 and node_2
+		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
+		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
+		let node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_1_privkey);
+		let node_id_2 = PublicKey::from_secret_key(&secp_ctx, node_2_privkey);
+		let node_1_btckey = &SecretKey::from_slice(&[40; 32]).unwrap();
+		let node_2_btckey = &SecretKey::from_slice(&[39; 32]).unwrap();
+
+		let short_channel_id = 0;
+		let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
+
+		{
+			// There is no nodes in the table at the beginning.
+			let network = net_graph_msg_handler.network_graph.read().unwrap();
+			assert_eq!(network.get_nodes().len(), 0);
+		}
+
+		{
+			// Announce a channel we will update
+			let unsigned_announcement = UnsignedChannelAnnouncement {
+				features: ChannelFeatures::empty(),
+				chain_hash,
+				short_channel_id,
+				node_id_1,
+				node_id_2,
+				bitcoin_key_1: PublicKey::from_secret_key(&secp_ctx, node_1_btckey),
+				bitcoin_key_2: PublicKey::from_secret_key(&secp_ctx, node_2_btckey),
+				excess_data: Vec::new(),
+			};
+
+			let msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
+			let valid_channel_announcement = ChannelAnnouncement {
+				node_signature_1: secp_ctx.sign(&msghash, node_1_privkey),
+				node_signature_2: secp_ctx.sign(&msghash, node_2_privkey),
+				bitcoin_signature_1: secp_ctx.sign(&msghash, node_1_btckey),
+				bitcoin_signature_2: secp_ctx.sign(&msghash, node_2_btckey),
+				contents: unsigned_announcement.clone(),
+			};
+			match net_graph_msg_handler.handle_channel_announcement(&valid_channel_announcement) {
+				Ok(_) => (),
+				Err(_) => panic!()
+			};
+		}
+
+		{
+			// At the start, the node_1 <-> node_2 channel's DirectionalChannelInfos should be 0.
+			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
+			let chan_id = network.get_nodes().get(&node_id_1).unwrap().channels[0];
+			let channel_info = network.channels.get_mut(&chan_id).unwrap();
+			// Assign a DirectionalChannelInfo and ChannelScore object to one_to_two of
+			// channel_info
+			let chan_score = ChannelScore {
+				payment_sent_score: 0,
+				payment_failed_score: 0,
+			};
+			let dummy_routing_fee = RoutingFees {
+				base_msat: 0,
+				proportional_millionths: 0,
+			};
+			let dir_chan_info = DirectionalChannelInfo {
+				last_update: 0,
+				enabled: true,
+				cltv_expiry_delta: 0,
+				htlc_minimum_msat: 0,
+				fees: dummy_routing_fee,
+				last_update_message: None,
+				channel_score: chan_score,
+			};
+			channel_info.one_to_two = Some(dir_chan_info);
+			let dir_one_to_two = channel_info.one_to_two.as_mut().unwrap();
+			assert_eq!(dir_one_to_two.channel_score.payment_sent_score, 0);
+			assert_eq!(dir_one_to_two.channel_score.payment_failed_score, 0);
+		}
+
+		{
+			// Assume a payment is made, and node 1 is learning of a PaymentSent event. It now calls
+			// its score_payment_sent_for_route on itself.
+			let route_hop = RouteHop {
+								pubkey: node_id_1,
+								node_features: NodeFeatures::empty(),
+								short_channel_id: 0,
+								channel_features: ChannelFeatures::empty(),
+								fee_msat: 0,
+								cltv_expiry_delta: 0,
+							};
+			let sent_paths: Vec<RouteHop> = vec![route_hop];
+			let sent_route: Vec<Vec<RouteHop>> = vec![sent_paths];
+			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
+			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_id_1).unwrap().channels[0];
+			let channel_info = network.channels.get_mut(&chan_id).unwrap();
+			let dir_one_to_two = &channel_info.one_to_two.as_ref();
+			assert_eq!(dir_one_to_two.unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(dir_one_to_two.unwrap().channel_score.payment_failed_score, 0);
+		}
+
+		{
+			let route_hop = RouteHop {
+								pubkey: node_id_1,
+								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
+			// incremented.
+			let faultive_nodes: Vec<PublicKey> = vec![node_id_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_id_1).unwrap().channels[0];
+			let channel_info = network.channels.get_mut(&chan_id).unwrap();
+			assert!(channel_info.node_two == node_id_2);
+			let dir_one_to_two = &channel_info.one_to_two.as_ref();
+			assert_eq!(dir_one_to_two.unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(dir_one_to_two.unwrap().channel_score.payment_failed_score, 1);
+		}
+	}
 }

lightning/src/util/events.rs

@@ -98,6 +98,8 @@ pub enum Event {
 		/// the payment has failed, not just the route in question. If this is not set, you may
 		/// retry the payment via a different route.
 		rejected_by_dest: bool,
+		/// Indicates the node responsible for the failure in the event of NodeFailure event.
+		faultive_node: Option<PublicKey>,
 #[cfg(test)]
 		error_code: Option<u16>,
 #[cfg(test)]
@@ -145,7 +147,7 @@ impl Writeable for Event {
 				3u8.write(writer)?;
 				payment_preimage.write(writer)?;
 			},
-			&Event::PaymentFailed { ref payment_hash, ref rejected_by_dest,
+			&Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, ref faultive_node,
 				#[cfg(test)]
 				ref error_code,
 				#[cfg(test)]
@@ -154,6 +156,7 @@ impl Writeable for Event {
 				4u8.write(writer)?;
 				payment_hash.write(writer)?;
 				rejected_by_dest.write(writer)?;
+				faultive_node.write(writer)?;
 				#[cfg(test)]
 				error_code.write(writer)?;
 				#[cfg(test)]
@@ -194,6 +197,7 @@ impl MaybeReadable for Event {
 			4u8 => Ok(Some(Event::PaymentFailed {
 					payment_hash: Readable::read(reader)?,
 					rejected_by_dest: Readable::read(reader)?,
+					faultive_node: Readable::read(reader)?,
 					#[cfg(test)]
 					error_code: Readable::read(reader)?,
 					#[cfg(test)]