Wrappers for TLV records of a variable-length type

TLV records containing a single variable-length type should not encoded
the types length in the value since it is redundant. Add a wrapper type
that can be used within a TLV stream to support the correct behavior
during serialization and de-serialization.

Likewise, subtypes of such records must include type lengths. Add a
wrapper type that includes the length using a specified unsigned type.

Author: jkczyz

lightning/src/util/ser.rs

@@ -516,6 +516,67 @@ impl_array!(PUBLIC_KEY_SIZE); // for PublicKey
 impl_array!(64); // for ecdsa::Signature and schnorr::Signature
 impl_array!(1300); // for OnionPacket.hop_data
 
+/// For variable-length values within TLV subtypes where the length cannot be inferred from the
+/// enclosing TLV record.
+///
+/// The length is encoded as an unsigned `U` type.
+#[derive(Clone)]
+pub(crate) struct WithLength<T, U>(pub T, pub core::marker::PhantomData<U>);
+
+impl<T: Writeable> Writeable for WithLength<Vec<T>, u8> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		(self.0.len() as u8).write(w)?;
+		for element in self.0.iter() {
+			element.write(w)?;
+		}
+		Ok(())
+	}
+}
+impl<T: Readable> Readable for WithLength<Vec<T>, u8> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let len = <u8 as Readable>::read(r)? as usize;
+		let mut result = Vec::with_capacity(len);
+		for _ in 0..len {
+			result.push(<T as Readable>::read(r)?);
+		}
+		Ok(Self(result, core::marker::PhantomData))
+	}
+}
+
+/// For variable-length values within TLV record where the length is encoded as part of the record.
+/// Used to prevent encoding the length twice.
+#[derive(Clone)]
+pub(crate) struct WithoutLength<T>(pub T);
+
+impl Writeable for WithoutLength<String> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		w.write_all(self.0.as_bytes())
+	}
+}
+impl Readable for WithoutLength<String> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let v: VecReadWrapper<u8> = Readable::read(r)?;
+		Ok(Self(String::from_utf8(v.0).map_err(|_| DecodeError::InvalidValue)?))
+	}
+}
+
+impl<T: Writeable> Writeable for WithoutLength<Vec<T>> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		VecWriteWrapper(&self.0).write(w)
+	}
+}
+impl<T: Readable> Readable for WithoutLength<Vec<T>> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		Ok(Self(<VecReadWrapper<T> as Readable>::read(r)?.0))
+	}
+}
+
 // HashMap
 impl<K, V> Writeable for HashMap<K, V>
 	where K: Writeable + Eq + Hash,