Add tests for handling channel announcements

Author: naumenkogs

lightning/src/ln/router.rs

@@ -1057,7 +1057,8 @@ mod tests {
 	use ln::channelmanager;
 	use ln::router::{Router,NodeInfo,NetworkMap,ChannelInfo,DirectionalChannelInfo,RouteHint};
 	use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
-	use ln::msgs::{ErrorAction, LightningError, RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement};
+	use ln::msgs::{ErrorAction, LightningError, RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement,
+	                UnsignedChannelAnnouncement, ChannelAnnouncement};
 	use util::test_utils;
 	use util::test_utils::TestVecWriter;
 	use util::logger::Logger;
@@ -1066,6 +1067,8 @@ mod tests {
 	use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 	use bitcoin_hashes::Hash;
 	use bitcoin::network::constants::Network;
+	use bitcoin::blockdata::constants::genesis_block;
+	use bitcoin::util::hash::BitcoinHash;
 
 	use hex;
 
@@ -1074,6 +1077,7 @@ mod tests {
 	use secp256k1::Secp256k1;
 
 	use std::sync::Arc;
+	use std::collections::btree_map::Entry as BtreeEntry;
 
 	fn create_router() -> (Secp256k1<All>, PublicKey, Router) {
 		let secp_ctx = Secp256k1::new();
@@ -1949,4 +1953,130 @@ mod tests {
 			Err(e) => assert_eq!(e.err, "Update older than last processed update")
 		};
 	}
+
+	#[test]
+	fn handling_channel_announcements() {
+		let (secp_ctx, _, router) = create_router();
+		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);
+		let node_id_2 = PublicKey::from_secret_key(&secp_ctx, node_2_privkey);
+		let node_1_btckey = &SecretKey::from_slice(&[40; 32]).unwrap();
+		let node_2_btckey = &SecretKey::from_slice(&[39; 32]).unwrap();
+
+		let mut 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 channel_key = NetworkMap::get_key(unsigned_announcement.short_channel_id,
+						    unsigned_announcement.chain_hash);
+
+		let mut 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(),
+		};
+
+		// So the channel doesn't exist on chain here. Lookup returns ChainError::NotSupported
+		// instead of UnknownTx, chain lookup seems to be not implemented yet.
+	 	// match router.handle_channel_announcement(&valid_announcement) {
+		// 	Ok(_) => panic!(),
+		// Err(e) => assert_eq!(e.err, "Channel announced without corresponding UTXO entry")
+		// };
+
+
+	 	match router.handle_channel_announcement(&valid_announcement) {
+			Ok(res) => assert!(res),
+			_ => panic!()
+		};
+		{
+			let mut network = router.network_map.write().unwrap();
+			match network.nodes.entry(node_id_1) {
+				BtreeEntry::Occupied(node_entry) => {
+					assert_eq!(node_entry.into_mut().channels[0], channel_key);
+				},
+				_ => panic!()
+			}
+			match network.nodes.entry(node_id_2) {
+				BtreeEntry::Occupied(node_entry) => {
+					assert_eq!(node_entry.into_mut().channels[0], channel_key);
+				},
+				_ => panic!()
+			}
+		}
+
+	 	match router.handle_channel_announcement(&valid_announcement) {
+			Ok(_) => panic!(),
+			Err(e) => assert_eq!(e.err, "Already have knowledge of channel")
+		};
+
+		unsigned_announcement.short_channel_id += 1;
+
+		unsigned_announcement.excess_data.push(1);
+		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(),
+		};
+		// Returns false because contains excess data.
+	 	match router.handle_channel_announcement(&valid_announcement) {
+			Ok(res) => assert!(!res),
+			_ => panic!()
+		};
+		unsigned_announcement.excess_data = Vec::new();
+
+		let invalid_sig_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_1_btckey),
+			contents: unsigned_announcement.clone(),
+		};
+	 	match router.handle_channel_announcement(&invalid_sig_announcement) {
+			Ok(_) => panic!(),
+			Err(e) => assert_eq!(e.err, "Invalid signature from remote node")
+		};
+
+		unsigned_announcement.chain_hash = genesis_block(Network::Regtest).header.bitcoin_hash();
+		msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
+		let invalid_chainhash_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(),
+		};
+	 	match router.handle_channel_announcement(&invalid_chainhash_announcement) {
+			Ok(_) => panic!(),
+			Err(e) => assert_eq!(e.err, "Channel announced on an unknown chain")
+		};
+		unsigned_announcement.chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
+
+		unsigned_announcement.node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_2_privkey);
+		msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
+		let channel_to_itself_announcement = ChannelAnnouncement {
+			node_signature_1: secp_ctx.sign(&msghash, node_1_privkey),
+			node_signature_2: secp_ctx.sign(&msghash, node_1_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(),
+		};
+	 	match router.handle_channel_announcement(&channel_to_itself_announcement) {
+			Ok(_) => panic!(),
+			Err(e) => assert_eq!(e.err, "Channel announcement node had a channel with itself")
+		};
+	}
 }