#[macro_export]
macro_rules! _encode_tlv_stream {
($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => { {
+ $crate::_encode_tlv_stream!($stream, { $(($type, $field, $fieldty)),* }, &[])
+ } };
+ ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}, $extra_tlvs: expr) => { {
#[allow(unused_imports)]
use $crate::{
ln::msgs::DecodeError,
$(
$crate::_encode_tlv!($stream, $type, $field, $fieldty);
)*
+ for tlv in $extra_tlvs {
+ let (typ, value): &(u64, Vec<u8>) = tlv;
+ $crate::_encode_tlv!($stream, *typ, *value, required_vec);
+ }
#[allow(unused_mut, unused_variables, unused_assignments)]
#[cfg(debug_assertions)]
$(
$crate::_check_encoded_tlv_order!(last_seen, $type, $fieldty);
)*
- }
- } };
- ($stream: expr, $tlvs: expr) => { {
- for tlv in $tlvs {
- let (typ, value): &&(u64, Vec<u8>) = tlv;
- $crate::_encode_tlv!($stream, *typ, *value, required_vec);
- }
-
- #[cfg(debug_assertions)] {
- let mut last_seen: Option<u64> = None;
- for tlv in $tlvs {
- let (typ, _): &&(u64, Vec<u8>) = tlv;
+ for tlv in $extra_tlvs {
+ let (typ, _): &(u64, Vec<u8>) = tlv;
$crate::_check_encoded_tlv_order!(last_seen, *typ, required_vec);
}
}
#[macro_export]
macro_rules! _encode_varint_length_prefixed_tlv {
($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),*}) => { {
- _encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*}, &[])
+ $crate::_encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*}, &[])
} };
($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),*}, $extra_tlvs: expr) => { {
+ extern crate alloc;
use $crate::util::ser::BigSize;
use alloc::vec::Vec;
let len = {
$crate::_get_varint_length_prefixed_tlv_length!(len, $type, $field, $fieldty);
)*
for tlv in $extra_tlvs {
- let (typ, value): &&(u64, Vec<u8>) = tlv;
+ let (typ, value): &(u64, Vec<u8>) = tlv;
$crate::_get_varint_length_prefixed_tlv_length!(len, *typ, *value, required_vec);
}
len.0
};
BigSize(len as u64).write($stream)?;
- $crate::_encode_tlv_stream!($stream, { $(($type, $field, $fieldty)),* });
- $crate::_encode_tlv_stream!($stream, $extra_tlvs);
+ $crate::_encode_tlv_stream!($stream, { $(($type, $field, $fieldty)),* }, $extra_tlvs);
} };
}
/// Equivalent to running [`_init_tlv_field_var`] then [`read_tlv_fields`].
///
+/// If any unused values are read, their type MUST be specified or else `rustc` will read them as an
+/// `i64`.
+///
/// This is exported for use by other exported macros, do not use directly.
#[doc(hidden)]
#[macro_export]
-macro_rules! _init_and_read_tlv_fields {
+macro_rules! _init_and_read_len_prefixed_tlv_fields {
($reader: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => {
$(
$crate::_init_tlv_field_var!($field, $fieldty);
}
}
+/// Equivalent to running [`_init_tlv_field_var`] then [`decode_tlv_stream`].
+///
+/// If any unused values are read, their type MUST be specified or else `rustc` will read them as an
+/// `i64`.
+macro_rules! _init_and_read_tlv_stream {
+ ($reader: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => {
+ $(
+ $crate::_init_tlv_field_var!($field, $fieldty);
+ )*
+
+ $crate::decode_tlv_stream!($reader, {
+ $(($type, $field, $fieldty)),*
+ });
+ }
+}
+
/// Implements [`Readable`]/[`Writeable`] for a struct storing it as a set of TLVs
/// If `$fieldty` is `required`, then `$field` is a required field that is not an [`Option`] nor a [`Vec`].
/// If `$fieldty` is `(default_value, $default)`, then `$field` will be set to `$default` if not present.
///
/// For example,
/// ```
-/// # use lightning::{impl_writeable_tlv_based, _encode_varint_length_prefixed_tlv};
-/// # extern crate alloc;
+/// # use lightning::impl_writeable_tlv_based;
/// struct LightningMessage {
/// tlv_integer: u32,
/// tlv_default_integer: u32,
impl $crate::util::ser::Readable for $st {
fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
- $crate::_init_and_read_tlv_fields!(reader, {
+ $crate::_init_and_read_len_prefixed_tlv_fields!(reader, {
$(($type, $field, $fieldty)),*
});
Ok(Self {
// 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 = || {
- $crate::_init_and_read_tlv_fields!(reader, {
+ $crate::_init_and_read_len_prefixed_tlv_fields!(reader, {
$(($type, $field, $fieldty)),*
});
Ok($st::$variant_name {
// 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 = || {
- $crate::_init_and_read_tlv_fields!(reader, {
+ $crate::_init_and_read_len_prefixed_tlv_fields!(reader, {
$(($type, $field, $fieldty)),*
});
Ok(Some($st::$variant_name {
use crate::prelude::*;
use crate::ln::msgs::DecodeError;
use crate::util::ser::{Writeable, HighZeroBytesDroppedBigSize, VecWriter};
+ use bitcoin::hashes::hex::FromHex;
use bitcoin::secp256k1::PublicKey;
// The BOLT TLV test cases don't include any tests which use our "required-value" logic since
#[test]
fn tlv_v_short_read() {
// We only expect a u32 for type 3 (which we are given), but the L says its 8 bytes.
- if let Err(DecodeError::ShortRead) = tlv_reader(&::hex::decode(
+ if let Err(DecodeError::ShortRead) = tlv_reader(&<Vec<u8>>::from_hex(
concat!("0100", "0208deadbeef1badbeef", "0308deadbeef")
).unwrap()[..]) {
} else { panic!(); }
#[test]
fn tlv_types_out_of_order() {
- if let Err(DecodeError::InvalidValue) = tlv_reader(&::hex::decode(
+ if let Err(DecodeError::InvalidValue) = tlv_reader(&<Vec<u8>>::from_hex(
concat!("0100", "0304deadbeef", "0208deadbeef1badbeef")
).unwrap()[..]) {
} else { panic!(); }
// ...even if its some field we don't understand
- if let Err(DecodeError::InvalidValue) = tlv_reader(&::hex::decode(
+ if let Err(DecodeError::InvalidValue) = tlv_reader(&<Vec<u8>>::from_hex(
concat!("0208deadbeef1badbeef", "0100", "0304deadbeef")
).unwrap()[..]) {
} else { panic!(); }
#[test]
fn tlv_req_type_missing_or_extra() {
// It's also bad if they included even fields we don't understand
- if let Err(DecodeError::UnknownRequiredFeature) = tlv_reader(&::hex::decode(
+ if let Err(DecodeError::UnknownRequiredFeature) = tlv_reader(&<Vec<u8>>::from_hex(
concat!("0100", "0208deadbeef1badbeef", "0304deadbeef", "0600")
).unwrap()[..]) {
} else { panic!(); }
// ... or if they're missing fields we need
- if let Err(DecodeError::InvalidValue) = tlv_reader(&::hex::decode(
+ if let Err(DecodeError::InvalidValue) = tlv_reader(&<Vec<u8>>::from_hex(
concat!("0100", "0208deadbeef1badbeef")
).unwrap()[..]) {
} else { panic!(); }
// ... even if that field is even
- if let Err(DecodeError::InvalidValue) = tlv_reader(&::hex::decode(
+ if let Err(DecodeError::InvalidValue) = tlv_reader(&<Vec<u8>>::from_hex(
concat!("0304deadbeef", "0500")
).unwrap()[..]) {
} else { panic!(); }
#[test]
fn tlv_simple_good_cases() {
- assert_eq!(tlv_reader(&::hex::decode(
+ assert_eq!(tlv_reader(&<Vec<u8>>::from_hex(
concat!("0208deadbeef1badbeef", "03041bad1dea")
).unwrap()[..]).unwrap(),
(0xdeadbeef1badbeef, 0x1bad1dea, None));
- assert_eq!(tlv_reader(&::hex::decode(
+ assert_eq!(tlv_reader(&<Vec<u8>>::from_hex(
concat!("0208deadbeef1badbeef", "03041bad1dea", "040401020304")
).unwrap()[..]).unwrap(),
(0xdeadbeef1badbeef, 0x1bad1dea, Some(0x01020304)));
#[test]
fn upgradable_tlv_simple_good_cases() {
- assert_eq!(upgradable_tlv_reader(&::hex::decode(
+ assert_eq!(upgradable_tlv_reader(&<Vec<u8>>::from_hex(
concat!("0204deadbeef", "03041bad1dea", "0404deadbeef")
).unwrap()[..]).unwrap(),
Some(TestUpgradable { a: 0xdeadbeef, b: 0x1bad1dea, c: Some(0xdeadbeef) }));
- assert_eq!(upgradable_tlv_reader(&::hex::decode(
+ assert_eq!(upgradable_tlv_reader(&<Vec<u8>>::from_hex(
concat!("0204deadbeef", "03041bad1dea")
).unwrap()[..]).unwrap(),
Some(TestUpgradable { a: 0xdeadbeef, b: 0x1bad1dea, c: None}));
#[test]
fn missing_required_upgradable() {
- if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&::hex::decode(
+ if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&<Vec<u8>>::from_hex(
concat!("0100", "0204deadbeef")
).unwrap()[..]) {
} else { panic!(); }
- if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&::hex::decode(
+ if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&<Vec<u8>>::from_hex(
concat!("0100", "03041bad1dea")
).unwrap()[..]) {
} else { panic!(); }
fn bolt_tlv_bogus_stream() {
macro_rules! do_test {
($stream: expr, $reason: ident) => {
- if let Err(DecodeError::$reason) = tlv_reader_n1(&::hex::decode($stream).unwrap()[..]) {
+ if let Err(DecodeError::$reason) = tlv_reader_n1(&<Vec<u8>>::from_hex($stream).unwrap()[..]) {
} else { panic!(); }
}
}
fn bolt_tlv_bogus_n1_stream() {
macro_rules! do_test {
($stream: expr, $reason: ident) => {
- if let Err(DecodeError::$reason) = tlv_reader_n1(&::hex::decode($stream).unwrap()[..]) {
+ if let Err(DecodeError::$reason) = tlv_reader_n1(&<Vec<u8>>::from_hex($stream).unwrap()[..]) {
} else { panic!(); }
}
}
fn bolt_tlv_valid_n1_stream() {
macro_rules! do_test {
($stream: expr, $tlv1: expr, $tlv2: expr, $tlv3: expr, $tlv4: expr) => {
- if let Ok((tlv1, tlv2, tlv3, tlv4)) = tlv_reader_n1(&::hex::decode($stream).unwrap()[..]) {
+ if let Ok((tlv1, tlv2, tlv3, tlv4)) = tlv_reader_n1(&<Vec<u8>>::from_hex($stream).unwrap()[..]) {
assert_eq!(tlv1.map(|v| v.0), $tlv1);
assert_eq!(tlv2, $tlv2);
assert_eq!(tlv3, $tlv3);
do_test!(concat!("02", "08", "0000000000000226"), None, Some((0 << 30) | (0 << 5) | (550 << 0)), None, None);
do_test!(concat!("03", "31", "023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb00000000000000010000000000000002"),
None, None, Some((
- PublicKey::from_slice(&::hex::decode("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]).unwrap(), 1, 2)),
+ PublicKey::from_slice(&<Vec<u8>>::from_hex("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]).unwrap(), 1, 2)),
None);
do_test!(concat!("fd00fe", "02", "0226"), None, None, None, Some(550));
}
stream.0.clear();
_encode_varint_length_prefixed_tlv!(&mut stream, {(1, 1u8, required), (42, None::<u64>, option)});
- assert_eq!(stream.0, ::hex::decode("03010101").unwrap());
+ assert_eq!(stream.0, <Vec<u8>>::from_hex("03010101").unwrap());
stream.0.clear();
_encode_varint_length_prefixed_tlv!(&mut stream, {(1, Some(1u8), option)});
- assert_eq!(stream.0, ::hex::decode("03010101").unwrap());
+ assert_eq!(stream.0, <Vec<u8>>::from_hex("03010101").unwrap());
stream.0.clear();
_encode_varint_length_prefixed_tlv!(&mut stream, {(4, 0xabcdu16, required), (42, None::<u64>, option)});
- assert_eq!(stream.0, ::hex::decode("040402abcd").unwrap());
+ assert_eq!(stream.0, <Vec<u8>>::from_hex("040402abcd").unwrap());
stream.0.clear();
_encode_varint_length_prefixed_tlv!(&mut stream, {(42, None::<u64>, option), (0xff, 0xabcdu16, required)});
- assert_eq!(stream.0, ::hex::decode("06fd00ff02abcd").unwrap());
+ assert_eq!(stream.0, <Vec<u8>>::from_hex("06fd00ff02abcd").unwrap());
stream.0.clear();
_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());
+ assert_eq!(stream.0, <Vec<u8>>::from_hex("0e00080000000000000001fd00ff00").unwrap());
stream.0.clear();
_encode_varint_length_prefixed_tlv!(&mut stream, {(0, Some(1u64), option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)});
- assert_eq!(stream.0, ::hex::decode("0e00080000000000000001fd00ff00").unwrap());
+ assert_eq!(stream.0, <Vec<u8>>::from_hex("0e00080000000000000001fd00ff00").unwrap());
Ok(())
}