Drop out_node from NetGraphMsgHandler::new

Author: naumenkogs

fuzz/src/full_stack.rs

@@ -336,7 +336,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 	config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
 	let channelmanager = Arc::new(ChannelManager::new(Network::Bitcoin, fee_est.clone(), monitor.clone(), broadcast.clone(), Arc::clone(&logger), keys_manager.clone(), config, 0).unwrap());
 	let our_id = PublicKey::from_secret_key(&Secp256k1::signing_only(), &keys_manager.get_node_secret());
-	let net_graph_msg_handler = Arc::new(NetGraphMsgHandler::new(our_id, watch.clone(), Arc::clone(&logger)));
+	let net_graph_msg_handler = Arc::new(NetGraphMsgHandler::new(watch.clone(), Arc::clone(&logger)));
 
 	let peers = RefCell::new([false; 256]);
 	let mut loss_detector = MoneyLossDetector::new(&peers, channelmanager.clone(), monitor.clone(), PeerManager::new(MessageHandler {

fuzz/src/router.rs

@@ -157,7 +157,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 	});
 
 	let our_pubkey = get_pubkey!();
-	let net_graph_msg_handler = NetGraphMsgHandler::new(our_pubkey.clone(), chain_monitor, Arc::clone(&logger));
+	let net_graph_msg_handler = NetGraphMsgHandler::new(chain_monitor, Arc::clone(&logger));
 
 	loop {
 		match get_slice!(1)[0] {

lightning/src/ln/functional_test_utils.rs

@@ -1108,7 +1108,7 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeC
 		let block_notifier = chaininterface::BlockNotifier::new(cfgs[i].chain_monitor.clone());
 		block_notifier.register_listener(&cfgs[i].chan_monitor.simple_monitor as &chaininterface::ChainListener);
 		block_notifier.register_listener(&chan_mgrs[i] as &chaininterface::ChainListener);
-		let net_graph_msg_handler = NetGraphMsgHandler::new(PublicKey::from_secret_key(&secp_ctx, &cfgs[i].keys_manager.get_node_secret()), cfgs[i].chain_monitor.clone(), cfgs[i].logger.clone() as Arc<Logger>);
+		let net_graph_msg_handler = NetGraphMsgHandler::new(cfgs[i].chain_monitor.clone(), cfgs[i].logger.clone() as Arc<Logger>);
 		nodes.push(Node{ chain_monitor: cfgs[i].chain_monitor.clone(), block_notifier,
 										 tx_broadcaster: cfgs[i].tx_broadcaster, chan_monitor: &cfgs[i].chan_monitor,
 										 keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i], net_graph_msg_handler,

lightning/src/routing/network_graph.rs

@@ -35,23 +35,12 @@ pub struct NetGraphMsgHandler {
 
 impl NetGraphMsgHandler {
 	/// Creates a new tracker of the actual state of the network of channels and nodes.
-	pub fn new(our_pubkey: PublicKey, chain_monitor: Arc<ChainWatchInterface>, logger: Arc<Logger>) -> Self {
-		let mut nodes = BTreeMap::new();
-		nodes.insert(our_pubkey.clone(), NodeInfo {
-			channels: Vec::new(),
-			lowest_inbound_channel_fees: None,
-			features: NodeFeatures::empty(),
-			last_update: None,
-			rgb: [0; 3],
-			alias: [0; 32],
-			addresses: Vec::new(),
-			announcement_message: None,
-		});
+	pub fn new(chain_monitor: Arc<ChainWatchInterface>, logger: Arc<Logger>) -> Self {
 		NetGraphMsgHandler {
 			secp_ctx: Secp256k1::verification_only(),
 			network_graph: RwLock::new(NetworkGraph {
 				channels: BTreeMap::new(),
-				nodes: nodes,
+				nodes: BTreeMap::new(),
 			}),
 			full_syncs_requested: AtomicUsize::new(0),
 			chain_monitor,
@@ -766,18 +755,17 @@ mod tests {
 
 	use std::sync::Arc;
 
-	fn create_net_graph_msg_handler() -> (Secp256k1<All>, PublicKey, NetGraphMsgHandler) {
+	fn create_net_graph_msg_handler() -> (Secp256k1<All>, NetGraphMsgHandler) {
 		let secp_ctx = Secp256k1::new();
-		let our_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap());
 		let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::new());
 		let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger)));
-		let net_graph_msg_handler = NetGraphMsgHandler::new(our_id, chain_monitor, Arc::clone(&logger));
-		(secp_ctx, our_id, net_graph_msg_handler)
+		let net_graph_msg_handler = NetGraphMsgHandler::new(chain_monitor, Arc::clone(&logger));
+		(secp_ctx, net_graph_msg_handler)
 	}
 
 	#[test]
 	fn request_full_sync_finite_times() {
-		let (secp_ctx, _, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
 		let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()[..]).unwrap());
 
 		assert!(net_graph_msg_handler.should_request_full_sync(&node_id));
@@ -790,7 +778,7 @@ mod tests {
 
 	#[test]
 	fn handling_node_announcements() {
-		let (secp_ctx, _, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
 
 		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
@@ -895,11 +883,9 @@ mod tests {
 	#[test]
 	fn handling_channel_announcements() {
 		let secp_ctx = Secp256k1::new();
-		let our_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(
-		   &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap());
 		let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::new());
 		let chain_monitor = Arc::new(test_utils::TestChainWatcher::new());
-		let net_graph_msg_handler = NetGraphMsgHandler::new(our_id, chain_monitor.clone(), Arc::clone(&logger));
+		let net_graph_msg_handler = NetGraphMsgHandler::new(chain_monitor.clone(), Arc::clone(&logger));
 
 
 		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
@@ -1084,7 +1070,7 @@ mod tests {
 
 	#[test]
 	fn handling_channel_update() {
-		let (secp_ctx, _, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
 		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
 		let node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_1_privkey);
@@ -1213,7 +1199,7 @@ mod tests {
 
 	#[test]
 	fn handling_htlc_fail_channel_update() {
-		let (secp_ctx, our_id, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
 		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
 		let node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_1_privkey);
@@ -1225,10 +1211,9 @@ mod tests {
 		let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
 
 		{
-			// There is only local node in the table at the beginning.
+			// There is no nodes in the table at the beginning.
 			let network = net_graph_msg_handler.network_graph.read().unwrap();
-			assert_eq!(network.get_nodes().len(), 1);
-			assert_eq!(network.get_nodes().contains_key(&our_id), true);
+			assert_eq!(network.get_nodes().len(), 0);
 		}
 
 		{
@@ -1290,16 +1275,14 @@ mod tests {
 			let network = net_graph_msg_handler.network_graph.read().unwrap();
 			assert_eq!(network.get_channels().len(), 0);
 			// Nodes are also deleted because there are no associated channels anymore
-			// Only the local node remains in the table.
-			assert_eq!(network.get_nodes().len(), 1);
-			assert_eq!(network.get_nodes().contains_key(&our_id), true);
+			assert_eq!(network.get_nodes().len(), 0);
 		}
 		// TODO: Test HTLCFailChannelUpdate::NodeFailure, which is not implemented yet.
 	}
 
 	#[test]
 	fn getting_next_channel_announcements() {
-		let (secp_ctx, _, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
 		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
 		let node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_1_privkey);
@@ -1431,7 +1414,7 @@ mod tests {
 
 	#[test]
 	fn getting_next_node_announcements() {
-		let (secp_ctx, _, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
 		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
 		let node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_1_privkey);
@@ -1548,7 +1531,7 @@ mod tests {
 
 	#[test]
 	fn network_graph_serialization() {
-		let (secp_ctx, _, net_graph_msg_handler) = create_net_graph_msg_handler();
+		let (secp_ctx, net_graph_msg_handler) = create_net_graph_msg_handler();
 
 		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();

lightning/src/routing/router.rs

@@ -490,7 +490,7 @@ mod tests {
 		let our_id = PublicKey::from_secret_key(&secp_ctx, our_privkey);
 		let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::new());
 		let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger)));
-		let net_graph_msg_handler = NetGraphMsgHandler::new(our_id, chain_monitor, Arc::clone(&logger));
+		let net_graph_msg_handler = NetGraphMsgHandler::new(chain_monitor, Arc::clone(&logger));
 		// Build network from our_id to node8:
 		//
 		//        -1(1)2-  node1  -1(3)2-