Remove mutable accessors from NetworkGraph

Author: naumenkogs

lightning/src/routing/network_graph.rs

@@ -441,7 +441,6 @@ impl Readable for NodeInfo {
 #[derive(PartialEq)]
 pub struct NetworkGraph {
 	channels: BTreeMap<u64, ChannelInfo>,
-	/// A set of known Lightning nodes and their properties
 	nodes: BTreeMap<PublicKey, NodeInfo>,
 }
 
@@ -501,20 +500,8 @@ impl std::fmt::Display for NetworkGraph {
 impl NetworkGraph {
 	/// Returns a list of known valid channels
 	pub fn get_channels<'a>(&'a self) -> &'a BTreeMap<u64, ChannelInfo> { &self.channels }
-	/// Returns a mutable reference to an existing channel
-	pub fn get_channel_mut<'a>(&'a mut self, chan_id: &u64) -> Option<&mut ChannelInfo> { self.channels.get_mut(chan_id) }
-	/// Store a valid channel
-	pub fn add_channel(&mut self, chan_id: u64, channel_info: ChannelInfo) {
-		self.channels.insert(chan_id, channel_info);
-	}
 	/// Returns a list of known nodes
 	pub fn get_nodes<'a>(&'a self) -> &'a BTreeMap<PublicKey, NodeInfo> { &self.nodes }
-	/// Returns a mutable reference to an existing node
-	pub fn get_node_mut<'a>(&'a mut self, node_id: &PublicKey) -> Option<&mut NodeInfo> { self.nodes.get_mut(node_id) }
-	/// Store a valid node
-	pub fn add_node(&mut self, node_id: PublicKey, node_info: NodeInfo) {
-		self.nodes.insert(node_id, node_info);
-	}
 
 	fn process_node_announcement(&mut self, msg: &msgs::NodeAnnouncement) -> Result<bool, LightningError> {
 		match self.nodes.get_mut(&msg.contents.node_id) {
@@ -756,7 +743,7 @@ impl NetworkGraph {
 mod tests {
 	use chain::chaininterface;
 	use ln::features::{ChannelFeatures, NodeFeatures};
-	use routing::network_graph::{NetGraphMsgHandler, NetworkGraph, DirectionalChannelInfo, ChannelInfo, NodeInfo, RoutingFees};
+	use routing::network_graph::{NetGraphMsgHandler, NetworkGraph};
 	use ln::msgs::{RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement,
 	   UnsignedChannelAnnouncement, ChannelAnnouncement, UnsignedChannelUpdate, ChannelUpdate, HTLCFailChannelUpdate};
 	use util::test_utils;
@@ -1560,60 +1547,69 @@ mod tests {
 
 	#[test]
 	fn network_graph_serialization() {
-		let (secp_ctx, our_id, net_graph_msg_handler) = create_net_graph_msg_handler();
-		let node1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
-		let node1 = PublicKey::from_secret_key(&secp_ctx, node1_privkey);
+		let (secp_ctx, _, net_graph_msg_handler) = create_net_graph_msg_handler();
 
-		let mut network = net_graph_msg_handler.network_graph.write().unwrap();
-		let zero_hash = Sha256dHash::hash(&[0; 32]);
+		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
+		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
+		let node_1_btckey = &SecretKey::from_slice(&[40; 32]).unwrap();
+		let node_2_btckey = &SecretKey::from_slice(&[39; 32]).unwrap();
 
+		// Announce a channel to add a corresponding node.
+		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 unsigned_announcement = UnsignedChannelAnnouncement {
+			features: ChannelFeatures::supported(),
+			chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
+			short_channel_id: 0,
+			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 node_routing_fees = RoutingFees {
-			base_msat: 100,
-			proportional_millionths: 0,
+		let msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
+		let valid_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(),
 		};
-		network.add_node(node1.clone(), NodeInfo {
-			channels: vec!(1, 3),
-			lowest_inbound_channel_fees: Some(node_routing_fees),
+		match net_graph_msg_handler.handle_channel_announcement(&valid_announcement) {
+			Ok(res) => assert!(res),
+			_ => panic!()
+		};
+
+
+		let node_id = PublicKey::from_secret_key(&secp_ctx, node_1_privkey);
+		let unsigned_announcement = UnsignedNodeAnnouncement {
 			features: NodeFeatures::supported(),
-			last_update: Some(1),
+			timestamp: 100,
+			node_id,
 			rgb: [0; 3],
 			alias: [0; 32],
 			addresses: Vec::new(),
-			announcement_message: None,
-		});
-		network.add_channel(1, ChannelInfo {
-			features: ChannelFeatures::supported(),
-			one_to_two: DirectionalChannelInfo {
-				src_node_id: our_id.clone(),
-				last_update: 0,
-				enabled: false,
-				cltv_expiry_delta: u16::max_value(),
-				htlc_minimum_msat: 0,
-				fees: RoutingFees {
-					base_msat: u32::max_value(),
-					proportional_millionths: u32::max_value(),
-				},
-				last_update_message: None,
-			}, two_to_one: DirectionalChannelInfo {
-				src_node_id: node1.clone(),
-				last_update: 0,
-				enabled: true,
-				cltv_expiry_delta: 0,
-				htlc_minimum_msat: 0,
-				fees: RoutingFees {
-					base_msat: u32::max_value(),
-					proportional_millionths: u32::max_value(),
-				},
-				last_update_message: None,
-			},
-			announcement_message: None,
-		});
+			excess_address_data: Vec::new(),
+			excess_data: Vec::new(),
+		};
+		let msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
+		let valid_announcement = NodeAnnouncement {
+			signature: secp_ctx.sign(&msghash, node_1_privkey),
+			contents: unsigned_announcement.clone()
+		};
+
+		match net_graph_msg_handler.handle_node_announcement(&valid_announcement) {
+			Ok(_) => (),
+			Err(_) => panic!()
+		};
 
+		let network = net_graph_msg_handler.network_graph.write().unwrap();
 		let mut w = test_utils::TestVecWriter(Vec::new());
 		assert!(!network.channels.is_empty());
 		assert!(!network.nodes.is_empty());
 		network.write(&mut w).unwrap();
 		assert!(<NetworkGraph>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap() == *network);
 	}
+
 }