Skip to content

Commit

Permalink
Introduce ChannelUpdateDeserWrap
Browse files Browse the repository at this point in the history
  • Loading branch information
@tnull
tnull committed Jul 14, 2022
1 parent 141bf0c commit c554e64
Showing 1 changed file with 44 additions and 73 deletions.
117 changes: 44 additions & 73 deletions lightning/src/routing/gossip.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -643,79 +643,50 @@ impl Writeable for ChannelUpdateInfo {
}
}

impl MaybeReadable for ChannelUpdateInfo {
fn read<R: io::Read>(reader: &mut R) -> Result<Option<Self>, DecodeError> {
macro_rules! read_channel_update_tlv_fields {
($reader: expr, {$(($type: expr, $field: ident)),* $(,)*}) => {{
let mut stream_ref = $reader;
$({
if stream_ref.bytes_remain() {
let tlv_type_res: Result<::util::ser::BigSize, DecodeError> = ::util::ser::Readable::read(stream_ref);
$field = if let Ok(ref tlv_type) = tlv_type_res {
println!("GOT TYPE: {}", tlv_type.0);
assert_eq!(tlv_type.0, $type);

let tlv_len_res: Result<::util::ser::BigSize, DecodeError> = ::util::ser::Readable::read(&mut stream_ref);
if let Ok(ref tlv_len) = tlv_len_res {
println!("GOT LEN: {}", tlv_len.0);
let mut s = ::util::ser::FixedLengthReader::new(&mut stream_ref, tlv_len.0);
let tlv_value_res = ::util::ser::Readable::read(&mut s);
let _ = s.eat_remaining();
tlv_value_res.ok()
} else {
None
}
} else {
None
};
}
})*
}};
}
struct ChannelUpdateInfoDeserWrap(ChannelUpdateInfo);

let outer_tlv_len: ::util::ser::BigSize = ::util::ser::Readable::read(reader)?;
if outer_tlv_len.0 == 0 {
return Ok(None);
impl MaybeReadable for ChannelUpdateInfoDeserWrap {
fn read<R: io::Read>(reader: &mut R) -> Result<Option<Self>, DecodeError> {
if let Ok(channel_update) = ::util::ser::Readable::read(reader) {
Ok(Some(Self(channel_update)))
} else {
Ok(None)
}
let mut outer_fixed_reader = ::util::ser::FixedLengthReader::new(reader, outer_tlv_len.0);

}
}

let mut last_update: Option<u32> = None;
let mut enabled: Option<bool> = None;
let mut cltv_expiry_delta: Option<u16> = None;
let mut htlc_minimum_msat: Option<u64> = None;
let mut htlc_maximum_msat: Option<Option<u64>> = None;
let mut fees: Option<RoutingFees> = None;
let mut last_update_message: Option<Option<ChannelUpdate>> = None;
impl Readable for ChannelUpdateInfo {
fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
init_tlv_field_var!(last_update, required);
init_tlv_field_var!(enabled, required);
init_tlv_field_var!(cltv_expiry_delta, required);
init_tlv_field_var!(htlc_minimum_msat, required);
init_tlv_field_var!(htlc_maximum_msat, option);
init_tlv_field_var!(fees, required);
init_tlv_field_var!(last_update_message, required);

read_channel_update_tlv_fields!(&mut outer_fixed_reader, {
(0, last_update),
(2, enabled),
(4, cltv_expiry_delta),
(6, htlc_minimum_msat),
(8, htlc_maximum_msat),
(10, fees),
(12, last_update_message),
read_tlv_fields!(reader, {
(0, last_update, required),
(2, enabled, required),
(4, cltv_expiry_delta, required),
(6, htlc_minimum_msat, required),
(8, htlc_maximum_msat, required),
(10, fees, required),
(12, last_update_message, required)
});
let decoding_success = last_update.is_some() && enabled.is_some() &&
cltv_expiry_delta.is_some() && htlc_minimum_msat.is_some() &&
htlc_maximum_msat.is_some() && fees.is_some() &&
last_update_message.is_some();

outer_fixed_reader.eat_remaining()?;
if decoding_success {
println!("DECODING SUCCESS");
Ok(Some(ChannelUpdateInfo {
last_update: last_update.unwrap(),
enabled: enabled.unwrap(),
cltv_expiry_delta: cltv_expiry_delta.unwrap(),
htlc_minimum_msat: htlc_minimum_msat.unwrap(),
htlc_maximum_msat: htlc_maximum_msat.unwrap().unwrap(),
fees: fees.unwrap(),
last_update_message: last_update_message.unwrap(),
}))

if let Some(htlc_maximum_msat) = htlc_maximum_msat {
Ok(ChannelUpdateInfo {
last_update: init_tlv_based_struct_field!(last_update, required),
enabled: init_tlv_based_struct_field!(enabled, required),
cltv_expiry_delta: init_tlv_based_struct_field!(cltv_expiry_delta, required),
htlc_minimum_msat: init_tlv_based_struct_field!(htlc_minimum_msat, required),
htlc_maximum_msat,
fees: init_tlv_based_struct_field!(fees, required),
last_update_message: init_tlv_based_struct_field!(last_update_message, required),
})
} else {
Ok(None)
Err(DecodeError::InvalidValue)
}
}
}
Expand Down Expand Up @@ -818,28 +789,28 @@ impl Readable for ChannelInfo {
init_tlv_field_var!(features, required);
init_tlv_field_var!(announcement_received_time, (default_value, 0));
init_tlv_field_var!(node_one, required);
let mut one_to_two = None;
let mut one_to_two_wrap: Option<ChannelUpdateInfoDeserWrap> = None;
init_tlv_field_var!(node_two, required);
let mut two_to_one = None;
let mut two_to_one_wrap: Option<ChannelUpdateInfoDeserWrap> = None;
init_tlv_field_var!(capacity_sats, required);
init_tlv_field_var!(announcement_message, required);
read_tlv_fields!(reader, {
(0, features, required),
(1, announcement_received_time, (default_value, 0)),
(2, node_one, required),
(4, one_to_two, ignorable),
(4, one_to_two_wrap, ignorable),
(6, node_two, required),
(8, two_to_one, ignorable),
(8, two_to_one_wrap, ignorable),
(10, capacity_sats, required),
(12, announcement_message, required),
});

Ok(ChannelInfo {
features: init_tlv_based_struct_field!(features, required),
node_one: init_tlv_based_struct_field!(node_one, required),
one_to_two,
one_to_two: one_to_two_wrap.map(|w| w.0),
node_two: init_tlv_based_struct_field!(node_two, required),
two_to_one,
two_to_one: two_to_one_wrap.map(|w| w.0),
capacity_sats: init_tlv_based_struct_field!(capacity_sats, required),
announcement_message: init_tlv_based_struct_field!(announcement_message, required),
announcement_received_time: init_tlv_based_struct_field!(announcement_received_time, (default_value, 0)),
Expand Down

0 comments on commit c554e64

Please sign in to comment.