Implement local channel tracking by Router at channel_update

Add test_channel_update_local_channel

Issue #149

Author: Antoine Riard

src/ln/channelmanager.rs

@@ -2722,6 +2722,22 @@ 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) -> Option<ChannelDetails> {
+		let channel_state = self.channel_state.lock().unwrap();
+		if let Some(channel_id) = channel_state.short_to_id.get(&msg.contents.short_channel_id) {
+			if let Some(channel) = channel_state.by_id.get(channel_id) {
+				return Some(ChannelDetails {
+					channel_id: channel_id.clone(),
+					short_channel_id: channel.get_short_channel_id(),
+					remote_network_id: channel.get_their_node_id(),
+					channel_value_satoshis: channel.get_value_satoshis(),
+					user_id: channel.get_user_id(),
+				});
+			}
+		}
+		None
+	}
+
 	fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool) {
 		let _ = self.total_consistency_lock.read().unwrap();
 		let mut failed_channels = Vec::new();
@@ -7532,4 +7548,17 @@ mod tests {
 			assert_eq!(msg.channel_id, channel_id);
 		} else { panic!("Unexpected result"); }
 	}
+
+	#[test]
+	fn test_channel_update_local_channel() {
+		let nodes = create_network(2);
+
+		let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
+
+		if let Some(_) = 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

@@ -21,6 +21,8 @@ use secp256k1;
 use bitcoin::util::hash::Sha256dHash;
 use bitcoin::blockdata::script::Script;
 
+use ln::channelmanager::ChannelDetails;
+
 use std::error::Error;
 use std::{cmp, fmt};
 use std::io::Read;
@@ -559,6 +561,8 @@ pub trait ChannelMessageHandler : events::MessageSendEventsProvider + Send + Syn
 	// 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) -> Option<ChannelDetails>;
 
 	// Connection loss/reestablish:
 	/// Indicates a connection to the peer failed/an existing connection was lost. If no connection
@@ -598,6 +602,8 @@ pub trait RoutingMessageHandler : Send + Sync {
 	/// starting at the node *after* the provided publickey and including batch_amount entries.
 	/// If None is provided for starting_point, we start at the first node.
 	fn get_next_node_announcements(&self, starting_point: Option<&PublicKey>, batch_amount: u8) -> Vec<NodeAnnouncement>;
+	/// 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};
@@ -744,8 +745,11 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 											},
 											258 => {
 												let msg = try_potential_decodeerror!(msgs::ChannelUpdate::read(&mut reader));
+												if let Some(chan) = self.message_handler.chan_handler.handle_channel_update(&msg) {
+													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, chan.remote_network_id, msgs::GlobalFeatures::new());
+												}
 												let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_update(&msg));
-
 												if should_forward {
 													// TODO: forward msg along to all our other peers!
 												}

src/ln/router.rs

@@ -492,7 +492,6 @@ impl RoutingMessageHandler for Router {
 		Ok(msg.contents.excess_data.is_empty())
 	}
 
-
 	fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(msgs::ChannelAnnouncement, msgs::ChannelUpdate,msgs::ChannelUpdate)> {
 		let mut result = Vec::with_capacity(batch_amount as usize);
 		let network = self.network_map.read().unwrap();
@@ -537,6 +536,63 @@ impl RoutingMessageHandler for Router {
 		}
 		result
 	}
+
+	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(),
+				last_update_message: None,
+			},
+			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(),
+				last_update_message: None,
+			},
+			announcement_message: None,
+		};
+
+		let mut network = self.network_map.write().unwrap();
+		match network.channels.entry(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
+			BtreeEntry::Occupied(mut entry) => {
+				*entry.get_mut() = chan_info;
+			},
+			BtreeEntry::Vacant(entry) => {
+				entry.insert(chan_info);
+			}
+		}
+
+		match network.nodes.entry(their_node_id) {
+			BtreeEntry::Occupied(node_entry) => {
+						node_entry.into_mut().channels.push(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash));
+			},
+			BtreeEntry::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(),
+					announcement_message: None,
+				});
+			}
+		}
+	}
 }
 
 #[derive(Eq, PartialEq)]

src/util/test_utils.rs

@@ -1,6 +1,7 @@
 use chain::chaininterface;
 use chain::chaininterface::ConfirmationTarget;
 use chain::transaction::OutPoint;
+use ln::channelmanager::ChannelDetails;
 use ln::channelmonitor;
 use ln::msgs;
 use ln::msgs::{HandleError};
@@ -136,6 +137,9 @@ impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
 	fn handle_channel_reestablish(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelReestablish) -> Result<(), HandleError> {
 		Err(HandleError { err: "", action: None })
 	}
+	fn handle_channel_update(&self, _msg: &msgs::ChannelUpdate) -> Option<ChannelDetails> {
+		None
+	}
 	fn peer_disconnected(&self, _their_node_id: &PublicKey, _no_connection_possible: bool) {}
 	fn peer_connected(&self, _their_node_id: &PublicKey) {}
 	fn handle_error(&self, _their_node_id: &PublicKey, _msg: &msgs::ErrorMessage) {}
@@ -174,6 +178,7 @@ impl msgs::RoutingMessageHandler for TestRoutingMessageHandler {
 	fn get_next_node_announcements(&self, _starting_point: Option<&PublicKey>, _batch_amount: u8) -> Vec<msgs::NodeAnnouncement> {
 		Vec::new()
 	}
+	fn handle_local_channel(&self, _msg: &msgs::ChannelUpdate, _our_node_id: PublicKey, _their_node_id: PublicKey, _features: msgs::GlobalFeatures) {}
 }
 
 pub struct TestLogger {