+ pub(super) fn would_broadcast_at_height(&self, height: u32) -> bool {
+ if let Some(ref cur_local_tx) = self.current_local_signed_commitment_tx {
+ for &(ref htlc, _, _) in cur_local_tx.htlc_outputs.iter() {
+ // For inbound HTLCs which we know the preimage for, we have to ensure we hit the
+ // chain with enough room to claim the HTLC without our counterparty being able to
+ // time out the HTLC first.
+ // For outbound HTLCs which our counterparty hasn't failed/claimed, our primary
+ // concern is being able to claim the corresponding inbound HTLC (on another
+ // channel) before it expires. In fact, we don't even really care if our
+ // counterparty here claims such an outbound HTLC after it expired as long as we
+ // can still claim the corresponding HTLC. Thus, to avoid needlessly hitting the
+ // chain when our counterparty is waiting for expiration to off-chain fail an HTLC
+ // we give ourselves a few blocks of headroom after expiration before going
+ // on-chain for an expired HTLC.
+ // Note that, to avoid a potential attack whereby a node delays claiming an HTLC
+ // from us until we've reached the point where we go on-chain with the
+ // corresponding inbound HTLC, we must ensure that outbound HTLCs go on chain at
+ // least CLTV_CLAIM_BUFFER blocks prior to the inbound HTLC.
+ // aka outbound_cltv + HTLC_FAIL_TIMEOUT_BLOCKS == height - CLTV_CLAIM_BUFFER
+ // inbound_cltv == height + CLTV_CLAIM_BUFFER
+ // outbound_cltv + HTLC_FAIL_TIMEOUT_BLOCKS + CLTV_CLAIM_BUFER <= inbound_cltv - CLTV_CLAIM_BUFFER
+ // HTLC_FAIL_TIMEOUT_BLOCKS + 2*CLTV_CLAIM_BUFER <= inbound_cltv - outbound_cltv
+ // HTLC_FAIL_TIMEOUT_BLOCKS + 2*CLTV_CLAIM_BUFER <= CLTV_EXPIRY_DELTA
+ if ( htlc.offered && htlc.cltv_expiry + HTLC_FAIL_TIMEOUT_BLOCKS <= height) ||
+ (!htlc.offered && htlc.cltv_expiry <= height + CLTV_CLAIM_BUFFER && self.payment_preimages.contains_key(&htlc.payment_hash)) {
+ return true;
+ }
+ }
+ }
+ false
+ }
+}
+
+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 payment_base_key = Readable::read(reader)?;
+ let shutdown_pubkey = 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,
+ payment_base_key,
+ shutdown_pubkey,
+ 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(reader.by_ref()) {
+ Ok(tx) => tx,
+ Err(e) => match e {
+ encode::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