Add tests for handling channel updates

Author: naumenkogs

lightning/src/ln/router.rs

@@ -1058,7 +1058,7 @@ mod tests {
 	use ln::router::{Router,NodeInfo,NetworkMap,ChannelInfo,DirectionalChannelInfo,RouteHint};
 	use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
 	use ln::msgs::{ErrorAction, LightningError, RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement,
-	                UnsignedChannelAnnouncement, ChannelAnnouncement};
+	                UnsignedChannelAnnouncement, ChannelAnnouncement, UnsignedChannelUpdate, ChannelUpdate};
 	use util::test_utils;
 	use util::test_utils::TestVecWriter;
 	use util::logger::Logger;
@@ -2079,4 +2079,154 @@ mod tests {
 			Err(e) => assert_eq!(e.err, "Channel announcement node had a channel with itself")
 		};
 	}
+
+	#[test]
+	fn handling_channel_update() {
+		let (secp_ctx, _, router) = create_router();
+		let secret_key = &SecretKey::from_slice(&hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()[..]).unwrap();
+		let public_key = PublicKey::from_secret_key(&secp_ctx, secret_key);
+
+		let zero_hash = Sha256dHash::hash(&[0; 32]);
+		let channel_id = 0;
+		let channel_time = 100;
+		let channel_key = NetworkMap::get_key(channel_id, genesis_block(Network::Testnet).header.bitcoin_hash());
+
+		{
+			let mut network = router.network_map.write().unwrap();
+			network.channels.insert(channel_key, ChannelInfo {
+				features: ChannelFeatures::empty(),
+				one_to_two: DirectionalChannelInfo {
+					src_node_id: public_key.clone(),
+					last_update: channel_time,
+					enabled: false,
+					cltv_expiry_delta: u16::max_value(),
+					htlc_minimum_msat: 0,
+					fee_base_msat: u32::max_value(),
+					fee_proportional_millionths: u32::max_value(),
+					last_update_message: None,
+				}, two_to_one: DirectionalChannelInfo {
+					src_node_id: public_key.clone(),
+					last_update: channel_time,
+					enabled: true,
+					cltv_expiry_delta: 0,
+					htlc_minimum_msat: 0,
+					fee_base_msat: u32::max_value(),
+					fee_proportional_millionths: 0,
+					last_update_message: None,
+				},
+				announcement_message: None,
+			});
+		}
+
+		let mut unsigned_channel_update = UnsignedChannelUpdate {
+			chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
+			short_channel_id: channel_id,
+			timestamp: channel_time + 100,
+			flags: 0,
+			cltv_expiry_delta: 144,
+			htlc_minimum_msat: 1000000,
+			fee_base_msat: 10000,
+			fee_proportional_millionths: 20,
+			excess_data: Vec::new()
+		};
+		let mut msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_channel_update.encode()[..])[..]);
+		let valid_channel_update = ChannelUpdate {
+			signature: secp_ctx.sign(&msghash, secret_key),
+			contents: unsigned_channel_update.clone()
+		};
+
+		// TODO: local node (not test) causes panic because remote node does not exist.
+		// Should this be handled?
+	 	// match router.handle_channel_update(&valid_channel_update) {
+		// 	Ok(res) => assert!(res),
+		// 	Err(e) => {
+		// 		println!("{}", e.err);
+		// 		panic!();
+		// 	}
+		// };
+
+		{
+			let mut network = router.network_map.write().unwrap();
+			network.nodes.insert(public_key.clone(), NodeInfo {
+				channels: vec!(channel_key),
+				lowest_inbound_channel_fee_base_msat: u32::max_value(),
+				lowest_inbound_channel_fee_proportional_millionths: 0,
+				features: NodeFeatures::empty(),
+				last_update: Some(1),
+				rgb: [0; 3],
+				alias: [0; 32],
+				addresses: Vec::new(),
+				announcement_message: None,
+			});
+		}
+
+	 	match router.handle_channel_update(&valid_channel_update) {
+			Ok(res) => assert!(res),
+			_ => panic!()
+		};
+
+		{
+			let mut network = router.network_map.write().unwrap();
+			match network.channels.get_mut(&channel_key) {
+				None => panic!(),
+				Some(channel_info) => {
+					assert_eq!(channel_info.one_to_two.cltv_expiry_delta, 144);
+					assert_eq!(channel_info.two_to_one.cltv_expiry_delta, 0);
+				}
+			}
+			let node = network.nodes.get_mut(&public_key).unwrap();
+			assert_eq!(node.lowest_inbound_channel_fee_base_msat, 10000);
+		}
+
+		unsigned_channel_update.timestamp += 100;
+		unsigned_channel_update.excess_data.push(1);
+		msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_channel_update.encode()[..])[..]);
+		let valid_channel_update = ChannelUpdate {
+			signature: secp_ctx.sign(&msghash, secret_key),
+			contents: unsigned_channel_update.clone()
+		};
+		// Return false because contains excess data
+	 	match router.handle_channel_update(&valid_channel_update) {
+			Ok(res) => assert!(!res),
+			_ => panic!()
+		};
+
+		unsigned_channel_update.short_channel_id += 1;
+		msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_channel_update.encode()[..])[..]);
+		let valid_channel_update = ChannelUpdate {
+			signature: secp_ctx.sign(&msghash, secret_key),
+			contents: unsigned_channel_update.clone()
+		};
+
+	 	match router.handle_channel_update(&valid_channel_update) {
+			Ok(_) => panic!(),
+			Err(e) => assert_eq!(e.err, "Couldn't find channel for update")
+		};
+		unsigned_channel_update.short_channel_id = channel_id;
+
+		unsigned_channel_update.timestamp = 0;
+		msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_channel_update.encode()[..])[..]);
+		let valid_channel_update = ChannelUpdate {
+			signature: secp_ctx.sign(&msghash, secret_key),
+			contents: unsigned_channel_update.clone()
+		};
+
+	 	match router.handle_channel_update(&valid_channel_update) {
+			Ok(_) => panic!(),
+			Err(e) => assert_eq!(e.err, "Update older than last processed update")
+		};
+		unsigned_channel_update.timestamp = channel_time;
+
+		let fake_msghash = hash_to_message!(&zero_hash);
+		let invalid_sig_channel_update = ChannelUpdate {
+			signature: secp_ctx.sign(&fake_msghash, secret_key),
+			contents: unsigned_channel_update.clone()
+		};
+
+	 	match router.handle_channel_update(&invalid_sig_channel_update) {
+			Ok(_) => panic!(),
+			Err(e) => assert_eq!(e.err, "Invalid signature from remote node")
+		};
+
+	}
 }