Implement local channel tracking by Router at channel_update

Add test_channel_update_local_channel

Issue #149

Author: Antoine Riard

src/ln/channelmanager.rs

@@ -2249,6 +2249,14 @@ impl ChannelMessageHandler for ChannelManager {
 		handle_error!(self, self.internal_channel_reestablish(their_node_id, msg), their_node_id)
 	}
 
+	fn handle_channel_update(&self, msg: &msgs::ChannelUpdate) -> bool {
+		let channel_state = self.channel_state.lock().unwrap();
+		if channel_state.short_to_id.get(&msg.contents.short_channel_id).is_some() {
+			return true
+		}
+		false
+	}
+
 	fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool) {
 		let mut new_events = Vec::new();
 		let mut failed_channels = Vec::new();
@@ -4587,4 +4595,17 @@ mod tests {
 		sign_msg!(unsigned_msg);
 		assert!(nodes[0].router.handle_channel_announcement(&chan_announcement).is_err());
 	}
+
+	#[test]
+	fn test_channel_update_local_channel() {
+		let nodes = create_network(2);
+
+		let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
+
+		if nodes[0].node.handle_channel_update(&chan_1.1) {
+			nodes[0].router.handle_local_channel(&chan_1.1, nodes[0].node.get_our_node_id().clone(), nodes[1].node.get_our_node_id().clone(), msgs::GlobalFeatures::new())
+		}
+		nodes[0].router.handle_channel_update(&chan_1.1).unwrap();
+
+	}
 }

src/ln/msgs.rs

@@ -530,6 +530,8 @@ pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync {
 	// Channel-to-announce:
 	/// Handle an incoming announcement_signatures message from the given peer.
 	fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures) -> Result<(), HandleError>;
+	/// Handle an incoming channel_update message, return true if it's an update on local channels
+	fn handle_channel_update(&self, msg: &ChannelUpdate) -> bool;
 
 	// Connection loss/reestablish:
 	/// Indicates a connection to the peer failed/an existing connection was lost. If no connection
@@ -561,6 +563,8 @@ pub trait RoutingMessageHandler : Send + Sync {
 	fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, HandleError>;
 	/// Handle some updates to the route graph that we learned due to an outbound failed payment.
 	fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate);
+	/// Add local channel into Router maps
+	fn handle_local_channel(&self, msg: &ChannelUpdate, our_node_id: PublicKey, their_node_id: PublicKey, features: GlobalFeatures);
 }
 
 pub(crate) struct OnionRealm0HopData {

src/ln/peer_handler.rs

@@ -7,6 +7,7 @@
 //! they should handle, and encoding/sending response messages.
 
 use secp256k1::key::{SecretKey,PublicKey};
+use secp256k1::{Secp256k1};
 
 use ln::msgs;
 use util::ser::{Writeable, Writer, Readable};
@@ -711,6 +712,15 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 											},
 											258 => {
 												let msg = try_potential_decodeerror!(msgs::ChannelUpdate::read(&mut reader));
+												if self.message_handler.chan_handler.handle_channel_update(&msg) {
+													let peers_state = self.peers.lock().unwrap();
+													if let Some(peer) = peers_state.peers.get(peer_descriptor) {
+														if let Some(ref their_node_id) = peer.their_node_id {
+															let our_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &self.our_node_secret);
+															self.message_handler.route_handler.handle_local_channel(&msg, our_node_id, their_node_id.clone(), if peer.their_global_features.is_some() { peer.their_global_features.clone().unwrap() } else { msgs::GlobalFeatures::new() });
+														}
+													}
+												}
 												let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_update(&msg));
 
 												if should_forward {

src/ln/router.rs

@@ -426,6 +426,59 @@ impl RoutingMessageHandler for Router {
 
 		Ok(msg.contents.excess_data.is_empty())
 	}
+
+	fn handle_local_channel(&self, msg: &msgs::ChannelUpdate, our_node_id: PublicKey, their_node_id: PublicKey, features: GlobalFeatures) {
+		let were_node_one = our_node_id.serialize()[..] < their_node_id.serialize()[..];
+		let chan_info = ChannelInfo {
+			features: features,
+			one_to_two: DirectionalChannelInfo {
+				src_node_id: if were_node_one { our_node_id } else { their_node_id },
+				last_update: 0,
+				enabled: false,
+				cltv_expiry_delta: u16::max_value(),
+				htlc_minimum_msat: u64::max_value(),
+				fee_base_msat: u32::max_value(),
+				fee_proportional_millionths: u32::max_value(),
+			},
+			two_to_one: DirectionalChannelInfo {
+				src_node_id: if were_node_one { their_node_id } else { our_node_id },
+				last_update: 0,
+				enabled: false,
+				cltv_expiry_delta: u16::max_value(),
+				htlc_minimum_msat: u64::max_value(),
+				fee_base_msat: u32::max_value(),
+				fee_proportional_millionths: u32::max_value(),
+			},
+		};
+
+		let mut network = self.network_map.write().unwrap();
+		match network.channels.entry(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
+			Entry::Occupied(mut entry) => {
+				*entry.get_mut() = chan_info;
+			},
+			Entry::Vacant(entry) => {
+				entry.insert(chan_info);
+			}
+		}
+
+		match network.nodes.entry(their_node_id) {
+			Entry::Occupied(node_entry) => {
+						node_entry.into_mut().channels.push(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash));
+			},
+			Entry::Vacant(node_entry) => {
+				node_entry.insert(NodeInfo {
+					channels: vec!(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)),
+					lowest_inbound_channel_fee_base_msat: u32::max_value(),
+					lowest_inbound_channel_fee_proportional_millionths: u32::max_value(),
+					features: GlobalFeatures::new(),
+					last_update: 0,
+					rgb: [0; 3],
+					alias: [0; 32],
+					addresses: Vec::new(),
+				});
+			}
+		}
+	}
 }
 
 #[derive(Eq, PartialEq)]

src/util/test_utils.rs

@@ -131,6 +131,9 @@ impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
 	fn handle_channel_reestablish(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelReestablish) -> Result<(Option<msgs::FundingLocked>, Option<msgs::RevokeAndACK>, Option<msgs::CommitmentUpdate>), HandleError> {
 		Err(HandleError { err: "", action: None })
 	}
+	fn handle_channel_update(&self, _msg: &msgs::ChannelUpdate) -> bool {
+		false
+	}
 	fn peer_disconnected(&self, _their_node_id: &PublicKey, _no_connection_possible: bool) {}
 	fn peer_connected(&self, _their_node_id: &PublicKey) -> Vec<msgs::ChannelReestablish> {
 		Vec::new()
@@ -166,6 +169,8 @@ impl msgs::RoutingMessageHandler for TestRoutingMessageHandler {
 		Err(HandleError { err: "", action: None })
 	}
 	fn handle_htlc_fail_channel_update(&self, _update: &msgs::HTLCFailChannelUpdate) {}
+
+	fn handle_local_channel(&self, _msg: &msgs::ChannelUpdate, _our_node_id: PublicKey, _their_node_id: PublicKey, _features: msgs::GlobalFeatures) {}
 }
 
 pub struct TestLogger {