X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fmsgs.rs;h=62c4bb0d288512605a7a9487658fe52c4cfa9927;hb=4d77e9d75216d84795bfbaf6a9b41f94637fac1c;hp=f87e3722f999d239934241e8aa5ee046872d8fd8;hpb=92ff499bdbc115fbb897e5aa8bf758fc66987e95;p=rust-lightning

diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs
index f87e3722..62c4bb0d 100644
--- a/src/ln/msgs.rs
+++ b/src/ln/msgs.rs
@@ -1,9 +1,11 @@
 //! Wire messages, traits representing wire message handlers, and a few error types live here.
+//!
 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
 //! server entirely) which handles only channel-related messages you may wish to implement
 //! ChannelMessageHandler yourself and use it to re-serialize messages and pass them across
 //! daemons/servers.
+//!
 //! Note that if you go with such an architecture (instead of passing raw socket events to a
 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
 //! source node_id of the mssage, however this does allow you to significantly reduce bandwidth
@@ -14,7 +16,7 @@
 //! track the network on the less-secure system.
 
 use secp256k1::key::PublicKey;
-use secp256k1::{Secp256k1, Signature};
+use secp256k1::Signature;
 use secp256k1;
 use bitcoin::util::hash::Sha256dHash;
 use bitcoin::blockdata::script::Script;
@@ -24,9 +26,11 @@ use std::{cmp, fmt};
 use std::io::Read;
 use std::result::Result;
 
-use util::{byte_utils, events};
+use util::events;
 use util::ser::{Readable, Writeable, Writer};
 
+use ln::channelmanager::{PaymentPreimage, PaymentHash};
+
 /// An error in decoding a message or struct.
 #[derive(Debug)]
 pub enum DecodeError {
@@ -43,7 +47,6 @@ pub enum DecodeError {
 	/// node_announcement included more than one address of a given type!
 	ExtraAddressesPerType,
 	/// A length descriptor in the packet didn't describe the later data correctly
-	/// (currently only generated in node_announcement)
 	BadLengthDescriptor,
 	/// Error from std::io
 	Io(::std::io::Error),
@@ -149,6 +152,7 @@ pub struct Init {
 }
 
 /// An error message to be sent or received from a peer
+#[derive(Clone)]
 pub struct ErrorMessage {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) data: String,
@@ -166,6 +170,7 @@ pub struct Pong {
 }
 
 /// An open_channel message to be sent or received from a peer
+#[derive(Clone)]
 pub struct OpenChannel {
 	pub(crate) chain_hash: Sha256dHash,
 	pub(crate) temporary_channel_id: [u8; 32],
@@ -185,10 +190,11 @@ pub struct OpenChannel {
 	pub(crate) htlc_basepoint: PublicKey,
 	pub(crate) first_per_commitment_point: PublicKey,
 	pub(crate) channel_flags: u8,
-	pub(crate) shutdown_scriptpubkey: Option<Script>,
+	pub(crate) shutdown_scriptpubkey: OptionalField<Script>,
 }
 
 /// An accept_channel message to be sent or received from a peer
+#[derive(Clone)]
 pub struct AcceptChannel {
 	pub(crate) temporary_channel_id: [u8; 32],
 	pub(crate) dust_limit_satoshis: u64,
@@ -204,10 +210,11 @@ pub struct AcceptChannel {
 	pub(crate) delayed_payment_basepoint: PublicKey,
 	pub(crate) htlc_basepoint: PublicKey,
 	pub(crate) first_per_commitment_point: PublicKey,
-	pub(crate) shutdown_scriptpubkey: Option<Script>,
+	pub(crate) shutdown_scriptpubkey: OptionalField<Script>
 }
 
 /// A funding_created message to be sent or received from a peer
+#[derive(Clone)]
 pub struct FundingCreated {
 	pub(crate) temporary_channel_id: [u8; 32],
 	pub(crate) funding_txid: Sha256dHash,
@@ -216,24 +223,28 @@ pub struct FundingCreated {
 }
 
 /// A funding_signed message to be sent or received from a peer
+#[derive(Clone)]
 pub struct FundingSigned {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) signature: Signature,
 }
 
 /// A funding_locked message to be sent or received from a peer
+#[derive(Clone, PartialEq)]
 pub struct FundingLocked {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) next_per_commitment_point: PublicKey,
 }
 
 /// A shutdown message to be sent or received from a peer
+#[derive(Clone, PartialEq)]
 pub struct Shutdown {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) scriptpubkey: Script,
 }
 
 /// A closing_signed message to be sent or received from a peer
+#[derive(Clone, PartialEq)]
 pub struct ClosingSigned {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) fee_satoshis: u64,
@@ -241,26 +252,26 @@ pub struct ClosingSigned {
 }
 
 /// An update_add_htlc message to be sent or received from a peer
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct UpdateAddHTLC {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) htlc_id: u64,
 	pub(crate) amount_msat: u64,
-	pub(crate) payment_hash: [u8; 32],
+	pub(crate) payment_hash: PaymentHash,
 	pub(crate) cltv_expiry: u32,
 	pub(crate) onion_routing_packet: OnionPacket,
 }
 
 /// An update_fulfill_htlc message to be sent or received from a peer
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct UpdateFulfillHTLC {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) htlc_id: u64,
-	pub(crate) payment_preimage: [u8; 32],
+	pub(crate) payment_preimage: PaymentPreimage,
 }
 
 /// An update_fail_htlc message to be sent or received from a peer
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct UpdateFailHTLC {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) htlc_id: u64,
@@ -268,7 +279,7 @@ pub struct UpdateFailHTLC {
 }
 
 /// An update_fail_malformed_htlc message to be sent or received from a peer
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct UpdateFailMalformedHTLC {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) htlc_id: u64,
@@ -277,7 +288,7 @@ pub struct UpdateFailMalformedHTLC {
 }
 
 /// A commitment_signed message to be sent or received from a peer
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct CommitmentSigned {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) signature: Signature,
@@ -285,6 +296,7 @@ pub struct CommitmentSigned {
 }
 
 /// A revoke_and_ack message to be sent or received from a peer
+#[derive(Clone, PartialEq)]
 pub struct RevokeAndACK {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) per_commitment_secret: [u8; 32],
@@ -292,22 +304,25 @@ pub struct RevokeAndACK {
 }
 
 /// An update_fee message to be sent or received from a peer
+#[derive(PartialEq, Clone)]
 pub struct UpdateFee {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) feerate_per_kw: u32,
 }
 
+#[derive(PartialEq, Clone)]
 pub(crate) struct DataLossProtect {
 	pub(crate) your_last_per_commitment_secret: [u8; 32],
 	pub(crate) my_current_per_commitment_point: PublicKey,
 }
 
 /// A channel_reestablish message to be sent or received from a peer
+#[derive(PartialEq, Clone)]
 pub struct ChannelReestablish {
 	pub(crate) channel_id: [u8; 32],
 	pub(crate) next_local_commitment_number: u64,
 	pub(crate) next_remote_commitment_number: u64,
-	pub(crate) data_loss_protect: Option<DataLossProtect>,
+	pub(crate) data_loss_protect: OptionalField<DataLossProtect>,
 }
 
 /// An announcement_signatures message to be sent or received from a peer
@@ -320,7 +335,7 @@ pub struct AnnouncementSignatures {
 }
 
 /// An address which can be used to connect to a remote peer
-#[derive(Clone)]
+#[derive(PartialEq, Clone)]
 pub enum NetAddress {
 	/// An IPv4 address/port on which the peer is listenting.
 	IPv4 {
@@ -366,8 +381,84 @@ impl NetAddress {
 			&NetAddress::OnionV3 {..} => { 4 },
 		}
 	}
+
+	/// Strict byte-length of address descriptor, 1-byte type not recorded
+	fn len(&self) -> u16 {
+		match self {
+			&NetAddress::IPv4 { .. } => { 6 },
+			&NetAddress::IPv6 { .. } => { 18 },
+			&NetAddress::OnionV2 { .. } => { 12 },
+			&NetAddress::OnionV3 { .. } => { 37 },
+		}
+	}
+}
+
+impl Writeable for NetAddress {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+		match self {
+			&NetAddress::IPv4 { ref addr, ref port } => {
+				1u8.write(writer)?;
+				addr.write(writer)?;
+				port.write(writer)?;
+			},
+			&NetAddress::IPv6 { ref addr, ref port } => {
+				2u8.write(writer)?;
+				addr.write(writer)?;
+				port.write(writer)?;
+			},
+			&NetAddress::OnionV2 { ref addr, ref port } => {
+				3u8.write(writer)?;
+				addr.write(writer)?;
+				port.write(writer)?;
+			},
+			&NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
+				4u8.write(writer)?;
+				ed25519_pubkey.write(writer)?;
+				checksum.write(writer)?;
+				version.write(writer)?;
+				port.write(writer)?;
+			}
+		}
+		Ok(())
+	}
 }
 
+impl<R: ::std::io::Read>  Readable<R> for Result<NetAddress, u8> {
+	fn read(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
+		let byte = <u8 as Readable<R>>::read(reader)?;
+		match byte {
+			1 => {
+				Ok(Ok(NetAddress::IPv4 {
+					addr: Readable::read(reader)?,
+					port: Readable::read(reader)?,
+				}))
+			},
+			2 => {
+				Ok(Ok(NetAddress::IPv6 {
+					addr: Readable::read(reader)?,
+					port: Readable::read(reader)?,
+				}))
+			},
+			3 => {
+				Ok(Ok(NetAddress::OnionV2 {
+					addr: Readable::read(reader)?,
+					port: Readable::read(reader)?,
+				}))
+			},
+			4 => {
+				Ok(Ok(NetAddress::OnionV3 {
+					ed25519_pubkey: Readable::read(reader)?,
+					checksum: Readable::read(reader)?,
+					version: Readable::read(reader)?,
+					port: Readable::read(reader)?,
+				}))
+			},
+			_ => return Ok(Err(byte)),
+		}
+	}
+}
+
+#[derive(PartialEq, Clone)]
 // Only exposed as broadcast of node_announcement should be filtered by node_id
 /// The unsigned part of a node_announcement
 pub struct UnsignedNodeAnnouncement {
@@ -384,6 +475,7 @@ pub struct UnsignedNodeAnnouncement {
 	pub(crate) excess_address_data: Vec<u8>,
 	pub(crate) excess_data: Vec<u8>,
 }
+#[derive(PartialEq, Clone)]
 /// A node_announcement message to be sent or received from a peer
 pub struct NodeAnnouncement {
 	pub(crate) signature: Signature,
@@ -435,6 +527,7 @@ pub struct ChannelUpdate {
 }
 
 /// Used to put an error message in a HandleError
+#[derive(Clone)]
 pub enum ErrorAction {
 	/// The peer took some action which made us think they were useless. Disconnect them.
 	DisconnectPeer {
@@ -460,17 +553,20 @@ pub struct HandleError { //TODO: rename me
 
 /// Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
 /// transaction updates if they were pending.
+#[derive(PartialEq, Clone)]
 pub struct CommitmentUpdate {
 	pub(crate) update_add_htlcs: Vec<UpdateAddHTLC>,
 	pub(crate) update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
 	pub(crate) update_fail_htlcs: Vec<UpdateFailHTLC>,
 	pub(crate) update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
+	pub(crate) update_fee: Option<UpdateFee>,
 	pub(crate) commitment_signed: CommitmentSigned,
 }
 
 /// The information we received from a peer along the route of a payment we originated. This is
 /// returned by ChannelMessageHandler::handle_update_fail_htlc to be passed into
 /// RoutingMessageHandler::handle_htlc_fail_channel_update to update our network map.
+#[derive(Clone)]
 pub enum HTLCFailChannelUpdate {
 	/// We received an error which included a full ChannelUpdate message.
 	ChannelUpdateMessage {
@@ -481,30 +577,55 @@ pub enum HTLCFailChannelUpdate {
 	ChannelClosed {
 		/// The short_channel_id which has now closed.
 		short_channel_id: u64,
+		/// when this true, this channel should be permanently removed from the
+		/// consideration. Otherwise, this channel can be restored as new channel_update is received
+		is_permanent: bool,
 	},
+	/// We received an error which indicated only that a node has failed
+	NodeFailure {
+		/// The node_id that has failed.
+		node_id: PublicKey,
+		/// when this true, node should be permanently removed from the
+		/// consideration. Otherwise, the channels connected to this node can be
+		/// restored as new channel_update is received
+		is_permanent: bool,
+	}
 }
 
-/// A trait to describe an object which can receive channel messages. Messages MAY be called in
-/// parallel when they originate from different their_node_ids, however they MUST NOT be called in
-/// parallel when the two calls have the same their_node_id.
-pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync {
+/// Messages could have optional fields to use with extended features
+/// As we wish to serialize these differently from Option<T>s (Options get a tag byte, but
+/// OptionalFeild simply gets Present if there are enough bytes to read into it), we have a
+/// separate enum type for them.
+#[derive(Clone, PartialEq)]
+pub enum OptionalField<T> {
+	/// Optional field is included in message
+	Present(T),
+	/// Optional field is absent in message
+	Absent
+}
+
+/// A trait to describe an object which can receive channel messages.
+///
+/// Messages MAY be called in parallel when they originate from different their_node_ids, however
+/// they MUST NOT be called in parallel when the two calls have the same their_node_id.
+pub trait ChannelMessageHandler : events::MessageSendEventsProvider + Send + Sync {
 	//Channel init:
 	/// Handle an incoming open_channel message from the given peer.
-	fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel) -> Result<AcceptChannel, HandleError>;
+	fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel) -> Result<(), HandleError>;
 	/// Handle an incoming accept_channel message from the given peer.
 	fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel) -> Result<(), HandleError>;
 	/// Handle an incoming funding_created message from the given peer.
-	fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated) -> Result<FundingSigned, HandleError>;
+	fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated) -> Result<(), HandleError>;
 	/// Handle an incoming funding_signed message from the given peer.
 	fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned) -> Result<(), HandleError>;
 	/// Handle an incoming funding_locked message from the given peer.
-	fn handle_funding_locked(&self, their_node_id: &PublicKey, msg: &FundingLocked) -> Result<Option<AnnouncementSignatures>, HandleError>;
+	fn handle_funding_locked(&self, their_node_id: &PublicKey, msg: &FundingLocked) -> Result<(), HandleError>;
 
 	// Channl close:
 	/// Handle an incoming shutdown message from the given peer.
-	fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown) -> Result<(Option<Shutdown>, Option<ClosingSigned>), HandleError>;
+	fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown) -> Result<(), HandleError>;
 	/// Handle an incoming closing_signed message from the given peer.
-	fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned) -> Result<Option<ClosingSigned>, HandleError>;
+	fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned) -> Result<(), HandleError>;
 
 	// HTLC handling:
 	/// Handle an incoming update_add_htlc message from the given peer.
@@ -512,13 +633,13 @@ pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync {
 	/// Handle an incoming update_fulfill_htlc message from the given peer.
 	fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC) -> Result<(), HandleError>;
 	/// Handle an incoming update_fail_htlc message from the given peer.
-	fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<Option<HTLCFailChannelUpdate>, HandleError>;
+	fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<(), HandleError>;
 	/// Handle an incoming update_fail_malformed_htlc message from the given peer.
 	fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC) -> Result<(), HandleError>;
 	/// Handle an incoming commitment_signed message from the given peer.
-	fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result<(RevokeAndACK, Option<CommitmentSigned>), HandleError>;
+	fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result<(), HandleError>;
 	/// Handle an incoming revoke_and_ack message from the given peer.
-	fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result<Option<CommitmentUpdate>, HandleError>;
+	fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result<(), HandleError>;
 
 	/// Handle an incoming update_fee message from the given peer.
 	fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee) -> Result<(), HandleError>;
@@ -535,9 +656,9 @@ pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync {
 	fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool);
 
 	/// Handle a peer reconnecting, possibly generating channel_reestablish message(s).
-	fn peer_connected(&self, their_node_id: &PublicKey) -> Vec<ChannelReestablish>;
+	fn peer_connected(&self, their_node_id: &PublicKey);
 	/// Handle an incoming channel_reestablish message from the given peer.
-	fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish) -> Result<(Option<FundingLocked>, Option<RevokeAndACK>, Option<CommitmentUpdate>), HandleError>;
+	fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish) -> Result<(), HandleError>;
 
 	// Error:
 	/// Handle an incoming error message from the given peer.
@@ -557,6 +678,14 @@ pub trait RoutingMessageHandler : Send + Sync {
 	fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, HandleError>;
 	/// Handle some updates to the route graph that we learned due to an outbound failed payment.
 	fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate);
+	/// Gets a subset of the channel announcements and updates required to dump our routing table
+	/// to a remote node, starting at the short_channel_id indicated by starting_point and
+	/// including batch_amount entries.
+	fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(ChannelAnnouncement, ChannelUpdate, ChannelUpdate)>;
+	/// Gets a subset of the node announcements required to dump our routing table to a remote node,
+	/// starting at the node *after* the provided publickey and including batch_amount entries.
+	/// If None is provided for starting_point, we start at the first node.
+	fn get_next_node_announcements(&self, starting_point: Option<&PublicKey>, batch_amount: u8) -> Vec<NodeAnnouncement>;
 }
 
 pub(crate) struct OnionRealm0HopData {
@@ -600,7 +729,18 @@ pub(crate) struct OnionPacket {
 	pub(crate) hmac: [u8; 32],
 }
 
-#[derive(Clone)]
+impl PartialEq for OnionPacket {
+	fn eq(&self, other: &OnionPacket) -> bool {
+		for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
+			if i != j { return false; }
+		}
+		self.version == other.version &&
+			self.public_key == other.public_key &&
+			self.hmac == other.hmac
+	}
+}
+
+#[derive(Clone, PartialEq)]
 pub(crate) struct OnionErrorPacket {
 	// This really should be a constant size slice, but the spec lets these things be up to 128KB?
 	// (TODO) We limit it in decode to much lower...
@@ -642,8 +782,35 @@ impl From<::std::io::Error> for DecodeError {
 	}
 }
 
+impl Writeable for OptionalField<Script> {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+		match *self {
+			OptionalField::Present(ref script) => {
+				// Note that Writeable for script includes the 16-bit length tag for us
+				script.write(w)?;
+			},
+			OptionalField::Absent => {}
+		}
+		Ok(())
+	}
+}
+
+impl<R: Read> Readable<R> for OptionalField<Script> {
+	fn read(r: &mut R) -> Result<Self, DecodeError> {
+		match <u16 as Readable<R>>::read(r) {
+			Ok(len) => {
+				let mut buf = vec![0; len as usize];
+				r.read_exact(&mut buf)?;
+				Ok(OptionalField::Present(Script::from(buf)))
+			},
+			Err(DecodeError::ShortRead) => Ok(OptionalField::Absent),
+			Err(e) => Err(e)
+		}
+	}
+}
+
 impl_writeable_len_match!(AcceptChannel, {
-		{AcceptChannel{ shutdown_scriptpubkey: Some(ref script), ..}, 270 + 2 + script.len()},
+		{AcceptChannel{ shutdown_scriptpubkey: OptionalField::Present(ref script), .. }, 270 + 2 + script.len()},
 		{_, 270}
 	}, {
 	temporary_channel_id,
@@ -672,13 +839,16 @@ impl_writeable!(AnnouncementSignatures, 32+8+64*2, {
 
 impl Writeable for ChannelReestablish {
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
-		w.size_hint(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 });
+		w.size_hint(if let OptionalField::Present(..) = self.data_loss_protect { 32+2*8+33+32 } else { 32+2*8 });
 		self.channel_id.write(w)?;
 		self.next_local_commitment_number.write(w)?;
 		self.next_remote_commitment_number.write(w)?;
-		if let Some(ref data_loss_protect) = self.data_loss_protect {
-			data_loss_protect.your_last_per_commitment_secret.write(w)?;
-			data_loss_protect.my_current_per_commitment_point.write(w)?;
+		match self.data_loss_protect {
+			OptionalField::Present(ref data_loss_protect) => {
+				(*data_loss_protect).your_last_per_commitment_secret.write(w)?;
+				(*data_loss_protect).my_current_per_commitment_point.write(w)?;
+			},
+			OptionalField::Absent => {}
 		}
 		Ok(())
 	}
@@ -693,11 +863,11 @@ impl<R: Read> Readable<R> for ChannelReestablish{
 			data_loss_protect: {
 				match <[u8; 32] as Readable<R>>::read(r) {
 					Ok(your_last_per_commitment_secret) =>
-						Some(DataLossProtect {
+						OptionalField::Present(DataLossProtect {
 							your_last_per_commitment_secret,
 							my_current_per_commitment_point: Readable::read(r)?,
 						}),
-					Err(DecodeError::ShortRead) => None,
+					Err(DecodeError::ShortRead) => OptionalField::Absent,
 					Err(e) => return Err(e)
 				}
 			}
@@ -764,8 +934,8 @@ impl_writeable_len_match!(Init, {
 });
 
 impl_writeable_len_match!(OpenChannel, {
-		{ OpenChannel { shutdown_scriptpubkey: Some(ref script), .. }, 319 + 2 + script.len() },
-		{ OpenChannel { shutdown_scriptpubkey: None, .. }, 319 }
+		{ OpenChannel { shutdown_scriptpubkey: OptionalField::Present(ref script), .. }, 319 + 2 + script.len() },
+		{ _, 319 }
 	}, {
 	chain_hash,
 	temporary_channel_id,
@@ -854,7 +1024,7 @@ impl<R: Read> Readable<R> for OnionPacket {
 			public_key: {
 				let mut buf = [0u8;33];
 				r.read_exact(&mut buf)?;
-				PublicKey::from_slice(&Secp256k1::without_caps(), &buf)
+				PublicKey::from_slice(&buf)
 			},
 			hop_data: Readable::read(r)?,
 			hmac: Readable::read(r)?,
@@ -1096,38 +1266,17 @@ impl Writeable for UnsignedNodeAnnouncement {
 		w.write_all(&self.rgb)?;
 		self.alias.write(w)?;
 
-		let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18);
 		let mut addrs_to_encode = self.addresses.clone();
 		addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) });
 		addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() });
-		for addr in addrs_to_encode.iter() {
-			match addr {
-				&NetAddress::IPv4{addr, port} => {
-					addr_slice.push(1);
-					addr_slice.extend_from_slice(&addr);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
-				},
-				&NetAddress::IPv6{addr, port} => {
-					addr_slice.push(2);
-					addr_slice.extend_from_slice(&addr);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
-				},
-				&NetAddress::OnionV2{addr, port} => {
-					addr_slice.push(3);
-					addr_slice.extend_from_slice(&addr);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
-				},
-				&NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => {
-					addr_slice.push(4);
-					addr_slice.extend_from_slice(&ed25519_pubkey);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum));
-					addr_slice.push(version);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
-				},
-			}
+		let mut addr_len = 0;
+		for addr in &addrs_to_encode {
+			addr_len += 1 + addr.len();
+		}
+		(addr_len + self.excess_address_data.len() as u16).write(w)?;
+		for addr in addrs_to_encode {
+			addr.write(w)?;
 		}
-		((addr_slice.len() + self.excess_address_data.len()) as u16).write(w)?;
-		w.write_all(&addr_slice[..])?;
 		w.write_all(&self.excess_address_data[..])?;
 		w.write_all(&self.excess_data[..])?;
 		Ok(())
@@ -1146,112 +1295,77 @@ impl<R: Read> Readable<R> for UnsignedNodeAnnouncement {
 		r.read_exact(&mut rgb)?;
 		let alias: [u8; 32] = Readable::read(r)?;
 
-		let addrlen: u16 = Readable::read(r)?;
+		let addr_len: u16 = Readable::read(r)?;
+		let mut addresses: Vec<NetAddress> = Vec::with_capacity(4);
 		let mut addr_readpos = 0;
-		let mut addresses = Vec::with_capacity(4);
-		let mut f: u8 = 0;
-		let mut excess = 0;
+		let mut excess = false;
+		let mut excess_byte = 0;
 		loop {
-			if addrlen <= addr_readpos { break; }
-			f = Readable::read(r)?;
-			match f {
-				1 => {
-					if addresses.len() > 0 {
-						return Err(DecodeError::ExtraAddressesPerType);
-					}
-					if addrlen < addr_readpos + 1 + 6 {
-						return Err(DecodeError::BadLengthDescriptor);
-					}
-					addresses.push(NetAddress::IPv4 {
-						addr: {
-							let mut addr = [0; 4];
-							r.read_exact(&mut addr)?;
-							addr
+			if addr_len <= addr_readpos { break; }
+			match Readable::read(r) {
+				Ok(Ok(addr)) => {
+					match addr {
+						NetAddress::IPv4 { .. } => {
+							if addresses.len() > 0 {
+								return Err(DecodeError::ExtraAddressesPerType);
+							}
 						},
-						port: Readable::read(r)?,
-					});
-					addr_readpos += 1 + 6
-				},
-				2 => {
-					if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
-						return Err(DecodeError::ExtraAddressesPerType);
-					}
-					if addrlen < addr_readpos + 1 + 18 {
-						return Err(DecodeError::BadLengthDescriptor);
-					}
-					addresses.push(NetAddress::IPv6 {
-						addr: {
-							let mut addr = [0; 16];
-							r.read_exact(&mut addr)?;
-							addr
+						NetAddress::IPv6 { .. } => {
+							if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
+								return Err(DecodeError::ExtraAddressesPerType);
+							}
 						},
-						port: Readable::read(r)?,
-					});
-					addr_readpos += 1 + 18
-				},
-				3 => {
-					if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
-						return Err(DecodeError::ExtraAddressesPerType);
-					}
-					if addrlen < addr_readpos + 1 + 12 {
-						return Err(DecodeError::BadLengthDescriptor);
-					}
-					addresses.push(NetAddress::OnionV2 {
-						addr: {
-							let mut addr = [0; 10];
-							r.read_exact(&mut addr)?;
-							addr
+						NetAddress::OnionV2 { .. } => {
+							if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
+								return Err(DecodeError::ExtraAddressesPerType);
+							}
+						},
+						NetAddress::OnionV3 { .. } => {
+							if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
+								return Err(DecodeError::ExtraAddressesPerType);
+							}
 						},
-						port: Readable::read(r)?,
-					});
-					addr_readpos += 1 + 12
-				},
-				4 => {
-					if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
-						return Err(DecodeError::ExtraAddressesPerType);
 					}
-					if addrlen < addr_readpos + 1 + 37 {
+					if addr_len < addr_readpos + 1 + addr.len() {
 						return Err(DecodeError::BadLengthDescriptor);
 					}
-					addresses.push(NetAddress::OnionV3 {
-						ed25519_pubkey: Readable::read(r)?,
-						checksum: Readable::read(r)?,
-						version: Readable::read(r)?,
-						port: Readable::read(r)?,
-					});
-					addr_readpos += 1 + 37
+					addr_readpos += (1 + addr.len()) as u16;
+					addresses.push(addr);
 				},
-				_ => { excess = 1; break; }
+				Ok(Err(unknown_descriptor)) => {
+					excess = true;
+					excess_byte = unknown_descriptor;
+					break;
+				},
+				Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
+				Err(e) => return Err(e),
 			}
 		}
 
 		let mut excess_data = vec![];
-		let excess_address_data = if addr_readpos < addrlen {
-			let mut excess_address_data = vec![0; (addrlen - addr_readpos) as usize];
-			r.read_exact(&mut excess_address_data[excess..])?;
-			if excess == 1 {
-				excess_address_data[0] = f;
+		let excess_address_data = if addr_readpos < addr_len {
+			let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
+			r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
+			if excess {
+				excess_address_data[0] = excess_byte;
 			}
 			excess_address_data
 		} else {
-			if excess == 1 {
-				excess_data.push(f);
+			if excess {
+				excess_data.push(excess_byte);
 			}
 			Vec::new()
 		};
-
+		r.read_to_end(&mut excess_data)?;
 		Ok(UnsignedNodeAnnouncement {
-			features: features,
-			timestamp: timestamp,
-			node_id: node_id,
-			rgb: rgb,
-			alias: alias,
-			addresses: addresses,
-			excess_address_data: excess_address_data,
-			excess_data: {
-				r.read_to_end(&mut excess_data)?;
-				excess_data
-			},
+			features,
+			timestamp,
+			node_id,
+			rgb,
+			alias,
+			addresses,
+			excess_address_data,
+			excess_data,
 		})
 	}
 }
@@ -1268,6 +1382,7 @@ impl_writeable_len_match!(NodeAnnouncement, {
 mod tests {
 	use hex;
 	use ln::msgs;
+	use ln::msgs::OptionalField;
 	use util::ser::Writeable;
 	use secp256k1::key::{PublicKey,SecretKey};
 	use secp256k1::Secp256k1;
@@ -1278,7 +1393,7 @@ mod tests {
 			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],
 			next_local_commitment_number: 3,
 			next_remote_commitment_number: 4,
-			data_loss_protect: None,
+			data_loss_protect: OptionalField::Absent,
 		};
 
 		let encoded_value = cr.encode();
@@ -1292,14 +1407,14 @@ mod tests {
 	fn encoding_channel_reestablish_with_secret() {
 		let public_key = {
 			let secp_ctx = Secp256k1::new();
-			PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
+			PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
 		};
 
 		let cr = msgs::ChannelReestablish {
 			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],
 			next_local_commitment_number: 3,
 			next_remote_commitment_number: 4,
-			data_loss_protect: Some(msgs::DataLossProtect { your_last_per_commitment_secret: [9;32], my_current_per_commitment_point: public_key}),
+			data_loss_protect: OptionalField::Present(msgs::DataLossProtect { your_last_per_commitment_secret: [9;32], my_current_per_commitment_point: public_key}),
 		};
 
 		let encoded_value = cr.encode();