+const MAX_ALLOC_SIZE: usize = 64*1024;
+
+impl<R: ::std::io::Read> ReadableArgs<R, Arc<Logger>> for (Sha256dHash, ChannelMonitor) {
+ fn read(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
+ let secp_ctx = Secp256k1::new();
+ macro_rules! unwrap_obj {
+ ($key: expr) => {
+ match $key {
+ Ok(res) => res,
+ Err(_) => return Err(DecodeError::InvalidValue),
+ }
+ }
+ }
+
+ let _ver: u8 = Readable::read(reader)?;
+ let min_ver: u8 = Readable::read(reader)?;
+ if min_ver > SERIALIZATION_VERSION {
+ return Err(DecodeError::UnknownVersion);
+ }
+
+ // Technically this can fail and serialize fail a round-trip, but only for serialization of
+ // barely-init'd ChannelMonitors that we can't do anything with.
+ let outpoint = OutPoint {
+ txid: Readable::read(reader)?,
+ index: Readable::read(reader)?,
+ };
+ let funding_txo = Some((outpoint, Readable::read(reader)?));
+ let commitment_transaction_number_obscure_factor = <U48 as Readable<R>>::read(reader)?.0;
+
+ let key_storage = match <u8 as Readable<R>>::read(reader)? {
+ 0 => {
+ let revocation_base_key = Readable::read(reader)?;
+ let htlc_base_key = Readable::read(reader)?;
+ let delayed_payment_base_key = Readable::read(reader)?;
+ let prev_latest_per_commitment_point = match <u8 as Readable<R>>::read(reader)? {
+ 0 => None,
+ 1 => Some(Readable::read(reader)?),
+ _ => return Err(DecodeError::InvalidValue),
+ };
+ let latest_per_commitment_point = match <u8 as Readable<R>>::read(reader)? {
+ 0 => None,
+ 1 => Some(Readable::read(reader)?),
+ _ => return Err(DecodeError::InvalidValue),
+ };
+ KeyStorage::PrivMode {
+ revocation_base_key,
+ htlc_base_key,
+ delayed_payment_base_key,
+ prev_latest_per_commitment_point,
+ latest_per_commitment_point,
+ }
+ },
+ _ => return Err(DecodeError::InvalidValue),
+ };
+
+ let their_htlc_base_key = Some(Readable::read(reader)?);
+ let their_delayed_payment_base_key = Some(Readable::read(reader)?);
+
+ let their_cur_revocation_points = {
+ let first_idx = <U48 as Readable<R>>::read(reader)?.0;
+ if first_idx == 0 {
+ None
+ } else {
+ let first_point = Readable::read(reader)?;
+ let second_point_slice: [u8; 33] = Readable::read(reader)?;
+ if second_point_slice[0..32] == [0; 32] && second_point_slice[32] == 0 {
+ Some((first_idx, first_point, None))
+ } else {
+ Some((first_idx, first_point, Some(unwrap_obj!(PublicKey::from_slice(&secp_ctx, &second_point_slice)))))
+ }
+ }
+ };
+
+ let our_to_self_delay: u16 = Readable::read(reader)?;
+ let their_to_self_delay: Option<u16> = Some(Readable::read(reader)?);
+
+ let mut old_secrets = [([0; 32], 1 << 48); 49];
+ for &mut (ref mut secret, ref mut idx) in old_secrets.iter_mut() {
+ *secret = Readable::read(reader)?;
+ *idx = Readable::read(reader)?;
+ }
+
+ macro_rules! read_htlc_in_commitment {
+ () => {
+ {
+ let offered: bool = Readable::read(reader)?;
+ let amount_msat: u64 = Readable::read(reader)?;
+ let cltv_expiry: u32 = Readable::read(reader)?;
+ let payment_hash: [u8; 32] = Readable::read(reader)?;
+ let transaction_output_index: u32 = Readable::read(reader)?;
+
+ HTLCOutputInCommitment {
+ offered, amount_msat, cltv_expiry, payment_hash, transaction_output_index
+ }
+ }
+ }
+ }
+
+ let remote_claimable_outpoints_len: u64 = Readable::read(reader)?;
+ let mut remote_claimable_outpoints = HashMap::with_capacity(cmp::min(remote_claimable_outpoints_len as usize, MAX_ALLOC_SIZE / 64));
+ for _ in 0..remote_claimable_outpoints_len {
+ let txid: Sha256dHash = Readable::read(reader)?;
+ let outputs_count: u64 = Readable::read(reader)?;
+ let mut outputs = Vec::with_capacity(cmp::min(outputs_count as usize, MAX_ALLOC_SIZE / 32));
+ for _ in 0..outputs_count {
+ outputs.push(read_htlc_in_commitment!());
+ }
+ if let Some(_) = remote_claimable_outpoints.insert(txid, outputs) {
+ return Err(DecodeError::InvalidValue);
+ }
+ }
+
+ let remote_commitment_txn_on_chain_len: u64 = Readable::read(reader)?;
+ let mut remote_commitment_txn_on_chain = HashMap::with_capacity(cmp::min(remote_commitment_txn_on_chain_len as usize, MAX_ALLOC_SIZE / 32));
+ for _ in 0..remote_commitment_txn_on_chain_len {
+ let txid: Sha256dHash = Readable::read(reader)?;
+ let commitment_number = <U48 as Readable<R>>::read(reader)?.0;
+ let outputs_count = <u64 as Readable<R>>::read(reader)?;
+ let mut outputs = Vec::with_capacity(cmp::min(outputs_count as usize, MAX_ALLOC_SIZE / 8));
+ for _ in 0..outputs_count {
+ outputs.push(Readable::read(reader)?);
+ }
+ if let Some(_) = remote_commitment_txn_on_chain.insert(txid, (commitment_number, outputs)) {
+ return Err(DecodeError::InvalidValue);
+ }
+ }
+
+ let remote_hash_commitment_number_len: u64 = Readable::read(reader)?;
+ let mut remote_hash_commitment_number = HashMap::with_capacity(cmp::min(remote_hash_commitment_number_len as usize, MAX_ALLOC_SIZE / 32));
+ for _ in 0..remote_hash_commitment_number_len {
+ let txid: [u8; 32] = Readable::read(reader)?;
+ let commitment_number = <U48 as Readable<R>>::read(reader)?.0;
+ if let Some(_) = remote_hash_commitment_number.insert(txid, commitment_number) {
+ return Err(DecodeError::InvalidValue);
+ }
+ }
+
+ macro_rules! read_local_tx {
+ () => {
+ {
+ let tx = match Transaction::consensus_decode(&mut serialize::RawDecoder::new(reader.by_ref())) {
+ Ok(tx) => tx,
+ Err(e) => match e {
+ serialize::Error::Io(ioe) => return Err(DecodeError::Io(ioe)),
+ _ => return Err(DecodeError::InvalidValue),
+ },
+ };
+
+ if tx.input.is_empty() {
+ // Ensure tx didn't hit the 0-input ambiguity case.
+ return Err(DecodeError::InvalidValue);
+ }
+
+ let revocation_key = Readable::read(reader)?;
+ let a_htlc_key = Readable::read(reader)?;
+ let b_htlc_key = Readable::read(reader)?;
+ let delayed_payment_key = Readable::read(reader)?;
+ let feerate_per_kw: u64 = Readable::read(reader)?;
+
+ let htlc_outputs_len: u64 = Readable::read(reader)?;
+ let mut htlc_outputs = Vec::with_capacity(cmp::min(htlc_outputs_len as usize, MAX_ALLOC_SIZE / 128));
+ for _ in 0..htlc_outputs_len {
+ htlc_outputs.push((read_htlc_in_commitment!(), Readable::read(reader)?, Readable::read(reader)?));
+ }
+
+ LocalSignedTx {
+ txid: tx.txid(),
+ tx, revocation_key, a_htlc_key, b_htlc_key, delayed_payment_key, feerate_per_kw, htlc_outputs
+ }
+ }
+ }
+ }
+
+ let prev_local_signed_commitment_tx = match <u8 as Readable<R>>::read(reader)? {
+ 0 => None,
+ 1 => {
+ Some(read_local_tx!())
+ },
+ _ => return Err(DecodeError::InvalidValue),
+ };
+
+ let current_local_signed_commitment_tx = match <u8 as Readable<R>>::read(reader)? {
+ 0 => None,
+ 1 => {
+ Some(read_local_tx!())
+ },
+ _ => return Err(DecodeError::InvalidValue),
+ };
+
+ let current_remote_commitment_number = <U48 as Readable<R>>::read(reader)?.0;
+
+ let payment_preimages_len: u64 = Readable::read(reader)?;
+ let mut payment_preimages = HashMap::with_capacity(cmp::min(payment_preimages_len as usize, MAX_ALLOC_SIZE / 32));
+ let mut sha = Sha256::new();
+ for _ in 0..payment_preimages_len {
+ let preimage: [u8; 32] = Readable::read(reader)?;
+ sha.reset();
+ sha.input(&preimage);
+ let mut hash = [0; 32];
+ sha.result(&mut hash);
+ if let Some(_) = payment_preimages.insert(hash, preimage) {
+ return Err(DecodeError::InvalidValue);
+ }
+ }
+
+ let last_block_hash: Sha256dHash = Readable::read(reader)?;
+ let destination_script = Readable::read(reader)?;
+
+ Ok((last_block_hash.clone(), ChannelMonitor {
+ funding_txo,
+ commitment_transaction_number_obscure_factor,
+
+ key_storage,
+ their_htlc_base_key,
+ their_delayed_payment_base_key,
+ their_cur_revocation_points,
+
+ our_to_self_delay,
+ their_to_self_delay,
+
+ old_secrets,
+ remote_claimable_outpoints,
+ remote_commitment_txn_on_chain,
+ remote_hash_commitment_number,
+
+ prev_local_signed_commitment_tx,
+ current_local_signed_commitment_tx,
+ current_remote_commitment_number,
+
+ payment_preimages,
+
+ destination_script,
+ last_block_hash,
+ secp_ctx,
+ logger,
+ }))
+ }
+
+}
+