Fix TLV serialization to work with large types.

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

diff --git a/lightning/src/chain/onchaintx.rs b/lightning/src/chain/onchaintx.rs
index 1f604422f5ccf5890c0901a4e43a2fd7bea56393..7e616ef291e009fdc2a1573e37b8a0832c08bd38 100644 (file)
--- a/lightning/src/chain/onchaintx.rs
+++ b/lightning/src/chain/onchaintx.rs
@@ -34,7 +34,6 @@ use util::byte_utils;
 
 use prelude::*;
 use alloc::collections::BTreeMap;
-use std::collections::HashMap;
 use core::cmp;
 use core::ops::Deref;
 use core::mem::replace;
@@ -79,6 +78,21 @@ enum OnchainEvent {
        }
 }
 
+impl_writeable_tlv_based!(OnchainEventEntry, {
+       (0, txid, required),
+       (2, height, required),
+       (4, event, required),
+});
+
+impl_writeable_tlv_based_enum!(OnchainEvent,
+       (0, Claim) => {
+               (0, claim_request, required),
+       },
+       (1, ContentiousOutpoint) => {
+               (0, package, required),
+       },
+;);
+
 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,21 +233,10 @@ 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, {}, {});
+               write_tlv_fields!(writer, {});
                Ok(())
        }
 }
@@ -292,27 +295,10 @@ 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, {}, {});
+               read_tlv_fields!(reader, {});
 
                let mut secp_ctx = Secp256k1::new();
                secp_ctx.seeded_randomize(&keys_manager.get_secure_random_bytes());