Convert most chain::* inner structs and enums to TLV-based ser macros

[rust-lightning] / lightning / src / chain / onchaintx.rs

diff --git a/lightning/src/chain/onchaintx.rs b/lightning/src/chain/onchaintx.rs
index 1f604422f5ccf5890c0901a4e43a2fd7bea56393..dd4d1d8f0b37f844c8262673cafc6e1b98407585 100644 (file)
--- a/lightning/src/chain/onchaintx.rs
+++ b/lightning/src/chain/onchaintx.rs
@@ -79,6 +79,21 @@ enum OnchainEvent {
        }
 }
 
+impl_writeable_tlv_based!(OnchainEventEntry, {
+       (0, txid),
+       (2, height),
+       (4, event),
+}, {}, {});
+
+impl_writeable_tlv_based_enum!(OnchainEvent,
+       (0, Claim) => {
+               (0, claim_request),
+       }, {}, {},
+       (1, ContentiousOutpoint) => {
+               (0, package),
+       }, {}, {},
+;);
+
 impl Readable for Option<Vec<Option<(usize, Signature)>>> {
        fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
                match Readable::read(reader)? {
@@ -219,18 +234,7 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 
                writer.write_all(&byte_utils::be64_to_array(self.onchain_events_awaiting_threshold_conf.len() as u64))?;
                for ref entry in self.onchain_events_awaiting_threshold_conf.iter() {
-                       entry.txid.write(writer)?;
-                       writer.write_all(&byte_utils::be32_to_array(entry.height))?;
-                       match entry.event {
-                               OnchainEvent::Claim { ref claim_request } => {
-                                       writer.write_all(&[0; 1])?;
-                                       claim_request.write(writer)?;
-                               },
-                               OnchainEvent::ContentiousOutpoint { ref package } => {
-                                       writer.write_all(&[1; 1])?;
-                                       package.write(writer)?;
-                               }
-                       }
+                       entry.write(writer)?;
                }
 
                write_tlv_fields!(writer, {}, {});
@@ -292,24 +296,7 @@ impl<'a, K: KeysInterface> ReadableArgs<&'a K> for OnchainTxHandler<K::Signer> {
                let waiting_threshold_conf_len: u64 = Readable::read(reader)?;
                let mut onchain_events_awaiting_threshold_conf = Vec::with_capacity(cmp::min(waiting_threshold_conf_len as usize, MAX_ALLOC_SIZE / 128));
                for _ in 0..waiting_threshold_conf_len {
-                       let txid = Readable::read(reader)?;
-                       let height = Readable::read(reader)?;
-                       let event = match <u8 as Readable>::read(reader)? {
-                               0 => {
-                                       let claim_request = Readable::read(reader)?;
-                                       OnchainEvent::Claim {
-                                               claim_request
-                                       }
-                               },
-                               1 => {
-                                       let package = Readable::read(reader)?;
-                                       OnchainEvent::ContentiousOutpoint {
-                                               package
-                                       }
-                               }
-                               _ => return Err(DecodeError::InvalidValue),
-                       };
-                       onchain_events_awaiting_threshold_conf.push(OnchainEventEntry { txid, height, event });
+                       onchain_events_awaiting_threshold_conf.push(Readable::read(reader)?);
                }
 
                read_tlv_fields!(reader, {}, {});