Add default implementation for tracking metadata

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;
 
@@ -278,7 +279,6 @@ impl_writeable!(ChannelInfo, 0, {
 	announcement_message
 });
 
-
 /// Fees for routing via a given channel or a node
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
 pub struct RoutingFees {
@@ -428,6 +428,64 @@ impl Readable for NodeInfo {
 	}
 }
 
+/// Allows for updating user's network metadata.
+pub trait RouteFeePenalty {
+	/// Gets a channel's fee penalty based on its channel_id (as stored in a NetworkGraph object).
+	fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64>;
+	/// Informs metadata object that a route has successfully executed its payment.
+	fn route_succeeded(&mut self, route: Vec<RouteHop>);
+}
+
+/// A default metadata object that is used to implement the default functionality for the
+/// NetworkTracker trait. A user could  make their own Metadata object and extend the
+/// functionality of it by implementing other functions/traits for their metadata.
+pub struct DefaultMetadata {
+	/// A lits of failed channels. Maps channel_id (as specified in the NetworkGraph object) to
+	/// the number of successful routes to participate before being removed from the list. All
+	/// channels in failed_channels are assumed to have a penalty of u64::max.
+	failed_channels: BTreeMap<u64, u64>,
+}
+
+impl RouteFeePenalty for DefaultMetadata {
+	fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64> {
+		if self.failed_channels.get(&chan_id) == None {
+			return Some(&0);
+		} else {
+			return Some(&u64::MAX);
+		}
+	}
+	fn route_succeeded(&mut self, route: Vec<RouteHop>) {
+		for route_hop in route {
+			let chan_id = route_hop.short_channel_id;
+			let successes_needed = self.failed_channels.get(&chan_id);
+			if successes_needed == None {
+				self.failed_channels.insert(chan_id, 5);
+			} else {
+				let dec_successes_needed = successes_needed.unwrap() - 1;
+				if dec_successes_needed > 0 {
+					self.failed_channels.insert(chan_id, dec_successes_needed);
+				} else {
+					self.failed_channels.remove(&chan_id);
+				}
+			}
+		}
+	}
+}
+
+/// Users store custom metadata about the network separately. This trait is implemented by users, who may use
+/// the NetworkGraph to update whatever metadata they are storing about their view of the network.
+pub trait NetworkTracker<T: RouteFeePenalty = DefaultMetadata> {
+	/// Return score for a given channel by using user-defined channel_scorers
+	fn calculate_minimum_fee_penalty_for_channel(&self, chan_id: u64, network_metadata: T) -> u64 {
+		let chan_score = network_metadata.get_channel_fee_penalty(chan_id);
+		if chan_score != None {
+			return *chan_score.unwrap();
+		} else {
+			return 0;
+		}
+	}
+}
+
 /// Represents the network as nodes and channels between them
 #[derive(PartialEq)]
 pub struct NetworkGraph {