Implement Readable for LengthReadable

lightning/src/ln/msgs.rs

@@ -1958,7 +1958,7 @@ impl Writeable for TrampolineOnionPacket {
 }
 
 impl LengthReadable for TrampolineOnionPacket {
-	fn read<R: LengthRead>(r: &mut R) -> Result<Self, DecodeError> {
+	fn read_from_fixed_length_buffer<R: LengthRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let version = Readable::read(r)?;
 		let public_key = Readable::read(r)?;
 
@@ -2684,7 +2684,7 @@ impl Readable for OnionMessage {
 		let len: u16 = Readable::read(r)?;
 		let mut packet_reader = FixedLengthReader::new(r, len as u64);
 		let onion_routing_packet: onion_message::packet::Packet =
-			<onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
+			<onion_message::packet::Packet as LengthReadable>::read_from_fixed_length_buffer(&mut packet_reader)?;
 		Ok(Self {
 			blinding_point,
 			onion_routing_packet,
@@ -4708,7 +4708,7 @@ mod tests {
 		{ // verify that a codec round trip works
 			let mut reader = Cursor::new(&encoded_trampoline_packet);
 			let mut trampoline_packet_reader = FixedLengthReader::new(&mut reader, encoded_trampoline_packet.len() as u64);
-			let decoded_trampoline_packet: TrampolineOnionPacket = <TrampolineOnionPacket as LengthReadable>::read(&mut trampoline_packet_reader).unwrap();
+			let decoded_trampoline_packet: TrampolineOnionPacket = <TrampolineOnionPacket as LengthReadable>::read_from_fixed_length_buffer(&mut trampoline_packet_reader).unwrap();
 			assert_eq!(decoded_trampoline_packet.encode(), encoded_trampoline_packet);
 		}
 

lightning/src/onion_message/functional_tests.rs

@@ -901,7 +901,7 @@ fn spec_test_vector() {
 	let mut reader = io::Cursor::new(sender_to_alice_packet_bytes);
 	let mut packet_reader = FixedLengthReader::new(&mut reader, sender_to_alice_packet_bytes_len);
 	let sender_to_alice_packet: Packet =
-		<Packet as LengthReadable>::read(&mut packet_reader).unwrap();
+		<Packet as LengthReadable>::read_from_fixed_length_buffer(&mut packet_reader).unwrap();
 	let secp_ctx = Secp256k1::new();
 	let sender_to_alice_om = msgs::OnionMessage {
 		blinding_point: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("6363636363636363636363636363636363636363636363636363636363636363").unwrap()).unwrap()),

lightning/src/onion_message/packet.rs

@@ -82,7 +82,7 @@ impl Writeable for Packet {
 }
 
 impl LengthReadable for Packet {
-	fn read<R: LengthRead>(r: &mut R) -> Result<Self, DecodeError> {
+	fn read_from_fixed_length_buffer<R: LengthRead>(r: &mut R) -> Result<Self, DecodeError> {
 		const READ_BUFFER_SIZE: usize = 4096;
 
 		let version = Readable::read(r)?;

lightning/src/util/ser.rs

@@ -344,8 +344,8 @@ where
 	fn read<R: Read>(reader: &mut R, params: P) -> Result<Self, DecodeError>;
 }
 
-/// A [`std::io::Read`] that also provides the total bytes available to be read.
-pub(crate) trait LengthRead: Read {
+/// A [`io::Read`] that also provides the total bytes available to be read.
+pub trait LengthRead: Read {
 	/// The total number of bytes available to be read.
 	fn total_bytes(&self) -> u64;
 }
@@ -361,14 +361,24 @@ where
 	fn read<R: LengthRead>(reader: &mut R, params: P) -> Result<Self, DecodeError>;
 }
 
-/// A trait that various higher-level LDK types implement allowing them to be read in
-/// from a [`Read`], requiring the implementer to provide the total length of the read.
-pub(crate) trait LengthReadable
+/// A trait that allows the implementer to be read in from a [`LengthRead`], requiring
+/// the reader to provide the total length of the read.
+///
+/// Any type that implements [`Readable`] also automatically has a [`LengthReadable`]
+/// implementation, but some types, most notably onion packets, only implement [`LengthReadable`].
+pub trait LengthReadable
 where
 	Self: Sized,
 {
 	/// Reads a `Self` in from the given [`LengthRead`].
-	fn read<R: LengthRead>(reader: &mut R) -> Result<Self, DecodeError>;
+	fn read_from_fixed_length_buffer<R: LengthRead>(reader: &mut R) -> Result<Self, DecodeError>;
+}
+
+impl<T: Readable> LengthReadable for T {
+	#[inline]
+	fn read_from_fixed_length_buffer<R: LengthRead>(reader: &mut R) -> Result<T, DecodeError> {
+		Readable::read(reader)
+	}
 }
 
 /// A trait that various LDK types implement allowing them to (maybe) be read in from a [`Read`].

lightning/src/util/ser_macros.rs

@@ -385,7 +385,7 @@ macro_rules! _decode_tlv {
 	($outer_reader: expr, $reader: expr, $field: ident, (static_value, $value: expr)) => {{
 	}};
 	($outer_reader: expr, $reader: expr, $field: ident, required) => {{
-		$field = $crate::util::ser::Readable::read(&mut $reader)?;
+		$field = $crate::util::ser::LengthReadable::read_from_fixed_length_buffer(&mut $reader)?;
 	}};
 	($outer_reader: expr, $reader: expr, $field: ident, (required: $trait: ident $(, $read_arg: expr)?)) => {{
 		$field = $trait::read(&mut $reader $(, $read_arg)*)?;
@@ -395,7 +395,7 @@ macro_rules! _decode_tlv {
 		$field = f.0;
 	}};
 	($outer_reader: expr, $reader: expr, $field: ident, option) => {{
-		$field = Some($crate::util::ser::Readable::read(&mut $reader)?);
+		$field = Some($crate::util::ser::LengthReadable::read_from_fixed_length_buffer(&mut $reader)?);
 	}};
 	($outer_reader: expr, $reader: expr, $field: ident, (option, explicit_type: $fieldty: ty)) => {{
 		let _field: &Option<$fieldty> = &$field;
@@ -453,7 +453,7 @@ macro_rules! _decode_tlv {
 	}};
 	($outer_reader: expr, $reader: expr, $field: ident, (option, encoding: ($fieldty: ty, $encoding: ident))) => {{
 		$field = {
-			let field: $encoding<$fieldty> = ser::Readable::read(&mut $reader)?;
+			let field: $encoding<$fieldty> = ser::LengthReadable::read_from_fixed_length_buffer(&mut $reader)?;
 			Some(field.0)
 		};
 	}};