Add bolt7 msgs serialization tests

Author: Antoine Riard

src/ln/msgs.rs

@@ -115,7 +115,7 @@ impl LocalFeatures {
 }
 
 /// Tracks globalfeatures which are in init messages and routing announcements
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Debug)]
 pub struct GlobalFeatures {
 	flags: Vec<u8>,
 }
@@ -327,7 +327,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,
@@ -336,7 +336,7 @@ pub struct AnnouncementSignatures {
 }
 
 /// An address which can be used to connect to a remote peer
-#[derive(Clone)]
+#[derive(Clone, PartialEq, Debug)]
 pub enum NetAddress {
 	/// An IPv4 address/port on which the peer is listenting.
 	IPv4 {
@@ -387,6 +387,7 @@ impl NetAddress {
 #[derive(Clone)]
 // Only exposed as broadcast of node_announcement should be filtered by node_id
 /// The unsigned part of a node_announcement
+#[derive(PartialEq, Debug)]
 pub struct UnsignedNodeAnnouncement {
 	pub(crate) features: GlobalFeatures,
 	pub(crate) timestamp: u32,
@@ -401,7 +402,7 @@ pub struct UnsignedNodeAnnouncement {
 	pub(crate) excess_address_data: Vec<u8>,
 	pub(crate) excess_data: Vec<u8>,
 }
-#[derive(Clone)]
+#[derive(PartialEq, Clone, Debug)]
 /// A node_announcement message to be sent or received from a peer
 pub struct NodeAnnouncement {
 	pub(crate) signature: Signature,
@@ -410,7 +411,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,
@@ -424,7 +425,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,
@@ -433,7 +434,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,
@@ -446,7 +447,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,
@@ -1322,9 +1323,27 @@ impl_writeable_len_match!(NodeAnnouncement, {
 mod tests {
 	use hex;
 	use ln::msgs;
-	use util::ser::Writeable;
+	use ln::msgs::GlobalFeatures;
+	use util::ser::{Writer, Writeable, Readable};
+
+	use bitcoin::util::hash::Sha256dHash;
+
 	use secp256k1::key::{PublicKey,SecretKey};
-	use secp256k1::Secp256k1;
+	use secp256k1::{Secp256k1, Message};
+
+	use rand::{Rng, thread_rng};
+
+
+	struct VecWriter(Vec<u8>);
+	impl Writer for VecWriter {
+		fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
+			self.0.extend_from_slice(buf);
+			Ok(())
+		}
+		fn size_hint(&mut self, size: usize) {
+			self.0.reserve_exact(size);
+		}
+	}
 
 	#[test]
 	fn encoding_channel_reestablish_no_secret() {
@@ -1362,4 +1381,127 @@ 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]
 		);
 	}
+
+	#[test]
+	fn test_serialization_bolt7_msgs() {
+
+		let mut rng = thread_rng();
+		let secp_ctx = Secp256k1::new();
+
+		let mut channel_id = [0; 32];
+		rng.fill_bytes(&mut channel_id);
+		let secret_key_1 = SecretKey::new(&secp_ctx, &mut rng);
+		let secret_key_2 = SecretKey::new(&secp_ctx, &mut rng);
+		let secret_key_3 = SecretKey::new(&secp_ctx, &mut rng);
+		let secret_key_4 = SecretKey::new(&secp_ctx, &mut rng);
+		let mut msg = [0; 32];
+		rng.fill_bytes(&mut msg);
+		let sighash = Message::from_slice(&msg).unwrap();
+		let signature_1 = secp_ctx.sign(&sighash, &secret_key_1);
+		let signature_2 = secp_ctx.sign(&sighash, &secret_key_2);
+		let signature_3 = secp_ctx.sign(&sighash, &secret_key_3);
+		let signature_4 = secp_ctx.sign(&sighash, &secret_key_4);
+		let pubkey_1 = PublicKey::from_secret_key(&secp_ctx, &secret_key_1);
+		let pubkey_2 = PublicKey::from_secret_key(&secp_ctx, &secret_key_2);
+		let pubkey_3 = PublicKey::from_secret_key(&secp_ctx, &secret_key_3);
+		let pubkey_4 = PublicKey::from_secret_key(&secp_ctx, &secret_key_4);
+		let bitcoin_hash = Sha256dHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
+		let features = GlobalFeatures::new();
+		let mut rgb = [0; 3];
+		rng.fill_bytes(&mut rgb);
+		let ipv4 = msgs::NetAddress::IPv4 {
+			addr: [127, 0, 0, 1],
+			port: 2
+		};
+		let ipv6 = msgs::NetAddress::IPv6 {
+			addr: [128, 91, 45, 157, 220, 40, 0, 0, 0, 0, 252, 87, 212, 200, 31, 255],
+			port: 2
+		};
+		let onionv2 = msgs::NetAddress::OnionV2 {
+			addr: [20, 122, 45, 90, 0, 0, 12, 245, 203, 10],
+			port: 2
+		};
+		//TODO: generate OnionV3
+		let addresses = vec![ipv4, ipv6, onionv2];
+
+		macro_rules! test_serialization {
+			($msg: expr, $type:ty) => {
+				let mut towire = VecWriter(Vec::new());
+				$msg.write(&mut towire).unwrap();
+				let mut r = ::std::io::Cursor::new(towire.0.as_slice());
+				if let Ok(fromwire) = <$type as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+					let p = r.position() as usize;
+					assert_eq!(towire.0.len(), p);
+					assert_eq!(&r.into_inner()[..p], &towire.0[..p]);
+					assert_eq!(fromwire, $msg);
+				}
+			}
+		}
+
+		let announcement_signatures = msgs::AnnouncementSignatures {
+			channel_id: channel_id.clone(),
+			short_channel_id: rng.gen(),
+			node_signature: signature_1.clone(),
+			bitcoin_signature: signature_2.clone()
+		};
+		test_serialization!(announcement_signatures, msgs::AnnouncementSignatures);
+
+		let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
+			features: features.clone(),
+			chain_hash: bitcoin_hash.clone(),
+			short_channel_id: rng.gen(),
+			node_id_1: pubkey_1.clone(),
+			node_id_2: pubkey_2.clone(),
+			bitcoin_key_1: pubkey_3.clone(),
+			bitcoin_key_2: pubkey_4.clone(),
+			excess_data: Vec::new()
+		};
+		test_serialization!(unsigned_channel_announcement, msgs::UnsignedChannelAnnouncement);
+
+		let channel_announcement = msgs::ChannelAnnouncement {
+			node_signature_1: signature_1.clone(),
+			node_signature_2: signature_2.clone(),
+			bitcoin_signature_1: signature_3.clone(),
+			bitcoin_signature_2: signature_4.clone(),
+			contents: unsigned_channel_announcement
+		};
+		test_serialization!(channel_announcement, msgs::ChannelAnnouncement);
+
+		let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
+			features: features.clone(),
+			timestamp: rng.gen(),
+			node_id: pubkey_1.clone(),
+			rgb,
+			alias: channel_id.clone(),
+			addresses,
+			excess_address_data: Vec::new(),
+			excess_data: Vec::new()
+		};
+		test_serialization!(unsigned_node_announcement, msgs::UnsignedNodeAnnouncement);
+
+		let node_announcement = msgs::NodeAnnouncement {
+			signature: signature_1.clone(),
+			contents: unsigned_node_announcement
+		};
+		test_serialization!(node_announcement, msgs::NodeAnnouncement);
+
+		let unsigned_channel_update = msgs::UnsignedChannelUpdate {
+			chain_hash: bitcoin_hash.clone(),
+			short_channel_id: rng.gen(),
+			timestamp: rng.gen(),
+			flags: rng.gen(),
+			cltv_expiry_delta: rng.gen(),
+			htlc_minimum_msat: rng.gen(),
+			fee_base_msat: rng.gen(),
+			fee_proportional_millionths: rng.gen(),
+			excess_data: Vec::new()
+		};
+		test_serialization!(unsigned_channel_update, msgs::UnsignedChannelUpdate);
+
+		let channel_update = msgs::ChannelUpdate {
+			signature: signature_1.clone(),
+			contents: unsigned_channel_update
+		};
+		test_serialization!(channel_update, msgs::ChannelUpdate);
+	}
 }