WIP: Serialize offer without cloning

Author: jkczyz

lightning/src/offers/mod.rs

@@ -123,43 +123,43 @@ impl Offer {
 		self.signature.as_ref()
 	}
 
-	fn to_tlv_stream(&self) -> OfferTlvStream {
-		let (currency, amount) = match self.amount.clone() {
+	fn as_tlv_stream(&self) -> reference::OfferTlvStream {
+		let (currency, amount) = match &self.amount {
 			None => (None, None),
 			Some(Amount::Bitcoin { amount_msats }) => (
-				None, Some(HighZeroBytesDroppedVarInt(amount_msats))
+				None, Some(HighZeroBytesDroppedVarInt(*amount_msats))
 			),
 			Some(Amount::Currency { iso4217_code, amount }) => (
-				Some(WithoutLength(iso4217_code)), Some(HighZeroBytesDroppedVarInt(amount))
+				Some(WithoutLength(iso4217_code)), Some(HighZeroBytesDroppedVarInt(*amount))
 			),
 		};
 
-		let (paths, node_id) = match self.destination.clone() {
+		let (paths, node_id) = match &self.destination {
 			Destination::NodeId(node_id) => (None, Some(node_id)),
 			Destination::Paths(paths) => (Some(WithoutLength(paths)), None),
 		};
 
-		let (send_invoice, refund_for) = match self.send_invoice.clone() {
+		let (send_invoice, refund_for) = match &self.send_invoice {
 			None => (None, None),
-			Some(SendInvoice { refund_for }) => (Some(()), refund_for),
+			Some(SendInvoice { refund_for }) => (Some(&()), refund_for.as_ref()),
 		};
 
-		OfferTlvStream {
-			chains: self.chains.clone().map(|chains| WithoutLength(chains)),
+		reference::OfferTlvStream {
+			chains: self.chains.as_ref().map(|chains| WithoutLength(chains)),
 			currency,
 			amount,
-			description: Some(WithoutLength(self.description.clone())),
-			features: self.features.clone(),
+			description: Some(WithoutLength(&self.description)),
+			features: self.features.as_ref(),
 			absolute_expiry: self.absolute_expiry.map(|d| HighZeroBytesDroppedVarInt(d.as_secs())),
 			paths,
-			issuer: self.issuer.clone().map(|issuer| WithoutLength(issuer)),
+			issuer: self.issuer.as_ref().map(|issuer| WithoutLength(issuer)),
 			quantity_min: self.quantity_min.map(|quantity| HighZeroBytesDroppedVarInt(quantity)),
 			quantity_max: self.quantity_max.map(|quantity| HighZeroBytesDroppedVarInt(quantity)),
-			recurrence: self.recurrence.clone(),
+			recurrence: self.recurrence.as_ref(),
 			node_id,
 			send_invoice,
 			refund_for,
-			signature: self.signature,
+			signature: self.signature.as_ref(),
 		}
 	}
 }
@@ -208,43 +208,22 @@ pub struct SendInvoice {
 	refund_for: Option<PaymentHash>,
 }
 
-/// An `offer` TLV stream without any semantic checks, apart from any checks performed when parsing
-/// the underlying types.
-#[derive(Debug)]
-struct OfferTlvStream {
-	chains: Option<WithoutLength<Vec<BlockHash>>>,
-	currency: Option<WithoutLength<String>>,
-	amount: Option<HighZeroBytesDroppedVarInt<u64>>,
-	description: Option<WithoutLength<String>>,
-	features: Option<OfferFeatures>,
-	absolute_expiry: Option<HighZeroBytesDroppedVarInt<u64>>,
-	paths: Option<WithoutLength<Vec<BlindedPath>>>,
-	issuer: Option<WithoutLength<String>>,
-	quantity_min: Option<HighZeroBytesDroppedVarInt<u64>>,
-	quantity_max: Option<HighZeroBytesDroppedVarInt<u64>>,
-	recurrence: Option<Recurrence>,
-	node_id: Option<XOnlyPublicKey>,
-	send_invoice: Option<()>,
-	refund_for: Option<PaymentHash>,
-	signature: Option<Signature>,
-}
-
-impl_writeable_tlv_stream!(OfferTlvStream, {
-	(2, chains, option),
-	(6, currency, option),
-	(8, amount, option),
-	(10, description, option),
-	(12, features, option),
-	(14, absolute_expiry, option),
-	(16, paths, option),
-	(20, issuer, option),
-	(22, quantity_min, option),
-	(24, quantity_max, option),
-	(26, recurrence, option),
-	(30, node_id, option),
-	(34, refund_for, option),
-	(54, send_invoice, option),
-	(240, signature, option),
+tlv_stream!(struct OfferTlvStream {
+	(2, chains: Vec<BlockHash>),
+	(6, currency: String),
+	(8, amount: u64),
+	(10, description: String),
+	(12, features: OfferFeatures),
+	(14, absolute_expiry: u64),
+	(16, paths: Vec<BlindedPath>),
+	(20, issuer: String),
+	(22, quantity_min: u64),
+	(24, quantity_max: u64),
+	(26, recurrence: Recurrence),
+	(30, node_id: XOnlyPublicKey),
+	(34, refund_for: PaymentHash),
+	(54, send_invoice: Empty),
+	(240, signature: Signature),
 });
 
 #[derive(Clone, Debug)]
@@ -273,6 +252,8 @@ struct Recurrence {
 
 impl_writeable!(Recurrence, { time_unit, period });
 
+type Empty = ();
+
 /// An offer parsed from a bech32-encoded string as a TLV stream and the corresponding bytes. The
 /// latter is used for signature verification.
 struct ParsedOffer(OfferTlvStream, Vec<u8>);
@@ -477,16 +458,10 @@ impl FromStr for ParsedOffer {
 }
 
 impl core::fmt::Display for Offer {
-	fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
-		self.to_tlv_stream().fmt(f)
-	}
-}
-
-impl core::fmt::Display for OfferTlvStream {
 	fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
 		use util::ser::Writeable;
 		let mut buffer = Vec::new();
-		self.write(&mut buffer).unwrap();
+		self.as_tlv_stream().write(&mut buffer).unwrap();
 
 		use bitcoin::bech32::ToBase32;
 		let data = buffer.to_base32();

lightning/src/util/ser.rs

@@ -557,6 +557,12 @@ impl Writeable for WithoutLength<String> {
 		w.write_all(self.0.as_bytes())
 	}
 }
+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> {
@@ -571,6 +577,12 @@ impl<T: Writeable> Writeable for WithoutLength<Vec<T>> {
 		VecWriteWrapper(&self.0).write(w)
 	}
 }
+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> {

lightning/src/util/ser_macros.rs

@@ -427,37 +427,94 @@ macro_rules! impl_writeable_tlv_based {
 	}
 }
 
-/// Implements [`Readable`]/[`Writeable`] for TLV streams (i.e., a sequence of TLV records).
-///
-///
-/// This is like [`impl_writeable_tlv_based`] only without a length prefix for the entire TLV
-/// stream.
-macro_rules! impl_writeable_tlv_stream {
-	($st: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => {
-		impl ::util::ser::Writeable for $st {
-			fn write<W: ::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
-				encode_tlv_stream!(writer, { $(($type, self.$field, $fieldty)),* });
-				Ok(())
+/// Defines a struct for a TLV stream and a similar struct using references for non-primitive types,
+/// implementing [`Readable`] for the former and [`Writeable`] for the latter. Useful as an
+/// intermediary format when reading or writing a type encoded as a TLV stream.
+macro_rules! tlv_stream {
+	(struct $name:ident { $(($type:expr, $field:ident : $fieldty:ident$(<$gen:ident>)?)),* $(,)*}) => {
+		#[derive(Debug)]
+		struct $name {
+			$(
+				$field: Option<tlv_record_type!($fieldty$(<$gen>)?)>,
+			)*
+		}
+
+		mod reference {
+			use super::*;
+
+			pub(super) struct $name<'a> {
+				$(
+					pub(super) $field: Option<tlv_record_ref_type!($fieldty$(<$gen>)?)>,
+				)*
+			}
+
+			impl<'a> ::util::ser::Writeable for $name<'a> {
+				fn write<W: ::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
+					encode_tlv_stream!(writer, { $(($type, self.$field, option)),* });
+					Ok(())
+				}
 			}
 		}
 
-		impl ::util::ser::Readable for $st {
+		impl ::util::ser::Readable for $name {
 			fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
 				$(
-					init_tlv_field_var!($field, $fieldty);
+					init_tlv_field_var!($field, option);
 				)*
-				decode_tlv_stream!(reader, {$(($type, $field, $fieldty)),*});
+				decode_tlv_stream!(reader, {$(($type, $field, option)),*});
 
-					Ok(Self {
-						$(
-							$field: init_tlv_based_struct_field!($field, $fieldty)
-						),*
-					})
+				Ok(Self {
+					$(
+						$field: init_tlv_based_struct_field!($field, option)
+					),*
+				})
 			}
 		}
 	}
 }
 
+macro_rules! tlv_record_type {
+	(u16) => {
+		HighZeroBytesDroppedVarInt<u16>
+	};
+	(u32) => {
+		HighZeroBytesDroppedVarInt<u32>
+	};
+	(u64) => {
+		HighZeroBytesDroppedVarInt<u64>
+	};
+	(String) => {
+		WithoutLength<String>
+	};
+	(Vec<$type:ty>) => {
+		WithoutLength<Vec<$type>>
+	};
+	($type:ident$(<$gen:ident>)?) => {
+		$type$(<$gen>)?
+	};
+}
+
+macro_rules! tlv_record_ref_type {
+	(u16) => {
+		HighZeroBytesDroppedVarInt<u16>
+	};
+	(u32) => {
+		HighZeroBytesDroppedVarInt<u32>
+	};
+	(u64) => {
+		HighZeroBytesDroppedVarInt<u64>
+	};
+	(String) => {
+		WithoutLength<&'a String>
+	};
+	(Vec<$type:ty>) => {
+		WithoutLength<&'a Vec<$type>>
+	};
+	($type:ident$(<$gen:ident>)?) => {
+		&'a $type$(<$gen>)?
+	};
+}
+
 macro_rules! _impl_writeable_tlv_based_enum_common {
 	($st: ident, $(($variant_id: expr, $variant_name: ident) =>
 		{$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}