Use LengthLimitedReadable for all read-to-end Readables

valentinewallace · valentinewallace · commit 3ddcf9ce5fad · 2025-03-07T16:38:57.000-05:00
When deserializing these structs, they will consume the reader until it is out
of bytes. Therefore, it's safer if they are only provided with readers that
limit how much of the byte stream will be read.

Most of the relevant structs were updated in the previous commit when we
transitioned impl_writeable_msg to use LengthReadable, here we finish the job.
diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs
@@ -2412,8 +2412,8 @@ impl Writeable for AcceptChannel {
 	}
 }
 
-impl Readable for AcceptChannel {
-	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+impl LengthReadable for AcceptChannel {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let temporary_channel_id: ChannelId = Readable::read(r)?;
 		let dust_limit_satoshis: u64 = Readable::read(r)?;
 		let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
@@ -2497,8 +2497,8 @@ impl Writeable for AcceptChannelV2 {
 	}
 }
 
-impl Readable for AcceptChannelV2 {
-	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+impl LengthReadable for AcceptChannelV2 {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let temporary_channel_id: ChannelId = Readable::read(r)?;
 		let funding_satoshis: u64 = Readable::read(r)?;
 		let dust_limit_satoshis: u64 = Readable::read(r)?;
@@ -2760,8 +2760,8 @@ impl Writeable for Init {
 	}
 }
 
-impl Readable for Init {
-	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+impl LengthReadable for Init {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let global_features: InitFeatures = Readable::read(r)?;
 		let features: InitFeatures = Readable::read(r)?;
 		let mut remote_network_address: Option<SocketAddress> = None;
@@ -2806,8 +2806,8 @@ impl Writeable for OpenChannel {
 	}
 }
 
-impl Readable for OpenChannel {
-	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+impl LengthReadable for OpenChannel {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let chain_hash: ChainHash = Readable::read(r)?;
 		let temporary_channel_id: ChannelId = Readable::read(r)?;
 		let funding_satoshis: u64 = Readable::read(r)?;
@@ -2890,8 +2890,8 @@ impl Writeable for OpenChannelV2 {
 	}
 }
 
-impl Readable for OpenChannelV2 {
-	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+impl LengthReadable for OpenChannelV2 {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let chain_hash: ChainHash = Readable::read(r)?;
 		let temporary_channel_id: ChannelId = Readable::read(r)?;
 		let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
diff --git a/lightning/src/ln/wire.rs b/lightning/src/ln/wire.rs
@@ -257,7 +257,9 @@ where
 	H::Target: CustomMessageReader<CustomMessage = T>,
 {
 	match message_type {
-		msgs::Init::TYPE => Ok(Message::Init(Readable::read(buffer)?)),
+		msgs::Init::TYPE => {
+			Ok(Message::Init(LengthReadable::read_from_fixed_length_buffer(buffer)?))
+		},
 		msgs::ErrorMessage::TYPE => Ok(Message::Error(Readable::read(buffer)?)),
 		msgs::WarningMessage::TYPE => Ok(Message::Warning(Readable::read(buffer)?)),
 		msgs::Ping::TYPE => Ok(Message::Ping(Readable::read(buffer)?)),
@@ -268,10 +270,18 @@ where
 		msgs::PeerStorageRetrieval::TYPE => Ok(Message::PeerStorageRetrieval(
 			LengthReadable::read_from_fixed_length_buffer(buffer)?,
 		)),
-		msgs::OpenChannel::TYPE => Ok(Message::OpenChannel(Readable::read(buffer)?)),
-		msgs::OpenChannelV2::TYPE => Ok(Message::OpenChannelV2(Readable::read(buffer)?)),
-		msgs::AcceptChannel::TYPE => Ok(Message::AcceptChannel(Readable::read(buffer)?)),
-		msgs::AcceptChannelV2::TYPE => Ok(Message::AcceptChannelV2(Readable::read(buffer)?)),
+		msgs::OpenChannel::TYPE => {
+			Ok(Message::OpenChannel(LengthReadable::read_from_fixed_length_buffer(buffer)?))
+		},
+		msgs::OpenChannelV2::TYPE => {
+			Ok(Message::OpenChannelV2(LengthReadable::read_from_fixed_length_buffer(buffer)?))
+		},
+		msgs::AcceptChannel::TYPE => {
+			Ok(Message::AcceptChannel(LengthReadable::read_from_fixed_length_buffer(buffer)?))
+		},
+		msgs::AcceptChannelV2::TYPE => {
+			Ok(Message::AcceptChannelV2(LengthReadable::read_from_fixed_length_buffer(buffer)?))
+		},
 		msgs::FundingCreated::TYPE => {
 			Ok(Message::FundingCreated(LengthReadable::read_from_fixed_length_buffer(buffer)?))
 		},
diff --git a/lightning/src/offers/invoice.rs b/lightning/src/offers/invoice.rs
@@ -148,8 +148,8 @@ use crate::offers::signer::{self, Metadata};
 use crate::types::features::{Bolt12InvoiceFeatures, InvoiceRequestFeatures, OfferFeatures};
 use crate::types::payment::PaymentHash;
 use crate::util::ser::{
-	CursorReadable, HighZeroBytesDroppedBigSize, Iterable, Readable, WithoutLength, Writeable,
-	Writer,
+	CursorReadable, HighZeroBytesDroppedBigSize, Iterable, LengthLimitedRead, LengthReadable,
+	WithoutLength, Writeable, Writer,
 };
 use crate::util::string::PrintableString;
 use bitcoin::address::Address;
@@ -1398,9 +1398,11 @@ impl Writeable for Bolt12Invoice {
 	}
 }
 
-impl Readable for Bolt12Invoice {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-		let bytes: WithoutLength<Vec<u8>> = Readable::read(reader)?;
+impl LengthReadable for Bolt12Invoice {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(
+		reader: &mut R,
+	) -> Result<Self, DecodeError> {
+		let bytes: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(reader)?;
 		Self::try_from(bytes.0).map_err(|_| DecodeError::InvalidValue)
 	}
 }
diff --git a/lightning/src/offers/invoice_request.rs b/lightning/src/offers/invoice_request.rs
@@ -86,7 +86,8 @@ use crate::onion_message::dns_resolution::HumanReadableName;
 use crate::types::features::InvoiceRequestFeatures;
 use crate::types::payment::PaymentHash;
 use crate::util::ser::{
-	CursorReadable, HighZeroBytesDroppedBigSize, Readable, WithoutLength, Writeable, Writer,
+	CursorReadable, HighZeroBytesDroppedBigSize, LengthLimitedRead, LengthReadable, Readable,
+	WithoutLength, Writeable, Writer,
 };
 use crate::util::string::{PrintableString, UntrustedString};
 use bitcoin::constants::ChainHash;
@@ -1119,9 +1120,9 @@ impl Writeable for InvoiceRequestContents {
 	}
 }
 
-impl Readable for InvoiceRequest {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-		let bytes: WithoutLength<Vec<u8>> = Readable::read(reader)?;
+impl LengthReadable for InvoiceRequest {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
+		let bytes: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(r)?;
 		Self::try_from(bytes.0).map_err(|_| DecodeError::InvalidValue)
 	}
 }
diff --git a/lightning/src/offers/offer.rs b/lightning/src/offers/offer.rs
@@ -88,7 +88,8 @@ use crate::offers::parse::{Bech32Encode, Bolt12ParseError, Bolt12SemanticError,
 use crate::offers::signer::{self, Metadata, MetadataMaterial};
 use crate::types::features::OfferFeatures;
 use crate::util::ser::{
-	CursorReadable, HighZeroBytesDroppedBigSize, Readable, WithoutLength, Writeable, Writer,
+	CursorReadable, HighZeroBytesDroppedBigSize, LengthLimitedRead, LengthReadable, Readable,
+	WithoutLength, Writeable, Writer,
 };
 use crate::util::string::PrintableString;
 use bitcoin::constants::ChainHash;
@@ -1033,9 +1034,11 @@ impl OfferContents {
 	}
 }
 
-impl Readable for Offer {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-		let bytes: WithoutLength<Vec<u8>> = Readable::read(reader)?;
+impl LengthReadable for Offer {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(
+		reader: &mut R,
+	) -> Result<Self, DecodeError> {
+		let bytes: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(reader)?;
 		Self::try_from(bytes.0).map_err(|_| DecodeError::InvalidValue)
 	}
 }
diff --git a/lightning/src/offers/refund.rs b/lightning/src/offers/refund.rs
@@ -102,7 +102,9 @@ use crate::offers::signer::{self, Metadata, MetadataMaterial};
 use crate::sign::EntropySource;
 use crate::types::features::InvoiceRequestFeatures;
 use crate::types::payment::PaymentHash;
-use crate::util::ser::{CursorReadable, Readable, WithoutLength, Writeable, Writer};
+use crate::util::ser::{
+	CursorReadable, LengthLimitedRead, LengthReadable, WithoutLength, Writeable, Writer,
+};
 use crate::util::string::PrintableString;
 use bitcoin::constants::ChainHash;
 use bitcoin::network::Network;
@@ -822,9 +824,11 @@ impl RefundContents {
 	}
 }
 
-impl Readable for Refund {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-		let bytes: WithoutLength<Vec<u8>> = Readable::read(reader)?;
+impl LengthReadable for Refund {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(
+		reader: &mut R,
+	) -> Result<Self, DecodeError> {
+		let bytes: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(reader)?;
 		Self::try_from(bytes.0).map_err(|_| DecodeError::InvalidValue)
 	}
 }
diff --git a/lightning/src/util/ser.rs b/lightning/src/util/ser.rs
@@ -740,10 +740,10 @@ impl Writeable for WithoutLength<&String> {
 		w.write_all(self.0.as_bytes())
 	}
 }
-impl Readable for WithoutLength<String> {
+impl LengthReadable for WithoutLength<String> {
 	#[inline]
-	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
-		let v: WithoutLength<Vec<u8>> = Readable::read(r)?;
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
+		let v: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(r)?;
 		Ok(Self(String::from_utf8(v.0).map_err(|_| DecodeError::InvalidValue)?))
 	}
 }
@@ -772,10 +772,10 @@ impl Writeable for WithoutLength<&UntrustedString> {
 		WithoutLength(&self.0 .0).write(w)
 	}
 }
-impl Readable for WithoutLength<UntrustedString> {
+impl LengthReadable for WithoutLength<UntrustedString> {
 	#[inline]
-	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
-		let s: WithoutLength<String> = Readable::read(r)?;
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
+		let s: WithoutLength<String> = LengthReadable::read_from_fixed_length_buffer(r)?;
 		Ok(Self(UntrustedString(s.0)))
 	}
 }
@@ -808,9 +808,11 @@ impl<S: AsWriteableSlice> Writeable for WithoutLength<S> {
 	}
 }
 
-impl<T: MaybeReadable> Readable for WithoutLength<Vec<T>> {
+impl<T: MaybeReadable> LengthReadable for WithoutLength<Vec<T>> {
 	#[inline]
-	fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(
+		reader: &mut R,
+	) -> Result<Self, DecodeError> {
 		let mut values = Vec::new();
 		loop {
 			let mut track_read = ReadTrackingReader::new(reader);
@@ -841,10 +843,10 @@ impl Writeable for WithoutLength<&ScriptBuf> {
 	}
 }
 
-impl Readable for WithoutLength<ScriptBuf> {
+impl LengthReadable for WithoutLength<ScriptBuf> {
 	#[inline]
-	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
-		let v: WithoutLength<Vec<u8>> = Readable::read(r)?;
+	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
+		let v: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(r)?;
 		Ok(WithoutLength(script::Builder::from(v.0).into_script()))
 	}
 }
diff --git a/lightning/src/util/ser_macros.rs b/lightning/src/util/ser_macros.rs
@@ -409,7 +409,7 @@ macro_rules! _decode_tlv {
 		$field = $trait::read(&mut $reader $(, $read_arg)*)?;
 	}};
 	($outer_reader: expr, $reader: expr, $field: ident, required_vec) => {{
-		let f: $crate::util::ser::WithoutLength<Vec<_>> = $crate::util::ser::Readable::read(&mut $reader)?;
+		let f: $crate::util::ser::WithoutLength<Vec<_>> = $crate::util::ser::LengthReadable::read_from_fixed_length_buffer(&mut $reader)?;
 		$field = f.0;
 	}};
 	($outer_reader: expr, $reader: expr, $field: ident, option) => {{
@@ -427,7 +427,7 @@ macro_rules! _decode_tlv {
 		_decode_tlv!($outer_reader, $reader, $field, required);
 	}};
 	($outer_reader: expr, $reader: expr, $field: ident, optional_vec) => {{
-		let f: $crate::util::ser::WithoutLength<Vec<_>> = $crate::util::ser::Readable::read(&mut $reader)?;
+		let f: $crate::util::ser::WithoutLength<Vec<_>> = $crate::util::ser::LengthReadable::read_from_fixed_length_buffer(&mut $reader)?;
 		$field = Some(f.0);
 	}};
 	// `upgradable_required` indicates we're reading a required TLV that may have been upgraded

Original file line number	Diff line number	Diff line change
`@@ -2412,8 +2412,8 @@ impl Writeable for AcceptChannel {`
`2412`	`2412`	`}`
`2413`	`2413`	`}`
`2414`	`2414`
`2415`		`-impl Readable for AcceptChannel {`
`2416`		`- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {`
	`2415`	`+impl LengthReadable for AcceptChannel {`
	`2416`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
`2417`	`2417`	`let temporary_channel_id: ChannelId = Readable::read(r)?;`
`2418`	`2418`	`let dust_limit_satoshis: u64 = Readable::read(r)?;`
`2419`	`2419`	`let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;`
`@@ -2497,8 +2497,8 @@ impl Writeable for AcceptChannelV2 {`
`2497`	`2497`	`}`
`2498`	`2498`	`}`
`2499`	`2499`
`2500`		`-impl Readable for AcceptChannelV2 {`
`2501`		`- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {`
	`2500`	`+impl LengthReadable for AcceptChannelV2 {`
	`2501`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
`2502`	`2502`	`let temporary_channel_id: ChannelId = Readable::read(r)?;`
`2503`	`2503`	`let funding_satoshis: u64 = Readable::read(r)?;`
`2504`	`2504`	`let dust_limit_satoshis: u64 = Readable::read(r)?;`
`@@ -2760,8 +2760,8 @@ impl Writeable for Init {`
`2760`	`2760`	`}`
`2761`	`2761`	`}`
`2762`	`2762`
`2763`		`-impl Readable for Init {`
`2764`		`- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {`
	`2763`	`+impl LengthReadable for Init {`
	`2764`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
`2765`	`2765`	`let global_features: InitFeatures = Readable::read(r)?;`
`2766`	`2766`	`let features: InitFeatures = Readable::read(r)?;`
`2767`	`2767`	`let mut remote_network_address: Option<SocketAddress> = None;`
`@@ -2806,8 +2806,8 @@ impl Writeable for OpenChannel {`
`2806`	`2806`	`}`
`2807`	`2807`	`}`
`2808`	`2808`
`2809`		`-impl Readable for OpenChannel {`
`2810`		`- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {`
	`2809`	`+impl LengthReadable for OpenChannel {`
	`2810`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
`2811`	`2811`	`let chain_hash: ChainHash = Readable::read(r)?;`
`2812`	`2812`	`let temporary_channel_id: ChannelId = Readable::read(r)?;`
`2813`	`2813`	`let funding_satoshis: u64 = Readable::read(r)?;`
`@@ -2890,8 +2890,8 @@ impl Writeable for OpenChannelV2 {`
`2890`	`2890`	`}`
`2891`	`2891`	`}`
`2892`	`2892`
`2893`		`-impl Readable for OpenChannelV2 {`
`2894`		`- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {`
	`2893`	`+impl LengthReadable for OpenChannelV2 {`
	`2894`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
`2895`	`2895`	`let chain_hash: ChainHash = Readable::read(r)?;`
`2896`	`2896`	`let temporary_channel_id: ChannelId = Readable::read(r)?;`
`2897`	`2897`	`let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;`
Original file line number	Diff line number	Diff line change
`@@ -148,8 +148,8 @@ use crate::offers::signer::{self, Metadata};`
`148`	`148`	`use crate::types::features::{Bolt12InvoiceFeatures, InvoiceRequestFeatures, OfferFeatures};`
`149`	`149`	`use crate::types::payment::PaymentHash;`
`150`	`150`	`use crate::util::ser::{`
`151`		`- CursorReadable, HighZeroBytesDroppedBigSize, Iterable, Readable, WithoutLength, Writeable,`
`152`		`- Writer,`
	`151`	`+ CursorReadable, HighZeroBytesDroppedBigSize, Iterable, LengthLimitedRead, LengthReadable,`
	`152`	`+ WithoutLength, Writeable, Writer,`
`153`	`153`	`};`
`154`	`154`	`use crate::util::string::PrintableString;`
`155`	`155`	`use bitcoin::address::Address;`
`@@ -1398,9 +1398,11 @@ impl Writeable for Bolt12Invoice {`
`1398`	`1398`	`}`
`1399`	`1399`	`}`
`1400`	`1400`
`1401`		`-impl Readable for Bolt12Invoice {`
`1402`		`- fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {`
`1403`		`- let bytes: WithoutLength<Vec<u8>> = Readable::read(reader)?;`
	`1401`	`+impl LengthReadable for Bolt12Invoice {`
	`1402`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(`
	`1403`	`+ reader: &mut R,`
	`1404`	`+ ) -> Result<Self, DecodeError> {`
	`1405`	`+ let bytes: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(reader)?;`
`1404`	`1406`	`Self::try_from(bytes.0).map_err(\|_\| DecodeError::InvalidValue)`
`1405`	`1407`	`}`
`1406`	`1408`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,8 @@ use crate::onion_message::dns_resolution::HumanReadableName;`
`86`	`86`	`use crate::types::features::InvoiceRequestFeatures;`
`87`	`87`	`use crate::types::payment::PaymentHash;`
`88`	`88`	`use crate::util::ser::{`
`89`		`- CursorReadable, HighZeroBytesDroppedBigSize, Readable, WithoutLength, Writeable, Writer,`
	`89`	`+ CursorReadable, HighZeroBytesDroppedBigSize, LengthLimitedRead, LengthReadable, Readable,`
	`90`	`+ WithoutLength, Writeable, Writer,`
`90`	`91`	`};`
`91`	`92`	`use crate::util::string::{PrintableString, UntrustedString};`
`92`	`93`	`use bitcoin::constants::ChainHash;`
`@@ -1119,9 +1120,9 @@ impl Writeable for InvoiceRequestContents {`
`1119`	`1120`	`}`
`1120`	`1121`	`}`
`1121`	`1122`
`1122`		`-impl Readable for InvoiceRequest {`
`1123`		`- fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {`
`1124`		`- let bytes: WithoutLength<Vec<u8>> = Readable::read(reader)?;`
	`1123`	`+impl LengthReadable for InvoiceRequest {`
	`1124`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
	`1125`	`+ let bytes: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(r)?;`
`1125`	`1126`	`Self::try_from(bytes.0).map_err(\|_\| DecodeError::InvalidValue)`
`1126`	`1127`	`}`
`1127`	`1128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,8 @@ use crate::offers::parse::{Bech32Encode, Bolt12ParseError, Bolt12SemanticError,`
`88`	`88`	`use crate::offers::signer::{self, Metadata, MetadataMaterial};`
`89`	`89`	`use crate::types::features::OfferFeatures;`
`90`	`90`	`use crate::util::ser::{`
`91`		`- CursorReadable, HighZeroBytesDroppedBigSize, Readable, WithoutLength, Writeable, Writer,`
	`91`	`+ CursorReadable, HighZeroBytesDroppedBigSize, LengthLimitedRead, LengthReadable, Readable,`
	`92`	`+ WithoutLength, Writeable, Writer,`
`92`	`93`	`};`
`93`	`94`	`use crate::util::string::PrintableString;`
`94`	`95`	`use bitcoin::constants::ChainHash;`
`@@ -1033,9 +1034,11 @@ impl OfferContents {`
`1033`	`1034`	`}`
`1034`	`1035`	`}`
`1035`	`1036`
`1036`		`-impl Readable for Offer {`
`1037`		`- fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {`
`1038`		`- let bytes: WithoutLength<Vec<u8>> = Readable::read(reader)?;`
	`1037`	`+impl LengthReadable for Offer {`
	`1038`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(`
	`1039`	`+ reader: &mut R,`
	`1040`	`+ ) -> Result<Self, DecodeError> {`
	`1041`	`+ let bytes: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(reader)?;`
`1039`	`1042`	`Self::try_from(bytes.0).map_err(\|_\| DecodeError::InvalidValue)`
`1040`	`1043`	`}`
`1041`	`1044`	`}`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,9 @@ use crate::offers::signer::{self, Metadata, MetadataMaterial};`
`102`	`102`	`use crate::sign::EntropySource;`
`103`	`103`	`use crate::types::features::InvoiceRequestFeatures;`
`104`	`104`	`use crate::types::payment::PaymentHash;`
`105`		`-use crate::util::ser::{CursorReadable, Readable, WithoutLength, Writeable, Writer};`
	`105`	`+use crate::util::ser::{`
	`106`	`+ CursorReadable, LengthLimitedRead, LengthReadable, WithoutLength, Writeable, Writer,`
	`107`	`+};`
`106`	`108`	`use crate::util::string::PrintableString;`
`107`	`109`	`use bitcoin::constants::ChainHash;`
`108`	`110`	`use bitcoin::network::Network;`
`@@ -822,9 +824,11 @@ impl RefundContents {`
`822`	`824`	`}`
`823`	`825`	`}`
`824`	`826`
`825`		`-impl Readable for Refund {`
`826`		`- fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {`
`827`		`- let bytes: WithoutLength<Vec<u8>> = Readable::read(reader)?;`
	`827`	`+impl LengthReadable for Refund {`
	`828`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(`
	`829`	`+ reader: &mut R,`
	`830`	`+ ) -> Result<Self, DecodeError> {`
	`831`	`+ let bytes: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(reader)?;`
`828`	`832`	`Self::try_from(bytes.0).map_err(\|_\| DecodeError::InvalidValue)`
`829`	`833`	`}`
`830`	`834`	`}`
Original file line number	Diff line number	Diff line change
`@@ -740,10 +740,10 @@ impl Writeable for WithoutLength<&String> {`
`740`	`740`	`w.write_all(self.0.as_bytes())`
`741`	`741`	`}`
`742`	`742`	`}`
`743`		`-impl Readable for WithoutLength<String> {`
	`743`	`+impl LengthReadable for WithoutLength<String> {`
`744`	`744`	`#[inline]`
`745`		`- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {`
`746`		`- let v: WithoutLength<Vec<u8>> = Readable::read(r)?;`
	`745`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
	`746`	`+ let v: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(r)?;`
`747`	`747`	`Ok(Self(String::from_utf8(v.0).map_err(\|_\| DecodeError::InvalidValue)?))`
`748`	`748`	`}`
`749`	`749`	`}`
`@@ -772,10 +772,10 @@ impl Writeable for WithoutLength<&UntrustedString> {`
`772`	`772`	`WithoutLength(&self.0 .0).write(w)`
`773`	`773`	`}`
`774`	`774`	`}`
`775`		`-impl Readable for WithoutLength<UntrustedString> {`
	`775`	`+impl LengthReadable for WithoutLength<UntrustedString> {`
`776`	`776`	`#[inline]`
`777`		`- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {`
`778`		`- let s: WithoutLength<String> = Readable::read(r)?;`
	`777`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
	`778`	`+ let s: WithoutLength<String> = LengthReadable::read_from_fixed_length_buffer(r)?;`
`779`	`779`	`Ok(Self(UntrustedString(s.0)))`
`780`	`780`	`}`
`781`	`781`	`}`
`@@ -808,9 +808,11 @@ impl<S: AsWriteableSlice> Writeable for WithoutLength<S> {`
`808`	`808`	`}`
`809`	`809`	`}`
`810`	`810`
`811`		`-impl<T: MaybeReadable> Readable for WithoutLength<Vec<T>> {`
	`811`	`+impl<T: MaybeReadable> LengthReadable for WithoutLength<Vec<T>> {`
`812`	`812`	`#[inline]`
`813`		`- fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {`
	`813`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(`
	`814`	`+ reader: &mut R,`
	`815`	`+ ) -> Result<Self, DecodeError> {`
`814`	`816`	`let mut values = Vec::new();`
`815`	`817`	`loop {`
`816`	`818`	`let mut track_read = ReadTrackingReader::new(reader);`
`@@ -841,10 +843,10 @@ impl Writeable for WithoutLength<&ScriptBuf> {`
`841`	`843`	`}`
`842`	`844`	`}`
`843`	`845`
`844`		`-impl Readable for WithoutLength<ScriptBuf> {`
	`846`	`+impl LengthReadable for WithoutLength<ScriptBuf> {`
`845`	`847`	`#[inline]`
`846`		`- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {`
`847`		`- let v: WithoutLength<Vec<u8>> = Readable::read(r)?;`
	`848`	`+ fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {`
	`849`	`+ let v: WithoutLength<Vec<u8>> = LengthReadable::read_from_fixed_length_buffer(r)?;`
`848`	`850`	`Ok(WithoutLength(script::Builder::from(v.0).into_script()))`
`849`	`851`	`}`
`850`	`852`	`}`