Added update channel

Added hashmap to keep track of sent syncs

Author: SWvheerden

src/ln/msgs.rs

@@ -563,19 +563,15 @@ 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);
-}
-
-///A trait to describe the functions required to access the local network topology
-pub trait NetworkTopology : Send + Sync {
 	///This should return a vec of all possible channel announcements or an error
-	fn get_all_channel_announcements(&self)-> Result<Vec<ChannelAnnouncement>, std::fmt::Error>;
+	fn get_all_channel_announcements(&self)-> Result<Vec<(ChannelAnnouncement,ChannelUpdate)>, std::fmt::Error>;
 	///This should return a vec of all possible node announcements or an error
 	fn get_all_node_announcements(&self)-> Result<Vec<NodeAnnouncement>, std::fmt::Error>;
 }
 
-///this is a combination trait of NetworkTopology and RoutingMerssageHandler
-pub trait NetworkAPI : RoutingMessageHandler + NetworkTopology{}
-impl<T> NetworkAPI for T where T: RoutingMessageHandler+NetworkTopology{}
+
+
+
 
 pub(crate) struct OnionRealm0HopData {
 	pub(crate) short_channel_id: u64,

src/ln/peer_handler.rs

@@ -27,7 +27,7 @@ pub struct MessageHandler {
 	pub chan_handler: Arc<msgs::ChannelMessageHandler>,
 	/// A message handler which handles messages updating our knowledge of the network channel
 	/// graph. Usually this is just a Router object.
-	pub route_handler: Arc<msgs::NetworkAPI>,
+	pub route_handler: Arc<msgs::RoutingMessageHandler>,
 }
 
 /// Provides an object which can be used to send data to and which uniquely identifies a connection
@@ -131,6 +131,7 @@ pub struct PeerManager<Descriptor: SocketDescriptor> {
 	our_node_secret: SecretKey,
 	initial_syncs_sent: AtomicUsize,
 	logger: Arc<Logger>,
+	sent_network_sync_info : HashMap<PublicKey,bool>,
 }
 
 struct VecWriter(Vec<u8>);
@@ -168,6 +169,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 			our_node_secret: our_node_secret,
 			initial_syncs_sent: AtomicUsize::new(0),
 			logger,
+			sent_network_sync_info: HashMap::new(),
 		}
 	}
 
@@ -312,7 +314,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 	/// course of this function!
 	///
 	/// Panics if the descriptor was not previously registered in a new_*_connection event.
-	pub fn read_event(&self, peer_descriptor: &mut Descriptor, data: Vec<u8>) -> Result<bool, PeerHandleError> {
+	pub fn read_event(&mut self, peer_descriptor: &mut Descriptor, data: Vec<u8>) -> Result<bool, PeerHandleError> {
 		match self.do_read_event(peer_descriptor, data) {
 			Ok(res) => Ok(res),
 			Err(e) => {
@@ -322,7 +324,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 		}
 	}
 
-	fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: Vec<u8>) -> Result<bool, PeerHandleError> {
+	fn do_read_event(&mut self, peer_descriptor: &mut Descriptor, data: Vec<u8>) -> Result<bool, PeerHandleError> {
 		let pause_read = {
 			let mut peers_lock = self.peers.lock().unwrap();
 			let peers = peers_lock.borrow_parts();
@@ -515,13 +517,24 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 													if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
 														self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
 														local_features.set_initial_routing_sync();
-														let channel_messages = self.message_handler.route_handler.get_all_channel_announcements().unwrap();
-														let node_messages = self.message_handler.route_handler.get_all_node_announcements().unwrap();
-														for message in channel_messages.iter(){
-															encode_and_send_msg!(message, 256);
-														}
-														for message in node_messages.iter(){
-															encode_and_send_msg!(message, 257);
+														if let Some(i) = peer.their_node_id{
+															let their_id = i;
+															if self.sent_network_sync_info.contains_key(&their_id){
+																let channel_messages_tuple = self.message_handler.route_handler.get_all_channel_announcements().unwrap();
+																let channel_announcements:Vec<msgs::ChannelAnnouncement> = channel_messages_tuple.clone().into_iter().map(|x| { x.0 }).collect();
+																let channel_updates:Vec<msgs::ChannelUpdate> = channel_messages_tuple.into_iter().map(|x| { x.1 }).collect();
+																let node_messages = self.message_handler.route_handler.get_all_node_announcements().unwrap();
+																for message in channel_announcements.iter(){
+																	encode_and_send_msg!(message, 256);
+																}
+																for message in channel_updates.iter(){
+																	encode_and_send_msg!(message, 256);
+																}
+																for message in node_messages.iter(){
+																	encode_and_send_msg!(message, 257);
+																}
+																self.sent_network_sync_info.insert(their_id,true);
+															}
 														}
 													}
 													encode_and_send_msg!(msgs::Init {

src/ln/router.rs

@@ -13,7 +13,8 @@ use bitcoin::blockdata::opcodes;
 
 use chain::chaininterface::{ChainError, ChainWatchInterface};
 use ln::channelmanager;
-use ln::msgs::{ErrorAction,HandleError,RoutingMessageHandler,NetAddress,GlobalFeatures,NetworkTopology};
+
+use ln::msgs::{ErrorAction,HandleError,RoutingMessageHandler,NetAddress,GlobalFeatures};
 use ln::msgs;
 use util::ser::Writeable;
 use util::logger::Logger;
@@ -71,6 +72,7 @@ struct ChannelInfo {
 	two_to_one: DirectionalChannelInfo,
 	//this is cached here so we can send out it later if required by route_init_sync
 	announcement_message : Option<msgs::ChannelAnnouncement>,
+	last_update_message : Option<msgs::ChannelUpdate>,
 }
 
 impl std::fmt::Display for ChannelInfo {
@@ -298,6 +300,7 @@ impl RoutingMessageHandler for Router {
 					bitcoin_key : msg.contents.bitcoin_key_2.clone(),
 				},
 				announcement_message : Some(msg.clone()),
+				last_update_message : None,
 			};
 
 		match network.channels.entry(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
@@ -392,6 +395,7 @@ impl RoutingMessageHandler for Router {
 					}
 				}
 
+				channel.last_update_message = Some(msg.clone());
 				let msg_hash = Message::from_slice(&Sha256dHash::from_data(&msg.contents.encode()[..])[..]).unwrap();
 				if msg.contents.flags & 1 == 1 {
 					dest_node_id = channel.one_to_two.src_node_id.clone();
@@ -436,42 +440,18 @@ impl RoutingMessageHandler for Router {
 
 		Ok(msg.contents.excess_data.is_empty())
 	}
-}
-
-impl NetworkTopology for Router {
-	fn get_all_channel_announcements(&self)-> Result<Vec<msgs::ChannelAnnouncement>, std::fmt::Error>{
+	fn get_all_channel_announcements(&self)-> Result<Vec<(msgs::ChannelAnnouncement, msgs::ChannelUpdate)>, std::fmt::Error>{
 		let mut result = Vec::new();
 		let network = self.network_map.read().unwrap();
 		for (key, value) in network.channels.iter(){
 			if let Some(ref i) = value.announcement_message{
-			result.push(i.clone());
+				if let Some(ref j) = value.last_update_message{
+					let temp_tuple = (i.clone(),j.clone());
+					result.push(temp_tuple);
+				}
 			}
 		}
 		return Ok(result)
-	/*	#[cfg(not(feature = "non_bitcoin_chain_hash_routing"))]
-		return Ok(Vec::new());
-		#[cfg(feature = "non_bitcoin_chain_hash_routing")]{
-		let result = Vec::new();
-		let network = self.network_map.read().unwrap();
-		for (key, value) in network.channels.iter(){
-			let (id, chainhash) = key;
-			let msg_contents = msgs::UnsignedChannelAnnouncement {
-				features: value.features.clone(),
-				chain_hash: chainhash,
-				short_channel_id: id.clone(),
-				node_id_1: value.one_to_two.src_node_id.clone(),
-				node_id_2: value.two_to_one.src_node_id.clone(),
-				bitcoin_key_1: value.one_to_two.bitcoin_key.clone(),
-				bitcoin_key_2: value.two_to_one.bitcoin_key.clone(),
-				excess_data: Vec::new()};
-			let msg_hash = Message::from_slice(&Sha256dHash::from_data(&msg_contents.encode()[..])[..]).unwrap();
-			let msg_signature = self.secp_ctx.sign(&msg_hash, key);
-			result.push(msgs::ChannelAnnouncement {
-				signature: msg_signature,
-				contents: msg_contents,
-			})
-		}
-		return Ok(result)}*/
 	}
 	///This function generates a vec of all node_annoucment messages for all nodes it known of
 	fn get_all_node_announcements(&self)-> Result<Vec<msgs::NodeAnnouncement>, std::fmt::Error>{
@@ -481,25 +461,11 @@ impl NetworkTopology for Router {
 			if let Some(ref i) = value.announcement_message{
 				result.push(i.clone());
 			}
-			/*let msg_contents = msgs::UnsignedNodeAnnouncement{
-							features: value.features.clone(),
-							timestamp: value.last_update,
-							node_id: key.clone(),
-							rgb: value.rgb.clone(),
-							alias: value.alias.clone(),
-							addresses: value.addresses.clone(),
-							excess_address_data: Vec::new(),
-							excess_data: Vec::new(),};
-			let msg_hash = Message::from_slice(&Sha256dHash::from_data(&msg_contents.encode()[..])[..]).unwrap();
-			let msg_signature = self.secp_ctx.sign(&msg_hash, key);
-			result.push(msgs::NodeAnnouncement {
-				signature: msg_signature,
-				contents: msg_contents,
-			})*/
 		}
 		Ok(result)
 	}
 }
+
 #[derive(Eq, PartialEq)]
 struct RouteGraphNode {
 	pubkey: PublicKey,