X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=lightning%2Fsrc%2Futil%2Fser_macros.rs;h=019bea3ee935d00d898973f5a619583f7a12584f;hb=227fd51cb49adaca903972464166b73468d3a257;hp=5178732c7457e93745d39319fa2f2ecee99a80dd;hpb=a265f1e97a9eff25b3418daf4b12fc9c6ad4c036;p=rust-lightning

diff --git a/lightning/src/util/ser_macros.rs b/lightning/src/util/ser_macros.rs
index 5178732c..019bea3e 100644
--- a/lightning/src/util/ser_macros.rs
+++ b/lightning/src/util/ser_macros.rs
@@ -17,7 +17,7 @@ macro_rules! encode_tlv {
 		$field.write($stream)?;
 	};
 	($stream: expr, $type: expr, $field: expr, vec_type) => {
-		encode_tlv!($stream, $type, ::util::ser::VecWriteWrapper(&$field), required);
+		encode_tlv!($stream, $type, $crate::util::ser::WithoutLength(&$field), required);
 	};
 	($stream: expr, $optional_type: expr, $optional_field: expr, option) => {
 		if let Some(ref field) = $optional_field {
@@ -31,7 +31,7 @@ macro_rules! encode_tlv {
 macro_rules! encode_tlv_stream {
 	($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => { {
 		#[allow(unused_imports)]
-		use {
+		use $crate::{
 			ln::msgs::DecodeError,
 			util::ser,
 			util::ser::BigSize,
@@ -66,7 +66,7 @@ macro_rules! get_varint_length_prefixed_tlv_length {
 		$len.0 += field_len;
 	};
 	($len: expr, $type: expr, $field: expr, vec_type) => {
-		get_varint_length_prefixed_tlv_length!($len, $type, ::util::ser::VecWriteWrapper(&$field), required);
+		get_varint_length_prefixed_tlv_length!($len, $type, $crate::util::ser::WithoutLength(&$field), required);
 	};
 	($len: expr, $optional_type: expr, $optional_field: expr, option) => {
 		if let Some(ref field) = $optional_field {
@@ -80,10 +80,10 @@ macro_rules! get_varint_length_prefixed_tlv_length {
 
 macro_rules! encode_varint_length_prefixed_tlv {
 	($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),*}) => { {
-		use util::ser::BigSize;
+		use $crate::util::ser::BigSize;
 		let len = {
 			#[allow(unused_mut)]
-			let mut len = ::util::ser::LengthCalculatingWriter(0);
+			let mut len = $crate::util::ser::LengthCalculatingWriter(0);
 			$(
 				get_varint_length_prefixed_tlv_length!(len, $type, $field, $fieldty);
 			)*
@@ -99,7 +99,7 @@ macro_rules! check_tlv_order {
 		#[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always true
 		let invalid_order = ($last_seen_type.is_none() || $last_seen_type.unwrap() < $type) && $typ.0 > $type;
 		if invalid_order {
-			$field = $default;
+			$field = $default.into();
 		}
 	}};
 	($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, required) => {{
@@ -118,6 +118,9 @@ macro_rules! check_tlv_order {
 	($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, ignorable) => {{
 		// no-op
 	}};
+	($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => {{
+		// no-op
+	}};
 }
 
 macro_rules! check_missing_tlv {
@@ -125,7 +128,7 @@ macro_rules! check_missing_tlv {
 		#[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always true
 		let missing_req_type = $last_seen_type.is_none() || $last_seen_type.unwrap() < $type;
 		if missing_req_type {
-			$field = $default;
+			$field = $default.into();
 		}
 	}};
 	($last_seen_type: expr, $type: expr, $field: ident, required) => {{
@@ -144,6 +147,9 @@ macro_rules! check_missing_tlv {
 	($last_seen_type: expr, $type: expr, $field: ident, ignorable) => {{
 		// no-op
 	}};
+	($last_seen_type: expr, $type: expr, $field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => {{
+		// no-op
+	}};
 }
 
 macro_rules! decode_tlv {
@@ -151,26 +157,35 @@ macro_rules! decode_tlv {
 		decode_tlv!($reader, $field, required)
 	}};
 	($reader: expr, $field: ident, required) => {{
-		$field = ser::Readable::read(&mut $reader)?;
+		$field = $crate::util::ser::Readable::read(&mut $reader)?;
 	}};
 	($reader: expr, $field: ident, vec_type) => {{
-		$field = Some(ser::Readable::read(&mut $reader)?);
+		let f: $crate::util::ser::WithoutLength<Vec<_>> = $crate::util::ser::Readable::read(&mut $reader)?;
+		$field = Some(f.0);
 	}};
 	($reader: expr, $field: ident, option) => {{
-		$field = Some(ser::Readable::read(&mut $reader)?);
+		$field = Some($crate::util::ser::Readable::read(&mut $reader)?);
 	}};
 	($reader: expr, $field: ident, ignorable) => {{
-		$field = ser::MaybeReadable::read(&mut $reader)?;
+		$field = $crate::util::ser::MaybeReadable::read(&mut $reader)?;
+	}};
+	($reader: expr, $field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => {{
+		$field = Some($trait::read(&mut $reader $(, $read_arg)*)?);
 	}};
 }
 
+// `$decode_custom_tlv` is a closure that may be optionally provided to handle custom message types.
+// If it is provided, it will be called with the custom type and the `FixedLengthReader` containing
+// the message contents. It should return `Ok(true)` if the custom message is successfully parsed,
+// `Ok(false)` if the message type is unknown, and `Err(DecodeError)` if parsing fails.
 macro_rules! decode_tlv_stream {
-	($stream: expr, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { {
-		use ln::msgs::DecodeError;
+	($stream: expr, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}
+	 $(, $decode_custom_tlv: expr)?) => { {
+		use $crate::ln::msgs::DecodeError;
 		let mut last_seen_type: Option<u64> = None;
 		let mut stream_ref = $stream;
 		'tlv_read: loop {
-			use util::ser;
+			use $crate::util::ser;
 
 			// First decode the type of this TLV:
 			let typ: ser::BigSize = {
@@ -179,7 +194,7 @@ macro_rules! decode_tlv_stream {
 				// UnexpectedEof. This should in every case be largely cosmetic, but its nice to
 				// pass the TLV test vectors exactly, which requre this distinction.
 				let mut tracking_reader = ser::ReadTrackingReader::new(&mut stream_ref);
-				match ser::Readable::read(&mut tracking_reader) {
+				match $crate::util::ser::Readable::read(&mut tracking_reader) {
 					Err(DecodeError::ShortRead) => {
 						if !tracking_reader.have_read {
 							break 'tlv_read;
@@ -206,7 +221,7 @@ macro_rules! decode_tlv_stream {
 			last_seen_type = Some(typ.0);
 
 			// Finally, read the length and value itself:
-			let length: ser::BigSize = ser::Readable::read(&mut stream_ref)?;
+			let length: ser::BigSize = $crate::util::ser::Readable::read(&mut stream_ref)?;
 			let mut s = ser::FixedLengthReader::new(&mut stream_ref, length.0);
 			match typ.0 {
 				$($type => {
@@ -216,10 +231,19 @@ macro_rules! decode_tlv_stream {
 						return Err(DecodeError::InvalidValue);
 					}
 				},)*
-				x if x % 2 == 0 => {
-					return Err(DecodeError::UnknownRequiredFeature);
-				},
-				_ => {},
+				t => {
+					$(
+						if $decode_custom_tlv(t, &mut s)? {
+							// If a custom TLV was successfully read (i.e. decode_custom_tlv returns true),
+							// continue to the next TLV read.
+							s.eat_remaining()?;
+							continue 'tlv_read;
+						}
+					)?
+					if t % 2 == 0 {
+						return Err(DecodeError::UnknownRequiredFeature);
+					}
+				}
 			}
 			s.eat_remaining()?;
 		}
@@ -230,103 +254,52 @@ macro_rules! decode_tlv_stream {
 	} }
 }
 
-macro_rules! impl_writeable {
-	($st:ident, $len: expr, {$($field:ident),*}) => {
-		impl ::util::ser::Writeable for $st {
-			fn write<W: ::util::ser::Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
-				if $len != 0 {
-					w.size_hint($len);
-				}
-				#[cfg(any(test, feature = "fuzztarget"))]
-				{
-					// In tests, assert that the hard-coded length matches the actual one
-					if $len != 0 {
-						let mut len_calc = ::util::ser::LengthCalculatingWriter(0);
-						$( self.$field.write(&mut len_calc).expect("No in-memory data may fail to serialize"); )*
-						assert_eq!(len_calc.0, $len);
-						assert_eq!(self.serialized_length(), $len);
-					}
-				}
+macro_rules! impl_writeable_msg {
+	($st:ident, {$($field:ident),* $(,)*}, {$(($type: expr, $tlvfield: ident, $fieldty: tt)),* $(,)*}) => {
+		impl $crate::util::ser::Writeable for $st {
+			fn write<W: $crate::util::ser::Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
 				$( self.$field.write(w)?; )*
+				encode_tlv_stream!(w, {$(($type, self.$tlvfield, $fieldty)),*});
 				Ok(())
 			}
-
-			#[inline]
-			fn serialized_length(&self) -> usize {
-				if $len == 0 || cfg!(any(test, feature = "fuzztarget")) {
-					let mut len_calc = 0;
-					$( len_calc += self.$field.serialized_length(); )*
-					if $len != 0 {
-						// In tests, assert that the hard-coded length matches the actual one
-						assert_eq!(len_calc, $len);
-					} else {
-						return len_calc;
-					}
-				}
-				$len
-			}
 		}
-
-		impl ::util::ser::Readable for $st {
-			fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
+		impl $crate::util::ser::Readable for $st {
+			fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
+				$(let $field = $crate::util::ser::Readable::read(r)?;)*
+				$(init_tlv_field_var!($tlvfield, $fieldty);)*
+				decode_tlv_stream!(r, {$(($type, $tlvfield, $fieldty)),*});
 				Ok(Self {
-					$($field: ::util::ser::Readable::read(r)?),*
+					$($field),*,
+					$($tlvfield),*
 				})
 			}
 		}
 	}
 }
-macro_rules! impl_writeable_len_match {
-	($struct: ident, $cmp: tt, ($calc_len: expr), {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => {
-		impl Writeable for $struct {
-			fn write<W: Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
-				let len = match *self {
-					$($match => $length,)*
-				};
-				w.size_hint(len);
-				#[cfg(any(test, feature = "fuzztarget"))]
-				{
-					// In tests, assert that the hard-coded length matches the actual one
-					let mut len_calc = ::util::ser::LengthCalculatingWriter(0);
-					$( self.$field.write(&mut len_calc).expect("No in-memory data may fail to serialize"); )*
-					assert!(len_calc.0 $cmp len);
-					assert_eq!(len_calc.0, self.serialized_length());
-				}
+
+macro_rules! impl_writeable {
+	($st:ident, {$($field:ident),*}) => {
+		impl $crate::util::ser::Writeable for $st {
+			fn write<W: $crate::util::ser::Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
 				$( self.$field.write(w)?; )*
 				Ok(())
 			}
 
 			#[inline]
 			fn serialized_length(&self) -> usize {
-				if $calc_len || cfg!(any(test, feature = "fuzztarget")) {
-					let mut len_calc = 0;
-					$( len_calc += self.$field.serialized_length(); )*
-					if !$calc_len {
-						assert_eq!(len_calc, match *self {
-							$($match => $length,)*
-						});
-					}
-					return len_calc
-				}
-				match *self {
-					$($match => $length,)*
-				}
+				let mut len_calc = 0;
+				$( len_calc += self.$field.serialized_length(); )*
+				return len_calc;
 			}
 		}
 
-		impl ::util::ser::Readable for $struct {
-			fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
+		impl $crate::util::ser::Readable for $st {
+			fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
 				Ok(Self {
-					$($field: Readable::read(r)?),*
+					$($field: $crate::util::ser::Readable::read(r)?),*
 				})
 			}
 		}
-	};
-	($struct: ident, $cmp: tt, {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => {
-		impl_writeable_len_match!($struct, $cmp, (true), { $({ $match, $length }),* }, { $($field),* });
-	};
-	($struct: ident, {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => {
-		impl_writeable_len_match!($struct, ==, (false), { $({ $match, $length }),* }, { $($field),* });
 	}
 }
 
@@ -360,7 +333,7 @@ macro_rules! write_ver_prefix {
 /// correctly.
 macro_rules! write_tlv_fields {
 	($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => {
-		encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*});
+		encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*})
 	}
 }
 
@@ -381,16 +354,16 @@ macro_rules! read_ver_prefix {
 /// Reads a suffix added by write_tlv_fields.
 macro_rules! read_tlv_fields {
 	($stream: expr, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { {
-		let tlv_len: ::util::ser::BigSize = ::util::ser::Readable::read($stream)?;
-		let mut rd = ::util::ser::FixedLengthReader::new($stream, tlv_len.0);
+		let tlv_len: $crate::util::ser::BigSize = $crate::util::ser::Readable::read($stream)?;
+		let mut rd = $crate::util::ser::FixedLengthReader::new($stream, tlv_len.0);
 		decode_tlv_stream!(&mut rd, {$(($type, $field, $fieldty)),*});
-		rd.eat_remaining().map_err(|_| ::ln::msgs::DecodeError::ShortRead)?;
+		rd.eat_remaining().map_err(|_| $crate::ln::msgs::DecodeError::ShortRead)?;
 	} }
 }
 
 macro_rules! init_tlv_based_struct_field {
 	($field: ident, (default_value, $default: expr)) => {
-		$field
+		$field.0.unwrap()
 	};
 	($field: ident, option) => {
 		$field
@@ -399,19 +372,19 @@ macro_rules! init_tlv_based_struct_field {
 		$field.0.unwrap()
 	};
 	($field: ident, vec_type) => {
-		$field.unwrap().0
+		$field.unwrap()
 	};
 }
 
 macro_rules! init_tlv_field_var {
 	($field: ident, (default_value, $default: expr)) => {
-		let mut $field = $default;
+		let mut $field = $crate::util::ser::OptionDeserWrapper(None);
 	};
 	($field: ident, required) => {
-		let mut $field = ::util::ser::OptionDeserWrapper(None);
+		let mut $field = $crate::util::ser::OptionDeserWrapper(None);
 	};
 	($field: ident, vec_type) => {
-		let mut $field = Some(::util::ser::VecReadWrapper(Vec::new()));
+		let mut $field = Some(Vec::new());
 	};
 	($field: ident, option) => {
 		let mut $field = None;
@@ -425,8 +398,8 @@ macro_rules! init_tlv_field_var {
 /// serialized.
 macro_rules! impl_writeable_tlv_based {
 	($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> {
+		impl $crate::util::ser::Writeable for $st {
+			fn write<W: $crate::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
 				write_tlv_fields!(writer, {
 					$(($type, self.$field, $fieldty)),*
 				});
@@ -435,23 +408,23 @@ macro_rules! impl_writeable_tlv_based {
 
 			#[inline]
 			fn serialized_length(&self) -> usize {
-				use util::ser::BigSize;
+				use $crate::util::ser::BigSize;
 				let len = {
 					#[allow(unused_mut)]
-					let mut len = ::util::ser::LengthCalculatingWriter(0);
+					let mut len = $crate::util::ser::LengthCalculatingWriter(0);
 					$(
 						get_varint_length_prefixed_tlv_length!(len, $type, self.$field, $fieldty);
 					)*
 					len.0
 				};
-				let mut len_calc = ::util::ser::LengthCalculatingWriter(0);
+				let mut len_calc = $crate::util::ser::LengthCalculatingWriter(0);
 				BigSize(len as u64).write(&mut len_calc).expect("No in-memory data may fail to serialize");
 				len + len_calc.0
 			}
 		}
 
-		impl ::util::ser::Readable for $st {
-			fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
+		impl $crate::util::ser::Readable for $st {
+			fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
 				$(
 					init_tlv_field_var!($field, $fieldty);
 				)*
@@ -473,14 +446,14 @@ macro_rules! _impl_writeable_tlv_based_enum_common {
 		{$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}
 	),* $(,)*;
 	$(($tuple_variant_id: expr, $tuple_variant_name: ident)),*  $(,)*) => {
-		impl ::util::ser::Writeable for $st {
-			fn write<W: ::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
+		impl $crate::util::ser::Writeable for $st {
+			fn write<W: $crate::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
 				match self {
 					$($st::$variant_name { $(ref $field),* } => {
 						let id: u8 = $variant_id;
 						id.write(writer)?;
 						write_tlv_fields!(writer, {
-							$(($type, $field, $fieldty)),*
+							$(($type, *$field, $fieldty)),*
 						});
 					}),*
 					$($st::$tuple_variant_name (ref field) => {
@@ -505,13 +478,16 @@ macro_rules! _impl_writeable_tlv_based_enum_common {
 macro_rules! impl_writeable_tlv_based_enum_upgradable {
 	($st: ident, $(($variant_id: expr, $variant_name: ident) =>
 		{$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}
-	),* $(,)*) => {
+	),* $(,)*
+	$(;
+	$(($tuple_variant_id: expr, $tuple_variant_name: ident)),*  $(,)*)*) => {
 		_impl_writeable_tlv_based_enum_common!($st,
-			$(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*; );
+			$(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*;
+			$($(($tuple_variant_id, $tuple_variant_name)),*)*);
 
-		impl ::util::ser::MaybeReadable for $st {
-			fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Option<Self>, ::ln::msgs::DecodeError> {
-				let id: u8 = ::util::ser::Readable::read(reader)?;
+		impl $crate::util::ser::MaybeReadable for $st {
+			fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Option<Self>, $crate::ln::msgs::DecodeError> {
+				let id: u8 = $crate::util::ser::Readable::read(reader)?;
 				match id {
 					$($variant_id => {
 						// Because read_tlv_fields creates a labeled loop, we cannot call it twice
@@ -531,6 +507,9 @@ macro_rules! impl_writeable_tlv_based_enum_upgradable {
 						};
 						f()
 					}),*
+					$($($tuple_variant_id => {
+						Ok(Some($st::$tuple_variant_name(Readable::read(reader)?)))
+					}),*)*
 					_ if id % 2 == 1 => Ok(None),
 					_ => Err(DecodeError::UnknownRequiredFeature),
 				}
@@ -559,9 +538,9 @@ macro_rules! impl_writeable_tlv_based_enum {
 			$(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*;
 			$(($tuple_variant_id, $tuple_variant_name)),*);
 
-		impl ::util::ser::Readable for $st {
-			fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
-				let id: u8 = ::util::ser::Readable::read(reader)?;
+		impl $crate::util::ser::Readable for $st {
+			fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
+				let id: u8 = $crate::util::ser::Readable::read(reader)?;
 				match id {
 					$($variant_id => {
 						// Because read_tlv_fields creates a labeled loop, we cannot call it twice
@@ -595,10 +574,10 @@ macro_rules! impl_writeable_tlv_based_enum {
 
 #[cfg(test)]
 mod tests {
-	use io::{self, Cursor};
-	use prelude::*;
-	use ln::msgs::DecodeError;
-	use util::ser::{Writeable, HighZeroBytesDroppedVarInt, VecWriter};
+	use crate::io::{self, Cursor};
+	use crate::prelude::*;
+	use crate::ln::msgs::DecodeError;
+	use crate::util::ser::{Writeable, HighZeroBytesDroppedBigSize, VecWriter};
 	use bitcoin::secp256k1::PublicKey;
 
 	// The BOLT TLV test cases don't include any tests which use our "required-value" logic since
@@ -667,9 +646,9 @@ mod tests {
 	}
 
 	// BOLT TLV test cases
-	fn tlv_reader_n1(s: &[u8]) -> Result<(Option<HighZeroBytesDroppedVarInt<u64>>, Option<u64>, Option<(PublicKey, u64, u64)>, Option<u16>), DecodeError> {
+	fn tlv_reader_n1(s: &[u8]) -> Result<(Option<HighZeroBytesDroppedBigSize<u64>>, Option<u64>, Option<(PublicKey, u64, u64)>, Option<u16>), DecodeError> {
 		let mut s = Cursor::new(s);
-		let mut tlv1: Option<HighZeroBytesDroppedVarInt<u64>> = None;
+		let mut tlv1: Option<HighZeroBytesDroppedBigSize<u64>> = None;
 		let mut tlv2: Option<u64> = None;
 		let mut tlv3: Option<(PublicKey, u64, u64)> = None;
 		let mut tlv4: Option<u16> = None;
@@ -800,11 +779,11 @@ mod tests {
 		assert_eq!(stream.0, ::hex::decode("06fd00ff02abcd").unwrap());
 
 		stream.0.clear();
-		encode_varint_length_prefixed_tlv!(&mut stream, {(0, 1u64, required), (42, None::<u64>, option), (0xff, HighZeroBytesDroppedVarInt(0u64), required)});
+		encode_varint_length_prefixed_tlv!(&mut stream, {(0, 1u64, required), (42, None::<u64>, option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)});
 		assert_eq!(stream.0, ::hex::decode("0e00080000000000000001fd00ff00").unwrap());
 
 		stream.0.clear();
-		encode_varint_length_prefixed_tlv!(&mut stream, {(0, Some(1u64), option), (0xff, HighZeroBytesDroppedVarInt(0u64), required)});
+		encode_varint_length_prefixed_tlv!(&mut stream, {(0, Some(1u64), option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)});
 		assert_eq!(stream.0, ::hex::decode("0e00080000000000000001fd00ff00").unwrap());
 
 		Ok(())