Introduce ChannelUpdateDeserWrap

Author: tnull

lightning/src/routing/gossip.rs

@@ -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)
 		}
 	}
 }
@@ -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)),