Add bolt7 msgs serialization tests

Author: Antoine Riard

src/ln/msgs.rs

@@ -114,9 +114,13 @@ impl LocalFeatures {
 }
 
 /// Tracks globalfeatures which are in init messages and routing announcements
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Debug)]
 pub struct GlobalFeatures {
+	#[cfg(not(test))]
 	flags: Vec<u8>,
+	// Used to test encoding of diverse msgs
+	#[cfg(test)]
+	pub flags: Vec<u8>
 }
 
 impl GlobalFeatures {
@@ -326,7 +330,7 @@ pub struct ChannelReestablish {
 }
 
 /// An announcement_signatures message to be sent or received from a peer
-#[derive(Clone)]
+#[derive(PartialEq, Clone, Debug)]
 pub struct AnnouncementSignatures {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) short_channel_id: u64,
@@ -335,7 +339,7 @@ pub struct AnnouncementSignatures {
 }
 
 /// An address which can be used to connect to a remote peer
-#[derive(PartialEq, Clone)]
+#[derive(Clone, PartialEq, Debug)]
 pub enum NetAddress {
 	/// An IPv4 address/port on which the peer is listening.
 	IPv4 {
@@ -458,9 +462,9 @@ impl<R: ::std::io::Read>  Readable<R> for Result<NetAddress, u8> {
 	}
 }
 
-#[derive(PartialEq, Clone)]
 // Only exposed as broadcast of node_announcement should be filtered by node_id
 /// The unsigned part of a node_announcement
+#[derive(PartialEq, Clone, Debug)]
 pub struct UnsignedNodeAnnouncement {
 	pub(crate) features: GlobalFeatures,
 	pub(crate) timestamp: u32,
@@ -484,7 +488,7 @@ pub struct NodeAnnouncement {
 
 // Only exposed as broadcast of channel_announcement should be filtered by node_id
 /// The unsigned part of a channel_announcement
-#[derive(PartialEq, Clone)]
+#[derive(PartialEq, Clone, Debug)]
 pub struct UnsignedChannelAnnouncement {
 	pub(crate) features: GlobalFeatures,
 	pub(crate) chain_hash: Sha256dHash,
@@ -498,7 +502,7 @@ pub struct UnsignedChannelAnnouncement {
 	pub(crate) excess_data: Vec<u8>,
 }
 /// A channel_announcement message to be sent or received from a peer
-#[derive(PartialEq, Clone)]
+#[derive(PartialEq, Clone, Debug)]
 pub struct ChannelAnnouncement {
 	pub(crate) node_signature_1: Signature,
 	pub(crate) node_signature_2: Signature,
@@ -507,7 +511,7 @@ pub struct ChannelAnnouncement {
 	pub(crate) contents: UnsignedChannelAnnouncement,
 }
 
-#[derive(PartialEq, Clone)]
+#[derive(PartialEq, Clone, Debug)]
 pub(crate) struct UnsignedChannelUpdate {
 	pub(crate) chain_hash: Sha256dHash,
 	pub(crate) short_channel_id: u64,
@@ -520,7 +524,7 @@ pub(crate) struct UnsignedChannelUpdate {
 	pub(crate) excess_data: Vec<u8>,
 }
 /// A channel_update message to be sent or received from a peer
-#[derive(PartialEq, Clone)]
+#[derive(PartialEq, Clone, Debug)]
 pub struct ChannelUpdate {
 	pub(crate) signature: Signature,
 	pub(crate) contents: UnsignedChannelUpdate,
@@ -1388,10 +1392,15 @@ impl_writeable_len_match!(NodeAnnouncement, {
 mod tests {
 	use hex;
 	use ln::msgs;
-	use ln::msgs::OptionalField;
-	use util::ser::Writeable;
+	use ln::msgs::GlobalFeatures;
+	use util::ser::{Writer, Writeable};
+
+	use bitcoin::util::hash::Sha256dHash;
+	use bitcoin::util::address::Address;
+	use bitcoin::network::constants::Network;
+
 	use secp256k1::key::{PublicKey,SecretKey};
-	use secp256k1::Secp256k1;
+	use secp256k1::{Secp256k1, Message};
 
 	#[test]
 	fn encoding_channel_reestablish_no_secret() {
@@ -1429,4 +1438,162 @@ mod tests {
 			vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143]
 		);
 	}
+
+	macro_rules! get_keys_from {
+		($slice: expr) => {
+			{
+				let secp_ctx = Secp256k1::new();
+				let privkey = SecretKey::from_slice(&secp_ctx, &hex::decode($slice).unwrap()[..]).unwrap();
+				let pubkey = PublicKey::from_secret_key(&secp_ctx, &privkey);
+				(privkey, pubkey, secp_ctx)
+			}
+		}
+	}
+
+	macro_rules! get_sig_on {
+		($privkey: expr, $ctx: expr, $string: expr) => {
+			{
+				let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
+				$ctx.sign(&sighash, &$privkey)
+			}
+		}
+	}
+
+	#[test]
+	fn encoding_announcement_signatures() {
+		let (privkey, _, secp_ctx) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101");
+		let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
+		let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
+		let announcement_signatures = msgs::AnnouncementSignatures {
+			channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
+			short_channel_id: 2316138423780173,
+			node_signature: sig_1,
+			bitcoin_signature: sig_2,
+		};
+
+		let encoded_value = announcement_signatures.encode();	
+		assert_eq!(
+			encoded_value,
+			vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 8, 58, 132, 0, 0, 3, 77, 217, 119, 203, 155, 83, 217, 58, 111, 246, 75, 181, 241, 225, 88, 180, 9, 75, 102, 231, 152, 251, 18, 145, 17, 104, 163, 204, 223, 128, 168, 48, 150, 52, 10, 106, 149, 218, 10, 232, 217, 247, 118, 82, 142, 236, 219, 183, 71, 235, 107, 84, 84, 149, 164, 49, 158, 213, 55, 142, 53, 178, 30, 7, 58, 207, 153, 83, 206, 244, 112, 8, 96, 245, 150, 120, 56, 235, 162, 186, 232, 146, 136, 173, 24, 142, 191, 139, 32, 191, 153, 92, 62, 165, 58, 38, 223, 24, 118, 208, 163, 160, 225, 49, 114, 186, 40, 106, 103, 49, 64, 25, 12, 2, 186, 157, 166, 10, 46, 67, 167, 69, 24, 140, 138, 131, 199, 243, 239]);
+	}
+
+	fn do_encoding_channel_announcement(unknown_features_bits: bool, non_bitcoin_chain_hash: bool, excess_data: bool) {
+		let (privkey_1, pubkey_1, secp_ctx_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101");
+		let (privkey_2, pubkey_2, secp_ctx_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202");
+		let (privkey_3, pubkey_3, secp_ctx_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303");
+		let (privkey_4, pubkey_4, secp_ctx_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404");
+		let sig_1 = get_sig_on!(privkey_1, secp_ctx_1, String::from("01010101010101010101010101010101"));
+		let sig_2 = get_sig_on!(privkey_2, secp_ctx_2, String::from("01010101010101010101010101010101"));
+		let sig_3 = get_sig_on!(privkey_3, secp_ctx_3, String::from("01010101010101010101010101010101"));
+		let sig_4 = get_sig_on!(privkey_4, secp_ctx_4, String::from("01010101010101010101010101010101"));
+		let mut features = GlobalFeatures::new();
+		if unknown_features_bits {
+			features.flags = vec![0xFF, 0xFF];
+		}
+		let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
+			features,
+			chain_hash: if !non_bitcoin_chain_hash { Sha256dHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap() } else { Sha256dHash::from_hex("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943").unwrap() },
+			short_channel_id: 2316138423780173,
+			node_id_1: pubkey_1,
+			node_id_2: pubkey_2,
+			bitcoin_key_1: pubkey_3,
+			bitcoin_key_2: pubkey_4,
+			excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
+		};
+		let channel_announcement = msgs::ChannelAnnouncement {
+			node_signature_1: sig_1,
+			node_signature_2: sig_2,
+			bitcoin_signature_1: sig_3,
+			bitcoin_signature_2: sig_4,
+			contents: unsigned_channel_announcement,
+		};
+		let encoded_value = channel_announcement.encode();
+		let mut target_value = vec![217, 119, 203, 155, 83, 217, 58, 111, 246, 75, 181, 241, 225, 88, 180, 9, 75, 102, 231, 152, 251, 18, 145, 17, 104, 163, 204, 223, 128, 168, 48, 150, 52, 10, 106, 149, 218, 10, 232, 217, 247, 118, 82, 142, 236, 219, 183, 71, 235, 107, 84, 84, 149, 164, 49, 158, 213, 55, 142, 53, 178, 30, 7, 58, 23, 53, 182, 164, 39, 232, 13, 95, 231, 205, 144, 162, 244, 238, 8, 220, 156, 39, 205, 167, 195, 90, 65, 114, 229, 216, 91, 18, 196, 157, 66, 50, 83, 126, 152, 249, 177, 243, 197, 230, 152, 154, 139, 150, 68, 233, 14, 137, 24, 18, 118, 128, 219, 208, 212, 4, 53, 16, 132, 15, 192, 241, 225, 26, 33, 108, 40, 11, 83, 149, 162, 84, 110, 126, 75, 38, 99, 224, 79, 129, 22, 34, 241, 90, 79, 145, 232, 58, 162, 233, 43, 162, 165, 115, 193, 57, 20, 44, 84, 174, 99, 7, 42, 30, 193, 238, 125, 192, 192, 75, 222, 92, 132, 120, 6, 23, 42, 160, 92, 146, 194, 42, 232, 227, 8, 209, 210, 105, 43, 18, 204, 25, 92, 224, 162, 209, 189, 166, 168, 139, 239, 161, 159, 160, 127, 81, 202, 167, 92, 232, 56, 55, 242, 137, 101, 96, 11, 138, 172, 171, 8, 85, 255, 176, 231, 65, 236, 95, 124, 65, 66, 30, 152, 41, 169, 212, 134, 17, 200, 200, 49, 247, 27, 229, 234, 115, 230, 101, 148, 151, 127, 253];
+		if unknown_features_bits {
+			target_value.append(&mut vec![0, 2, 255, 255]);
+		} else {
+			target_value.append(&mut vec![0, 0]);
+		}
+		if non_bitcoin_chain_hash {
+			target_value.append(&mut vec![67, 73, 127, 215, 248, 38, 149, 113, 8, 244, 163, 15, 217, 206, 195, 174, 186, 121, 151, 32, 132, 233, 14, 173, 1, 234, 51, 9, 0, 0, 0, 0]);
+		} else {
+			target_value.append(&mut vec![0, 0, 0, 0, 0, 25, 214, 104, 156, 8, 90, 225, 101, 131, 30, 147, 79, 247, 99, 174, 70, 162, 166, 193, 114, 179, 241, 182, 10, 140, 226, 111]);
+		}
+		target_value.append(&mut vec![0, 8, 58, 132, 0, 0, 3, 77, 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, 2, 77, 75, 108, 209, 54, 16, 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217, 234, 216, 10, 201, 66, 51, 116, 196, 81, 167, 37, 77, 7, 102, 2, 83, 31, 230, 6, 129, 52, 80, 61, 39, 35, 19, 50, 39, 200, 103, 172, 143, 166, 200, 60, 83, 126, 154, 68, 195, 197, 189, 189, 203, 31, 227, 55, 3, 70, 39, 121, 173, 74, 173, 57, 81, 70, 20, 117, 26, 113, 8, 95, 47, 16, 225, 199, 165, 147, 228, 224, 48, 239, 181, 184, 114, 28, 229, 91, 11]);
+		if excess_data {
+			target_value.append(&mut vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40]);
+		}
+		assert_eq!(encoded_value, target_value);
+	}
+
+	#[test]
+	fn encoding_channel_announcement() {
+		do_encoding_channel_announcement(false, false, false);
+		do_encoding_channel_announcement(true, false, false);
+		do_encoding_channel_announcement(false, true, false);
+		do_encoding_channel_announcement(false, false, true);
+		do_encoding_channel_announcement(true, true, true);
+	}
+
+	#[test]
+	fn encoding_node_announcement() {
+		//TODO:
+	}
+
+	fn do_encoding_channel_update(non_bitcoin_chain_hash: bool, direction: bool, disable: bool, htlc_maximum_msat: bool) {
+		let (privkey_1, _, secp_ctx_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101");
+		let sig_1 = get_sig_on!(privkey_1, secp_ctx_1, String::from("01010101010101010101010101010101"));
+		let unsigned_channel_update = msgs::UnsignedChannelUpdate {
+			chain_hash: if !non_bitcoin_chain_hash { Sha256dHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap() } else { Sha256dHash::from_hex("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943").unwrap() },
+			short_channel_id: 2316138423780173,
+			timestamp: 20190119,
+			flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 } | if htlc_maximum_msat { 1 << 8 } else { 0 },
+			cltv_expiry_delta: 144,
+			htlc_minimum_msat: 1000000,
+			fee_base_msat: 10000,
+			fee_proportional_millionths: 20,
+			excess_data: if htlc_maximum_msat { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
+		};
+		let channel_update = msgs::ChannelUpdate {
+			signature: sig_1,
+			contents: unsigned_channel_update
+		};
+		let encoded_value = channel_update.encode();
+		let mut target_value = vec![217, 119, 203, 155, 83, 217, 58, 111, 246, 75, 181, 241, 225, 88, 180, 9, 75, 102, 231, 152, 251, 18, 145, 17, 104, 163, 204, 223, 128, 168, 48, 150, 52, 10, 106, 149, 218, 10, 232, 217, 247, 118, 82, 142, 236, 219, 183, 71, 235, 107, 84, 84, 149, 164, 49, 158, 213, 55, 142, 53, 178, 30, 7, 58];
+		if non_bitcoin_chain_hash {
+			target_value.append(&mut vec![67, 73, 127, 215, 248, 38, 149, 113, 8, 244, 163, 15, 217, 206, 195, 174, 186, 121, 151, 32, 132, 233, 14, 173, 1, 234, 51, 9, 0, 0, 0, 0]);
+		} else {
+			target_value.append(&mut vec![0, 0, 0, 0, 0, 25, 214, 104, 156, 8, 90, 225, 101, 131, 30, 147, 79, 247, 99, 174, 70, 162, 166, 193, 114, 179, 241, 182, 10, 140, 226, 111]);
+		}
+		target_value.append(&mut vec![0, 8, 58, 132, 0, 0, 3, 77, 1, 52, 19, 167]);
+		if htlc_maximum_msat {
+			target_value.append(&mut vec![1]);
+		} else {
+			target_value.append(&mut vec![0]);
+		}
+		target_value.append(&mut vec![0]);
+		if direction {
+			let flag = target_value.last_mut().unwrap();
+			*flag = 1;
+		}
+		if disable {
+			let flag = target_value.last_mut().unwrap();
+			*flag = *flag | 1 << 1;
+		}
+		target_value.append(&mut vec![0, 144, 0, 0, 0, 0, 0, 15, 66, 64, 0, 0, 39, 16, 0, 0, 0, 20]);
+		if htlc_maximum_msat {
+			target_value.append(&mut vec![0, 0, 0, 0, 59, 154, 202, 0]);
+		}
+		assert_eq!(encoded_value, target_value);
+	}
+
+	#[test]
+	fn encoding_channel_update() {
+		do_encoding_channel_update(false, false, false, false);
+		do_encoding_channel_update(true, false, false, false);
+		do_encoding_channel_update(false, true, false, false);
+		do_encoding_channel_update(false, false, true, false);
+		do_encoding_channel_update(false, false, false, true);
+		do_encoding_channel_update(true, true, true, true);
+	}
 }