diff --git a/fuzz/src/msg_targets/utils.rs b/fuzz/src/msg_targets/utils.rs
index 2a7731ccd13..6125e5afd61 100644
--- a/fuzz/src/msg_targets/utils.rs
+++ b/fuzz/src/msg_targets/utils.rs
@@ -28,7 +28,7 @@ macro_rules! test_msg {
 		{
 			use lightning::util::ser::{Writeable, Readable};
 			let mut r = ::std::io::Cursor::new($data);
-			if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+			if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
 				let p = r.position() as usize;
 				let mut w = VecWriter(Vec::new());
 				msg.write(&mut w).unwrap();
@@ -48,11 +48,11 @@ macro_rules! test_msg_simple {
 		{
 			use lightning::util::ser::{Writeable, Readable};
 			let mut r = ::std::io::Cursor::new($data);
-			if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+			if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
 				let mut w = VecWriter(Vec::new());
 				msg.write(&mut w).unwrap();
 
-				let msg = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap();
+				let msg = <$MsgType as Readable>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap();
 				let mut w_two = VecWriter(Vec::new());
 				msg.write(&mut w_two).unwrap();
 				assert_eq!(&w.0[..], &w_two.0[..]);
@@ -69,7 +69,7 @@ macro_rules! test_msg_exact {
 		{
 			use lightning::util::ser::{Writeable, Readable};
 			let mut r = ::std::io::Cursor::new($data);
-			if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+			if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
 				let mut w = VecWriter(Vec::new());
 				msg.write(&mut w).unwrap();
 				assert_eq!(&r.into_inner()[..], &w.0[..]);
@@ -86,7 +86,7 @@ macro_rules! test_msg_hole {
 		{
 			use lightning::util::ser::{Writeable, Readable};
 			let mut r = ::std::io::Cursor::new($data);
-			if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+			if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
 				let mut w = VecWriter(Vec::new());
 				msg.write(&mut w).unwrap();
 				let p = w.0.len() as usize;
diff --git a/lightning/src/chain/keysinterface.rs b/lightning/src/chain/keysinterface.rs
index 544df015a8f..43a044524e4 100644
--- a/lightning/src/chain/keysinterface.rs
+++ b/lightning/src/chain/keysinterface.rs
@@ -115,8 +115,8 @@ impl Writeable for SpendableOutputDescriptor {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for SpendableOutputDescriptor {
-	fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for SpendableOutputDescriptor {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
 		match Readable::read(reader)? {
 			0u8 => Ok(SpendableOutputDescriptor::StaticOutput {
 				outpoint: Readable::read(reader)?,
@@ -381,8 +381,8 @@ impl Writeable for InMemoryChannelKeys {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for InMemoryChannelKeys {
-	fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for InMemoryChannelKeys {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
 		let funding_key = Readable::read(reader)?;
 		let revocation_base_key = Readable::read(reader)?;
 		let payment_base_key = Readable::read(reader)?;
diff --git a/lightning/src/ln/chan_utils.rs b/lightning/src/ln/chan_utils.rs
index 3fd489fa1a9..561448c8fbf 100644
--- a/lightning/src/ln/chan_utils.rs
+++ b/lightning/src/ln/chan_utils.rs
@@ -156,8 +156,8 @@ impl Writeable for CounterpartyCommitmentSecrets {
 		Ok(())
 	}
 }
-impl<R: ::std::io::Read> Readable<R> for CounterpartyCommitmentSecrets {
-	fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for CounterpartyCommitmentSecrets {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
 		let mut old_secrets = [([0; 32], 1 << 48); 49];
 		for &mut (ref mut secret, ref mut idx) in old_secrets.iter_mut() {
 			*secret = Readable::read(reader)?;
@@ -607,8 +607,8 @@ impl Writeable for LocalCommitmentTransaction {
 		Ok(())
 	}
 }
-impl<R: ::std::io::Read> Readable<R> for LocalCommitmentTransaction {
-	fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for LocalCommitmentTransaction {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
 		let tx = match Transaction::consensus_decode(reader.by_ref()) {
 			Ok(tx) => tx,
 			Err(e) => match e {
diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index 2e4f49ce837..f155a0bd295 100644
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -3811,9 +3811,9 @@ impl Writeable for InboundHTLCRemovalReason {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for InboundHTLCRemovalReason {
-	fn read(reader: &mut R) -> Result<Self, DecodeError> {
-		Ok(match <u8 as Readable<R>>::read(reader)? {
+impl Readable for InboundHTLCRemovalReason {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+		Ok(match <u8 as Readable>::read(reader)? {
 			0 => InboundHTLCRemovalReason::FailRelay(Readable::read(reader)?),
 			1 => InboundHTLCRemovalReason::FailMalformed((Readable::read(reader)?, Readable::read(reader)?)),
 			2 => InboundHTLCRemovalReason::Fulfill(Readable::read(reader)?),
@@ -3883,18 +3883,6 @@ impl<ChanSigner: ChannelKeys + Writeable> Writeable for Channel<ChanSigner> {
 			}
 		}
 
-		macro_rules! write_option {
-			($thing: expr) => {
-				match &$thing {
-					&None => 0u8.write(writer)?,
-					&Some(ref v) => {
-						1u8.write(writer)?;
-						v.write(writer)?;
-					},
-				}
-			}
-		}
-
 		(self.pending_outbound_htlcs.len() as u64).write(writer)?;
 		for htlc in self.pending_outbound_htlcs.iter() {
 			htlc.htlc_id.write(writer)?;
@@ -3912,15 +3900,15 @@ impl<ChanSigner: ChannelKeys + Writeable> Writeable for Channel<ChanSigner> {
 				},
 				&OutboundHTLCState::RemoteRemoved(ref fail_reason) => {
 					2u8.write(writer)?;
-					write_option!(*fail_reason);
+					fail_reason.write(writer)?;
 				},
 				&OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref fail_reason) => {
 					3u8.write(writer)?;
-					write_option!(*fail_reason);
+					fail_reason.write(writer)?;
 				},
 				&OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref fail_reason) => {
 					4u8.write(writer)?;
-					write_option!(*fail_reason);
+					fail_reason.write(writer)?;
 				},
 			}
 		}
@@ -3971,8 +3959,8 @@ impl<ChanSigner: ChannelKeys + Writeable> Writeable for Channel<ChanSigner> {
 			fail_reason.write(writer)?;
 		}
 
-		write_option!(self.pending_update_fee);
-		write_option!(self.holding_cell_update_fee);
+		self.pending_update_fee.write(writer)?;
+		self.holding_cell_update_fee.write(writer)?;
 
 		self.next_local_htlc_id.write(writer)?;
 		(self.next_remote_htlc_id - dropped_inbound_htlcs).write(writer)?;
@@ -3989,9 +3977,9 @@ impl<ChanSigner: ChannelKeys + Writeable> Writeable for Channel<ChanSigner> {
 			None => 0u8.write(writer)?,
 		}
 
-		write_option!(self.funding_txo);
-		write_option!(self.funding_tx_confirmed_in);
-		write_option!(self.short_channel_id);
+		self.funding_txo.write(writer)?;
+		self.funding_tx_confirmed_in.write(writer)?;
+		self.short_channel_id.write(writer)?;
 
 		self.last_block_connected.write(writer)?;
 		self.funding_tx_confirmations.write(writer)?;
@@ -4007,13 +3995,13 @@ impl<ChanSigner: ChannelKeys + Writeable> Writeable for Channel<ChanSigner> {
 		self.their_max_accepted_htlcs.write(writer)?;
 		self.minimum_depth.write(writer)?;
 
-		write_option!(self.their_pubkeys);
-		write_option!(self.their_cur_commitment_point);
+		self.their_pubkeys.write(writer)?;
+		self.their_cur_commitment_point.write(writer)?;
 
-		write_option!(self.their_prev_commitment_point);
+		self.their_prev_commitment_point.write(writer)?;
 		self.their_node_id.write(writer)?;
 
-		write_option!(self.their_shutdown_scriptpubkey);
+		self.their_shutdown_scriptpubkey.write(writer)?;
 
 		self.commitment_secrets.write(writer)?;
 
@@ -4022,8 +4010,8 @@ impl<ChanSigner: ChannelKeys + Writeable> Writeable for Channel<ChanSigner> {
 	}
 }
 
-impl<R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R, Arc<Logger>> for Channel<ChanSigner> {
-	fn read(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
+impl<ChanSigner: ChannelKeys + Readable> ReadableArgs<Arc<Logger>> for Channel<ChanSigner> {
+	fn read<R : ::std::io::Read>(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
 		let _ver: u8 = Readable::read(reader)?;
 		let min_ver: u8 = Readable::read(reader)?;
 		if min_ver > SERIALIZATION_VERSION {
@@ -4056,7 +4044,7 @@ impl<R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 				amount_msat: Readable::read(reader)?,
 				cltv_expiry: Readable::read(reader)?,
 				payment_hash: Readable::read(reader)?,
-				state: match <u8 as Readable<R>>::read(reader)? {
+				state: match <u8 as Readable>::read(reader)? {
 					1 => InboundHTLCState::AwaitingRemoteRevokeToAnnounce(Readable::read(reader)?),
 					2 => InboundHTLCState::AwaitingAnnouncedRemoteRevoke(Readable::read(reader)?),
 					3 => InboundHTLCState::Committed,
@@ -4075,7 +4063,7 @@ impl<R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 				cltv_expiry: Readable::read(reader)?,
 				payment_hash: Readable::read(reader)?,
 				source: Readable::read(reader)?,
-				state: match <u8 as Readable<R>>::read(reader)? {
+				state: match <u8 as Readable>::read(reader)? {
 					0 => OutboundHTLCState::LocalAnnounced(Box::new(Readable::read(reader)?)),
 					1 => OutboundHTLCState::Committed,
 					2 => OutboundHTLCState::RemoteRemoved(Readable::read(reader)?),
@@ -4089,7 +4077,7 @@ impl<R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 		let holding_cell_htlc_update_count: u64 = Readable::read(reader)?;
 		let mut holding_cell_htlc_updates = Vec::with_capacity(cmp::min(holding_cell_htlc_update_count as usize, OUR_MAX_HTLCS as usize*2));
 		for _ in 0..holding_cell_htlc_update_count {
-			holding_cell_htlc_updates.push(match <u8 as Readable<R>>::read(reader)? {
+			holding_cell_htlc_updates.push(match <u8 as Readable>::read(reader)? {
 				0 => HTLCUpdateAwaitingACK::AddHTLC {
 					amount_msat: Readable::read(reader)?,
 					cltv_expiry: Readable::read(reader)?,
@@ -4109,7 +4097,7 @@ impl<R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 			});
 		}
 
-		let resend_order = match <u8 as Readable<R>>::read(reader)? {
+		let resend_order = match <u8 as Readable>::read(reader)? {
 			0 => RAACommitmentOrder::CommitmentFirst,
 			1 => RAACommitmentOrder::RevokeAndACKFirst,
 			_ => return Err(DecodeError::InvalidValue),
@@ -4139,7 +4127,7 @@ impl<R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 		let channel_update_count = Readable::read(reader)?;
 		let feerate_per_kw = Readable::read(reader)?;
 
-		let last_sent_closing_fee = match <u8 as Readable<R>>::read(reader)? {
+		let last_sent_closing_fee = match <u8 as Readable>::read(reader)? {
 			0 => None,
 			1 => Some((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?)),
 			_ => return Err(DecodeError::InvalidValue),
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 63e32c1a57b..5f7e903fd20 100644
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -3062,8 +3062,8 @@ impl Writeable for PendingHTLCInfo {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for PendingHTLCInfo {
-	fn read(reader: &mut R) -> Result<PendingHTLCInfo, DecodeError> {
+impl Readable for PendingHTLCInfo {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<PendingHTLCInfo, DecodeError> {
 		Ok(PendingHTLCInfo {
 			onion_packet: Readable::read(reader)?,
 			incoming_shared_secret: Readable::read(reader)?,
@@ -3091,9 +3091,9 @@ impl Writeable for HTLCFailureMsg {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCFailureMsg {
-	fn read(reader: &mut R) -> Result<HTLCFailureMsg, DecodeError> {
-		match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCFailureMsg {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCFailureMsg, DecodeError> {
+		match <u8 as Readable>::read(reader)? {
 			0 => Ok(HTLCFailureMsg::Relay(Readable::read(reader)?)),
 			1 => Ok(HTLCFailureMsg::Malformed(Readable::read(reader)?)),
 			_ => Err(DecodeError::InvalidValue),
@@ -3117,9 +3117,9 @@ impl Writeable for PendingHTLCStatus {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for PendingHTLCStatus {
-	fn read(reader: &mut R) -> Result<PendingHTLCStatus, DecodeError> {
-		match <u8 as Readable<R>>::read(reader)? {
+impl Readable for PendingHTLCStatus {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<PendingHTLCStatus, DecodeError> {
+		match <u8 as Readable>::read(reader)? {
 			0 => Ok(PendingHTLCStatus::Forward(Readable::read(reader)?)),
 			1 => Ok(PendingHTLCStatus::Fail(Readable::read(reader)?)),
 			_ => Err(DecodeError::InvalidValue),
@@ -3151,9 +3151,9 @@ impl Writeable for HTLCSource {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCSource {
-	fn read(reader: &mut R) -> Result<HTLCSource, DecodeError> {
-		match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCSource {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCSource, DecodeError> {
+		match <u8 as Readable>::read(reader)? {
 			0 => Ok(HTLCSource::PreviousHopData(Readable::read(reader)?)),
 			1 => Ok(HTLCSource::OutboundRoute {
 				route: Readable::read(reader)?,
@@ -3182,9 +3182,9 @@ impl Writeable for HTLCFailReason {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCFailReason {
-	fn read(reader: &mut R) -> Result<HTLCFailReason, DecodeError> {
-		match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCFailReason {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCFailReason, DecodeError> {
+		match <u8 as Readable>::read(reader)? {
 			0 => Ok(HTLCFailReason::LightningError { err: Readable::read(reader)? }),
 			1 => Ok(HTLCFailReason::Reason {
 				failure_code: Readable::read(reader)?,
@@ -3214,9 +3214,9 @@ impl Writeable for HTLCForwardInfo {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCForwardInfo {
-	fn read(reader: &mut R) -> Result<HTLCForwardInfo, DecodeError> {
-		match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCForwardInfo {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCForwardInfo, DecodeError> {
+		match <u8 as Readable>::read(reader)? {
 			0 => Ok(HTLCForwardInfo::AddHTLC {
 				prev_short_channel_id: Readable::read(reader)?,
 				prev_htlc_id: Readable::read(reader)?,
@@ -3353,14 +3353,29 @@ pub struct ChannelManagerReadArgs<'a, ChanSigner: 'a + ChannelKeys, M: Deref, T:
 	pub channel_monitors: &'a mut HashMap<OutPoint, &'a mut ChannelMonitor<ChanSigner>>,
 }
 
-impl<'a, R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>, M: Deref, T: Deref, K: Deref, F: Deref>
-	ReadableArgs<R, ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)
+// Implement ReadableArgs for an Arc'd ChannelManager to make it a bit easier to work with the
+// SipmleArcChannelManager type:
+impl<'a, ChanSigner: ChannelKeys + Readable, M: Deref, T: Deref, K: Deref, F: Deref>
+	ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, Arc<ChannelManager<ChanSigner, M, T, K, F>>)
 	where M::Target: ManyChannelMonitor<ChanSigner>,
         T::Target: BroadcasterInterface,
         K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
         F::Target: FeeEstimator,
 {
-	fn read(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
+	fn read<R: ::std::io::Read>(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
+		let (blockhash, chan_manager) = <(Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)>::read(reader, args)?;
+		Ok((blockhash, Arc::new(chan_manager)))
+	}
+}
+
+impl<'a, ChanSigner: ChannelKeys + Readable, M: Deref, T: Deref, K: Deref, F: Deref>
+	ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)
+	where M::Target: ManyChannelMonitor<ChanSigner>,
+        T::Target: BroadcasterInterface,
+        K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
+        F::Target: FeeEstimator,
+{
+	fn read<R: ::std::io::Read>(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
 		let _ver: u8 = Readable::read(reader)?;
 		let min_ver: u8 = Readable::read(reader)?;
 		if min_ver > SERIALIZATION_VERSION {
diff --git a/lightning/src/ln/channelmonitor.rs b/lightning/src/ln/channelmonitor.rs
index 1bc8c76b49e..b1e8428bd0a 100644
--- a/lightning/src/ln/channelmonitor.rs
+++ b/lightning/src/ln/channelmonitor.rs
@@ -72,8 +72,8 @@ impl Writeable for ChannelMonitorUpdate {
 		Ok(())
 	}
 }
-impl<R: ::std::io::Read> Readable<R> for ChannelMonitorUpdate {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ChannelMonitorUpdate {
+	fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let update_id: u64 = Readable::read(r)?;
 		let len: u64 = Readable::read(r)?;
 		let mut updates = Vec::with_capacity(cmp::min(len as usize, MAX_ALLOC_SIZE / ::std::mem::size_of::<ChannelMonitorUpdateStep>()));
@@ -489,11 +489,7 @@ impl Writeable for InputMaterial  {
 				script.write(writer)?;
 				pubkey.write(writer)?;
 				writer.write_all(&key[..])?;
-				if *is_htlc {
-					writer.write_all(&[0; 1])?;
-				} else {
-					writer.write_all(&[1; 1])?;
-				}
+				is_htlc.write(writer)?;
 				writer.write_all(&byte_utils::be64_to_array(*amount))?;
 			},
 			&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref amount, ref locktime } => {
@@ -517,18 +513,14 @@ impl Writeable for InputMaterial  {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for InputMaterial {
-	fn read(reader: &mut R) -> Result<Self, DecodeError> {
-		let input_material = match <u8 as Readable<R>>::read(reader)? {
+impl Readable for InputMaterial {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+		let input_material = match <u8 as Readable>::read(reader)? {
 			0 => {
 				let script = Readable::read(reader)?;
 				let pubkey = Readable::read(reader)?;
 				let key = Readable::read(reader)?;
-				let is_htlc = match <u8 as Readable<R>>::read(reader)? {
-					0 => true,
-					1 => false,
-					_ => return Err(DecodeError::InvalidValue),
-				};
+				let is_htlc = Readable::read(reader)?;
 				let amount = Readable::read(reader)?;
 				InputMaterial::Revoked {
 					script,
@@ -624,8 +616,8 @@ impl Writeable for ClaimTxBumpMaterial  {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for ClaimTxBumpMaterial {
-	fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ClaimTxBumpMaterial {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
 		let height_timer = Readable::read(reader)?;
 		let feerate_previous = Readable::read(reader)?;
 		let soonest_timelock = Readable::read(reader)?;
@@ -698,13 +690,7 @@ impl Writeable for ChannelMonitorUpdateStep {
 				(htlc_outputs.len() as u64).write(w)?;
 				for &(ref output, ref source) in htlc_outputs.iter() {
 					output.write(w)?;
-					match source {
-						&None => 0u8.write(w)?,
-						&Some(ref s) => {
-							1u8.write(w)?;
-							s.write(w)?;
-						},
-					}
+					source.as_ref().map(|b| b.as_ref()).write(w)?;
 				}
 			},
 			&ChannelMonitorUpdateStep::PaymentPreimage { ref payment_preimage } => {
@@ -724,8 +710,8 @@ impl Writeable for ChannelMonitorUpdateStep {
 		Ok(())
 	}
 }
-impl<R: ::std::io::Read> Readable<R> for ChannelMonitorUpdateStep {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ChannelMonitorUpdateStep {
+	fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
 		match Readable::read(r)? {
 			0u8 => {
 				Ok(ChannelMonitorUpdateStep::LatestLocalCommitmentTXInfo {
@@ -751,7 +737,7 @@ impl<R: ::std::io::Read> Readable<R> for ChannelMonitorUpdateStep {
 						let len: u64 = Readable::read(r)?;
 						let mut res = Vec::new();
 						for _ in 0..len {
-							res.push((Readable::read(r)?, <Option<HTLCSource> as Readable<R>>::read(r)?.map(|o| Box::new(o))));
+							res.push((Readable::read(r)?, <Option<HTLCSource> as Readable>::read(r)?.map(|o| Box::new(o))));
 						}
 						res
 					},
@@ -973,18 +959,6 @@ impl<ChanSigner: ChannelKeys + Writeable> ChannelMonitor<ChanSigner> {
 		// Set in initial Channel-object creation, so should always be set by now:
 		U48(self.commitment_transaction_number_obscure_factor).write(writer)?;
 
-		macro_rules! write_option {
-			($thing: expr) => {
-				match $thing {
-					&Some(ref t) => {
-						1u8.write(writer)?;
-						t.write(writer)?;
-					},
-					&None => 0u8.write(writer)?,
-				}
-			}
-		}
-
 		match self.key_storage {
 			Storage::Local { ref keys, ref funding_key, ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref funding_info, ref current_remote_commitment_txid, ref prev_remote_commitment_txid } => {
 				writer.write_all(&[0; 1])?;
@@ -1055,7 +1029,7 @@ impl<ChanSigner: ChannelKeys + Writeable> ChannelMonitor<ChanSigner> {
 			writer.write_all(&byte_utils::be64_to_array(htlc_infos.len() as u64))?;
 			for &(ref htlc_output, ref htlc_source) in htlc_infos.iter() {
 				serialize_htlc_in_commitment!(htlc_output);
-				write_option!(htlc_source);
+				htlc_source.as_ref().map(|b| b.as_ref()).write(writer)?;
 			}
 		}
 
@@ -1098,7 +1072,7 @@ impl<ChanSigner: ChannelKeys + Writeable> ChannelMonitor<ChanSigner> {
 					} else {
 						0u8.write(writer)?;
 					}
-					write_option!(htlc_source);
+					htlc_source.write(writer)?;
 				}
 			}
 		}
@@ -3191,8 +3165,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 
 const MAX_ALLOC_SIZE: usize = 64*1024;
 
-impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R, Arc<Logger>> for (Sha256dHash, ChannelMonitor<ChanSigner>) {
-	fn read(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
+impl<ChanSigner: ChannelKeys + Readable> ReadableArgs<Arc<Logger>> for (Sha256dHash, ChannelMonitor<ChanSigner>) {
+	fn read<R: ::std::io::Read>(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
 		let secp_ctx = Secp256k1::new();
 		macro_rules! unwrap_obj {
 			($key: expr) => {
@@ -3210,9 +3184,9 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 		}
 
 		let latest_update_id: u64 = Readable::read(reader)?;
-		let commitment_transaction_number_obscure_factor = <U48 as Readable<R>>::read(reader)?.0;
+		let commitment_transaction_number_obscure_factor = <U48 as Readable>::read(reader)?.0;
 
-		let key_storage = match <u8 as Readable<R>>::read(reader)? {
+		let key_storage = match <u8 as Readable>::read(reader)? {
 			0 => {
 				let keys = Readable::read(reader)?;
 				let funding_key = Readable::read(reader)?;
@@ -3252,7 +3226,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 		let channel_value_satoshis = Some(Readable::read(reader)?);
 
 		let their_cur_revocation_points = {
-			let first_idx = <U48 as Readable<R>>::read(reader)?.0;
+			let first_idx = <U48 as Readable>::read(reader)?.0;
 			if first_idx == 0 {
 				None
 			} else {
@@ -3294,7 +3268,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 			let htlcs_count: u64 = Readable::read(reader)?;
 			let mut htlcs = Vec::with_capacity(cmp::min(htlcs_count as usize, MAX_ALLOC_SIZE / 32));
 			for _ in 0..htlcs_count {
-				htlcs.push((read_htlc_in_commitment!(), <Option<HTLCSource> as Readable<R>>::read(reader)?.map(|o: HTLCSource| Box::new(o))));
+				htlcs.push((read_htlc_in_commitment!(), <Option<HTLCSource> as Readable>::read(reader)?.map(|o: HTLCSource| Box::new(o))));
 			}
 			if let Some(_) = remote_claimable_outpoints.insert(txid, htlcs) {
 				return Err(DecodeError::InvalidValue);
@@ -3305,8 +3279,8 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 		let mut remote_commitment_txn_on_chain = HashMap::with_capacity(cmp::min(remote_commitment_txn_on_chain_len as usize, MAX_ALLOC_SIZE / 32));
 		for _ in 0..remote_commitment_txn_on_chain_len {
 			let txid: Sha256dHash = Readable::read(reader)?;
-			let commitment_number = <U48 as Readable<R>>::read(reader)?.0;
-			let outputs_count = <u64 as Readable<R>>::read(reader)?;
+			let commitment_number = <U48 as Readable>::read(reader)?.0;
+			let outputs_count = <u64 as Readable>::read(reader)?;
 			let mut outputs = Vec::with_capacity(cmp::min(outputs_count as usize, MAX_ALLOC_SIZE / 8));
 			for _ in 0..outputs_count {
 				outputs.push(Readable::read(reader)?);
@@ -3320,7 +3294,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 		let mut remote_hash_commitment_number = HashMap::with_capacity(cmp::min(remote_hash_commitment_number_len as usize, MAX_ALLOC_SIZE / 32));
 		for _ in 0..remote_hash_commitment_number_len {
 			let payment_hash: PaymentHash = Readable::read(reader)?;
-			let commitment_number = <U48 as Readable<R>>::read(reader)?.0;
+			let commitment_number = <U48 as Readable>::read(reader)?.0;
 			if let Some(_) = remote_hash_commitment_number.insert(payment_hash, commitment_number) {
 				return Err(DecodeError::InvalidValue);
 			}
@@ -3329,7 +3303,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 		macro_rules! read_local_tx {
 			() => {
 				{
-					let tx = <LocalCommitmentTransaction as Readable<R>>::read(reader)?;
+					let tx = <LocalCommitmentTransaction as Readable>::read(reader)?;
 					let revocation_key = Readable::read(reader)?;
 					let a_htlc_key = Readable::read(reader)?;
 					let b_htlc_key = Readable::read(reader)?;
@@ -3341,7 +3315,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 					let mut htlcs = Vec::with_capacity(cmp::min(htlcs_len as usize, MAX_ALLOC_SIZE / 128));
 					for _ in 0..htlcs_len {
 						let htlc = read_htlc_in_commitment!();
-						let sigs = match <u8 as Readable<R>>::read(reader)? {
+						let sigs = match <u8 as Readable>::read(reader)? {
 							0 => None,
 							1 => Some(Readable::read(reader)?),
 							_ => return Err(DecodeError::InvalidValue),
@@ -3358,7 +3332,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 			}
 		}
 
-		let prev_local_signed_commitment_tx = match <u8 as Readable<R>>::read(reader)? {
+		let prev_local_signed_commitment_tx = match <u8 as Readable>::read(reader)? {
 			0 => None,
 			1 => {
 				Some(read_local_tx!())
@@ -3366,7 +3340,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 			_ => return Err(DecodeError::InvalidValue),
 		};
 
-		let current_local_signed_commitment_tx = match <u8 as Readable<R>>::read(reader)? {
+		let current_local_signed_commitment_tx = match <u8 as Readable>::read(reader)? {
 			0 => None,
 			1 => {
 				Some(read_local_tx!())
@@ -3374,7 +3348,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 			_ => return Err(DecodeError::InvalidValue),
 		};
 
-		let current_remote_commitment_number = <U48 as Readable<R>>::read(reader)?.0;
+		let current_remote_commitment_number = <U48 as Readable>::read(reader)?.0;
 
 		let payment_preimages_len: u64 = Readable::read(reader)?;
 		let mut payment_preimages = HashMap::with_capacity(cmp::min(payment_preimages_len as usize, MAX_ALLOC_SIZE / 32));
@@ -3402,7 +3376,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 
 		let last_block_hash: Sha256dHash = Readable::read(reader)?;
 		let destination_script = Readable::read(reader)?;
-		let to_remote_rescue = match <u8 as Readable<R>>::read(reader)? {
+		let to_remote_rescue = match <u8 as Readable>::read(reader)? {
 			0 => None,
 			1 => {
 				let to_remote_script = Readable::read(reader)?;
@@ -3434,7 +3408,7 @@ impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R,
 			let events_len: u64 = Readable::read(reader)?;
 			let mut events = Vec::with_capacity(cmp::min(events_len as usize, MAX_ALLOC_SIZE / 128));
 			for _ in 0..events_len {
-				let ev = match <u8 as Readable<R>>::read(reader)? {
+				let ev = match <u8 as Readable>::read(reader)? {
 					0 => {
 						let claim_request = Readable::read(reader)?;
 						OnchainEvent::Claim {
diff --git a/lightning/src/ln/features.rs b/lightning/src/ln/features.rs
index 61a862c0c55..990e0478c4d 100644
--- a/lightning/src/ln/features.rs
+++ b/lightning/src/ln/features.rs
@@ -283,8 +283,8 @@ impl<T: sealed::Context> Writeable for Features<T> {
 	}
 }
 
-impl<R: ::std::io::Read, T: sealed::Context> Readable<R> for Features<T> {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl<T: sealed::Context> Readable for Features<T> {
+	fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let mut flags: Vec<u8> = Readable::read(r)?;
 		flags.reverse(); // Swap to little-endian
 		Ok(Self {
diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index 25927a8ee4c..655e3681de0 100644
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -6,7 +6,7 @@ use chain::transaction::OutPoint;
 use chain::keysinterface::KeysInterface;
 use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash};
 use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor};
-use ln::router::{Route, Router};
+use ln::router::{Route, Router, RouterReadArgs};
 use ln::features::InitFeatures;
 use ln::msgs;
 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
@@ -97,6 +97,36 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 			assert!(self.node.get_and_clear_pending_events().is_empty());
 			assert!(self.chan_monitor.added_monitors.lock().unwrap().is_empty());
 
+			// Check that if we serialize the Router, we can deserialize it again.
+			{
+				let mut w = test_utils::TestVecWriter(Vec::new());
+				self.router.write(&mut w).unwrap();
+				let deserialized_router = Router::read(&mut ::std::io::Cursor::new(&w.0), RouterReadArgs {
+					chain_monitor: Arc::clone(&self.chain_monitor) as Arc<chaininterface::ChainWatchInterface>,
+					logger: Arc::clone(&self.logger) as Arc<Logger>
+				}).unwrap();
+				let mut chan_progress = 0;
+				loop {
+					let orig_announcements = self.router.get_next_channel_announcements(chan_progress, 255);
+					let deserialized_announcements = deserialized_router.get_next_channel_announcements(chan_progress, 255);
+					assert!(orig_announcements == deserialized_announcements);
+					chan_progress = match orig_announcements.last() {
+						Some(announcement) => announcement.0.contents.short_channel_id + 1,
+						None => break,
+					};
+				}
+				let mut node_progress = None;
+				loop {
+					let orig_announcements = self.router.get_next_node_announcements(node_progress.as_ref(), 255);
+					let deserialized_announcements = deserialized_router.get_next_node_announcements(node_progress.as_ref(), 255);
+					assert!(orig_announcements == deserialized_announcements);
+					node_progress = match orig_announcements.last() {
+						Some(announcement) => Some(announcement.contents.node_id),
+						None => break,
+					};
+				}
+			}
+
 			// Check that if we serialize and then deserialize all our channel monitors we get the
 			// same set of outputs to watch for on chain as we have now. Note that if we write
 			// tests that fully close channels and remove the monitors at some point this may break.
diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs
index b50e35b96dc..8d23ac9a8e5 100644
--- a/lightning/src/ln/msgs.rs
+++ b/lightning/src/ln/msgs.rs
@@ -336,9 +336,9 @@ impl Writeable for NetAddress {
 	}
 }
 
-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)?;
+impl Readable for Result<NetAddress, u8> {
+	fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
+		let byte = <u8 as Readable>::read(reader)?;
 		match byte {
 			1 => {
 				Ok(Ok(NetAddress::IPv4 {
@@ -718,9 +718,9 @@ impl Writeable for OptionalField<Script> {
 	}
 }
 
-impl<R: Read> Readable<R> for OptionalField<Script> {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
-		match <u16 as Readable<R>>::read(r) {
+impl Readable for OptionalField<Script> {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		match <u16 as Readable>::read(r) {
 			Ok(len) => {
 				let mut buf = vec![0; len as usize];
 				r.read_exact(&mut buf)?;
@@ -777,14 +777,14 @@ impl Writeable for ChannelReestablish {
 	}
 }
 
-impl<R: Read> Readable<R> for ChannelReestablish{
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ChannelReestablish{
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		Ok(Self {
 			channel_id: Readable::read(r)?,
 			next_local_commitment_number: Readable::read(r)?,
 			next_remote_commitment_number: Readable::read(r)?,
 			data_loss_protect: {
-				match <[u8; 32] as Readable<R>>::read(r) {
+				match <[u8; 32] as Readable>::read(r) {
 					Ok(your_last_per_commitment_secret) =>
 						OptionalField::Present(DataLossProtect {
 							your_last_per_commitment_secret,
@@ -846,8 +846,8 @@ impl Writeable for Init {
 	}
 }
 
-impl<R: Read> Readable<R> for Init {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Init {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let global_features: InitFeatures = Readable::read(r)?;
 		let features: InitFeatures = Readable::read(r)?;
 		Ok(Init {
@@ -940,8 +940,8 @@ impl Writeable for OnionPacket {
 	}
 }
 
-impl<R: Read> Readable<R> for OnionPacket {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for OnionPacket {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		Ok(OnionPacket {
 			version: Readable::read(r)?,
 			public_key: {
@@ -993,8 +993,8 @@ impl Writeable for OnionHopData {
 	}
 }
 
-impl<R: Read> Readable<R> for OnionHopData {
-	fn read(mut r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for OnionHopData {
+	fn read<R: Read>(mut r: &mut R) -> Result<Self, DecodeError> {
 		use bitcoin::consensus::encode::{Decodable, Error, VarInt};
 		let v: VarInt = Decodable::consensus_decode(&mut r)
 			.map_err(|e| match e {
@@ -1049,8 +1049,8 @@ impl Writeable for Ping {
 	}
 }
 
-impl<R: Read> Readable<R> for Ping {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Ping {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		Ok(Ping {
 			ponglen: Readable::read(r)?,
 			byteslen: {
@@ -1070,8 +1070,8 @@ impl Writeable for Pong {
 	}
 }
 
-impl<R: Read> Readable<R> for Pong {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Pong {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		Ok(Pong {
 			byteslen: {
 				let byteslen = Readable::read(r)?;
@@ -1097,8 +1097,8 @@ impl Writeable for UnsignedChannelAnnouncement {
 	}
 }
 
-impl<R: Read> Readable<R> for UnsignedChannelAnnouncement {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for UnsignedChannelAnnouncement {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		Ok(Self {
 			features: Readable::read(r)?,
 			chain_hash: Readable::read(r)?,
@@ -1143,8 +1143,8 @@ impl Writeable for UnsignedChannelUpdate {
 	}
 }
 
-impl<R: Read> Readable<R> for UnsignedChannelUpdate {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for UnsignedChannelUpdate {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		Ok(Self {
 			chain_hash: Readable::read(r)?,
 			short_channel_id: Readable::read(r)?,
@@ -1181,12 +1181,12 @@ impl Writeable for ErrorMessage {
 	}
 }
 
-impl<R: Read> Readable<R> for ErrorMessage {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ErrorMessage {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		Ok(Self {
 			channel_id: Readable::read(r)?,
 			data: {
-				let mut sz: usize = <u16 as Readable<R>>::read(r)? as usize;
+				let mut sz: usize = <u16 as Readable>::read(r)? as usize;
 				let mut data = vec![];
 				let data_len = r.read_to_end(&mut data)?;
 				sz = cmp::min(data_len, sz);
@@ -1225,8 +1225,8 @@ impl Writeable for UnsignedNodeAnnouncement {
 	}
 }
 
-impl<R: Read> Readable<R> for UnsignedNodeAnnouncement {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for UnsignedNodeAnnouncement {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let features: NodeFeatures = Readable::read(r)?;
 		let timestamp: u32 = Readable::read(r)?;
 		let node_id: PublicKey = Readable::read(r)?;
diff --git a/lightning/src/ln/router.rs b/lightning/src/ln/router.rs
index 36e68462c39..2b23ae56ddf 100644
--- a/lightning/src/ln/router.rs
+++ b/lightning/src/ln/router.rs
@@ -71,8 +71,8 @@ impl Writeable for Route {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for Route {
-	fn read(reader: &mut R) -> Result<Route, DecodeError> {
+impl Readable for Route {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Route, DecodeError> {
 		let hops_count: u8 = Readable::read(reader)?;
 		let mut hops = Vec::with_capacity(hops_count as usize);
 		for _ in 0..hops_count {
@@ -195,8 +195,8 @@ impl Writeable for NodeInfo {
 
 const MAX_ALLOC_SIZE: u64 = 64*1024;
 
-impl<R: ::std::io::Read> Readable<R> for NodeInfo {
-	fn read(reader: &mut R) -> Result<NodeInfo, DecodeError> {
+impl Readable for NodeInfo {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<NodeInfo, DecodeError> {
 		let channels_count: u64 = Readable::read(reader)?;
 		let mut channels = Vec::with_capacity(cmp::min(channels_count, MAX_ALLOC_SIZE / 8) as usize);
 		for _ in 0..channels_count {
@@ -261,8 +261,8 @@ impl Writeable for NetworkMap {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for NetworkMap {
-	fn read(reader: &mut R) -> Result<NetworkMap, DecodeError> {
+impl Readable for NetworkMap {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<NetworkMap, DecodeError> {
 		let channels_count: u64 = Readable::read(reader)?;
 		let mut channels = BTreeMap::new();
 		for _ in 0..channels_count {
@@ -381,8 +381,8 @@ pub struct RouterReadArgs {
 	pub logger: Arc<Logger>,
 }
 
-impl<R: ::std::io::Read> ReadableArgs<R, RouterReadArgs> for Router {
-	fn read(reader: &mut R, args: RouterReadArgs) -> Result<Router, DecodeError> {
+impl ReadableArgs<RouterReadArgs> for Router {
+	fn read<R: ::std::io::Read>(reader: &mut R, args: RouterReadArgs) -> Result<Router, DecodeError> {
 		let _ver: u8 = Readable::read(reader)?;
 		let min_ver: u8 = Readable::read(reader)?;
 		if min_ver > SERIALIZATION_VERSION {
diff --git a/lightning/src/ln/wire.rs b/lightning/src/ln/wire.rs
index c1a596b0c6c..dfd11fc7e57 100644
--- a/lightning/src/ln/wire.rs
+++ b/lightning/src/ln/wire.rs
@@ -106,7 +106,7 @@ impl ::std::fmt::Display for MessageType {
 ///
 /// Returns an error if the message payload code not be decoded as the specified type.
 pub fn read<R: ::std::io::Read>(buffer: &mut R) -> Result<Message, msgs::DecodeError> {
-	let message_type = <u16 as Readable<R>>::read(buffer)?;
+	let message_type = <u16 as Readable>::read(buffer)?;
 	match message_type {
 		msgs::Init::TYPE => {
 			Ok(Message::Init(Readable::read(buffer)?))
diff --git a/lightning/src/util/enforcing_trait_impls.rs b/lightning/src/util/enforcing_trait_impls.rs
index d66f5373e7a..26c3a07775f 100644
--- a/lightning/src/util/enforcing_trait_impls.rs
+++ b/lightning/src/util/enforcing_trait_impls.rs
@@ -101,8 +101,8 @@ impl Writeable for EnforcingChannelKeys {
 	}
 }
 
-impl<R: ::std::io::Read> Readable<R> for EnforcingChannelKeys {
-	fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for EnforcingChannelKeys {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
 		let inner = Readable::read(reader)?;
 		let obscure_and_last = Readable::read(reader)?;
 		Ok(EnforcingChannelKeys {
diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs
index d165f200adb..5fb70f65417 100644
--- a/lightning/src/util/events.rs
+++ b/lightning/src/util/events.rs
@@ -154,8 +154,8 @@ impl Writeable for Event {
 		Ok(())
 	}
 }
-impl<R: ::std::io::Read> MaybeReadable<R> for Event {
-	fn read(reader: &mut R) -> Result<Option<Self>, msgs::DecodeError> {
+impl MaybeReadable for Event {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Option<Self>, msgs::DecodeError> {
 		match Readable::read(reader)? {
 			0u8 => Ok(None),
 			1u8 => Ok(Some(Event::FundingBroadcastSafe {
diff --git a/lightning/src/util/ser.rs b/lightning/src/util/ser.rs
index 96936fe9541..60d5329d781 100644
--- a/lightning/src/util/ser.rs
+++ b/lightning/src/util/ser.rs
@@ -172,32 +172,33 @@ pub trait Writeable {
 	}
 }
 
+impl<'a, T: Writeable> Writeable for &'a T {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> { (*self).write(writer) }
+}
+
 /// A trait that various rust-lightning types implement allowing them to be read in from a Read
-pub trait Readable<R>
-	where Self: Sized,
-	      R: Read
+pub trait Readable
+	where Self: Sized
 {
 	/// Reads a Self in from the given Read
-	fn read(reader: &mut R) -> Result<Self, DecodeError>;
+	fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError>;
 }
 
 /// A trait that various higher-level rust-lightning types implement allowing them to be read in
 /// from a Read given some additional set of arguments which is required to deserialize.
-pub trait ReadableArgs<R, P>
-	where Self: Sized,
-	      R: Read
+pub trait ReadableArgs<P>
+	where Self: Sized
 {
 	/// Reads a Self in from the given Read
-	fn read(reader: &mut R, params: P) -> Result<Self, DecodeError>;
+	fn read<R: Read>(reader: &mut R, params: P) -> Result<Self, DecodeError>;
 }
 
 /// A trait that various rust-lightning types implement allowing them to (maybe) be read in from a Read
-pub trait MaybeReadable<R>
-	where Self: Sized,
-	      R: Read
+pub trait MaybeReadable
+	where Self: Sized
 {
 	/// Reads a Self in from the given Read
-	fn read(reader: &mut R) -> Result<Option<Self>, DecodeError>;
+	fn read<R: Read>(reader: &mut R) -> Result<Option<Self>, DecodeError>;
 }
 
 pub(crate) struct U48(pub u64);
@@ -207,9 +208,9 @@ impl Writeable for U48 {
 		writer.write_all(&be48_to_array(self.0))
 	}
 }
-impl<R: Read> Readable<R> for U48 {
+impl Readable for U48 {
 	#[inline]
-	fn read(reader: &mut R) -> Result<U48, DecodeError> {
+	fn read<R: Read>(reader: &mut R) -> Result<U48, DecodeError> {
 		let mut buf = [0; 6];
 		reader.read_exact(&mut buf)?;
 		Ok(U48(slice_to_be48(&buf)))
@@ -246,9 +247,9 @@ impl Writeable for BigSize {
 		}
 	}
 }
-impl<R: Read> Readable<R> for BigSize {
+impl Readable for BigSize {
 	#[inline]
-	fn read(reader: &mut R) -> Result<BigSize, DecodeError> {
+	fn read<R: Read>(reader: &mut R) -> Result<BigSize, DecodeError> {
 		let n: u8 = Readable::read(reader)?;
 		match n {
 			0xFF => {
@@ -301,17 +302,17 @@ macro_rules! impl_writeable_primitive {
 				writer.write_all(&$meth_write(self.0)[(self.0.leading_zeros()/8) as usize..$len])
 			}
 		}
-		impl<R: Read> Readable<R> for $val_type {
+		impl Readable for $val_type {
 			#[inline]
-			fn read(reader: &mut R) -> Result<$val_type, DecodeError> {
+			fn read<R: Read>(reader: &mut R) -> Result<$val_type, DecodeError> {
 				let mut buf = [0; $len];
 				reader.read_exact(&mut buf)?;
 				Ok($meth_read(&buf))
 			}
 		}
-		impl<R: Read> Readable<R> for HighZeroBytesDroppedVarInt<$val_type> {
+		impl Readable for HighZeroBytesDroppedVarInt<$val_type> {
 			#[inline]
-			fn read(reader: &mut R) -> Result<HighZeroBytesDroppedVarInt<$val_type>, DecodeError> {
+			fn read<R: Read>(reader: &mut R) -> Result<HighZeroBytesDroppedVarInt<$val_type>, DecodeError> {
 				// We need to accept short reads (read_len == 0) as "EOF" and handle them as simply
 				// the high bytes being dropped. To do so, we start reading into the middle of buf
 				// and then convert the appropriate number of bytes with extra high bytes out of
@@ -346,9 +347,9 @@ impl Writeable for u8 {
 		writer.write_all(&[*self])
 	}
 }
-impl<R: Read> Readable<R> for u8 {
+impl Readable for u8 {
 	#[inline]
-	fn read(reader: &mut R) -> Result<u8, DecodeError> {
+	fn read<R: Read>(reader: &mut R) -> Result<u8, DecodeError> {
 		let mut buf = [0; 1];
 		reader.read_exact(&mut buf)?;
 		Ok(buf[0])
@@ -361,9 +362,9 @@ impl Writeable for bool {
 		writer.write_all(&[if *self {1} else {0}])
 	}
 }
-impl<R: Read> Readable<R> for bool {
+impl Readable for bool {
 	#[inline]
-	fn read(reader: &mut R) -> Result<bool, DecodeError> {
+	fn read<R: Read>(reader: &mut R) -> Result<bool, DecodeError> {
 		let mut buf = [0; 1];
 		reader.read_exact(&mut buf)?;
 		if buf[0] != 0 && buf[0] != 1 {
@@ -384,10 +385,10 @@ macro_rules! impl_array {
 			}
 		}
 
-		impl<R: Read> Readable<R> for [u8; $size]
+		impl Readable for [u8; $size]
 		{
 			#[inline]
-			fn read(r: &mut R) -> Result<Self, DecodeError> {
+			fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 				let mut buf = [0u8; $size];
 				r.read_exact(&mut buf)?;
 				Ok(buf)
@@ -422,13 +423,12 @@ impl<K, V> Writeable for HashMap<K, V>
 	}
 }
 
-impl<R, K, V> Readable<R> for HashMap<K, V>
-	where R: Read,
-	      K: Readable<R> + Eq + Hash,
-	      V: Readable<R>
+impl<K, V> Readable for HashMap<K, V>
+	where K: Readable + Eq + Hash,
+	      V: Readable
 {
 	#[inline]
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let len: u16 = Readable::read(r)?;
 		let mut ret = HashMap::with_capacity(len as usize);
 		for _ in 0..len {
@@ -447,9 +447,9 @@ impl Writeable for Vec<u8> {
 	}
 }
 
-impl<R: Read> Readable<R> for Vec<u8> {
+impl Readable for Vec<u8> {
 	#[inline]
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let len: u16 = Readable::read(r)?;
 		let mut ret = Vec::with_capacity(len as usize);
 		ret.resize(len as usize, 0);
@@ -468,9 +468,9 @@ impl Writeable for Vec<Signature> {
 	}
 }
 
-impl<R: Read> Readable<R> for Vec<Signature> {
+impl Readable for Vec<Signature> {
 	#[inline]
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let len: u16 = Readable::read(r)?;
 		let byte_size = (len as usize)
 		                .checked_mul(33)
@@ -491,9 +491,9 @@ impl Writeable for Script {
 	}
 }
 
-impl<R: Read> Readable<R> for Script {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
-		let len = <u16 as Readable<R>>::read(r)? as usize;
+impl Readable for Script {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let len = <u16 as Readable>::read(r)? as usize;
 		let mut buf = vec![0; len];
 		r.read_exact(&mut buf)?;
 		Ok(Script::from(buf))
@@ -506,8 +506,8 @@ impl Writeable for PublicKey {
 	}
 }
 
-impl<R: Read> Readable<R> for PublicKey {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for PublicKey {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let buf: [u8; 33] = Readable::read(r)?;
 		match PublicKey::from_slice(&buf) {
 			Ok(key) => Ok(key),
@@ -524,8 +524,8 @@ impl Writeable for SecretKey {
 	}
 }
 
-impl<R: Read> Readable<R> for SecretKey {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for SecretKey {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let buf: [u8; 32] = Readable::read(r)?;
 		match SecretKey::from_slice(&buf) {
 			Ok(key) => Ok(key),
@@ -540,8 +540,8 @@ impl Writeable for Sha256dHash {
 	}
 }
 
-impl<R: Read> Readable<R> for Sha256dHash {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Sha256dHash {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		use bitcoin_hashes::Hash;
 
 		let buf: [u8; 32] = Readable::read(r)?;
@@ -555,8 +555,8 @@ impl Writeable for Signature {
 	}
 }
 
-impl<R: Read> Readable<R> for Signature {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Signature {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let buf: [u8; 64] = Readable::read(r)?;
 		match Signature::from_compact(&buf) {
 			Ok(sig) => Ok(sig),
@@ -571,8 +571,8 @@ impl Writeable for PaymentPreimage {
 	}
 }
 
-impl<R: Read> Readable<R> for PaymentPreimage {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for PaymentPreimage {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let buf: [u8; 32] = Readable::read(r)?;
 		Ok(PaymentPreimage(buf))
 	}
@@ -584,8 +584,8 @@ impl Writeable for PaymentHash {
 	}
 }
 
-impl<R: Read> Readable<R> for PaymentHash {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for PaymentHash {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let buf: [u8; 32] = Readable::read(r)?;
 		Ok(PaymentHash(buf))
 	}
@@ -596,7 +596,9 @@ impl<T: Writeable> Writeable for Option<T> {
 		match *self {
 			None => 0u8.write(w)?,
 			Some(ref data) => {
-				1u8.write(w)?;
+				let mut len_calc = LengthCalculatingWriter(0);
+				data.write(&mut len_calc).expect("No in-memory data may fail to serialize");
+				BigSize(len_calc.0 as u64 + 1).write(w)?;
 				data.write(w)?;
 			}
 		}
@@ -604,15 +606,15 @@ impl<T: Writeable> Writeable for Option<T> {
 	}
 }
 
-impl<R, T> Readable<R> for Option<T>
-	where R: Read,
-	      T: Readable<R>
+impl<T: Readable> Readable for Option<T>
 {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
-		match <u8 as Readable<R>>::read(r)? {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		match BigSize::read(r)?.0 {
 			0 => Ok(None),
-			1 => Ok(Some(Readable::read(r)?)),
-			_ => return Err(DecodeError::InvalidValue),
+			len => {
+				let mut reader = FixedLengthReader::new(r, len - 1);
+				Ok(Some(Readable::read(&mut reader)?))
+			}
 		}
 	}
 }
@@ -625,8 +627,8 @@ impl Writeable for OutPoint {
 	}
 }
 
-impl<R: Read> Readable<R> for OutPoint {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for OutPoint {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let txid = Readable::read(r)?;
 		let vout = Readable::read(r)?;
 		Ok(OutPoint {
@@ -648,8 +650,8 @@ macro_rules! impl_consensus_ser {
 			}
 		}
 
-		impl<R: Read> Readable<R> for $bitcoin_type {
-			fn read(r: &mut R) -> Result<Self, DecodeError> {
+		impl Readable for $bitcoin_type {
+			fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 				match consensus::encode::Decodable::consensus_decode(r) {
 					Ok(t) => Ok(t),
 					Err(consensus::encode::Error::Io(ref e)) if e.kind() == ::std::io::ErrorKind::UnexpectedEof => Err(DecodeError::ShortRead),
@@ -663,8 +665,8 @@ macro_rules! impl_consensus_ser {
 impl_consensus_ser!(Transaction);
 impl_consensus_ser!(TxOut);
 
-impl<R: Read, T: Readable<R>> Readable<R> for Mutex<T> {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl<T: Readable> Readable for Mutex<T> {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let t: T = Readable::read(r)?;
 		Ok(Mutex::new(t))
 	}
@@ -675,8 +677,8 @@ impl<T: Writeable> Writeable for Mutex<T> {
 	}
 }
 
-impl<R: Read, A: Readable<R>, B: Readable<R>> Readable<R> for (A, B) {
-	fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl<A: Readable, B: Readable> Readable for (A, B) {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let a: A = Readable::read(r)?;
 		let b: B = Readable::read(r)?;
 		Ok((a, b))
diff --git a/lightning/src/util/ser_macros.rs b/lightning/src/util/ser_macros.rs
index 766d4ee2d78..28bd0e6882b 100644
--- a/lightning/src/util/ser_macros.rs
+++ b/lightning/src/util/ser_macros.rs
@@ -116,8 +116,8 @@ macro_rules! impl_writeable {
 			}
 		}
 
-		impl<R: ::std::io::Read> ::util::ser::Readable<R> for $st {
-			fn read(r: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
+		impl ::util::ser::Readable for $st {
+			fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
 				Ok(Self {
 					$($field: ::util::ser::Readable::read(r)?),*
 				})
@@ -137,8 +137,8 @@ macro_rules! impl_writeable_len_match {
 			}
 		}
 
-		impl<R: ::std::io::Read> Readable<R> for $st {
-			fn read(r: &mut R) -> Result<Self, DecodeError> {
+		impl ::util::ser::Readable for $st {
+			fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
 				Ok(Self {
 					$($field: Readable::read(r)?),*
 				})
@@ -219,9 +219,9 @@ mod tests {
 			(0xdeadbeef1badbeef, 0x1bad1dea, Some(0x01020304)));
 	}
 
-	impl<R: Read> Readable<R> for (PublicKey, u64, u64) {
+	impl Readable for (PublicKey, u64, u64) {
 		#[inline]
-		fn read(reader: &mut R) -> Result<(PublicKey, u64, u64), DecodeError> {
+		fn read<R: Read>(reader: &mut R) -> Result<(PublicKey, u64, u64), DecodeError> {
 			Ok((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?))
 		}
 	}