git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/ln/monitor_tests.rs

   1 // This file is Copyright its original authors, visible in version control
   2 // history.
   3 //
   4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
   5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   7 // You may not use this file except in accordance with one or both of these
   8 // licenses.
   9
  10 //! Further functional tests which test blockchain reorganizations.
  11
  12 #[cfg(anchors)]
  13 use crate::chain::keysinterface::{ChannelSigner, EcdsaChannelSigner};
  14 #[cfg(anchors)]
  15 use crate::chain::channelmonitor::LATENCY_GRACE_PERIOD_BLOCKS;
  16 use crate::chain::channelmonitor::{ANTI_REORG_DELAY, Balance};
  17 use crate::chain::transaction::OutPoint;
  18 use crate::chain::chaininterface::LowerBoundedFeeEstimator;
  19 #[cfg(anchors)]
  20 use crate::events::bump_transaction::BumpTransactionEvent;
  21 use crate::events::{Event, MessageSendEvent, MessageSendEventsProvider, ClosureReason, HTLCDestination};
  22 use crate::ln::channel;
  23 #[cfg(anchors)]
  24 use crate::ln::chan_utils;
  25 #[cfg(anchors)]
  26 use crate::ln::channelmanager::ChannelManager;
  27 use crate::ln::channelmanager::{BREAKDOWN_TIMEOUT, PaymentId, RecipientOnionFields};
  28 use crate::ln::msgs::ChannelMessageHandler;
  29 #[cfg(anchors)]
  30 use crate::util::config::UserConfig;
  31 #[cfg(anchors)]
  32 use crate::util::crypto::sign;
  33 #[cfg(anchors)]
  34 use crate::util::ser::Writeable;
  35 #[cfg(anchors)]
  36 use crate::util::test_utils;
  37
  38 #[cfg(anchors)]
  39 use bitcoin::blockdata::transaction::EcdsaSighashType;
  40 use bitcoin::blockdata::script::Builder;
  41 use bitcoin::blockdata::opcodes;
  42 use bitcoin::secp256k1::Secp256k1;
  43 #[cfg(anchors)]
  44 use bitcoin::secp256k1::SecretKey;
  45 #[cfg(anchors)]
  46 use bitcoin::{Amount, PublicKey, Script, TxIn, TxOut, PackedLockTime, Witness};
  47 use bitcoin::Transaction;
  48 #[cfg(anchors)]
  49 use bitcoin::util::sighash::SighashCache;
  50
  51 use crate::prelude::*;
  52
  53 use crate::ln::functional_test_utils::*;
  54
  55 #[test]
  56 fn chanmon_fail_from_stale_commitment() {
  57         // If we forward an HTLC to our counterparty, but we force-closed the channel before our
  58         // counterparty provides us an updated commitment transaction, we'll end up with a commitment
  59         // transaction that does not contain the HTLC which we attempted to forward. In this case, we
  60         // need to wait `ANTI_REORG_DELAY` blocks and then fail back the HTLC as there is no way for us
  61         // to learn the preimage and the confirmed commitment transaction paid us the value of the
  62         // HTLC.
  63         //
  64         // However, previously, we did not do this, ignoring the HTLC entirely.
  65         //
  66         // This could lead to channel closure if the sender we received the HTLC from decides to go on
  67         // chain to get their HTLC back before it times out.
  68         //
  69         // Here, we check exactly this case, forwarding a payment from A, through B, to C, before B
  70         // broadcasts its latest commitment transaction, which should result in it eventually failing
  71         // the HTLC back off-chain to A.
  72         let chanmon_cfgs = create_chanmon_cfgs(3);
  73         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
  74         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
  75         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  76
  77         create_announced_chan_between_nodes(&nodes, 0, 1);
  78         let (update_a, _, chan_id_2, _) = create_announced_chan_between_nodes(&nodes, 1, 2);
  79
  80         let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 1_000_000);
  81         nodes[0].node.send_payment_with_route(&route, payment_hash,
  82                 RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap();
  83         check_added_monitors!(nodes[0], 1);
  84
  85         let bs_txn = get_local_commitment_txn!(nodes[1], chan_id_2);
  86
  87         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  88         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
  89         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
  90
  91         expect_pending_htlcs_forwardable!(nodes[1]);
  92         get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
  93         check_added_monitors!(nodes[1], 1);
  94
  95         // Don't bother delivering the new HTLC add/commits, instead confirming the pre-HTLC commitment
  96         // transaction for nodes[1].
  97         mine_transaction(&nodes[1], &bs_txn[0]);
  98         check_added_monitors!(nodes[1], 1);
  99         check_closed_broadcast!(nodes[1], true);
 100         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
 101         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 102
 103         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 104         expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[1], vec![HTLCDestination::NextHopChannel { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_id_2 }]);
 105         check_added_monitors!(nodes[1], 1);
 106         let fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 107
 108         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_updates.update_fail_htlcs[0]);
 109         commitment_signed_dance!(nodes[0], nodes[1], fail_updates.commitment_signed, true, true);
 110         expect_payment_failed_with_update!(nodes[0], payment_hash, false, update_a.contents.short_channel_id, true);
 111 }
 112
 113 fn test_spendable_output<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, spendable_tx: &Transaction) {
 114         let mut spendable = node.chain_monitor.chain_monitor.get_and_clear_pending_events();
 115         assert_eq!(spendable.len(), 1);
 116         if let Event::SpendableOutputs { outputs } = spendable.pop().unwrap() {
 117                 assert_eq!(outputs.len(), 1);
 118                 let spend_tx = node.keys_manager.backing.spend_spendable_outputs(&[&outputs[0]], Vec::new(),
 119                         Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), 253, &Secp256k1::new()).unwrap();
 120                 check_spends!(spend_tx, spendable_tx);
 121         } else { panic!(); }
 122 }
 123
 124 #[test]
 125 fn revoked_output_htlc_resolution_timing() {
 126         // Tests that HTLCs which were present in a broadcasted remote revoked commitment transaction
 127         // are resolved only after a spend of the HTLC output reaches six confirmations. Preivously
 128         // they would resolve after the revoked commitment transaction itself reaches six
 129         // confirmations.
 130         let chanmon_cfgs = create_chanmon_cfgs(2);
 131         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 132         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 133         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 134
 135         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000);
 136
 137         let payment_hash_1 = route_payment(&nodes[1], &[&nodes[0]], 1_000_000).1;
 138
 139         // Get a commitment transaction which contains the HTLC we care about, but which we'll revoke
 140         // before forwarding.
 141         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan.2);
 142         assert_eq!(revoked_local_txn.len(), 1);
 143
 144         // Route a dust payment to revoke the above commitment transaction
 145         route_payment(&nodes[0], &[&nodes[1]], 1_000);
 146
 147         // Confirm the revoked commitment transaction, closing the channel.
 148         mine_transaction(&nodes[1], &revoked_local_txn[0]);
 149         check_added_monitors!(nodes[1], 1);
 150         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
 151         check_closed_broadcast!(nodes[1], true);
 152
 153         let bs_spend_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 154         assert_eq!(bs_spend_txn.len(), 1);
 155         check_spends!(bs_spend_txn[0], revoked_local_txn[0]);
 156
 157         // After the commitment transaction confirms, we should still wait on the HTLC spend
 158         // transaction to confirm before resolving the HTLC.
 159         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 160         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 161         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 162
 163         // Spend the HTLC output, generating a HTLC failure event after ANTI_REORG_DELAY confirmations.
 164         mine_transaction(&nodes[1], &bs_spend_txn[0]);
 165         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 166         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 167
 168         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 169         expect_payment_failed!(nodes[1], payment_hash_1, false);
 170 }
 171
 172 #[test]
 173 fn chanmon_claim_value_coop_close() {
 174         // Tests `get_claimable_balances` returns the correct values across a simple cooperative claim.
 175         // Specifically, this tests that the channel non-HTLC balances show up in
 176         // `get_claimable_balances` until the cooperative claims have confirmed and generated a
 177         // `SpendableOutputs` event, and no longer.
 178         let chanmon_cfgs = create_chanmon_cfgs(2);
 179         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 180         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 181         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 182
 183         let (_, _, chan_id, funding_tx) =
 184                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 1_000_000);
 185         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 186         assert_eq!(funding_outpoint.to_channel_id(), chan_id);
 187
 188         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
 189         let opt_anchors = get_opt_anchors!(nodes[0], nodes[1], chan_id);
 190
 191         assert_eq!(vec![Balance::ClaimableOnChannelClose {
 192                         claimable_amount_satoshis: 1_000_000 - 1_000 - chan_feerate * channel::commitment_tx_base_weight(opt_anchors) / 1000
 193                 }],
 194                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 195         assert_eq!(vec![Balance::ClaimableOnChannelClose { claimable_amount_satoshis: 1_000, }],
 196                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 197
 198         nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
 199         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 200         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 201         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 202         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 203
 204         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 205         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 206         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 207         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 208         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 209         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
 210         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 211         assert!(node_1_none.is_none());
 212
 213         let shutdown_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 214         assert_eq!(shutdown_tx, nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0));
 215         assert_eq!(shutdown_tx.len(), 1);
 216
 217         mine_transaction(&nodes[0], &shutdown_tx[0]);
 218         mine_transaction(&nodes[1], &shutdown_tx[0]);
 219
 220         assert!(nodes[0].node.list_channels().is_empty());
 221         assert!(nodes[1].node.list_channels().is_empty());
 222
 223         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 224         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 225
 226         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 227                         claimable_amount_satoshis: 1_000_000 - 1_000 - chan_feerate * channel::commitment_tx_base_weight(opt_anchors) / 1000,
 228                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
 229                 }],
 230                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 231         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 232                         claimable_amount_satoshis: 1000,
 233                         confirmation_height: nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1,
 234                 }],
 235                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 236
 237         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 238         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 239
 240         assert_eq!(Vec::<Balance>::new(),
 241                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 242         assert_eq!(Vec::<Balance>::new(),
 243                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 244
 245         test_spendable_output(&nodes[0], &shutdown_tx[0]);
 246         test_spendable_output(&nodes[1], &shutdown_tx[0]);
 247
 248         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
 249         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
 250 }
 251
 252 fn sorted_vec<T: Ord>(mut v: Vec<T>) -> Vec<T> {
 253         v.sort_unstable();
 254         v
 255 }
 256
 257 /// Asserts that `a` and `b` are close, but maybe off by up to 5.
 258 /// This is useful when checking fees and weights on transactions as things may vary by a few based
 259 /// on signature size and signature size estimation being non-exact.
 260 fn fuzzy_assert_eq<V: core::convert::TryInto<u64>>(a: V, b: V) {
 261         let a_u64 = a.try_into().map_err(|_| ()).unwrap();
 262         let b_u64 = b.try_into().map_err(|_| ()).unwrap();
 263         eprintln!("Checking {} and {} for fuzzy equality", a_u64, b_u64);
 264         assert!(a_u64 >= b_u64 - 5);
 265         assert!(b_u64 >= a_u64 - 5);
 266 }
 267
 268 fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
 269         // Tests `get_claimable_balances` with an HTLC across a force-close.
 270         // We build a channel with an HTLC pending, then force close the channel and check that the
 271         // `get_claimable_balances` return value is correct as transactions confirm on-chain.
 272         let mut chanmon_cfgs = create_chanmon_cfgs(2);
 273         if prev_commitment_tx {
 274                 // We broadcast a second-to-latest commitment transaction, without providing the revocation
 275                 // secret to the counterparty. However, because we always immediately take the revocation
 276                 // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
 277                 // transaction which, from the point of view of our keys_manager, is revoked.
 278                 chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
 279         }
 280         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 281         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 282         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 283
 284         let (_, _, chan_id, funding_tx) =
 285                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 1_000_000);
 286         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 287         assert_eq!(funding_outpoint.to_channel_id(), chan_id);
 288
 289         // This HTLC is immediately claimed, giving node B the preimage
 290         let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 3_000_000);
 291         // This HTLC is allowed to time out, letting A claim it. However, in order to test claimable
 292         // balances more fully we also give B the preimage for this HTLC.
 293         let (timeout_payment_preimage, timeout_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 4_000_000);
 294         // This HTLC will be dust, and not be claimable at all:
 295         let (dust_payment_preimage, dust_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 3_000);
 296
 297         let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
 298
 299         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
 300         let opt_anchors = get_opt_anchors!(nodes[0], nodes[1], chan_id);
 301
 302         let remote_txn = get_local_commitment_txn!(nodes[1], chan_id);
 303         // Before B receives the payment preimage, it only suggests the push_msat value of 1_000 sats
 304         // as claimable. A lists both its to-self balance and the (possibly-claimable) HTLCs.
 305         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 306                         claimable_amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *
 307                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 308                 }, Balance::MaybeTimeoutClaimableHTLC {
 309                         claimable_amount_satoshis: 3_000,
 310                         claimable_height: htlc_cltv_timeout,
 311                 }, Balance::MaybeTimeoutClaimableHTLC {
 312                         claimable_amount_satoshis: 4_000,
 313                         claimable_height: htlc_cltv_timeout,
 314                 }]),
 315                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 316         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 317                         claimable_amount_satoshis: 1_000,
 318                 }, Balance::MaybePreimageClaimableHTLC {
 319                         claimable_amount_satoshis: 3_000,
 320                         expiry_height: htlc_cltv_timeout,
 321                 }, Balance::MaybePreimageClaimableHTLC {
 322                         claimable_amount_satoshis: 4_000,
 323                         expiry_height: htlc_cltv_timeout,
 324                 }]),
 325                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 326
 327         nodes[1].node.claim_funds(payment_preimage);
 328         check_added_monitors!(nodes[1], 1);
 329         expect_payment_claimed!(nodes[1], payment_hash, 3_000_000);
 330
 331         let b_htlc_msgs = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
 332         // We claim the dust payment here as well, but it won't impact our claimable balances as its
 333         // dust and thus doesn't appear on chain at all.
 334         nodes[1].node.claim_funds(dust_payment_preimage);
 335         check_added_monitors!(nodes[1], 1);
 336         expect_payment_claimed!(nodes[1], dust_payment_hash, 3_000);
 337
 338         nodes[1].node.claim_funds(timeout_payment_preimage);
 339         check_added_monitors!(nodes[1], 1);
 340         expect_payment_claimed!(nodes[1], timeout_payment_hash, 4_000_000);
 341
 342         if prev_commitment_tx {
 343                 // To build a previous commitment transaction, deliver one round of commitment messages.
 344                 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &b_htlc_msgs.update_fulfill_htlcs[0]);
 345                 expect_payment_sent_without_paths!(nodes[0], payment_preimage);
 346                 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &b_htlc_msgs.commitment_signed);
 347                 check_added_monitors!(nodes[0], 1);
 348                 let (as_raa, as_cs) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 349                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
 350                 let _htlc_updates = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
 351                 check_added_monitors!(nodes[1], 1);
 352                 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs);
 353                 let _bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 354                 check_added_monitors!(nodes[1], 1);
 355         }
 356
 357         // Once B has received the payment preimage, it includes the value of the HTLC in its
 358         // "claimable if you were to close the channel" balance.
 359         let mut a_expected_balances = vec![Balance::ClaimableOnChannelClose {
 360                         claimable_amount_satoshis: 1_000_000 - // Channel funding value in satoshis
 361                                 4_000 - // The to-be-failed HTLC value in satoshis
 362                                 3_000 - // The claimed HTLC value in satoshis
 363                                 1_000 - // The push_msat value in satoshis
 364                                 3 - // The dust HTLC value in satoshis
 365                                 // The commitment transaction fee with two HTLC outputs:
 366                                 chan_feerate * (channel::commitment_tx_base_weight(opt_anchors) +
 367                                                                 if prev_commitment_tx { 1 } else { 2 } *
 368                                                                 channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 369                 }, Balance::MaybeTimeoutClaimableHTLC {
 370                         claimable_amount_satoshis: 4_000,
 371                         claimable_height: htlc_cltv_timeout,
 372                 }];
 373         if !prev_commitment_tx {
 374                 a_expected_balances.push(Balance::MaybeTimeoutClaimableHTLC {
 375                         claimable_amount_satoshis: 3_000,
 376                         claimable_height: htlc_cltv_timeout,
 377                 });
 378         }
 379         assert_eq!(sorted_vec(a_expected_balances),
 380                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 381         assert_eq!(vec![Balance::ClaimableOnChannelClose {
 382                         claimable_amount_satoshis: 1_000 + 3_000 + 4_000,
 383                 }],
 384                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 385
 386         // Broadcast the closing transaction (which has both pending HTLCs in it) and get B's
 387         // broadcasted HTLC claim transaction with preimage.
 388         let node_b_commitment_claimable = nodes[1].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 389         mine_transaction(&nodes[0], &remote_txn[0]);
 390         mine_transaction(&nodes[1], &remote_txn[0]);
 391
 392         let b_broadcast_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 393         assert_eq!(b_broadcast_txn.len(), 2);
 394         // b_broadcast_txn should spend the HTLCs output of the commitment tx for 3_000 and 4_000 sats
 395         check_spends!(b_broadcast_txn[0], remote_txn[0]);
 396         check_spends!(b_broadcast_txn[1], remote_txn[0]);
 397         assert_eq!(b_broadcast_txn[0].input.len(), 1);
 398         assert_eq!(b_broadcast_txn[1].input.len(), 1);
 399         assert_eq!(remote_txn[0].output[b_broadcast_txn[0].input[0].previous_output.vout as usize].value, 3_000);
 400         assert_eq!(remote_txn[0].output[b_broadcast_txn[1].input[0].previous_output.vout as usize].value, 4_000);
 401
 402         assert!(nodes[0].node.list_channels().is_empty());
 403         check_closed_broadcast!(nodes[0], true);
 404         check_added_monitors!(nodes[0], 1);
 405         check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
 406         assert!(nodes[1].node.list_channels().is_empty());
 407         check_closed_broadcast!(nodes[1], true);
 408         check_added_monitors!(nodes[1], 1);
 409         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
 410         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 411         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 412
 413         // Once the commitment transaction confirms, we will wait until ANTI_REORG_DELAY until we
 414         // generate any `SpendableOutputs` events. Thus, the same balances will still be listed
 415         // available in `get_claimable_balances`. However, both will swap from `ClaimableOnClose` to
 416         // other Balance variants, as close has already happened.
 417         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 418         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 419
 420         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 421                         claimable_amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *
 422                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 423                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
 424                 }, Balance::MaybeTimeoutClaimableHTLC {
 425                         claimable_amount_satoshis: 3_000,
 426                         claimable_height: htlc_cltv_timeout,
 427                 }, Balance::MaybeTimeoutClaimableHTLC {
 428                         claimable_amount_satoshis: 4_000,
 429                         claimable_height: htlc_cltv_timeout,
 430                 }]),
 431                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 432         // The main non-HTLC balance is just awaiting confirmations, but the claimable height is the
 433         // CSV delay, not ANTI_REORG_DELAY.
 434         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 435                         claimable_amount_satoshis: 1_000,
 436                         confirmation_height: node_b_commitment_claimable,
 437                 },
 438                 // Both HTLC balances are "contentious" as our counterparty could claim them if we wait too
 439                 // long.
 440                 Balance::ContentiousClaimable {
 441                         claimable_amount_satoshis: 3_000,
 442                         timeout_height: htlc_cltv_timeout,
 443                 }, Balance::ContentiousClaimable {
 444                         claimable_amount_satoshis: 4_000,
 445                         timeout_height: htlc_cltv_timeout,
 446                 }]),
 447                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 448
 449         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 450         expect_payment_failed!(nodes[0], dust_payment_hash, false);
 451         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 452
 453         // After ANTI_REORG_DELAY, A will consider its balance fully spendable and generate a
 454         // `SpendableOutputs` event. However, B still has to wait for the CSV delay.
 455         assert_eq!(sorted_vec(vec![Balance::MaybeTimeoutClaimableHTLC {
 456                         claimable_amount_satoshis: 3_000,
 457                         claimable_height: htlc_cltv_timeout,
 458                 }, Balance::MaybeTimeoutClaimableHTLC {
 459                         claimable_amount_satoshis: 4_000,
 460                         claimable_height: htlc_cltv_timeout,
 461                 }]),
 462                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 463         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 464                         claimable_amount_satoshis: 1_000,
 465                         confirmation_height: node_b_commitment_claimable,
 466                 }, Balance::ContentiousClaimable {
 467                         claimable_amount_satoshis: 3_000,
 468                         timeout_height: htlc_cltv_timeout,
 469                 }, Balance::ContentiousClaimable {
 470                         claimable_amount_satoshis: 4_000,
 471                         timeout_height: htlc_cltv_timeout,
 472                 }]),
 473                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 474
 475         test_spendable_output(&nodes[0], &remote_txn[0]);
 476         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 477
 478         // After broadcasting the HTLC claim transaction, node A will still consider the HTLC
 479         // possibly-claimable up to ANTI_REORG_DELAY, at which point it will drop it.
 480         mine_transaction(&nodes[0], &b_broadcast_txn[0]);
 481         if prev_commitment_tx {
 482                 expect_payment_path_successful!(nodes[0]);
 483         } else {
 484                 expect_payment_sent!(nodes[0], payment_preimage);
 485         }
 486         assert_eq!(sorted_vec(vec![Balance::MaybeTimeoutClaimableHTLC {
 487                         claimable_amount_satoshis: 3_000,
 488                         claimable_height: htlc_cltv_timeout,
 489                 }, Balance::MaybeTimeoutClaimableHTLC {
 490                         claimable_amount_satoshis: 4_000,
 491                         claimable_height: htlc_cltv_timeout,
 492                 }]),
 493                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 494         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 495         assert_eq!(vec![Balance::MaybeTimeoutClaimableHTLC {
 496                         claimable_amount_satoshis: 4_000,
 497                         claimable_height: htlc_cltv_timeout,
 498                 }],
 499                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 500
 501         // When the HTLC timeout output is spendable in the next block, A should broadcast it
 502         connect_blocks(&nodes[0], htlc_cltv_timeout - nodes[0].best_block_info().1 - 1);
 503         let a_broadcast_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 504         assert_eq!(a_broadcast_txn.len(), 2);
 505         assert_eq!(a_broadcast_txn[0].input.len(), 1);
 506         check_spends!(a_broadcast_txn[0], remote_txn[0]);
 507         assert_eq!(a_broadcast_txn[1].input.len(), 1);
 508         check_spends!(a_broadcast_txn[1], remote_txn[0]);
 509         assert_ne!(a_broadcast_txn[0].input[0].previous_output.vout,
 510                    a_broadcast_txn[1].input[0].previous_output.vout);
 511         // a_broadcast_txn [0] and [1] should spend the HTLC outputs of the commitment tx
 512         assert_eq!(remote_txn[0].output[a_broadcast_txn[0].input[0].previous_output.vout as usize].value, 3_000);
 513         assert_eq!(remote_txn[0].output[a_broadcast_txn[1].input[0].previous_output.vout as usize].value, 4_000);
 514
 515         // Once the HTLC-Timeout transaction confirms, A will no longer consider the HTLC
 516         // "MaybeClaimable", but instead move it to "AwaitingConfirmations".
 517         mine_transaction(&nodes[0], &a_broadcast_txn[1]);
 518         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 519         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 520                         claimable_amount_satoshis: 4_000,
 521                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
 522                 }],
 523                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 524         // After ANTI_REORG_DELAY, A will generate a SpendableOutputs event and drop the claimable
 525         // balance entry.
 526         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 527         assert_eq!(Vec::<Balance>::new(),
 528                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 529         expect_payment_failed!(nodes[0], timeout_payment_hash, false);
 530
 531         test_spendable_output(&nodes[0], &a_broadcast_txn[1]);
 532
 533         // Node B will no longer consider the HTLC "contentious" after the HTLC claim transaction
 534         // confirms, and consider it simply "awaiting confirmations". Note that it has to wait for the
 535         // standard revocable transaction CSV delay before receiving a `SpendableOutputs`.
 536         let node_b_htlc_claimable = nodes[1].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 537         mine_transaction(&nodes[1], &b_broadcast_txn[0]);
 538
 539         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 540                         claimable_amount_satoshis: 1_000,
 541                         confirmation_height: node_b_commitment_claimable,
 542                 }, Balance::ClaimableAwaitingConfirmations {
 543                         claimable_amount_satoshis: 3_000,
 544                         confirmation_height: node_b_htlc_claimable,
 545                 }, Balance::ContentiousClaimable {
 546                         claimable_amount_satoshis: 4_000,
 547                         timeout_height: htlc_cltv_timeout,
 548                 }]),
 549                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 550
 551         // After reaching the commitment output CSV, we'll get a SpendableOutputs event for it and have
 552         // only the HTLCs claimable on node B.
 553         connect_blocks(&nodes[1], node_b_commitment_claimable - nodes[1].best_block_info().1);
 554         test_spendable_output(&nodes[1], &remote_txn[0]);
 555
 556         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 557                         claimable_amount_satoshis: 3_000,
 558                         confirmation_height: node_b_htlc_claimable,
 559                 }, Balance::ContentiousClaimable {
 560                         claimable_amount_satoshis: 4_000,
 561                         timeout_height: htlc_cltv_timeout,
 562                 }]),
 563                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 564
 565         // After reaching the claimed HTLC output CSV, we'll get a SpendableOutptus event for it and
 566         // have only one HTLC output left spendable.
 567         connect_blocks(&nodes[1], node_b_htlc_claimable - nodes[1].best_block_info().1);
 568         test_spendable_output(&nodes[1], &b_broadcast_txn[0]);
 569
 570         assert_eq!(vec![Balance::ContentiousClaimable {
 571                         claimable_amount_satoshis: 4_000,
 572                         timeout_height: htlc_cltv_timeout,
 573                 }],
 574                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 575
 576         // Finally, mine the HTLC timeout transaction that A broadcasted (even though B should be able
 577         // to claim this HTLC with the preimage it knows!). It will remain listed as a claimable HTLC
 578         // until ANTI_REORG_DELAY confirmations on the spend.
 579         mine_transaction(&nodes[1], &a_broadcast_txn[1]);
 580         assert_eq!(vec![Balance::ContentiousClaimable {
 581                         claimable_amount_satoshis: 4_000,
 582                         timeout_height: htlc_cltv_timeout,
 583                 }],
 584                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 585         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 586         assert_eq!(Vec::<Balance>::new(),
 587                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 588
 589         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
 590         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
 591         // monitor events or claimable balances.
 592         for node in nodes.iter() {
 593                 connect_blocks(node, 6);
 594                 connect_blocks(node, 6);
 595                 assert!(node.chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 596                 assert!(node.chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
 597         }
 598 }
 599
 600 #[test]
 601 fn test_claim_value_force_close() {
 602         do_test_claim_value_force_close(true);
 603         do_test_claim_value_force_close(false);
 604 }
 605
 606 #[test]
 607 fn test_balances_on_local_commitment_htlcs() {
 608         // Previously, when handling the broadcast of a local commitment transactions (with associated
 609         // CSV delays prior to spendability), we incorrectly handled the CSV delays on HTLC
 610         // transactions. This caused us to miss spendable outputs for HTLCs which were awaiting a CSV
 611         // delay prior to spendability.
 612         //
 613         // Further, because of this, we could hit an assertion as `get_claimable_balances` asserted
 614         // that HTLCs were resolved after the funding spend was resolved, which was not true if the
 615         // HTLC did not have a CSV delay attached (due to the above bug or due to it being an HTLC
 616         // claim by our counterparty).
 617         let chanmon_cfgs = create_chanmon_cfgs(2);
 618         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 619         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 620         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 621
 622         // Create a single channel with two pending HTLCs from nodes[0] to nodes[1], one which nodes[1]
 623         // knows the preimage for, one which it does not.
 624         let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
 625         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 626
 627         let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 10_000_000);
 628         let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
 629         nodes[0].node.send_payment_with_route(&route, payment_hash,
 630                 RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap();
 631         check_added_monitors!(nodes[0], 1);
 632
 633         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 634         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 635         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
 636
 637         expect_pending_htlcs_forwardable!(nodes[1]);
 638         expect_payment_claimable!(nodes[1], payment_hash, payment_secret, 10_000_000);
 639
 640         let (route_2, payment_hash_2, payment_preimage_2, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[1], 20_000_000);
 641         nodes[0].node.send_payment_with_route(&route_2, payment_hash_2,
 642                 RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap();
 643         check_added_monitors!(nodes[0], 1);
 644
 645         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 646         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 647         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
 648
 649         expect_pending_htlcs_forwardable!(nodes[1]);
 650         expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 20_000_000);
 651         nodes[1].node.claim_funds(payment_preimage_2);
 652         get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 653         check_added_monitors!(nodes[1], 1);
 654         expect_payment_claimed!(nodes[1], payment_hash_2, 20_000_000);
 655
 656         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
 657         let opt_anchors = get_opt_anchors!(nodes[0], nodes[1], chan_id);
 658
 659         // Get nodes[0]'s commitment transaction and HTLC-Timeout transactions
 660         let as_txn = get_local_commitment_txn!(nodes[0], chan_id);
 661         assert_eq!(as_txn.len(), 3);
 662         check_spends!(as_txn[1], as_txn[0]);
 663         check_spends!(as_txn[2], as_txn[0]);
 664         check_spends!(as_txn[0], funding_tx);
 665
 666         // First confirm the commitment transaction on nodes[0], which should leave us with three
 667         // claimable balances.
 668         let node_a_commitment_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 669         mine_transaction(&nodes[0], &as_txn[0]);
 670         check_added_monitors!(nodes[0], 1);
 671         check_closed_broadcast!(nodes[0], true);
 672         check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
 673
 674         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 675                         claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
 676                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 677                         confirmation_height: node_a_commitment_claimable,
 678                 }, Balance::MaybeTimeoutClaimableHTLC {
 679                         claimable_amount_satoshis: 10_000,
 680                         claimable_height: htlc_cltv_timeout,
 681                 }, Balance::MaybeTimeoutClaimableHTLC {
 682                         claimable_amount_satoshis: 20_000,
 683                         claimable_height: htlc_cltv_timeout,
 684                 }]),
 685                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 686
 687         // Get nodes[1]'s HTLC claim tx for the second HTLC
 688         mine_transaction(&nodes[1], &as_txn[0]);
 689         check_added_monitors!(nodes[1], 1);
 690         check_closed_broadcast!(nodes[1], true);
 691         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
 692         let bs_htlc_claim_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 693         assert_eq!(bs_htlc_claim_txn.len(), 1);
 694         check_spends!(bs_htlc_claim_txn[0], as_txn[0]);
 695
 696         // Connect blocks until the HTLCs expire, allowing us to (validly) broadcast the HTLC-Timeout
 697         // transaction.
 698         connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
 699         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 700                         claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
 701                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 702                         confirmation_height: node_a_commitment_claimable,
 703                 }, Balance::MaybeTimeoutClaimableHTLC {
 704                         claimable_amount_satoshis: 10_000,
 705                         claimable_height: htlc_cltv_timeout,
 706                 }, Balance::MaybeTimeoutClaimableHTLC {
 707                         claimable_amount_satoshis: 20_000,
 708                         claimable_height: htlc_cltv_timeout,
 709                 }]),
 710                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 711         assert_eq!(as_txn[1].lock_time.0, nodes[0].best_block_info().1 + 1); // as_txn[1] can be included in the next block
 712
 713         // Now confirm nodes[0]'s HTLC-Timeout transaction, which changes the claimable balance to an
 714         // "awaiting confirmations" one.
 715         let node_a_htlc_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 716         mine_transaction(&nodes[0], &as_txn[1]);
 717         // Note that prior to the fix in the commit which introduced this test, this (and the next
 718         // balance) check failed. With this check removed, the code panicked in the `connect_blocks`
 719         // call, as described, two hunks down.
 720         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 721                         claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
 722                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 723                         confirmation_height: node_a_commitment_claimable,
 724                 }, Balance::ClaimableAwaitingConfirmations {
 725                         claimable_amount_satoshis: 10_000,
 726                         confirmation_height: node_a_htlc_claimable,
 727                 }, Balance::MaybeTimeoutClaimableHTLC {
 728                         claimable_amount_satoshis: 20_000,
 729                         claimable_height: htlc_cltv_timeout,
 730                 }]),
 731                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 732
 733         // Now confirm nodes[1]'s HTLC claim, giving nodes[0] the preimage. Note that the "maybe
 734         // claimable" balance remains until we see ANTI_REORG_DELAY blocks.
 735         mine_transaction(&nodes[0], &bs_htlc_claim_txn[0]);
 736         expect_payment_sent!(nodes[0], payment_preimage_2);
 737         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 738                         claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
 739                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 740                         confirmation_height: node_a_commitment_claimable,
 741                 }, Balance::ClaimableAwaitingConfirmations {
 742                         claimable_amount_satoshis: 10_000,
 743                         confirmation_height: node_a_htlc_claimable,
 744                 }, Balance::MaybeTimeoutClaimableHTLC {
 745                         claimable_amount_satoshis: 20_000,
 746                         claimable_height: htlc_cltv_timeout,
 747                 }]),
 748                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 749
 750         // Finally make the HTLC transactions have ANTI_REORG_DELAY blocks. This call previously
 751         // panicked as described in the test introduction. This will remove the "maybe claimable"
 752         // spendable output as nodes[1] has fully claimed the second HTLC.
 753         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 754         expect_payment_failed!(nodes[0], payment_hash, false);
 755
 756         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 757                         claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
 758                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 759                         confirmation_height: node_a_commitment_claimable,
 760                 }, Balance::ClaimableAwaitingConfirmations {
 761                         claimable_amount_satoshis: 10_000,
 762                         confirmation_height: node_a_htlc_claimable,
 763                 }]),
 764                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 765
 766         // Connect blocks until the commitment transaction's CSV expires, providing us the relevant
 767         // `SpendableOutputs` event and removing the claimable balance entry.
 768         connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
 769         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 770                         claimable_amount_satoshis: 10_000,
 771                         confirmation_height: node_a_htlc_claimable,
 772                 }],
 773                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 774         test_spendable_output(&nodes[0], &as_txn[0]);
 775
 776         // Connect blocks until the HTLC-Timeout's CSV expires, providing us the relevant
 777         // `SpendableOutputs` event and removing the claimable balance entry.
 778         connect_blocks(&nodes[0], node_a_htlc_claimable - nodes[0].best_block_info().1);
 779         assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
 780         test_spendable_output(&nodes[0], &as_txn[1]);
 781
 782         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
 783         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
 784         // monitor events or claimable balances.
 785         connect_blocks(&nodes[0], 6);
 786         connect_blocks(&nodes[0], 6);
 787         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 788         assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
 789 }
 790
 791 #[test]
 792 fn test_no_preimage_inbound_htlc_balances() {
 793         // Tests that MaybePreimageClaimableHTLC are generated for inbound HTLCs for which we do not
 794         // have a preimage.
 795         let chanmon_cfgs = create_chanmon_cfgs(2);
 796         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 797         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 798         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 799
 800         let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000);
 801         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 802
 803         // Send two HTLCs, one from A to B, and one from B to A.
 804         let to_b_failed_payment_hash = route_payment(&nodes[0], &[&nodes[1]], 10_000_000).1;
 805         let to_a_failed_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 20_000_000).1;
 806         let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
 807
 808         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
 809         let opt_anchors = get_opt_anchors!(nodes[0], nodes[1], chan_id);
 810
 811         // Both A and B will have an HTLC that's claimable on timeout and one that's claimable if they
 812         // receive the preimage. These will remain the same through the channel closure and until the
 813         // HTLC output is spent.
 814
 815         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 816                         claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
 817                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 818                 }, Balance::MaybePreimageClaimableHTLC {
 819                         claimable_amount_satoshis: 20_000,
 820                         expiry_height: htlc_cltv_timeout,
 821                 }, Balance::MaybeTimeoutClaimableHTLC {
 822                         claimable_amount_satoshis: 10_000,
 823                         claimable_height: htlc_cltv_timeout,
 824                 }]),
 825                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 826
 827         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 828                         claimable_amount_satoshis: 500_000 - 20_000,
 829                 }, Balance::MaybePreimageClaimableHTLC {
 830                         claimable_amount_satoshis: 10_000,
 831                         expiry_height: htlc_cltv_timeout,
 832                 }, Balance::MaybeTimeoutClaimableHTLC {
 833                         claimable_amount_satoshis: 20_000,
 834                         claimable_height: htlc_cltv_timeout,
 835                 }]),
 836                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 837
 838         // Get nodes[0]'s commitment transaction and HTLC-Timeout transaction
 839         let as_txn = get_local_commitment_txn!(nodes[0], chan_id);
 840         assert_eq!(as_txn.len(), 2);
 841         check_spends!(as_txn[1], as_txn[0]);
 842         check_spends!(as_txn[0], funding_tx);
 843
 844         // Now close the channel by confirming A's commitment transaction on both nodes, checking the
 845         // claimable balances remain the same except for the non-HTLC balance changing variant.
 846         let node_a_commitment_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 847         let as_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 848                         claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
 849                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 850                         confirmation_height: node_a_commitment_claimable,
 851                 }, Balance::MaybePreimageClaimableHTLC {
 852                         claimable_amount_satoshis: 20_000,
 853                         expiry_height: htlc_cltv_timeout,
 854                 }, Balance::MaybeTimeoutClaimableHTLC {
 855                         claimable_amount_satoshis: 10_000,
 856                         claimable_height: htlc_cltv_timeout,
 857                 }]);
 858
 859         mine_transaction(&nodes[0], &as_txn[0]);
 860         nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 861         check_added_monitors!(nodes[0], 1);
 862         check_closed_broadcast!(nodes[0], true);
 863         check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
 864
 865         assert_eq!(as_pre_spend_claims,
 866                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 867
 868         mine_transaction(&nodes[1], &as_txn[0]);
 869         check_added_monitors!(nodes[1], 1);
 870         check_closed_broadcast!(nodes[1], true);
 871         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
 872
 873         let node_b_commitment_claimable = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
 874         let mut bs_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 875                         claimable_amount_satoshis: 500_000 - 20_000,
 876                         confirmation_height: node_b_commitment_claimable,
 877                 }, Balance::MaybePreimageClaimableHTLC {
 878                         claimable_amount_satoshis: 10_000,
 879                         expiry_height: htlc_cltv_timeout,
 880                 }, Balance::MaybeTimeoutClaimableHTLC {
 881                         claimable_amount_satoshis: 20_000,
 882                         claimable_height: htlc_cltv_timeout,
 883                 }]);
 884         assert_eq!(bs_pre_spend_claims,
 885                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 886
 887         // We'll broadcast the HTLC-Timeout transaction one block prior to the htlc's expiration (as it
 888         // is confirmable in the next block), but will still include the same claimable balances as no
 889         // HTLC has been spent, even after the HTLC expires. We'll also fail the inbound HTLC, but it
 890         // won't do anything as the channel is already closed.
 891
 892         connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
 893         let as_htlc_timeout_claim = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 894         assert_eq!(as_htlc_timeout_claim.len(), 1);
 895         check_spends!(as_htlc_timeout_claim[0], as_txn[0]);
 896         expect_pending_htlcs_forwardable_conditions!(nodes[0],
 897                 [HTLCDestination::FailedPayment { payment_hash: to_a_failed_payment_hash }]);
 898
 899         assert_eq!(as_pre_spend_claims,
 900                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 901
 902         connect_blocks(&nodes[0], 1);
 903         assert_eq!(as_pre_spend_claims,
 904                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 905
 906         // For node B, we'll get the non-HTLC funds claimable after ANTI_REORG_DELAY confirmations
 907         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 908         test_spendable_output(&nodes[1], &as_txn[0]);
 909         bs_pre_spend_claims.retain(|e| if let Balance::ClaimableAwaitingConfirmations { .. } = e { false } else { true });
 910
 911         // The next few blocks for B look the same as for A, though for the opposite HTLC
 912         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 913         connect_blocks(&nodes[1], TEST_FINAL_CLTV - (ANTI_REORG_DELAY - 1) - 1);
 914         expect_pending_htlcs_forwardable_conditions!(nodes[1],
 915                 [HTLCDestination::FailedPayment { payment_hash: to_b_failed_payment_hash }]);
 916         let bs_htlc_timeout_claim = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 917         assert_eq!(bs_htlc_timeout_claim.len(), 1);
 918         check_spends!(bs_htlc_timeout_claim[0], as_txn[0]);
 919
 920         assert_eq!(bs_pre_spend_claims,
 921                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 922
 923         connect_blocks(&nodes[1], 1);
 924         assert_eq!(bs_pre_spend_claims,
 925                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 926
 927         // Now confirm the two HTLC timeout transactions for A, checking that the inbound HTLC resolves
 928         // after ANTI_REORG_DELAY confirmations and the other takes BREAKDOWN_TIMEOUT confirmations.
 929         mine_transaction(&nodes[0], &as_htlc_timeout_claim[0]);
 930         let as_timeout_claimable_height = nodes[0].best_block_info().1 + (BREAKDOWN_TIMEOUT as u32) - 1;
 931         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 932                         claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
 933                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 934                         confirmation_height: node_a_commitment_claimable,
 935                 }, Balance::MaybePreimageClaimableHTLC {
 936                         claimable_amount_satoshis: 20_000,
 937                         expiry_height: htlc_cltv_timeout,
 938                 }, Balance::ClaimableAwaitingConfirmations {
 939                         claimable_amount_satoshis: 10_000,
 940                         confirmation_height: as_timeout_claimable_height,
 941                 }]),
 942                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 943
 944         mine_transaction(&nodes[0], &bs_htlc_timeout_claim[0]);
 945         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 946                         claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
 947                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 948                         confirmation_height: node_a_commitment_claimable,
 949                 }, Balance::MaybePreimageClaimableHTLC {
 950                         claimable_amount_satoshis: 20_000,
 951                         expiry_height: htlc_cltv_timeout,
 952                 }, Balance::ClaimableAwaitingConfirmations {
 953                         claimable_amount_satoshis: 10_000,
 954                         confirmation_height: as_timeout_claimable_height,
 955                 }]),
 956                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 957
 958         // Once as_htlc_timeout_claim[0] reaches ANTI_REORG_DELAY confirmations, we should get a
 959         // payment failure event.
 960         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
 961         expect_payment_failed!(nodes[0], to_b_failed_payment_hash, false);
 962
 963         connect_blocks(&nodes[0], 1);
 964         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 965                         claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
 966                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 967                         confirmation_height: node_a_commitment_claimable,
 968                 }, Balance::ClaimableAwaitingConfirmations {
 969                         claimable_amount_satoshis: 10_000,
 970                         confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
 971                 }]),
 972                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 973
 974         connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
 975         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 976                         claimable_amount_satoshis: 10_000,
 977                         confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
 978                 }],
 979                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 980         test_spendable_output(&nodes[0], &as_txn[0]);
 981
 982         connect_blocks(&nodes[0], as_timeout_claimable_height - nodes[0].best_block_info().1);
 983         assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
 984         test_spendable_output(&nodes[0], &as_htlc_timeout_claim[0]);
 985
 986         // The process for B should be completely identical as well, noting that the non-HTLC-balance
 987         // was already claimed.
 988         mine_transaction(&nodes[1], &bs_htlc_timeout_claim[0]);
 989         let bs_timeout_claimable_height = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
 990         assert_eq!(sorted_vec(vec![Balance::MaybePreimageClaimableHTLC {
 991                         claimable_amount_satoshis: 10_000,
 992                         expiry_height: htlc_cltv_timeout,
 993                 }, Balance::ClaimableAwaitingConfirmations {
 994                         claimable_amount_satoshis: 20_000,
 995                         confirmation_height: bs_timeout_claimable_height,
 996                 }]),
 997                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 998
 999         mine_transaction(&nodes[1], &as_htlc_timeout_claim[0]);
1000         assert_eq!(sorted_vec(vec![Balance::MaybePreimageClaimableHTLC {
1001                         claimable_amount_satoshis: 10_000,
1002                         expiry_height: htlc_cltv_timeout,
1003                 }, Balance::ClaimableAwaitingConfirmations {
1004                         claimable_amount_satoshis: 20_000,
1005                         confirmation_height: bs_timeout_claimable_height,
1006                 }]),
1007                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1008
1009         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 2);
1010         expect_payment_failed!(nodes[1], to_a_failed_payment_hash, false);
1011
1012         assert_eq!(vec![Balance::MaybePreimageClaimableHTLC {
1013                         claimable_amount_satoshis: 10_000,
1014                         expiry_height: htlc_cltv_timeout,
1015                 }],
1016                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
1017         test_spendable_output(&nodes[1], &bs_htlc_timeout_claim[0]);
1018
1019         connect_blocks(&nodes[1], 1);
1020         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1021
1022         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
1023         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
1024         // monitor events or claimable balances.
1025         connect_blocks(&nodes[1], 6);
1026         connect_blocks(&nodes[1], 6);
1027         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1028         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1029 }
1030
1031 fn sorted_vec_with_additions<T: Ord + Clone>(v_orig: &Vec<T>, extra_ts: &[&T]) -> Vec<T> {
1032         let mut v = v_orig.clone();
1033         for t in extra_ts {
1034                 v.push((*t).clone());
1035         }
1036         v.sort_unstable();
1037         v
1038 }
1039
1040 fn do_test_revoked_counterparty_commitment_balances(confirm_htlc_spend_first: bool) {
1041         // Tests `get_claimable_balances` for revoked counterparty commitment transactions.
1042         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1043         // We broadcast a second-to-latest commitment transaction, without providing the revocation
1044         // secret to the counterparty. However, because we always immediately take the revocation
1045         // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
1046         // transaction which, from the point of view of our keys_manager, is revoked.
1047         chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1048         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1049         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1050         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1051
1052         let (_, _, chan_id, funding_tx) =
1053                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 100_000_000);
1054         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1055         assert_eq!(funding_outpoint.to_channel_id(), chan_id);
1056
1057         // We create five HTLCs for B to claim against A's revoked commitment transaction:
1058         //
1059         // (1) one for which A is the originator and B knows the preimage
1060         // (2) one for which B is the originator where the HTLC has since timed-out
1061         // (3) one for which B is the originator but where the HTLC has not yet timed-out
1062         // (4) one dust HTLC which is lost in the channel closure
1063         // (5) one that actually isn't in the revoked commitment transaction at all, but was added in
1064         //     later commitment transaction updates
1065         //
1066         // Though they could all be claimed in a single claim transaction, due to CLTV timeouts they
1067         // are all currently claimed in separate transactions, which helps us test as we can claim
1068         // HTLCs individually.
1069
1070         let (claimed_payment_preimage, claimed_payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 3_000_000);
1071         let timeout_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 4_000_000).1;
1072         let dust_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 3_000).1;
1073
1074         let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1075
1076         connect_blocks(&nodes[0], 10);
1077         connect_blocks(&nodes[1], 10);
1078
1079         let live_htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1080         let live_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 5_000_000).1;
1081
1082         // Get the latest commitment transaction from A and then update the fee to revoke it
1083         let as_revoked_txn = get_local_commitment_txn!(nodes[0], chan_id);
1084         let opt_anchors = get_opt_anchors!(nodes[0], nodes[1], chan_id);
1085
1086         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
1087
1088         let missing_htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1089         let missing_htlc_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 2_000_000).1;
1090
1091         nodes[1].node.claim_funds(claimed_payment_preimage);
1092         expect_payment_claimed!(nodes[1], claimed_payment_hash, 3_000_000);
1093         check_added_monitors!(nodes[1], 1);
1094         let _b_htlc_msgs = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
1095
1096         connect_blocks(&nodes[0], htlc_cltv_timeout + 1 - 10);
1097         check_closed_broadcast!(nodes[0], true);
1098         check_added_monitors!(nodes[0], 1);
1099
1100         let mut events = nodes[0].node.get_and_clear_pending_events();
1101         assert_eq!(events.len(), 6);
1102         let mut failed_payments: HashSet<_> =
1103                 [timeout_payment_hash, dust_payment_hash, live_payment_hash, missing_htlc_payment_hash]
1104                 .iter().map(|a| *a).collect();
1105         events.retain(|ev| {
1106                 match ev {
1107                         Event::HTLCHandlingFailed { failed_next_destination: HTLCDestination::NextHopChannel { node_id, channel_id }, .. } => {
1108                                 assert_eq!(*channel_id, chan_id);
1109                                 assert_eq!(*node_id, Some(nodes[1].node.get_our_node_id()));
1110                                 false
1111                         },
1112                         Event::HTLCHandlingFailed { failed_next_destination: HTLCDestination::FailedPayment { payment_hash }, .. } => {
1113                                 assert!(failed_payments.remove(payment_hash));
1114                                 false
1115                         },
1116                         _ => true,
1117                 }
1118         });
1119         assert!(failed_payments.is_empty());
1120         if let Event::PendingHTLCsForwardable { .. } = events[0] {} else { panic!(); }
1121         match &events[1] {
1122                 Event::ChannelClosed { reason: ClosureReason::CommitmentTxConfirmed, .. } => {},
1123                 _ => panic!(),
1124         }
1125
1126         connect_blocks(&nodes[1], htlc_cltv_timeout + 1 - 10);
1127         check_closed_broadcast!(nodes[1], true);
1128         check_added_monitors!(nodes[1], 1);
1129         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
1130
1131         // Prior to channel closure, B considers the preimage HTLC as its own, and otherwise only
1132         // lists the two on-chain timeout-able HTLCs as claimable balances.
1133         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
1134                         claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3 - 2_000 + 3_000,
1135                 }, Balance::MaybeTimeoutClaimableHTLC {
1136                         claimable_amount_satoshis: 2_000,
1137                         claimable_height: missing_htlc_cltv_timeout,
1138                 }, Balance::MaybeTimeoutClaimableHTLC {
1139                         claimable_amount_satoshis: 4_000,
1140                         claimable_height: htlc_cltv_timeout,
1141                 }, Balance::MaybeTimeoutClaimableHTLC {
1142                         claimable_amount_satoshis: 5_000,
1143                         claimable_height: live_htlc_cltv_timeout,
1144                 }]),
1145                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1146
1147         mine_transaction(&nodes[1], &as_revoked_txn[0]);
1148         let mut claim_txn: Vec<_> = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().drain(..).filter(|tx| tx.input.iter().any(|inp| inp.previous_output.txid == as_revoked_txn[0].txid())).collect();
1149         // Currently the revoked commitment is claimed in four transactions as the HTLCs all expire
1150         // quite soon.
1151         assert_eq!(claim_txn.len(), 4);
1152         claim_txn.sort_unstable_by_key(|tx| tx.output.iter().map(|output| output.value).sum::<u64>());
1153
1154         // The following constants were determined experimentally
1155         const BS_TO_SELF_CLAIM_EXP_WEIGHT: usize = 483;
1156         const OUTBOUND_HTLC_CLAIM_EXP_WEIGHT: usize = 571;
1157         const INBOUND_HTLC_CLAIM_EXP_WEIGHT: usize = 578;
1158
1159         // Check that the weight is close to the expected weight. Note that signature sizes vary
1160         // somewhat so it may not always be exact.
1161         fuzzy_assert_eq(claim_txn[0].weight(), OUTBOUND_HTLC_CLAIM_EXP_WEIGHT);
1162         fuzzy_assert_eq(claim_txn[1].weight(), INBOUND_HTLC_CLAIM_EXP_WEIGHT);
1163         fuzzy_assert_eq(claim_txn[2].weight(), INBOUND_HTLC_CLAIM_EXP_WEIGHT);
1164         fuzzy_assert_eq(claim_txn[3].weight(), BS_TO_SELF_CLAIM_EXP_WEIGHT);
1165
1166         // The expected balance for the next three checks, with the largest-HTLC and to_self output
1167         // claim balances separated out.
1168         let expected_balance = vec![Balance::ClaimableAwaitingConfirmations {
1169                         // to_remote output in A's revoked commitment
1170                         claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3,
1171                         confirmation_height: nodes[1].best_block_info().1 + 5,
1172                 }, Balance::CounterpartyRevokedOutputClaimable {
1173                         claimable_amount_satoshis: 3_000,
1174                 }, Balance::CounterpartyRevokedOutputClaimable {
1175                         claimable_amount_satoshis: 4_000,
1176                 }];
1177
1178         let to_self_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {
1179                 claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
1180                         (channel::commitment_tx_base_weight(opt_anchors) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1181         };
1182         let to_self_claimed_avail_height;
1183         let largest_htlc_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {
1184                 claimable_amount_satoshis: 5_000,
1185         };
1186         let largest_htlc_claimed_avail_height;
1187
1188         // Once the channel has been closed by A, B now considers all of the commitment transactions'
1189         // outputs as `CounterpartyRevokedOutputClaimable`.
1190         assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_unclaimed_balance, &largest_htlc_unclaimed_balance]),
1191                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1192
1193         if confirm_htlc_spend_first {
1194                 mine_transaction(&nodes[1], &claim_txn[2]);
1195                 largest_htlc_claimed_avail_height = nodes[1].best_block_info().1 + 5;
1196                 to_self_claimed_avail_height = nodes[1].best_block_info().1 + 6; // will be claimed in the next block
1197         } else {
1198                 // Connect the to_self output claim, taking all of A's non-HTLC funds
1199                 mine_transaction(&nodes[1], &claim_txn[3]);
1200                 to_self_claimed_avail_height = nodes[1].best_block_info().1 + 5;
1201                 largest_htlc_claimed_avail_height = nodes[1].best_block_info().1 + 6; // will be claimed in the next block
1202         }
1203
1204         let largest_htlc_claimed_balance = Balance::ClaimableAwaitingConfirmations {
1205                 claimable_amount_satoshis: 5_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
1206                 confirmation_height: largest_htlc_claimed_avail_height,
1207         };
1208         let to_self_claimed_balance = Balance::ClaimableAwaitingConfirmations {
1209                 claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
1210                         (channel::commitment_tx_base_weight(opt_anchors) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
1211                         - chan_feerate * claim_txn[3].weight() as u64 / 1000,
1212                 confirmation_height: to_self_claimed_avail_height,
1213         };
1214
1215         if confirm_htlc_spend_first {
1216                 assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_unclaimed_balance, &largest_htlc_claimed_balance]),
1217                         sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1218         } else {
1219                 assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_claimed_balance, &largest_htlc_unclaimed_balance]),
1220                         sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1221         }
1222
1223         if confirm_htlc_spend_first {
1224                 mine_transaction(&nodes[1], &claim_txn[3]);
1225         } else {
1226                 mine_transaction(&nodes[1], &claim_txn[2]);
1227         }
1228         assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_claimed_balance, &largest_htlc_claimed_balance]),
1229                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1230
1231         // Finally, connect the last two remaining HTLC spends and check that they move to
1232         // `ClaimableAwaitingConfirmations`
1233         mine_transaction(&nodes[1], &claim_txn[0]);
1234         mine_transaction(&nodes[1], &claim_txn[1]);
1235
1236         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1237                         // to_remote output in A's revoked commitment
1238                         claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3,
1239                         confirmation_height: nodes[1].best_block_info().1 + 1,
1240                 }, Balance::ClaimableAwaitingConfirmations {
1241                         claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
1242                                 (channel::commitment_tx_base_weight(opt_anchors) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
1243                                 - chan_feerate * claim_txn[3].weight() as u64 / 1000,
1244                         confirmation_height: to_self_claimed_avail_height,
1245                 }, Balance::ClaimableAwaitingConfirmations {
1246                         claimable_amount_satoshis: 3_000 - chan_feerate * OUTBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
1247                         confirmation_height: nodes[1].best_block_info().1 + 4,
1248                 }, Balance::ClaimableAwaitingConfirmations {
1249                         claimable_amount_satoshis: 4_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
1250                         confirmation_height: nodes[1].best_block_info().1 + 5,
1251                 }, Balance::ClaimableAwaitingConfirmations {
1252                         claimable_amount_satoshis: 5_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
1253                         confirmation_height: largest_htlc_claimed_avail_height,
1254                 }]),
1255                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1256
1257         connect_blocks(&nodes[1], 1);
1258         test_spendable_output(&nodes[1], &as_revoked_txn[0]);
1259
1260         let mut payment_failed_events = nodes[1].node.get_and_clear_pending_events();
1261         expect_payment_failed_conditions_event(payment_failed_events[..2].to_vec(),
1262                 missing_htlc_payment_hash, false, PaymentFailedConditions::new());
1263         expect_payment_failed_conditions_event(payment_failed_events[2..].to_vec(),
1264                 dust_payment_hash, false, PaymentFailedConditions::new());
1265
1266         connect_blocks(&nodes[1], 1);
1267         test_spendable_output(&nodes[1], &claim_txn[if confirm_htlc_spend_first { 2 } else { 3 }]);
1268         connect_blocks(&nodes[1], 1);
1269         test_spendable_output(&nodes[1], &claim_txn[if confirm_htlc_spend_first { 3 } else { 2 }]);
1270         expect_payment_failed!(nodes[1], live_payment_hash, false);
1271         connect_blocks(&nodes[1], 1);
1272         test_spendable_output(&nodes[1], &claim_txn[0]);
1273         connect_blocks(&nodes[1], 1);
1274         test_spendable_output(&nodes[1], &claim_txn[1]);
1275         expect_payment_failed!(nodes[1], timeout_payment_hash, false);
1276         assert_eq!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances(), Vec::new());
1277
1278         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
1279         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
1280         // monitor events or claimable balances.
1281         connect_blocks(&nodes[1], 6);
1282         connect_blocks(&nodes[1], 6);
1283         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1284         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1285 }
1286
1287 #[test]
1288 fn test_revoked_counterparty_commitment_balances() {
1289         do_test_revoked_counterparty_commitment_balances(true);
1290         do_test_revoked_counterparty_commitment_balances(false);
1291 }
1292
1293 #[test]
1294 fn test_revoked_counterparty_htlc_tx_balances() {
1295         // Tests `get_claimable_balances` for revocation spends of HTLC transactions.
1296         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1297         chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1298         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1299         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1300         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1301
1302         // Create some initial channels
1303         let (_, _, chan_id, funding_tx) =
1304                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 11_000_000);
1305         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1306         assert_eq!(funding_outpoint.to_channel_id(), chan_id);
1307
1308         let payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 3_000_000).0;
1309         let failed_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 1_000_000).1;
1310         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_id);
1311         assert_eq!(revoked_local_txn[0].input.len(), 1);
1312         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, funding_tx.txid());
1313
1314         // The to-be-revoked commitment tx should have two HTLCs and an output for both sides
1315         assert_eq!(revoked_local_txn[0].output.len(), 4);
1316
1317         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
1318
1319         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
1320         let opt_anchors = get_opt_anchors!(nodes[0], nodes[1], chan_id);
1321
1322         // B will generate an HTLC-Success from its revoked commitment tx
1323         mine_transaction(&nodes[1], &revoked_local_txn[0]);
1324         check_closed_broadcast!(nodes[1], true);
1325         check_added_monitors!(nodes[1], 1);
1326         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
1327         let revoked_htlc_success_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1328
1329         assert_eq!(revoked_htlc_success_txn.len(), 1);
1330         assert_eq!(revoked_htlc_success_txn[0].input.len(), 1);
1331         assert_eq!(revoked_htlc_success_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
1332         check_spends!(revoked_htlc_success_txn[0], revoked_local_txn[0]);
1333
1334         connect_blocks(&nodes[1], TEST_FINAL_CLTV);
1335         let revoked_htlc_timeout_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1336         assert_eq!(revoked_htlc_timeout_txn.len(), 1);
1337         check_spends!(revoked_htlc_timeout_txn[0], revoked_local_txn[0]);
1338         assert_ne!(revoked_htlc_success_txn[0].input[0].previous_output, revoked_htlc_timeout_txn[0].input[0].previous_output);
1339         assert_eq!(revoked_htlc_success_txn[0].lock_time.0, 0);
1340         assert_ne!(revoked_htlc_timeout_txn[0].lock_time.0, 0);
1341
1342         // A will generate justice tx from B's revoked commitment/HTLC tx
1343         mine_transaction(&nodes[0], &revoked_local_txn[0]);
1344         check_closed_broadcast!(nodes[0], true);
1345         check_added_monitors!(nodes[0], 1);
1346         check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
1347         let to_remote_conf_height = nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1;
1348
1349         let as_commitment_claim_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1350         assert_eq!(as_commitment_claim_txn.len(), 1);
1351         check_spends!(as_commitment_claim_txn[0], revoked_local_txn[0]);
1352
1353         // The next two checks have the same balance set for A - even though we confirm a revoked HTLC
1354         // transaction our balance tracking doesn't use the on-chain value so the
1355         // `CounterpartyRevokedOutputClaimable` entry doesn't change.
1356         let as_balances = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1357                         // to_remote output in B's revoked commitment
1358                         claimable_amount_satoshis: 1_000_000 - 11_000 - 3_000 - chan_feerate *
1359                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1360                         confirmation_height: to_remote_conf_height,
1361                 }, Balance::CounterpartyRevokedOutputClaimable {
1362                         // to_self output in B's revoked commitment
1363                         claimable_amount_satoshis: 10_000,
1364                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1365                         claimable_amount_satoshis: 3_000,
1366                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1367                         claimable_amount_satoshis: 1_000,
1368                 }]);
1369         assert_eq!(as_balances,
1370                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1371
1372         mine_transaction(&nodes[0], &revoked_htlc_success_txn[0]);
1373         let as_htlc_claim_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1374         assert_eq!(as_htlc_claim_tx.len(), 2);
1375         check_spends!(as_htlc_claim_tx[0], revoked_htlc_success_txn[0]);
1376         check_spends!(as_htlc_claim_tx[1], revoked_local_txn[0]); // A has to generate a new claim for the remaining revoked
1377                                                                   // outputs (which no longer includes the spent HTLC output)
1378
1379         assert_eq!(as_balances,
1380                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1381
1382         assert_eq!(as_htlc_claim_tx[0].output.len(), 1);
1383         fuzzy_assert_eq(as_htlc_claim_tx[0].output[0].value,
1384                 3_000 - chan_feerate * (revoked_htlc_success_txn[0].weight() + as_htlc_claim_tx[0].weight()) as u64 / 1000);
1385
1386         mine_transaction(&nodes[0], &as_htlc_claim_tx[0]);
1387         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1388                         // to_remote output in B's revoked commitment
1389                         claimable_amount_satoshis: 1_000_000 - 11_000 - 3_000 - chan_feerate *
1390                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1391                         confirmation_height: to_remote_conf_height,
1392                 }, Balance::CounterpartyRevokedOutputClaimable {
1393                         // to_self output in B's revoked commitment
1394                         claimable_amount_satoshis: 10_000,
1395                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1396                         claimable_amount_satoshis: 1_000,
1397                 }, Balance::ClaimableAwaitingConfirmations {
1398                         claimable_amount_satoshis: as_htlc_claim_tx[0].output[0].value,
1399                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1400                 }]),
1401                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1402
1403         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 3);
1404         test_spendable_output(&nodes[0], &revoked_local_txn[0]);
1405         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1406                         // to_self output to B
1407                         claimable_amount_satoshis: 10_000,
1408                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1409                         claimable_amount_satoshis: 1_000,
1410                 }, Balance::ClaimableAwaitingConfirmations {
1411                         claimable_amount_satoshis: as_htlc_claim_tx[0].output[0].value,
1412                         confirmation_height: nodes[0].best_block_info().1 + 2,
1413                 }]),
1414                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1415
1416         connect_blocks(&nodes[0], 2);
1417         test_spendable_output(&nodes[0], &as_htlc_claim_tx[0]);
1418         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1419                         // to_self output in B's revoked commitment
1420                         claimable_amount_satoshis: 10_000,
1421                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1422                         claimable_amount_satoshis: 1_000,
1423                 }]),
1424                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1425
1426         connect_blocks(&nodes[0], revoked_htlc_timeout_txn[0].lock_time.0 - nodes[0].best_block_info().1);
1427         expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(&nodes[0],
1428                 [HTLCDestination::FailedPayment { payment_hash: failed_payment_hash }]);
1429         // As time goes on A may split its revocation claim transaction into multiple.
1430         let as_fewer_input_rbf = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1431         for tx in as_fewer_input_rbf.iter() {
1432                 check_spends!(tx, revoked_local_txn[0]);
1433         }
1434
1435         // Connect a number of additional blocks to ensure we don't forget the HTLC output needs
1436         // claiming.
1437         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
1438         let as_fewer_input_rbf = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1439         for tx in as_fewer_input_rbf.iter() {
1440                 check_spends!(tx, revoked_local_txn[0]);
1441         }
1442
1443         mine_transaction(&nodes[0], &revoked_htlc_timeout_txn[0]);
1444         let as_second_htlc_claim_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1445         assert_eq!(as_second_htlc_claim_tx.len(), 2);
1446
1447         check_spends!(as_second_htlc_claim_tx[0], revoked_htlc_timeout_txn[0]);
1448         check_spends!(as_second_htlc_claim_tx[1], revoked_local_txn[0]);
1449
1450         // Connect blocks to finalize the HTLC resolution with the HTLC-Timeout transaction. In a
1451         // previous iteration of the revoked balance handling this would result in us "forgetting" that
1452         // the revoked HTLC output still needed to be claimed.
1453         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
1454         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1455                         // to_self output in B's revoked commitment
1456                         claimable_amount_satoshis: 10_000,
1457                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1458                         claimable_amount_satoshis: 1_000,
1459                 }]),
1460                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1461
1462         mine_transaction(&nodes[0], &as_second_htlc_claim_tx[0]);
1463         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1464                         // to_self output in B's revoked commitment
1465                         claimable_amount_satoshis: 10_000,
1466                 }, Balance::ClaimableAwaitingConfirmations {
1467                         claimable_amount_satoshis: as_second_htlc_claim_tx[0].output[0].value,
1468                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1469                 }]),
1470                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1471
1472         mine_transaction(&nodes[0], &as_second_htlc_claim_tx[1]);
1473         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1474                         // to_self output in B's revoked commitment
1475                         claimable_amount_satoshis: as_second_htlc_claim_tx[1].output[0].value,
1476                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1477                 }, Balance::ClaimableAwaitingConfirmations {
1478                         claimable_amount_satoshis: as_second_htlc_claim_tx[0].output[0].value,
1479                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 2,
1480                 }]),
1481                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1482
1483         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
1484         test_spendable_output(&nodes[0], &as_second_htlc_claim_tx[0]);
1485         connect_blocks(&nodes[0], 1);
1486         test_spendable_output(&nodes[0], &as_second_htlc_claim_tx[1]);
1487
1488         assert_eq!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances(), Vec::new());
1489
1490         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
1491         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
1492         // monitor events or claimable balances.
1493         connect_blocks(&nodes[0], 6);
1494         connect_blocks(&nodes[0], 6);
1495         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1496         assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1497 }
1498
1499 #[test]
1500 fn test_revoked_counterparty_aggregated_claims() {
1501         // Tests `get_claimable_balances` for revoked counterparty commitment transactions when
1502         // claiming with an aggregated claim transaction.
1503         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1504         // We broadcast a second-to-latest commitment transaction, without providing the revocation
1505         // secret to the counterparty. However, because we always immediately take the revocation
1506         // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
1507         // transaction which, from the point of view of our keys_manager, is revoked.
1508         chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1509         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1510         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1511         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1512
1513         let (_, _, chan_id, funding_tx) =
1514                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 100_000_000);
1515         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1516         assert_eq!(funding_outpoint.to_channel_id(), chan_id);
1517
1518         // We create two HTLCs, one which we will give A the preimage to to generate an HTLC-Success
1519         // transaction, and one which we will not, allowing B to claim the HTLC output in an aggregated
1520         // revocation-claim transaction.
1521
1522         let (claimed_payment_preimage, claimed_payment_hash, ..) = route_payment(&nodes[1], &[&nodes[0]], 3_000_000);
1523         let revoked_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 4_000_000).1;
1524
1525         let htlc_cltv_timeout = nodes[1].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1526
1527         // Cheat by giving A's ChannelMonitor the preimage to the to-be-claimed HTLC so that we have an
1528         // HTLC-claim transaction on the to-be-revoked state.
1529         get_monitor!(nodes[0], chan_id).provide_payment_preimage(&claimed_payment_hash, &claimed_payment_preimage,
1530                 &node_cfgs[0].tx_broadcaster, &LowerBoundedFeeEstimator::new(node_cfgs[0].fee_estimator), &nodes[0].logger);
1531
1532         // Now get the latest commitment transaction from A and then update the fee to revoke it
1533         let as_revoked_txn = get_local_commitment_txn!(nodes[0], chan_id);
1534
1535         assert_eq!(as_revoked_txn.len(), 2);
1536         check_spends!(as_revoked_txn[0], funding_tx);
1537         check_spends!(as_revoked_txn[1], as_revoked_txn[0]); // The HTLC-Claim transaction
1538
1539         let opt_anchors = get_opt_anchors!(nodes[0], nodes[1], chan_id);
1540         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
1541
1542         {
1543                 let mut feerate = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap();
1544                 *feerate += 1;
1545         }
1546         nodes[0].node.timer_tick_occurred();
1547         check_added_monitors!(nodes[0], 1);
1548
1549         let fee_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1550         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &fee_update.update_fee.unwrap());
1551         commitment_signed_dance!(nodes[1], nodes[0], fee_update.commitment_signed, false);
1552
1553         nodes[0].node.claim_funds(claimed_payment_preimage);
1554         expect_payment_claimed!(nodes[0], claimed_payment_hash, 3_000_000);
1555         check_added_monitors!(nodes[0], 1);
1556         let _a_htlc_msgs = get_htlc_update_msgs!(&nodes[0], nodes[1].node.get_our_node_id());
1557
1558         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
1559                         claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
1560                 }, Balance::MaybeTimeoutClaimableHTLC {
1561                         claimable_amount_satoshis: 4_000,
1562                         claimable_height: htlc_cltv_timeout,
1563                 }, Balance::MaybeTimeoutClaimableHTLC {
1564                         claimable_amount_satoshis: 3_000,
1565                         claimable_height: htlc_cltv_timeout,
1566                 }]),
1567                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1568
1569         mine_transaction(&nodes[1], &as_revoked_txn[0]);
1570         check_closed_broadcast!(nodes[1], true);
1571         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
1572         check_added_monitors!(nodes[1], 1);
1573
1574         let mut claim_txn: Vec<_> = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().drain(..).filter(|tx| tx.input.iter().any(|inp| inp.previous_output.txid == as_revoked_txn[0].txid())).collect();
1575         // Currently the revoked commitment outputs are all claimed in one aggregated transaction
1576         assert_eq!(claim_txn.len(), 1);
1577         assert_eq!(claim_txn[0].input.len(), 3);
1578         check_spends!(claim_txn[0], as_revoked_txn[0]);
1579
1580         let to_remote_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1581
1582         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1583                         // to_remote output in A's revoked commitment
1584                         claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
1585                         confirmation_height: to_remote_maturity,
1586                 }, Balance::CounterpartyRevokedOutputClaimable {
1587                         // to_self output in A's revoked commitment
1588                         claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1589                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1590                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1591                         claimable_amount_satoshis: 4_000,
1592                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1593                         claimable_amount_satoshis: 3_000,
1594                 }]),
1595                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1596
1597         // Confirm A's HTLC-Success tranasction which presumably raced B's claim, causing B to create a
1598         // new claim.
1599         mine_transaction(&nodes[1], &as_revoked_txn[1]);
1600         expect_payment_sent!(nodes[1], claimed_payment_preimage);
1601         let mut claim_txn_2: Vec<_> = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
1602         claim_txn_2.sort_unstable_by_key(|tx| if tx.input.iter().any(|inp| inp.previous_output.txid == as_revoked_txn[0].txid()) { 0 } else { 1 });
1603         // Once B sees the HTLC-Success transaction it splits its claim transaction into two, though in
1604         // theory it could re-aggregate the claims as well.
1605         assert_eq!(claim_txn_2.len(), 2);
1606         assert_eq!(claim_txn_2[0].input.len(), 2);
1607         check_spends!(claim_txn_2[0], as_revoked_txn[0]);
1608         assert_eq!(claim_txn_2[1].input.len(), 1);
1609         check_spends!(claim_txn_2[1], as_revoked_txn[1]);
1610
1611         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1612                         // to_remote output in A's revoked commitment
1613                         claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
1614                         confirmation_height: to_remote_maturity,
1615                 }, Balance::CounterpartyRevokedOutputClaimable {
1616                         // to_self output in A's revoked commitment
1617                         claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1618                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1619                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1620                         claimable_amount_satoshis: 4_000,
1621                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1622                         // The amount here is a bit of a misnomer, really its been reduced by the HTLC
1623                         // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
1624                         // anyway, so its not a big change.
1625                         claimable_amount_satoshis: 3_000,
1626                 }]),
1627                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1628
1629         connect_blocks(&nodes[1], 5);
1630         test_spendable_output(&nodes[1], &as_revoked_txn[0]);
1631
1632         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1633                         // to_self output in A's revoked commitment
1634                         claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1635                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1636                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1637                         claimable_amount_satoshis: 4_000,
1638                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1639                         // The amount here is a bit of a misnomer, really its been reduced by the HTLC
1640                         // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
1641                         // anyway, so its not a big change.
1642                         claimable_amount_satoshis: 3_000,
1643                 }]),
1644                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1645
1646         mine_transaction(&nodes[1], &claim_txn_2[1]);
1647         let htlc_2_claim_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1648
1649         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1650                         // to_self output in A's revoked commitment
1651                         claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1652                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1653                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1654                         claimable_amount_satoshis: 4_000,
1655                 }, Balance::ClaimableAwaitingConfirmations { // HTLC 2
1656                         claimable_amount_satoshis: claim_txn_2[1].output[0].value,
1657                         confirmation_height: htlc_2_claim_maturity,
1658                 }]),
1659                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1660
1661         connect_blocks(&nodes[1], 5);
1662         test_spendable_output(&nodes[1], &claim_txn_2[1]);
1663
1664         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1665                         // to_self output in A's revoked commitment
1666                         claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1667                                 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1668                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1669                         claimable_amount_satoshis: 4_000,
1670                 }]),
1671                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1672
1673         mine_transaction(&nodes[1], &claim_txn_2[0]);
1674         let rest_claim_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1675
1676         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
1677                         claimable_amount_satoshis: claim_txn_2[0].output[0].value,
1678                         confirmation_height: rest_claim_maturity,
1679                 }],
1680                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
1681
1682         assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); // We shouldn't fail the payment until we spend the output
1683
1684         connect_blocks(&nodes[1], 5);
1685         expect_payment_failed!(nodes[1], revoked_payment_hash, false);
1686         test_spendable_output(&nodes[1], &claim_txn_2[0]);
1687         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1688
1689         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
1690         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
1691         // monitor events or claimable balances.
1692         connect_blocks(&nodes[1], 6);
1693         connect_blocks(&nodes[1], 6);
1694         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1695         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1696 }
1697
1698 #[cfg(anchors)]
1699 #[test]
1700 fn test_yield_anchors_events() {
1701         // Tests that two parties supporting anchor outputs can open a channel, route payments over
1702         // it, and finalize its resolution uncooperatively. Once the HTLCs are locked in, one side will
1703         // force close once the HTLCs expire. The force close should stem from an event emitted by LDK,
1704         // allowing the consumer to provide additional fees to the commitment transaction to be
1705         // broadcast. Once the commitment transaction confirms, events for the HTLC resolution should be
1706         // emitted by LDK, such that the consumer can attach fees to the zero fee HTLC transactions.
1707         let secp = Secp256k1::new();
1708         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1709         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1710         let mut anchors_config = UserConfig::default();
1711         anchors_config.channel_handshake_config.announced_channel = true;
1712         anchors_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
1713         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(anchors_config), Some(anchors_config)]);
1714         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1715
1716         let chan_id = create_announced_chan_between_nodes_with_value(
1717                 &nodes, 0, 1, 1_000_000, 500_000_000
1718         ).2;
1719         route_payment(&nodes[0], &[&nodes[1]], 1_000_000);
1720         let (payment_preimage, payment_hash, _) = route_payment(&nodes[1], &[&nodes[0]], 1_000_000);
1721
1722         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
1723
1724         connect_blocks(&nodes[0], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1);
1725         check_closed_broadcast!(&nodes[0], true);
1726         assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
1727
1728         get_monitor!(nodes[0], chan_id).provide_payment_preimage(
1729                 &payment_hash, &payment_preimage, &node_cfgs[0].tx_broadcaster,
1730                 &LowerBoundedFeeEstimator::new(node_cfgs[0].fee_estimator), &nodes[0].logger
1731         );
1732
1733         let mut holder_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
1734         assert_eq!(holder_events.len(), 1);
1735         let (commitment_tx, anchor_tx) = match holder_events.pop().unwrap() {
1736                 Event::BumpTransaction(BumpTransactionEvent::ChannelClose { commitment_tx, anchor_descriptor, .. })  => {
1737                         assert_eq!(commitment_tx.input.len(), 1);
1738                         assert_eq!(commitment_tx.output.len(), 6);
1739                         let mut anchor_tx = Transaction {
1740                                 version: 2,
1741                                 lock_time: PackedLockTime::ZERO,
1742                                 input: vec![
1743                                         TxIn { previous_output: anchor_descriptor.outpoint, ..Default::default() },
1744                                         TxIn { ..Default::default() },
1745                                 ],
1746                                 output: vec![TxOut {
1747                                         value: Amount::ONE_BTC.to_sat(),
1748                                         script_pubkey: Script::new_op_return(&[]),
1749                                 }],
1750                         };
1751                         let signer = nodes[0].keys_manager.derive_channel_keys(
1752                                 anchor_descriptor.channel_value_satoshis, &anchor_descriptor.channel_keys_id,
1753                         );
1754                         let funding_sig = signer.sign_holder_anchor_input(&mut anchor_tx, 0, &secp).unwrap();
1755                         anchor_tx.input[0].witness = chan_utils::build_anchor_input_witness(
1756                                 &signer.pubkeys().funding_pubkey, &funding_sig
1757                         );
1758                         (commitment_tx, anchor_tx)
1759                 },
1760                 _ => panic!("Unexpected event"),
1761         };
1762
1763         mine_transactions(&nodes[0], &[&commitment_tx, &anchor_tx]);
1764         check_added_monitors!(nodes[0], 1);
1765
1766         let mut holder_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
1767         // Certain block `ConnectStyle`s cause an extra `ChannelClose` event to be emitted since the
1768         // best block is updated before the confirmed transactions are notified.
1769         match *nodes[0].connect_style.borrow() {
1770                 ConnectStyle::BestBlockFirst|ConnectStyle::BestBlockFirstReorgsOnlyTip|ConnectStyle::BestBlockFirstSkippingBlocks => {
1771                         assert_eq!(holder_events.len(), 3);
1772                         if let Event::BumpTransaction(BumpTransactionEvent::ChannelClose { .. }) = holder_events.remove(0) {}
1773                         else { panic!("unexpected event"); }
1774
1775                 },
1776                 _ => assert_eq!(holder_events.len(), 2),
1777         };
1778         let mut htlc_txs = Vec::with_capacity(2);
1779         for event in holder_events {
1780                 match event {
1781                         Event::BumpTransaction(BumpTransactionEvent::HTLCResolution { htlc_descriptors, tx_lock_time, .. }) => {
1782                                 assert_eq!(htlc_descriptors.len(), 1);
1783                                 let htlc_descriptor = &htlc_descriptors[0];
1784                                 let signer = nodes[0].keys_manager.derive_channel_keys(
1785                                         htlc_descriptor.channel_value_satoshis, &htlc_descriptor.channel_keys_id
1786                                 );
1787                                 let per_commitment_point = signer.get_per_commitment_point(htlc_descriptor.per_commitment_number, &secp);
1788                                 let mut htlc_tx = Transaction {
1789                                         version: 2,
1790                                         lock_time: tx_lock_time,
1791                                         input: vec![
1792                                                 htlc_descriptor.unsigned_tx_input(), // HTLC input
1793                                                 TxIn { ..Default::default() } // Fee input
1794                                         ],
1795                                         output: vec![
1796                                                 htlc_descriptor.tx_output(&per_commitment_point, &secp), // HTLC output
1797                                                 TxOut { // Fee input change
1798                                                         value: Amount::ONE_BTC.to_sat(),
1799                                                         script_pubkey: Script::new_op_return(&[]),
1800                                                 }
1801                                         ]
1802                                 };
1803                                 let our_sig = signer.sign_holder_htlc_transaction(&mut htlc_tx, 0, htlc_descriptor, &secp).unwrap();
1804                                 let witness_script = htlc_descriptor.witness_script(&per_commitment_point, &secp);
1805                                 htlc_tx.input[0].witness = htlc_descriptor.tx_input_witness(&our_sig, &witness_script);
1806                                 htlc_txs.push(htlc_tx);
1807                         },
1808                         _ => panic!("Unexpected event"),
1809                 }
1810         }
1811
1812         mine_transactions(&nodes[0], &[&htlc_txs[0], &htlc_txs[1]]);
1813         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
1814
1815         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1816
1817         connect_blocks(&nodes[0], BREAKDOWN_TIMEOUT as u32);
1818
1819         let holder_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
1820         assert_eq!(holder_events.len(), 3);
1821         for event in holder_events {
1822                 match event {
1823                         Event::SpendableOutputs { .. } => {},
1824                         _ => panic!("Unexpected event"),
1825                 }
1826         }
1827
1828         // Clear the remaining events as they're not relevant to what we're testing.
1829         nodes[0].node.get_and_clear_pending_events();
1830 }
1831
1832 #[cfg(anchors)]
1833 #[test]
1834 fn test_anchors_aggregated_revoked_htlc_tx() {
1835         // Test that `ChannelMonitor`s can properly detect and claim funds from a counterparty claiming
1836         // multiple HTLCs from multiple channels in a single transaction via the success path from a
1837         // revoked commitment.
1838         let secp = Secp256k1::new();
1839         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1840         // Required to sign a revoked commitment transaction
1841         chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1842         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1843         let mut anchors_config = UserConfig::default();
1844         anchors_config.channel_handshake_config.announced_channel = true;
1845         anchors_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
1846         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(anchors_config), Some(anchors_config)]);
1847
1848         let bob_persister: test_utils::TestPersister;
1849         let bob_chain_monitor: test_utils::TestChainMonitor;
1850         let bob_deserialized: ChannelManager<
1851                 &test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface,
1852                 &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator,
1853                 &test_utils::TestRouter, &test_utils::TestLogger,
1854         >;
1855
1856         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1857
1858         let chan_a = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 20_000_000);
1859         let chan_b = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 20_000_000);
1860
1861         // Serialize Bob with the initial state of both channels, which we'll use later.
1862         let bob_serialized = nodes[1].node.encode();
1863
1864         // Route two payments for each channel from Alice to Bob to lock in the HTLCs.
1865         let payment_a = route_payment(&nodes[0], &[&nodes[1]], 50_000_000);
1866         let payment_b = route_payment(&nodes[0], &[&nodes[1]], 50_000_000);
1867         let payment_c = route_payment(&nodes[0], &[&nodes[1]], 50_000_000);
1868         let payment_d = route_payment(&nodes[0], &[&nodes[1]], 50_000_000);
1869
1870         // Serialize Bob's monitors with the HTLCs locked in. We'll restart Bob later on with the state
1871         // at this point such that he broadcasts a revoked commitment transaction with the HTLCs
1872         // present.
1873         let bob_serialized_monitor_a = get_monitor!(nodes[1], chan_a.2).encode();
1874         let bob_serialized_monitor_b = get_monitor!(nodes[1], chan_b.2).encode();
1875
1876         // Bob claims all the HTLCs...
1877         claim_payment(&nodes[0], &[&nodes[1]], payment_a.0);
1878         claim_payment(&nodes[0], &[&nodes[1]], payment_b.0);
1879         claim_payment(&nodes[0], &[&nodes[1]], payment_c.0);
1880         claim_payment(&nodes[0], &[&nodes[1]], payment_d.0);
1881
1882         // ...and sends one back through each channel such that he has a motive to broadcast his
1883         // revoked state.
1884         send_payment(&nodes[1], &[&nodes[0]], 30_000_000);
1885         send_payment(&nodes[1], &[&nodes[0]], 30_000_000);
1886
1887         // Restart Bob with the revoked state and provide the HTLC preimages he claimed.
1888         reload_node!(
1889                 nodes[1], anchors_config, bob_serialized, &[&bob_serialized_monitor_a, &bob_serialized_monitor_b],
1890                 bob_persister, bob_chain_monitor, bob_deserialized
1891         );
1892         for chan_id in [chan_a.2, chan_b.2].iter() {
1893                 let monitor = get_monitor!(nodes[1], chan_id);
1894                 for payment in [payment_a, payment_b, payment_c, payment_d].iter() {
1895                         monitor.provide_payment_preimage(
1896                                 &payment.1, &payment.0, &node_cfgs[1].tx_broadcaster,
1897                                 &LowerBoundedFeeEstimator::new(node_cfgs[1].fee_estimator), &nodes[1].logger
1898                         );
1899                 }
1900         }
1901
1902         // Bob force closes by restarting with the outdated state, prompting the ChannelMonitors to
1903         // broadcast the latest commitment transaction known to them, which in our case is the one with
1904         // the HTLCs still pending.
1905         nodes[1].node.timer_tick_occurred();
1906         check_added_monitors(&nodes[1], 2);
1907         check_closed_event!(&nodes[1], 2, ClosureReason::OutdatedChannelManager);
1908         let (revoked_commitment_a, revoked_commitment_b) = {
1909                 let txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1910                 assert_eq!(txn.len(), 2);
1911                 assert_eq!(txn[0].output.len(), 6); // 2 HTLC outputs + 1 to_self output + 1 to_remote output + 2 anchor outputs
1912                 assert_eq!(txn[1].output.len(), 6); // 2 HTLC outputs + 1 to_self output + 1 to_remote output + 2 anchor outputs
1913                 if txn[0].input[0].previous_output.txid == chan_a.3.txid() {
1914                         check_spends!(&txn[0], &chan_a.3);
1915                         check_spends!(&txn[1], &chan_b.3);
1916                         (txn[0].clone(), txn[1].clone())
1917                 } else {
1918                         check_spends!(&txn[1], &chan_a.3);
1919                         check_spends!(&txn[0], &chan_b.3);
1920                         (txn[1].clone(), txn[0].clone())
1921                 }
1922         };
1923
1924         // Bob should now receive two events to bump his revoked commitment transaction fees.
1925         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1926         let events = nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events();
1927         assert_eq!(events.len(), 2);
1928         let anchor_tx = {
1929                 let secret_key = SecretKey::from_slice(&[1; 32]).unwrap();
1930                 let public_key = PublicKey::new(secret_key.public_key(&secp));
1931                 let fee_utxo_script = Script::new_v0_p2wpkh(&public_key.wpubkey_hash().unwrap());
1932                 let coinbase_tx = Transaction {
1933                         version: 2,
1934                         lock_time: PackedLockTime::ZERO,
1935                         input: vec![TxIn { ..Default::default() }],
1936                         output: vec![TxOut { // UTXO to attach fees to `anchor_tx`
1937                                 value: Amount::ONE_BTC.to_sat(),
1938                                 script_pubkey: fee_utxo_script.clone(),
1939                         }],
1940                 };
1941                 let mut anchor_tx = Transaction {
1942                         version: 2,
1943                         lock_time: PackedLockTime::ZERO,
1944                         input: vec![
1945                                 TxIn { // Fee input
1946                                         previous_output: bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 },
1947                                         ..Default::default()
1948                                 },
1949                         ],
1950                         output: vec![TxOut { // Fee input change
1951                                 value: coinbase_tx.output[0].value / 2 ,
1952                                 script_pubkey: Script::new_op_return(&[]),
1953                         }],
1954                 };
1955                 let mut signers = Vec::with_capacity(2);
1956                 for event in events {
1957                         match event {
1958                                 Event::BumpTransaction(BumpTransactionEvent::ChannelClose { anchor_descriptor, .. })  => {
1959                                         anchor_tx.input.push(TxIn {
1960                                                 previous_output: anchor_descriptor.outpoint,
1961                                                 ..Default::default()
1962                                         });
1963                                         let signer = nodes[1].keys_manager.derive_channel_keys(
1964                                                 anchor_descriptor.channel_value_satoshis, &anchor_descriptor.channel_keys_id,
1965                                         );
1966                                         signers.push(signer);
1967                                 },
1968                                 _ => panic!("Unexpected event"),
1969                         }
1970                 }
1971                 for (i, signer) in signers.into_iter().enumerate() {
1972                         let anchor_idx = i + 1;
1973                         let funding_sig = signer.sign_holder_anchor_input(&mut anchor_tx, anchor_idx, &secp).unwrap();
1974                         anchor_tx.input[anchor_idx].witness = chan_utils::build_anchor_input_witness(
1975                                 &signer.pubkeys().funding_pubkey, &funding_sig
1976                         );
1977                 }
1978                 let fee_utxo_sig = {
1979                         let witness_script = Script::new_p2pkh(&public_key.pubkey_hash());
1980                         let sighash = hash_to_message!(&SighashCache::new(&anchor_tx).segwit_signature_hash(
1981                                 0, &witness_script, coinbase_tx.output[0].value, EcdsaSighashType::All
1982                         ).unwrap()[..]);
1983                         let sig = sign(&secp, &sighash, &secret_key);
1984                         let mut sig = sig.serialize_der().to_vec();
1985                         sig.push(EcdsaSighashType::All as u8);
1986                         sig
1987                 };
1988                 anchor_tx.input[0].witness = Witness::from_vec(vec![fee_utxo_sig, public_key.to_bytes()]);
1989                 check_spends!(anchor_tx, coinbase_tx, revoked_commitment_a, revoked_commitment_b);
1990                 anchor_tx
1991         };
1992
1993         for node in &nodes {
1994                 mine_transactions(node, &[&revoked_commitment_a, &revoked_commitment_b, &anchor_tx]);
1995         }
1996         check_added_monitors!(&nodes[0], 2);
1997         check_closed_broadcast(&nodes[0], 2, true);
1998         check_closed_event!(&nodes[0], 2, ClosureReason::CommitmentTxConfirmed);
1999
2000         // Alice should detect the confirmed revoked commitments, and attempt to claim all of the
2001         // revoked outputs.
2002         {
2003                 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
2004                 assert_eq!(txn.len(), 2);
2005
2006                 let (revoked_claim_a, revoked_claim_b) = if txn[0].input[0].previous_output.txid == revoked_commitment_a.txid() {
2007                         (&txn[0], &txn[1])
2008                 } else {
2009                         (&txn[1], &txn[0])
2010                 };
2011
2012                 // TODO: to_self claim must be separate from HTLC claims
2013                 assert_eq!(revoked_claim_a.input.len(), 3); // Spends both HTLC outputs and to_self output
2014                 assert_eq!(revoked_claim_a.output.len(), 1);
2015                 check_spends!(revoked_claim_a, revoked_commitment_a);
2016                 assert_eq!(revoked_claim_b.input.len(), 3); // Spends both HTLC outputs and to_self output
2017                 assert_eq!(revoked_claim_b.output.len(), 1);
2018                 check_spends!(revoked_claim_b, revoked_commitment_b);
2019         }
2020
2021         // Since Bob was able to confirm his revoked commitment, he'll now try to claim the HTLCs
2022         // through the success path.
2023         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2024         let mut events = nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events();
2025         // Certain block `ConnectStyle`s cause an extra `ChannelClose` event to be emitted since the
2026         // best block is updated before the confirmed transactions are notified.
2027         match *nodes[1].connect_style.borrow() {
2028                 ConnectStyle::BestBlockFirst|ConnectStyle::BestBlockFirstReorgsOnlyTip|ConnectStyle::BestBlockFirstSkippingBlocks => {
2029                         assert_eq!(events.len(), 4);
2030                         if let Event::BumpTransaction(BumpTransactionEvent::ChannelClose { .. }) = events.remove(0) {}
2031                         else { panic!("unexpected event"); }
2032                         if let Event::BumpTransaction(BumpTransactionEvent::ChannelClose { .. }) = events.remove(1) {}
2033                         else { panic!("unexpected event"); }
2034
2035                 },
2036                 _ => assert_eq!(events.len(), 2),
2037         };
2038         let htlc_tx = {
2039                 let secret_key = SecretKey::from_slice(&[1; 32]).unwrap();
2040                 let public_key = PublicKey::new(secret_key.public_key(&secp));
2041                 let fee_utxo_script = Script::new_v0_p2wpkh(&public_key.wpubkey_hash().unwrap());
2042                 let coinbase_tx = Transaction {
2043                         version: 2,
2044                         lock_time: PackedLockTime::ZERO,
2045                         input: vec![TxIn { ..Default::default() }],
2046                         output: vec![TxOut { // UTXO to attach fees to `htlc_tx`
2047                                 value: Amount::ONE_BTC.to_sat(),
2048                                 script_pubkey: fee_utxo_script.clone(),
2049                         }],
2050                 };
2051                 let mut htlc_tx = Transaction {
2052                         version: 2,
2053                         lock_time: PackedLockTime::ZERO,
2054                         input: vec![TxIn { // Fee input
2055                                 previous_output: bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 },
2056                                 ..Default::default()
2057                         }],
2058                         output: vec![TxOut { // Fee input change
2059                                 value: coinbase_tx.output[0].value / 2 ,
2060                                 script_pubkey: Script::new_op_return(&[]),
2061                         }],
2062                 };
2063                 let mut descriptors = Vec::with_capacity(4);
2064                 for event in events {
2065                         if let Event::BumpTransaction(BumpTransactionEvent::HTLCResolution { mut htlc_descriptors, tx_lock_time, .. }) = event {
2066                                 assert_eq!(htlc_descriptors.len(), 2);
2067                                 for htlc_descriptor in &htlc_descriptors {
2068                                         assert!(!htlc_descriptor.htlc.offered);
2069                                         let signer = nodes[1].keys_manager.derive_channel_keys(
2070                                                 htlc_descriptor.channel_value_satoshis, &htlc_descriptor.channel_keys_id
2071                                         );
2072                                         let per_commitment_point = signer.get_per_commitment_point(htlc_descriptor.per_commitment_number, &secp);
2073                                         htlc_tx.input.push(htlc_descriptor.unsigned_tx_input());
2074                                         htlc_tx.output.push(htlc_descriptor.tx_output(&per_commitment_point, &secp));
2075                                 }
2076                                 descriptors.append(&mut htlc_descriptors);
2077                                 htlc_tx.lock_time = tx_lock_time;
2078                         } else {
2079                                 panic!("Unexpected event");
2080                         }
2081                 }
2082                 for (idx, htlc_descriptor) in descriptors.into_iter().enumerate() {
2083                         let htlc_input_idx = idx + 1;
2084                         let signer = nodes[1].keys_manager.derive_channel_keys(
2085                                 htlc_descriptor.channel_value_satoshis, &htlc_descriptor.channel_keys_id
2086                         );
2087                         let our_sig = signer.sign_holder_htlc_transaction(&htlc_tx, htlc_input_idx, &htlc_descriptor, &secp).unwrap();
2088                         let per_commitment_point = signer.get_per_commitment_point(htlc_descriptor.per_commitment_number, &secp);
2089                         let witness_script = htlc_descriptor.witness_script(&per_commitment_point, &secp);
2090                         htlc_tx.input[htlc_input_idx].witness = htlc_descriptor.tx_input_witness(&our_sig, &witness_script);
2091                 }
2092                 let fee_utxo_sig = {
2093                         let witness_script = Script::new_p2pkh(&public_key.pubkey_hash());
2094                         let sighash = hash_to_message!(&SighashCache::new(&htlc_tx).segwit_signature_hash(
2095                                 0, &witness_script, coinbase_tx.output[0].value, EcdsaSighashType::All
2096                         ).unwrap()[..]);
2097                         let sig = sign(&secp, &sighash, &secret_key);
2098                         let mut sig = sig.serialize_der().to_vec();
2099                         sig.push(EcdsaSighashType::All as u8);
2100                         sig
2101                 };
2102                 htlc_tx.input[0].witness = Witness::from_vec(vec![fee_utxo_sig, public_key.to_bytes()]);
2103                 check_spends!(htlc_tx, coinbase_tx, revoked_commitment_a, revoked_commitment_b);
2104                 htlc_tx
2105         };
2106
2107         for node in &nodes {
2108                 mine_transaction(node, &htlc_tx);
2109         }
2110
2111         // Alice should see that Bob is trying to claim to HTLCs, so she should now try to claim them at
2112         // the second level instead.
2113         let revoked_claims = {
2114                 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
2115                 assert_eq!(txn.len(), 4);
2116
2117                 let revoked_to_self_claim_a = txn.iter().find(|tx|
2118                         tx.input.len() == 1 &&
2119                         tx.output.len() == 1 &&
2120                         tx.input[0].previous_output.txid == revoked_commitment_a.txid()
2121                 ).unwrap();
2122                 check_spends!(revoked_to_self_claim_a, revoked_commitment_a);
2123
2124                 let revoked_to_self_claim_b = txn.iter().find(|tx|
2125                         tx.input.len() == 1 &&
2126                         tx.output.len() == 1 &&
2127                         tx.input[0].previous_output.txid == revoked_commitment_b.txid()
2128                 ).unwrap();
2129                 check_spends!(revoked_to_self_claim_b, revoked_commitment_b);
2130
2131                 let revoked_htlc_claims = txn.iter().filter(|tx|
2132                         tx.input.len() == 2 &&
2133                         tx.output.len() == 1 &&
2134                         tx.input[0].previous_output.txid == htlc_tx.txid()
2135                 ).collect::<Vec<_>>();
2136                 assert_eq!(revoked_htlc_claims.len(), 2);
2137                 for revoked_htlc_claim in revoked_htlc_claims {
2138                         check_spends!(revoked_htlc_claim, htlc_tx);
2139                 }
2140
2141                 txn
2142         };
2143         for node in &nodes {
2144                 mine_transactions(node, &revoked_claims.iter().collect::<Vec<_>>());
2145         }
2146
2147
2148         // Connect one block to make sure the HTLC events are not yielded while ANTI_REORG_DELAY has not
2149         // been reached.
2150         connect_blocks(&nodes[0], 1);
2151         connect_blocks(&nodes[1], 1);
2152
2153         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2154         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2155
2156         // Connect the remaining blocks to reach ANTI_REORG_DELAY.
2157         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
2158         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 2);
2159
2160         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2161         let spendable_output_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
2162         assert_eq!(spendable_output_events.len(), 4);
2163         for (idx, event) in spendable_output_events.iter().enumerate() {
2164                 if let Event::SpendableOutputs { outputs } = event {
2165                         assert_eq!(outputs.len(), 1);
2166                         let spend_tx = nodes[0].keys_manager.backing.spend_spendable_outputs(
2167                                 &[&outputs[0]], Vec::new(), Script::new_op_return(&[]), 253, &Secp256k1::new(),
2168                         ).unwrap();
2169                         check_spends!(spend_tx, revoked_claims[idx]);
2170                 } else {
2171                         panic!("unexpected event");
2172                 }
2173         }
2174
2175         assert!(nodes[0].node.list_channels().is_empty());
2176         assert!(nodes[1].node.list_channels().is_empty());
2177         assert!(nodes[0].chain_monitor.chain_monitor.get_claimable_balances(&[]).is_empty());
2178         // TODO: From Bob's PoV, he still thinks he can claim the outputs from his revoked commitment.
2179         // This needs to be fixed before we enable pruning `ChannelMonitor`s once they don't have any
2180         // balances to claim.
2181         //
2182         // The 6 claimable balances correspond to his `to_self` outputs and the 2 HTLC outputs in each
2183         // revoked commitment which Bob has the preimage for.
2184         assert_eq!(nodes[1].chain_monitor.chain_monitor.get_claimable_balances(&[]).len(), 6);
2185 }