// licenses.
macro_rules! encode_tlv {
+ ($stream: expr, $type: expr, $field: expr, (default_value, $default: expr)) => {
+ encode_tlv!($stream, $type, $field, required)
+ };
($stream: expr, $type: expr, $field: expr, required) => {
BigSize($type).write($stream)?;
BigSize($field.serialized_length() as u64).write($stream)?;
$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 {
}
macro_rules! encode_tlv_stream {
- ($stream: expr, {$(($type: expr, $field: expr, $fieldty: ident)),*}) => { {
+ ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => { {
#[allow(unused_imports)]
- use {
+ use $crate::{
ln::msgs::DecodeError,
util::ser,
util::ser::BigSize,
}
macro_rules! get_varint_length_prefixed_tlv_length {
+ ($len: expr, $type: expr, $field: expr, (default_value, $default: expr)) => {
+ get_varint_length_prefixed_tlv_length!($len, $type, $field, required)
+ };
($len: expr, $type: expr, $field: expr, required) => {
BigSize($type).write(&mut $len).expect("No in-memory data may fail to serialize");
let field_len = $field.serialized_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 {
}
macro_rules! encode_varint_length_prefixed_tlv {
- ($stream: expr, {$(($type: expr, $field: expr, $fieldty: ident)),*}) => { {
- use util::ser::BigSize;
+ ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),*}) => { {
+ 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);
)*
}
macro_rules! check_tlv_order {
- ($last_seen_type: expr, $typ: expr, $type: expr, required) => {{
+ ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, (default_value, $default: expr)) => {{
+ #[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.into();
+ }
+ }};
+ ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, required) => {{
#[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 {
- Err(DecodeError::InvalidValue)?
+ return Err(DecodeError::InvalidValue);
}
}};
- ($last_seen_type: expr, $typ: expr, $type: expr, option) => {{
+ ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, option) => {{
// no-op
}};
- ($last_seen_type: expr, $typ: expr, $type: expr, vec_type) => {{
+ ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, vec_type) => {{
+ // no-op
+ }};
+ ($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 {
- ($last_seen_type: expr, $type: expr, required) => {{
+ ($last_seen_type: expr, $type: expr, $field: ident, (default_value, $default: expr)) => {{
+ #[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.into();
+ }
+ }};
+ ($last_seen_type: expr, $type: expr, $field: ident, required) => {{
#[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 {
- Err(DecodeError::InvalidValue)?
+ return Err(DecodeError::InvalidValue);
}
}};
- ($last_seen_type: expr, $type: expr, vec_type) => {{
+ ($last_seen_type: expr, $type: expr, $field: ident, vec_type) => {{
+ // no-op
+ }};
+ ($last_seen_type: expr, $type: expr, $field: ident, option) => {{
// no-op
}};
- ($last_seen_type: expr, $type: expr, option) => {{
+ ($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 {
+ ($reader: expr, $field: ident, (default_value, $default: expr)) => {{
+ 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 = $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: ident)),* $(,)*}) => { {
- 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 = {
// determine whether we should break or return ShortRead if we get an
// 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($stream);
- match ser::Readable::read(&mut tracking_reader) {
+ let mut tracking_reader = ser::ReadTrackingReader::new(&mut stream_ref);
+ match $crate::util::ser::Readable::read(&mut tracking_reader) {
Err(DecodeError::ShortRead) => {
if !tracking_reader.have_read {
- break 'tlv_read
+ break 'tlv_read;
} else {
- Err(DecodeError::ShortRead)?
+ return Err(DecodeError::ShortRead);
}
},
- Err(e) => Err(e)?,
+ Err(e) => return Err(e),
Ok(t) => t,
}
};
// Types must be unique and monotonically increasing:
match last_seen_type {
Some(t) if typ.0 <= t => {
- Err(DecodeError::InvalidValue)?
+ return Err(DecodeError::InvalidValue);
},
_ => {},
}
// As we read types, make sure we hit every required type:
$({
- check_tlv_order!(last_seen_type, typ, $type, $fieldty);
+ check_tlv_order!(last_seen_type, typ, $type, $field, $fieldty);
})*
last_seen_type = Some(typ.0);
// Finally, read the length and value itself:
- let length: ser::BigSize = Readable::read($stream)?;
- let mut s = ser::FixedLengthReader::new($stream, length.0);
+ 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 => {
decode_tlv!(s, $field, $fieldty);
if s.bytes_remain() {
s.eat_remaining()?; // Return ShortRead if there's actually not enough bytes
- Err(DecodeError::InvalidValue)?
+ return Err(DecodeError::InvalidValue);
}
},)*
- x if x % 2 == 0 => {
- 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()?;
}
// Make sure we got to each required type after we've read every TLV:
$({
- check_missing_tlv!(last_seen_type, $type, $fieldty);
+ check_missing_tlv!(last_seen_type, $type, $field, $fieldty);
})*
} }
}
-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<(), ::std::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: ::std::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<(), ::std::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: ::std::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),* });
}
}
/// This is the preferred method of adding new fields that old nodes can ignore and still function
/// correctly.
macro_rules! write_tlv_fields {
- ($stream: expr, {$(($type: expr, $field: expr, $fieldty: ident)),* $(,)*}) => {
- encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*});
+ ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => {
+ encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*})
}
}
/// Reads a suffix added by write_tlv_fields.
macro_rules! read_tlv_fields {
- ($stream: expr, {$(($type: expr, $field: ident, $fieldty: ident)),* $(,)*}) => { {
- let tlv_len = ::util::ser::BigSize::read($stream)?;
- let mut rd = ::util::ser::FixedLengthReader::new($stream, tlv_len.0);
+ ($stream: expr, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { {
+ 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.0.unwrap()
+ };
($field: ident, option) => {
$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 = $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;
- }
+ };
}
/// Implements Readable/Writeable for a struct storing it as a set of TLVs
/// if $fieldty is `vec_type`, then $field is a Vec, which needs to have its individual elements
/// serialized.
macro_rules! impl_writeable_tlv_based {
- ($st: ident, {$(($type: expr, $field: ident, $fieldty: ident)),* $(,)*}) => {
- impl ::util::ser::Writeable for $st {
- fn write<W: ::util::ser::Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+ ($st: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => {
+ 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)),*
});
#[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: ::std::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);
)*
}
}
-/// Implement Readable and Writeable for an enum, with struct variants stored as TLVs and tuple
-/// variants stored directly.
-/// The format is, for example
-/// impl_writeable_tlv_based_enum!(EnumName,
-/// (0, StructVariantA) => {(0, required_variant_field, required), (1, optional_variant_field, option)},
-/// (1, StructVariantB) => {(0, variant_field_a, required), (1, variant_field_b, required), (2, variant_vec_field, vec_type)};
-/// (2, TupleVariantA), (3, TupleVariantB),
-/// );
-/// The type is written as a single byte, followed by any variant data.
-/// Attempts to read an unknown type byte result in DecodeError::UnknownRequiredFeature.
-macro_rules! impl_writeable_tlv_based_enum {
+macro_rules! _impl_writeable_tlv_based_enum_common {
($st: ident, $(($variant_id: expr, $variant_name: ident) =>
- {$(($type: expr, $field: ident, $fieldty: ident)),* $(,)*}
+ {$(($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<(), ::std::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) => {
Ok(())
}
}
+ }
+}
+
+/// Implement MaybeReadable and Writeable for an enum, with struct variants stored as TLVs and
+/// tuple variants stored directly.
+///
+/// This is largely identical to `impl_writeable_tlv_based_enum`, except that odd variants will
+/// return `Ok(None)` instead of `Err(UnknownRequiredFeature)`. It should generally be preferred
+/// when `MaybeReadable` is practical instead of just `Readable` as it provides an upgrade path for
+/// new variants to be added which are simply ignored by existing clients.
+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)),*}),*;
+ $($(($tuple_variant_id, $tuple_variant_name)),*)*);
+
+ 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
+ // in the same function body. Instead, we define a closure and call it.
+ let f = || {
+ $(
+ init_tlv_field_var!($field, $fieldty);
+ )*
+ read_tlv_fields!(reader, {
+ $(($type, $field, $fieldty)),*
+ });
+ Ok(Some($st::$variant_name {
+ $(
+ $field: init_tlv_based_struct_field!($field, $fieldty)
+ ),*
+ }))
+ };
+ f()
+ }),*
+ $($($tuple_variant_id => {
+ Ok(Some($st::$tuple_variant_name(Readable::read(reader)?)))
+ }),*)*
+ _ if id % 2 == 1 => Ok(None),
+ _ => Err(DecodeError::UnknownRequiredFeature),
+ }
+ }
+ }
+
+ }
+}
+
+/// Implement Readable and Writeable for an enum, with struct variants stored as TLVs and tuple
+/// variants stored directly.
+/// The format is, for example
+/// impl_writeable_tlv_based_enum!(EnumName,
+/// (0, StructVariantA) => {(0, required_variant_field, required), (1, optional_variant_field, option)},
+/// (1, StructVariantB) => {(0, variant_field_a, required), (1, variant_field_b, required), (2, variant_vec_field, vec_type)};
+/// (2, TupleVariantA), (3, TupleVariantB),
+/// );
+/// The type is written as a single byte, followed by any variant data.
+/// Attempts to read an unknown type byte result in DecodeError::UnknownRequiredFeature.
+macro_rules! impl_writeable_tlv_based_enum {
+ ($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)),*}),*;
+ $(($tuple_variant_id, $tuple_variant_name)),*);
- impl ::util::ser::Readable for $st {
- fn read<R: ::std::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
Ok($st::$tuple_variant_name(Readable::read(reader)?))
}),*
_ => {
- Err(DecodeError::UnknownRequiredFeature)?
+ Err(DecodeError::UnknownRequiredFeature)
},
}
}
#[cfg(test)]
mod tests {
- use prelude::*;
- use std::io::Cursor;
- use ln::msgs::DecodeError;
- use util::ser::{Readable, 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
}
// 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;
do_test!(concat!("fd00fe", "02", "0226"), None, None, None, Some(550));
}
- fn do_simple_test_tlv_write() -> Result<(), ::std::io::Error> {
+ fn do_simple_test_tlv_write() -> Result<(), io::Error> {
let mut stream = VecWriter(Vec::new());
stream.0.clear();
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(())
projects / rust-lightning / blobdiff