f De/ser in two u64, RIP ChannelDetails macro

Author: tnull

lightning/src/ln/channelmanager.rs

@@ -57,7 +57,7 @@ use crate::util::events::{EventHandler, EventsProvider, MessageSendEvent, Messag
 use crate::util::{byte_utils, events};
 use crate::util::wakers::{Future, Notifier};
 use crate::util::scid_utils::fake_scid;
-use crate::util::ser::{BigSize, FixedLengthReader, Readable, ReadableArgs, MaybeReadable, Writeable, Writer, VecWriter};
+use crate::util::ser::{BigSize, FixedLengthReader, Readable, ReadableArgs, MaybeReadable, Writeable, Writer, VecWriter, OptionDeserWrapper};
 use crate::util::logger::{Level, Logger};
 use crate::util::errors::APIError;
 
@@ -6407,33 +6407,134 @@ impl_writeable_tlv_based!(ChannelCounterparty, {
 	(11, outbound_htlc_maximum_msat, option),
 });
 
-impl_writeable_tlv_based!(ChannelDetails, {
-	(1, inbound_scid_alias, option),
-	(2, channel_id, required),
-	(3, channel_type, option),
-	(4, counterparty, required),
-	(5, outbound_scid_alias, option),
-	(6, funding_txo, option),
-	(7, config, option),
-	(8, short_channel_id, option),
-	(10, channel_value_satoshis, required),
-	(12, unspendable_punishment_reserve, option),
-	(14, user_channel_id, required),
-	(16, balance_msat, required),
-	(18, outbound_capacity_msat, required),
-	// Note that by the time we get past the required read above, outbound_capacity_msat will be
-	// filled in, so we can safely unwrap it here.
-	(19, next_outbound_htlc_limit_msat, (default_value, outbound_capacity_msat.0.unwrap() as u64)),
-	(20, inbound_capacity_msat, required),
-	(22, confirmations_required, option),
-	(24, force_close_spend_delay, option),
-	(26, is_outbound, required),
-	(28, is_channel_ready, required),
-	(30, is_usable, required),
-	(32, is_public, required),
-	(33, inbound_htlc_minimum_msat, option),
-	(35, inbound_htlc_maximum_msat, option),
-});
+impl Writeable for ChannelDetails {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+		// `user_channel_id` used to be a single u64 value. In order to remain backwards compatible with
+		// versions prior to 0.0.113, the u128 is serialized as two separate u64 values.
+		let user_channel_id_low = self.user_channel_id as u64;
+		let user_channel_id_high_opt = Some((self.user_channel_id >> 64) as u64);
+		write_tlv_fields!(writer, {
+			(1, self.inbound_scid_alias, option),
+			(2, self.channel_id, required),
+			(3, self.channel_type, option),
+			(4, self.counterparty, required),
+			(5, self.outbound_scid_alias, option),
+			(6, self.funding_txo, option),
+			(7, self.config, option),
+			(8, self.short_channel_id, option),
+			(10, self.channel_value_satoshis, required),
+			(12, self.unspendable_punishment_reserve, option),
+			(14, user_channel_id_low, required),
+			(16, self.balance_msat, required),
+			(18, self.outbound_capacity_msat, required),
+			// Note that by the time we get past the required read above, outbound_capacity_msat will be
+			// filled in, so we can safely unwrap it here.
+			(19, self.next_outbound_htlc_limit_msat, (default_value, outbound_capacity_msat.0.unwrap() as u64)),
+			(20, self.inbound_capacity_msat, required),
+			(22, self.confirmations_required, option),
+			(24, self.force_close_spend_delay, option),
+			(26, self.is_outbound, required),
+			(28, self.is_channel_ready, required),
+			(30, self.is_usable, required),
+			(32, self.is_public, required),
+			(33, self.inbound_htlc_minimum_msat, option),
+			(35, self.inbound_htlc_maximum_msat, option),
+			(35, user_channel_id_high_opt, option),
+		});
+		Ok(())
+	}
+}
+
+impl Readable for ChannelDetails {
+	fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
+		let mut inbound_scid_alias = None;
+		let mut channel_id = OptionDeserWrapper(None);
+		let mut channel_type = None;
+		let mut counterparty = OptionDeserWrapper(None);
+		let mut outbound_scid_alias = None;
+		let mut funding_txo = None;
+		let mut config = None;
+		let mut short_channel_id = None;
+		let mut channel_value_satoshis = OptionDeserWrapper(None);
+		let mut unspendable_punishment_reserve = None;
+		// `user_channel_id` used to be a single u64 value. In order to remain backwards compatible with
+		// versions prior to 0.0.113, the u128 is serialized as two separate u64 values.
+		let mut user_channel_id_low: OptionDeserWrapper<u64> = OptionDeserWrapper(None);
+		let mut balance_msat = OptionDeserWrapper(None);
+		let mut outbound_capacity_msat = OptionDeserWrapper(None);
+		let mut next_outbound_htlc_limit_msat = OptionDeserWrapper(None);
+		let mut inbound_capacity_msat = OptionDeserWrapper(None);
+		let mut confirmations_required = None;
+		let mut force_close_spend_delay = None;
+		let mut is_outbound = OptionDeserWrapper(None);
+		let mut is_channel_ready = OptionDeserWrapper(None);
+		let mut is_usable = OptionDeserWrapper(None);
+		let mut is_public = OptionDeserWrapper(None);
+		let mut inbound_htlc_minimum_msat = None;
+		let mut inbound_htlc_maximum_msat = None;
+		// `user_channel_id` used to be a single u64 value. In order to remain backwards compatible with
+		// versions prior to 0.0.113, the u128 is serialized as two separate u64 values.
+		let mut user_channel_id_high_opt: Option<u64> = None;
+
+		read_tlv_fields!(reader, {
+			(1, inbound_scid_alias, option),
+			(2, channel_id, required),
+			(3, channel_type, option),
+			(4, counterparty, required),
+			(5, outbound_scid_alias, option),
+			(6, funding_txo, option),
+			(7, config, option),
+			(8, short_channel_id, option),
+			(10, channel_value_satoshis, required),
+			(12, unspendable_punishment_reserve, option),
+			(14, user_channel_id_low, required),
+			(16, balance_msat, required),
+			(18, outbound_capacity_msat, required),
+			// Note that by the time we get past the required read above, outbound_capacity_msat will be
+			// filled in, so we can safely unwrap it here.
+			(19, next_outbound_htlc_limit_msat, (default_value, outbound_capacity_msat.0.unwrap() as u64)),
+			(20, inbound_capacity_msat, required),
+			(22, confirmations_required, option),
+			(24, force_close_spend_delay, option),
+			(26, is_outbound, required),
+			(28, is_channel_ready, required),
+			(30, is_usable, required),
+			(32, is_public, required),
+			(33, inbound_htlc_minimum_msat, option),
+			(35, inbound_htlc_maximum_msat, option),
+			(37, user_channel_id_high_opt, option),
+		});
+
+		let user_channel_id = user_channel_id_low.0.unwrap() as u128 +
+			((user_channel_id_high_opt.unwrap_or(0) as u128) << 64);
+
+		Ok(Self {
+			inbound_scid_alias,
+			channel_id: channel_id.0.unwrap(),
+			channel_type,
+			counterparty: counterparty.0.unwrap(),
+			outbound_scid_alias,
+			funding_txo,
+			config,
+			short_channel_id,
+			channel_value_satoshis: channel_value_satoshis.0.unwrap(),
+			unspendable_punishment_reserve,
+			user_channel_id,
+			balance_msat: balance_msat.0.unwrap(),
+			outbound_capacity_msat: outbound_capacity_msat.0.unwrap(),
+			next_outbound_htlc_limit_msat: next_outbound_htlc_limit_msat.0.unwrap(),
+			inbound_capacity_msat: inbound_capacity_msat.0.unwrap(),
+			confirmations_required,
+			force_close_spend_delay,
+			is_outbound: is_outbound.0.unwrap(),
+			is_channel_ready: is_channel_ready.0.unwrap(),
+			is_usable: is_usable.0.unwrap(),
+			is_public: is_public.0.unwrap(),
+			inbound_htlc_minimum_msat,
+			inbound_htlc_maximum_msat,
+		})
+	}
+}
 
 impl_writeable_tlv_based!(PhantomRouteHints, {
 	(2, channels, vec_type),