_ 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 use crate::sign::{ecdsa::EcdsaChannelSigner, OutputSpender, SpendableOutputDescriptor};
  13 use crate::chain::channelmonitor::{ANTI_REORG_DELAY, LATENCY_GRACE_PERIOD_BLOCKS, Balance};
  14 use crate::chain::transaction::OutPoint;
  15 use crate::chain::chaininterface::{LowerBoundedFeeEstimator, compute_feerate_sat_per_1000_weight};
  16 use crate::events::bump_transaction::{BumpTransactionEvent, WalletSource};
  17 use crate::events::{Event, MessageSendEvent, MessageSendEventsProvider, ClosureReason, HTLCDestination};
  18 use crate::ln::{channel, ChannelId};
  19 use crate::ln::channelmanager::{BREAKDOWN_TIMEOUT, PaymentId, RecipientOnionFields};
  20 use crate::ln::msgs::ChannelMessageHandler;
  21 use crate::util::config::UserConfig;
  22 use crate::crypto::utils::sign;
  23 use crate::util::ser::Writeable;
  24 use crate::util::scid_utils::block_from_scid;
  25 use crate::util::test_utils;
  26
  27 use bitcoin::{Amount, PublicKey, ScriptBuf, Transaction, TxIn, TxOut, Witness};
  28 use bitcoin::blockdata::locktime::absolute::LockTime;
  29 use bitcoin::blockdata::script::Builder;
  30 use bitcoin::blockdata::opcodes;
  31 use bitcoin::hashes::hex::FromHex;
  32 use bitcoin::secp256k1::{Secp256k1, SecretKey};
  33 use bitcoin::sighash::{SighashCache, EcdsaSighashType};
  34
  35 use crate::prelude::*;
  36
  37 use crate::ln::functional_test_utils::*;
  38
  39 #[test]
  40 fn chanmon_fail_from_stale_commitment() {
  41         // If we forward an HTLC to our counterparty, but we force-closed the channel before our
  42         // counterparty provides us an updated commitment transaction, we'll end up with a commitment
  43         // transaction that does not contain the HTLC which we attempted to forward. In this case, we
  44         // need to wait `ANTI_REORG_DELAY` blocks and then fail back the HTLC as there is no way for us
  45         // to learn the preimage and the confirmed commitment transaction paid us the value of the
  46         // HTLC.
  47         //
  48         // However, previously, we did not do this, ignoring the HTLC entirely.
  49         //
  50         // This could lead to channel closure if the sender we received the HTLC from decides to go on
  51         // chain to get their HTLC back before it times out.
  52         //
  53         // Here, we check exactly this case, forwarding a payment from A, through B, to C, before B
  54         // broadcasts its latest commitment transaction, which should result in it eventually failing
  55         // the HTLC back off-chain to A.
  56         let chanmon_cfgs = create_chanmon_cfgs(3);
  57         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
  58         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
  59         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  60
  61         create_announced_chan_between_nodes(&nodes, 0, 1);
  62         let (update_a, _, chan_id_2, _) = create_announced_chan_between_nodes(&nodes, 1, 2);
  63
  64         let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 1_000_000);
  65         nodes[0].node.send_payment_with_route(&route, payment_hash,
  66                 RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap();
  67         check_added_monitors!(nodes[0], 1);
  68
  69         let bs_txn = get_local_commitment_txn!(nodes[1], chan_id_2);
  70
  71         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  72         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
  73         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
  74
  75         expect_pending_htlcs_forwardable!(nodes[1]);
  76         get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
  77         check_added_monitors!(nodes[1], 1);
  78
  79         // Don't bother delivering the new HTLC add/commits, instead confirming the pre-HTLC commitment
  80         // transaction for nodes[1].
  81         mine_transaction(&nodes[1], &bs_txn[0]);
  82         check_added_monitors!(nodes[1], 1);
  83         check_closed_broadcast!(nodes[1], true);
  84         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [nodes[2].node.get_our_node_id()], 100000);
  85         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  86
  87         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
  88         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 }]);
  89         check_added_monitors!(nodes[1], 1);
  90         let fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
  91
  92         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_updates.update_fail_htlcs[0]);
  93         commitment_signed_dance!(nodes[0], nodes[1], fail_updates.commitment_signed, true, true);
  94         expect_payment_failed_with_update!(nodes[0], payment_hash, false, update_a.contents.short_channel_id, true);
  95 }
  96
  97 fn test_spendable_output<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, spendable_tx: &Transaction, has_anchors_htlc_event: bool) -> Vec<SpendableOutputDescriptor> {
  98         let mut spendable = node.chain_monitor.chain_monitor.get_and_clear_pending_events();
  99         assert_eq!(spendable.len(), if has_anchors_htlc_event { 2 } else { 1 });
 100         if has_anchors_htlc_event {
 101                 if let Event::BumpTransaction(BumpTransactionEvent::HTLCResolution { .. }) = spendable.pop().unwrap() {}
 102                 else { panic!(); }
 103         }
 104         if let Event::SpendableOutputs { outputs, .. } = spendable.pop().unwrap() {
 105                 assert_eq!(outputs.len(), 1);
 106                 let spend_tx = node.keys_manager.backing.spend_spendable_outputs(&[&outputs[0]], Vec::new(),
 107                         Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), 253, None, &Secp256k1::new()).unwrap();
 108                 check_spends!(spend_tx, spendable_tx);
 109                 outputs
 110         } else { panic!(); }
 111 }
 112
 113 #[test]
 114 fn revoked_output_htlc_resolution_timing() {
 115         // Tests that HTLCs which were present in a broadcasted remote revoked commitment transaction
 116         // are resolved only after a spend of the HTLC output reaches six confirmations. Preivously
 117         // they would resolve after the revoked commitment transaction itself reaches six
 118         // confirmations.
 119         let chanmon_cfgs = create_chanmon_cfgs(2);
 120         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 121         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 122         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 123
 124         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000);
 125
 126         let payment_hash_1 = route_payment(&nodes[1], &[&nodes[0]], 1_000_000).1;
 127
 128         // Get a commitment transaction which contains the HTLC we care about, but which we'll revoke
 129         // before forwarding.
 130         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan.2);
 131         assert_eq!(revoked_local_txn.len(), 1);
 132
 133         // Route a dust payment to revoke the above commitment transaction
 134         route_payment(&nodes[0], &[&nodes[1]], 1_000);
 135
 136         // Confirm the revoked commitment transaction, closing the channel.
 137         mine_transaction(&nodes[1], &revoked_local_txn[0]);
 138         check_added_monitors!(nodes[1], 1);
 139         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [nodes[0].node.get_our_node_id()], 1000000);
 140         check_closed_broadcast!(nodes[1], true);
 141
 142         let bs_spend_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 143         assert_eq!(bs_spend_txn.len(), 1);
 144         check_spends!(bs_spend_txn[0], revoked_local_txn[0]);
 145
 146         // After the commitment transaction confirms, we should still wait on the HTLC spend
 147         // transaction to confirm before resolving the HTLC.
 148         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 149         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 150         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 151
 152         // Spend the HTLC output, generating a HTLC failure event after ANTI_REORG_DELAY confirmations.
 153         mine_transaction(&nodes[1], &bs_spend_txn[0]);
 154         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 155         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 156
 157         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 158         expect_payment_failed!(nodes[1], payment_hash_1, false);
 159 }
 160
 161 #[test]
 162 fn archive_fully_resolved_monitors() {
 163         // Test we can archive fully resolved channel monitor.
 164         let chanmon_cfgs = create_chanmon_cfgs(2);
 165         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 166         let mut user_config = test_default_channel_config();
 167         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
 168         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 169
 170         let (_, _, chan_id, funding_tx) =
 171                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 1_000_000);
 172
 173         nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
 174         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 175         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 176         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 177         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 178
 179         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 180         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 181         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 182         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 183         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 184         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
 185         let (_, _) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 186
 187         let shutdown_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 188
 189         mine_transaction(&nodes[0], &shutdown_tx[0]);
 190         mine_transaction(&nodes[1], &shutdown_tx[0]);
 191
 192         connect_blocks(&nodes[0], 6);
 193         connect_blocks(&nodes[1], 6);
 194
 195         check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 1000000);
 196         check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 1000000);
 197
 198         assert_eq!(nodes[0].chain_monitor.chain_monitor.list_monitors().len(), 1);
 199         // First archive should set balances_empty_height to current block height
 200         nodes[0].chain_monitor.chain_monitor.archive_fully_resolved_channel_monitors();
 201         assert_eq!(nodes[0].chain_monitor.chain_monitor.list_monitors().len(), 1);
 202         connect_blocks(&nodes[0], 4032);
 203         // Second call after 4032 blocks, should archive the monitor
 204         nodes[0].chain_monitor.chain_monitor.archive_fully_resolved_channel_monitors();
 205         // Should have no monitors left
 206         assert_eq!(nodes[0].chain_monitor.chain_monitor.list_monitors().len(), 0);
 207         // Remove the corresponding outputs and transactions the chain source is
 208         // watching. This is to make sure the `Drop` function assertions pass.
 209         nodes.get_mut(0).unwrap().chain_source.remove_watched_txn_and_outputs(
 210                 OutPoint { txid: funding_tx.txid(), index: 0 },
 211                 funding_tx.output[0].script_pubkey.clone()
 212         );
 213 }
 214
 215 fn do_chanmon_claim_value_coop_close(anchors: bool) {
 216         // Tests `get_claimable_balances` returns the correct values across a simple cooperative claim.
 217         // Specifically, this tests that the channel non-HTLC balances show up in
 218         // `get_claimable_balances` until the cooperative claims have confirmed and generated a
 219         // `SpendableOutputs` event, and no longer.
 220         let chanmon_cfgs = create_chanmon_cfgs(2);
 221         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 222         let mut user_config = test_default_channel_config();
 223         if anchors {
 224                 user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
 225                 user_config.manually_accept_inbound_channels = true;
 226         }
 227         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
 228         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 229
 230         let (_, _, chan_id, funding_tx) =
 231                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 1_000_000);
 232         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 233         assert_eq!(ChannelId::v1_from_funding_outpoint(funding_outpoint), chan_id);
 234
 235         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
 236         let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 237
 238         let commitment_tx_fee = chan_feerate * channel::commitment_tx_base_weight(&channel_type_features) / 1000;
 239         let anchor_outputs_value = if anchors { channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 };
 240         assert_eq!(vec![Balance::ClaimableOnChannelClose {
 241                         amount_satoshis: 1_000_000 - 1_000 - commitment_tx_fee - anchor_outputs_value
 242                 }],
 243                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 244         assert_eq!(vec![Balance::ClaimableOnChannelClose { amount_satoshis: 1_000, }],
 245                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 246
 247         nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
 248         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 249         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 250         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 251         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 252
 253         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 254         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 255         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 256         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 257         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 258         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
 259         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 260         assert!(node_1_none.is_none());
 261
 262         let shutdown_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 263         assert_eq!(shutdown_tx, nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0));
 264         assert_eq!(shutdown_tx.len(), 1);
 265
 266         let shutdown_tx_conf_height_a = block_from_scid(mine_transaction(&nodes[0], &shutdown_tx[0]));
 267         let shutdown_tx_conf_height_b = block_from_scid(mine_transaction(&nodes[1], &shutdown_tx[0]));
 268
 269         assert!(nodes[0].node.list_channels().is_empty());
 270         assert!(nodes[1].node.list_channels().is_empty());
 271
 272         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 273         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 274
 275         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 276                         amount_satoshis: 1_000_000 - 1_000 - commitment_tx_fee - anchor_outputs_value,
 277                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
 278                 }],
 279                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 280         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 281                         amount_satoshis: 1000,
 282                         confirmation_height: nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1,
 283                 }],
 284                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 285
 286         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
 287         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 2);
 288
 289         assert!(get_monitor!(nodes[0], chan_id)
 290                 .get_spendable_outputs(&shutdown_tx[0], shutdown_tx_conf_height_a).is_empty());
 291         assert!(get_monitor!(nodes[1], chan_id)
 292                 .get_spendable_outputs(&shutdown_tx[0], shutdown_tx_conf_height_b).is_empty());
 293
 294         connect_blocks(&nodes[0], 1);
 295         connect_blocks(&nodes[1], 1);
 296
 297         assert_eq!(Vec::<Balance>::new(),
 298                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 299         assert_eq!(Vec::<Balance>::new(),
 300                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 301
 302         let spendable_outputs_a = test_spendable_output(&nodes[0], &shutdown_tx[0], false);
 303         assert_eq!(
 304                 get_monitor!(nodes[0], chan_id).get_spendable_outputs(&shutdown_tx[0], shutdown_tx_conf_height_a),
 305                 spendable_outputs_a
 306         );
 307
 308         let spendable_outputs_b = test_spendable_output(&nodes[1], &shutdown_tx[0], false);
 309         assert_eq!(
 310                 get_monitor!(nodes[1], chan_id).get_spendable_outputs(&shutdown_tx[0], shutdown_tx_conf_height_b),
 311                 spendable_outputs_b
 312         );
 313
 314         check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 1000000);
 315         check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 1000000);
 316 }
 317
 318 #[test]
 319 fn chanmon_claim_value_coop_close() {
 320         do_chanmon_claim_value_coop_close(false);
 321         do_chanmon_claim_value_coop_close(true);
 322 }
 323
 324 fn sorted_vec<T: Ord>(mut v: Vec<T>) -> Vec<T> {
 325         v.sort_unstable();
 326         v
 327 }
 328
 329 /// Asserts that `a` and `b` are close, but maybe off by up to 5.
 330 /// This is useful when checking fees and weights on transactions as things may vary by a few based
 331 /// on signature size and signature size estimation being non-exact.
 332 fn fuzzy_assert_eq<V: core::convert::TryInto<u64>>(a: V, b: V) {
 333         let a_u64 = a.try_into().map_err(|_| ()).unwrap();
 334         let b_u64 = b.try_into().map_err(|_| ()).unwrap();
 335         eprintln!("Checking {} and {} for fuzzy equality", a_u64, b_u64);
 336         assert!(a_u64 >= b_u64 - 5);
 337         assert!(b_u64 >= a_u64 - 5);
 338 }
 339
 340 fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 341         // Tests `get_claimable_balances` with an HTLC across a force-close.
 342         // We build a channel with an HTLC pending, then force close the channel and check that the
 343         // `get_claimable_balances` return value is correct as transactions confirm on-chain.
 344         let mut chanmon_cfgs = create_chanmon_cfgs(2);
 345         if prev_commitment_tx {
 346                 // We broadcast a second-to-latest commitment transaction, without providing the revocation
 347                 // secret to the counterparty. However, because we always immediately take the revocation
 348                 // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
 349                 // transaction which, from the point of view of our keys_manager, is revoked.
 350                 chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
 351         }
 352         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 353         let mut user_config = test_default_channel_config();
 354         if anchors {
 355                 user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
 356                 user_config.manually_accept_inbound_channels = true;
 357         }
 358         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
 359         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 360
 361         let coinbase_tx = Transaction {
 362                 version: 2,
 363                 lock_time: LockTime::ZERO,
 364                 input: vec![TxIn { ..Default::default() }],
 365                 output: vec![
 366                         TxOut {
 367                                 value: Amount::ONE_BTC.to_sat(),
 368                                 script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
 369                         },
 370                         TxOut {
 371                                 value: Amount::ONE_BTC.to_sat(),
 372                                 script_pubkey: nodes[1].wallet_source.get_change_script().unwrap(),
 373                         },
 374                 ],
 375         };
 376         if anchors {
 377                 nodes[0].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, coinbase_tx.output[0].value);
 378                 nodes[1].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 1 }, coinbase_tx.output[1].value);
 379         }
 380
 381         let (_, _, chan_id, funding_tx) =
 382                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 1_000_000);
 383         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 384         assert_eq!(ChannelId::v1_from_funding_outpoint(funding_outpoint), chan_id);
 385
 386         // This HTLC is immediately claimed, giving node B the preimage
 387         let (payment_preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 3_000_000);
 388         // This HTLC is allowed to time out, letting A claim it. However, in order to test claimable
 389         // balances more fully we also give B the preimage for this HTLC.
 390         let (timeout_payment_preimage, timeout_payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 4_000_000);
 391         // This HTLC will be dust, and not be claimable at all:
 392         let (dust_payment_preimage, dust_payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 3_000);
 393
 394         let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
 395
 396         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id);
 397         let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 398
 399         let remote_txn = get_local_commitment_txn!(nodes[1], chan_id);
 400         let sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {
 401                 amount_satoshis: 3_000,
 402                 claimable_height: htlc_cltv_timeout,
 403                 payment_hash,
 404         };
 405         let sent_htlc_timeout_balance = Balance::MaybeTimeoutClaimableHTLC {
 406                 amount_satoshis: 4_000,
 407                 claimable_height: htlc_cltv_timeout,
 408                 payment_hash: timeout_payment_hash,
 409         };
 410         let received_htlc_balance = Balance::MaybePreimageClaimableHTLC {
 411                 amount_satoshis: 3_000,
 412                 expiry_height: htlc_cltv_timeout,
 413                 payment_hash,
 414         };
 415         let received_htlc_timeout_balance = Balance::MaybePreimageClaimableHTLC {
 416                 amount_satoshis: 4_000,
 417                 expiry_height: htlc_cltv_timeout,
 418                 payment_hash: timeout_payment_hash,
 419         };
 420         let received_htlc_claiming_balance = Balance::ContentiousClaimable {
 421                 amount_satoshis: 3_000,
 422                 timeout_height: htlc_cltv_timeout,
 423                 payment_hash,
 424                 payment_preimage,
 425         };
 426         let received_htlc_timeout_claiming_balance = Balance::ContentiousClaimable {
 427                 amount_satoshis: 4_000,
 428                 timeout_height: htlc_cltv_timeout,
 429                 payment_hash: timeout_payment_hash,
 430                 payment_preimage: timeout_payment_preimage,
 431         };
 432
 433         // Before B receives the payment preimage, it only suggests the push_msat value of 1_000 sats
 434         // as claimable. A lists both its to-self balance and the (possibly-claimable) HTLCs.
 435         let commitment_tx_fee = chan_feerate as u64 *
 436                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
 437         let anchor_outputs_value = if anchors { 2 * channel::ANCHOR_OUTPUT_VALUE_SATOSHI } else { 0 };
 438         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 439                         amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - commitment_tx_fee - anchor_outputs_value,
 440                 }, sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
 441                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 442         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 443                         amount_satoshis: 1_000,
 444                 }, received_htlc_balance.clone(), received_htlc_timeout_balance.clone()]),
 445                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 446
 447         nodes[1].node.claim_funds(payment_preimage);
 448         check_added_monitors!(nodes[1], 1);
 449         expect_payment_claimed!(nodes[1], payment_hash, 3_000_000);
 450
 451         let b_htlc_msgs = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
 452         // We claim the dust payment here as well, but it won't impact our claimable balances as its
 453         // dust and thus doesn't appear on chain at all.
 454         nodes[1].node.claim_funds(dust_payment_preimage);
 455         check_added_monitors!(nodes[1], 1);
 456         expect_payment_claimed!(nodes[1], dust_payment_hash, 3_000);
 457
 458         nodes[1].node.claim_funds(timeout_payment_preimage);
 459         check_added_monitors!(nodes[1], 1);
 460         expect_payment_claimed!(nodes[1], timeout_payment_hash, 4_000_000);
 461
 462         if prev_commitment_tx {
 463                 // To build a previous commitment transaction, deliver one round of commitment messages.
 464                 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &b_htlc_msgs.update_fulfill_htlcs[0]);
 465                 expect_payment_sent(&nodes[0], payment_preimage, None, false, false);
 466                 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &b_htlc_msgs.commitment_signed);
 467                 check_added_monitors!(nodes[0], 1);
 468                 let (as_raa, as_cs) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 469                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
 470                 let _htlc_updates = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
 471                 check_added_monitors!(nodes[1], 1);
 472                 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs);
 473                 let _bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 474                 check_added_monitors!(nodes[1], 1);
 475         }
 476
 477         // Once B has received the payment preimage, it includes the value of the HTLC in its
 478         // "claimable if you were to close the channel" balance.
 479         let commitment_tx_fee = chan_feerate as u64 *
 480                 (channel::commitment_tx_base_weight(&channel_type_features) +
 481                 if prev_commitment_tx { 1 } else { 2 } * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
 482         let mut a_expected_balances = vec![Balance::ClaimableOnChannelClose {
 483                         amount_satoshis: 1_000_000 - // Channel funding value in satoshis
 484                                 4_000 - // The to-be-failed HTLC value in satoshis
 485                                 3_000 - // The claimed HTLC value in satoshis
 486                                 1_000 - // The push_msat value in satoshis
 487                                 3 - // The dust HTLC value in satoshis
 488                                 commitment_tx_fee - // The commitment transaction fee with two HTLC outputs
 489                                 anchor_outputs_value, // The anchor outputs value in satoshis
 490                 }, sent_htlc_timeout_balance.clone()];
 491         if !prev_commitment_tx {
 492                 a_expected_balances.push(sent_htlc_balance.clone());
 493         }
 494         assert_eq!(sorted_vec(a_expected_balances),
 495                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 496         assert_eq!(vec![Balance::ClaimableOnChannelClose {
 497                         amount_satoshis: 1_000 + 3_000 + 4_000,
 498                 }],
 499                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 500
 501         // Broadcast the closing transaction (which has both pending HTLCs in it) and get B's
 502         // broadcasted HTLC claim transaction with preimage.
 503         let node_b_commitment_claimable = nodes[1].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 504         mine_transaction(&nodes[0], &remote_txn[0]);
 505         mine_transaction(&nodes[1], &remote_txn[0]);
 506
 507         if anchors {
 508                 let mut events = nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events();
 509                 assert_eq!(events.len(), 1);
 510                 match events.pop().unwrap() {
 511                         Event::BumpTransaction(bump_event) => {
 512                                 let mut first_htlc_event = bump_event.clone();
 513                                 if let BumpTransactionEvent::HTLCResolution { ref mut htlc_descriptors, .. } = &mut first_htlc_event {
 514                                         htlc_descriptors.remove(1);
 515                                 } else {
 516                                         panic!("Unexpected event");
 517                                 }
 518                                 let mut second_htlc_event = bump_event;
 519                                 if let BumpTransactionEvent::HTLCResolution { ref mut htlc_descriptors, .. } = &mut second_htlc_event {
 520                                         htlc_descriptors.remove(0);
 521                                 } else {
 522                                         panic!("Unexpected event");
 523                                 }
 524                                 nodes[1].bump_tx_handler.handle_event(&first_htlc_event);
 525                                 nodes[1].bump_tx_handler.handle_event(&second_htlc_event);
 526                         },
 527                         _ => panic!("Unexpected event"),
 528                 }
 529         }
 530
 531         let b_broadcast_txn = nodes[1].tx_broadcaster.txn_broadcast();
 532         assert_eq!(b_broadcast_txn.len(), 2);
 533         // b_broadcast_txn should spend the HTLCs output of the commitment tx for 3_000 and 4_000 sats
 534         check_spends!(b_broadcast_txn[0], remote_txn[0], coinbase_tx);
 535         check_spends!(b_broadcast_txn[1], remote_txn[0], coinbase_tx);
 536         assert_eq!(b_broadcast_txn[0].input.len(), if anchors { 2 } else { 1 });
 537         assert_eq!(b_broadcast_txn[1].input.len(), if anchors { 2 } else { 1 });
 538         assert_eq!(remote_txn[0].output[b_broadcast_txn[0].input[0].previous_output.vout as usize].value, 3_000);
 539         assert_eq!(remote_txn[0].output[b_broadcast_txn[1].input[0].previous_output.vout as usize].value, 4_000);
 540
 541         assert!(nodes[0].node.list_channels().is_empty());
 542         check_closed_broadcast!(nodes[0], true);
 543         check_added_monitors!(nodes[0], 1);
 544         check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id()], 1000000);
 545         assert!(nodes[1].node.list_channels().is_empty());
 546         check_closed_broadcast!(nodes[1], true);
 547         check_added_monitors!(nodes[1], 1);
 548         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [nodes[0].node.get_our_node_id()], 1000000);
 549         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 550         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 551
 552         // Once the commitment transaction confirms, we will wait until ANTI_REORG_DELAY until we
 553         // generate any `SpendableOutputs` events. Thus, the same balances will still be listed
 554         // available in `get_claimable_balances`. However, both will swap from `ClaimableOnClose` to
 555         // other Balance variants, as close has already happened.
 556         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 557         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 558         let commitment_tx_fee = chan_feerate as u64 *
 559                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
 560         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 561                         amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - commitment_tx_fee - anchor_outputs_value,
 562                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
 563                 }, sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
 564                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 565         // The main non-HTLC balance is just awaiting confirmations, but the claimable height is the
 566         // CSV delay, not ANTI_REORG_DELAY.
 567         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 568                         amount_satoshis: 1_000,
 569                         confirmation_height: node_b_commitment_claimable,
 570                 },
 571                 // Both HTLC balances are "contentious" as our counterparty could claim them if we wait too
 572                 // long.
 573                 received_htlc_claiming_balance.clone(), received_htlc_timeout_claiming_balance.clone()]),
 574                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 575
 576         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 577         expect_payment_failed!(nodes[0], dust_payment_hash, false);
 578         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 579
 580         // After ANTI_REORG_DELAY, A will consider its balance fully spendable and generate a
 581         // `SpendableOutputs` event. However, B still has to wait for the CSV delay.
 582         assert_eq!(sorted_vec(vec![sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
 583                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 584         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 585                         amount_satoshis: 1_000,
 586                         confirmation_height: node_b_commitment_claimable,
 587                 }, received_htlc_claiming_balance.clone(), received_htlc_timeout_claiming_balance.clone()]),
 588                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 589
 590         test_spendable_output(&nodes[0], &remote_txn[0], false);
 591         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 592
 593         // After broadcasting the HTLC claim transaction, node A will still consider the HTLC
 594         // possibly-claimable up to ANTI_REORG_DELAY, at which point it will drop it.
 595         mine_transaction(&nodes[0], &b_broadcast_txn[0]);
 596         if prev_commitment_tx {
 597                 expect_payment_path_successful!(nodes[0]);
 598         } else {
 599                 expect_payment_sent(&nodes[0], payment_preimage, None, true, false);
 600         }
 601         assert_eq!(sorted_vec(vec![sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
 602                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 603         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 604         assert_eq!(vec![sent_htlc_timeout_balance.clone()],
 605                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 606
 607         // When the HTLC timeout output is spendable in the next block, A should broadcast it
 608         connect_blocks(&nodes[0], htlc_cltv_timeout - nodes[0].best_block_info().1);
 609         let a_broadcast_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 610         assert_eq!(a_broadcast_txn.len(), 2);
 611         assert_eq!(a_broadcast_txn[0].input.len(), 1);
 612         check_spends!(a_broadcast_txn[0], remote_txn[0]);
 613         assert_eq!(a_broadcast_txn[1].input.len(), 1);
 614         check_spends!(a_broadcast_txn[1], remote_txn[0]);
 615         assert_ne!(a_broadcast_txn[0].input[0].previous_output.vout,
 616                    a_broadcast_txn[1].input[0].previous_output.vout);
 617         // a_broadcast_txn [0] and [1] should spend the HTLC outputs of the commitment tx
 618         assert_eq!(remote_txn[0].output[a_broadcast_txn[0].input[0].previous_output.vout as usize].value, 3_000);
 619         assert_eq!(remote_txn[0].output[a_broadcast_txn[1].input[0].previous_output.vout as usize].value, 4_000);
 620
 621         // Once the HTLC-Timeout transaction confirms, A will no longer consider the HTLC
 622         // "MaybeClaimable", but instead move it to "AwaitingConfirmations".
 623         mine_transaction(&nodes[0], &a_broadcast_txn[1]);
 624         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 625         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 626                         amount_satoshis: 4_000,
 627                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
 628                 }],
 629                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 630         // After ANTI_REORG_DELAY, A will generate a SpendableOutputs event and drop the claimable
 631         // balance entry.
 632         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 633         assert_eq!(Vec::<Balance>::new(),
 634                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 635         expect_payment_failed!(nodes[0], timeout_payment_hash, false);
 636
 637         test_spendable_output(&nodes[0], &a_broadcast_txn[1], false);
 638
 639         // Node B will no longer consider the HTLC "contentious" after the HTLC claim transaction
 640         // confirms, and consider it simply "awaiting confirmations". Note that it has to wait for the
 641         // standard revocable transaction CSV delay before receiving a `SpendableOutputs`.
 642         let node_b_htlc_claimable = nodes[1].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 643         mine_transaction(&nodes[1], &b_broadcast_txn[0]);
 644
 645         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 646                         amount_satoshis: 1_000,
 647                         confirmation_height: node_b_commitment_claimable,
 648                 }, Balance::ClaimableAwaitingConfirmations {
 649                         amount_satoshis: 3_000,
 650                         confirmation_height: node_b_htlc_claimable,
 651                 }, received_htlc_timeout_claiming_balance.clone()]),
 652                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 653
 654         // After reaching the commitment output CSV, we'll get a SpendableOutputs event for it and have
 655         // only the HTLCs claimable on node B.
 656         connect_blocks(&nodes[1], node_b_commitment_claimable - nodes[1].best_block_info().1);
 657         test_spendable_output(&nodes[1], &remote_txn[0], anchors);
 658
 659         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 660                         amount_satoshis: 3_000,
 661                         confirmation_height: node_b_htlc_claimable,
 662                 }, received_htlc_timeout_claiming_balance.clone()]),
 663                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 664
 665         // After reaching the claimed HTLC output CSV, we'll get a SpendableOutptus event for it and
 666         // have only one HTLC output left spendable.
 667         connect_blocks(&nodes[1], node_b_htlc_claimable - nodes[1].best_block_info().1);
 668         test_spendable_output(&nodes[1], &b_broadcast_txn[0], anchors);
 669
 670         assert_eq!(vec![received_htlc_timeout_claiming_balance.clone()],
 671                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 672
 673         // Finally, mine the HTLC timeout transaction that A broadcasted (even though B should be able
 674         // to claim this HTLC with the preimage it knows!). It will remain listed as a claimable HTLC
 675         // until ANTI_REORG_DELAY confirmations on the spend.
 676         mine_transaction(&nodes[1], &a_broadcast_txn[1]);
 677         assert_eq!(vec![received_htlc_timeout_claiming_balance.clone()],
 678                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 679         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 680         assert_eq!(Vec::<Balance>::new(),
 681                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 682
 683         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
 684         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
 685         // monitor events or claimable balances.
 686         for node in nodes.iter() {
 687                 connect_blocks(node, 6);
 688                 connect_blocks(node, 6);
 689                 assert!(node.chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 690                 assert!(node.chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
 691         }
 692 }
 693
 694 #[test]
 695 fn test_claim_value_force_close() {
 696         do_test_claim_value_force_close(false, true);
 697         do_test_claim_value_force_close(false, false);
 698         do_test_claim_value_force_close(true, true);
 699         do_test_claim_value_force_close(true, false);
 700 }
 701
 702 fn do_test_balances_on_local_commitment_htlcs(anchors: bool) {
 703         // Previously, when handling the broadcast of a local commitment transactions (with associated
 704         // CSV delays prior to spendability), we incorrectly handled the CSV delays on HTLC
 705         // transactions. This caused us to miss spendable outputs for HTLCs which were awaiting a CSV
 706         // delay prior to spendability.
 707         //
 708         // Further, because of this, we could hit an assertion as `get_claimable_balances` asserted
 709         // that HTLCs were resolved after the funding spend was resolved, which was not true if the
 710         // HTLC did not have a CSV delay attached (due to the above bug or due to it being an HTLC
 711         // claim by our counterparty).
 712         let chanmon_cfgs = create_chanmon_cfgs(2);
 713         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 714         let mut user_config = test_default_channel_config();
 715         if anchors {
 716                 user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
 717                 user_config.manually_accept_inbound_channels = true;
 718         }
 719         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
 720         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 721
 722         let coinbase_tx = Transaction {
 723                 version: 2,
 724                 lock_time: LockTime::ZERO,
 725                 input: vec![TxIn { ..Default::default() }],
 726                 output: vec![
 727                         TxOut {
 728                                 value: Amount::ONE_BTC.to_sat(),
 729                                 script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
 730                         },
 731                         TxOut {
 732                                 value: Amount::ONE_BTC.to_sat(),
 733                                 script_pubkey: nodes[1].wallet_source.get_change_script().unwrap(),
 734                         },
 735                 ],
 736         };
 737         if anchors {
 738                 nodes[0].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, coinbase_tx.output[0].value);
 739                 nodes[1].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 1 }, coinbase_tx.output[1].value);
 740         }
 741
 742         // Create a single channel with two pending HTLCs from nodes[0] to nodes[1], one which nodes[1]
 743         // knows the preimage for, one which it does not.
 744         let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
 745         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 746
 747         let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 10_000_000);
 748         let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
 749         nodes[0].node.send_payment_with_route(&route, payment_hash,
 750                 RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap();
 751         check_added_monitors!(nodes[0], 1);
 752
 753         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 754         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 755         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
 756
 757         expect_pending_htlcs_forwardable!(nodes[1]);
 758         expect_payment_claimable!(nodes[1], payment_hash, payment_secret, 10_000_000);
 759
 760         let (route_2, payment_hash_2, payment_preimage_2, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[1], 20_000_000);
 761         nodes[0].node.send_payment_with_route(&route_2, payment_hash_2,
 762                 RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap();
 763         check_added_monitors!(nodes[0], 1);
 764
 765         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 766         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 767         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
 768
 769         expect_pending_htlcs_forwardable!(nodes[1]);
 770         expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 20_000_000);
 771         nodes[1].node.claim_funds(payment_preimage_2);
 772         get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 773         check_added_monitors!(nodes[1], 1);
 774         expect_payment_claimed!(nodes[1], payment_hash_2, 20_000_000);
 775
 776         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
 777         let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 778
 779         // First confirm the commitment transaction on nodes[0], which should leave us with three
 780         // claimable balances.
 781         let node_a_commitment_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 782         nodes[0].node.force_close_broadcasting_latest_txn(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
 783         check_added_monitors!(nodes[0], 1);
 784         check_closed_broadcast!(nodes[0], true);
 785         check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed, [nodes[1].node.get_our_node_id()], 1000000);
 786         let commitment_tx = {
 787                 let mut txn = nodes[0].tx_broadcaster.unique_txn_broadcast();
 788                 assert_eq!(txn.len(), 1);
 789                 let commitment_tx = txn.pop().unwrap();
 790                 check_spends!(commitment_tx, funding_tx);
 791                 commitment_tx
 792         };
 793         let commitment_tx_conf_height_a = block_from_scid(mine_transaction(&nodes[0], &commitment_tx));
 794         if nodes[0].connect_style.borrow().updates_best_block_first() {
 795                 let mut txn = nodes[0].tx_broadcaster.txn_broadcast();
 796                 assert_eq!(txn.len(), 1);
 797                 assert_eq!(txn[0].txid(), commitment_tx.txid());
 798         }
 799
 800         let htlc_balance_known_preimage = Balance::MaybeTimeoutClaimableHTLC {
 801                 amount_satoshis: 10_000,
 802                 claimable_height: htlc_cltv_timeout,
 803                 payment_hash,
 804         };
 805         let htlc_balance_unknown_preimage = Balance::MaybeTimeoutClaimableHTLC {
 806                 amount_satoshis: 20_000,
 807                 claimable_height: htlc_cltv_timeout,
 808                 payment_hash: payment_hash_2,
 809         };
 810
 811         let commitment_tx_fee = chan_feerate *
 812                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
 813         let anchor_outputs_value = if anchors { 2 * channel::ANCHOR_OUTPUT_VALUE_SATOSHI } else { 0 };
 814         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 815                         amount_satoshis: 1_000_000 - 10_000 - 20_000 - commitment_tx_fee - anchor_outputs_value,
 816                         confirmation_height: node_a_commitment_claimable,
 817                 }, htlc_balance_known_preimage.clone(), htlc_balance_unknown_preimage.clone()]),
 818                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 819
 820         // Get nodes[1]'s HTLC claim tx for the second HTLC
 821         mine_transaction(&nodes[1], &commitment_tx);
 822         check_added_monitors!(nodes[1], 1);
 823         check_closed_broadcast!(nodes[1], true);
 824         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [nodes[0].node.get_our_node_id()], 1000000);
 825         let bs_htlc_claim_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 826         assert_eq!(bs_htlc_claim_txn.len(), 1);
 827         check_spends!(bs_htlc_claim_txn[0], commitment_tx);
 828
 829         // Connect blocks until the HTLCs expire, allowing us to (validly) broadcast the HTLC-Timeout
 830         // transaction.
 831         connect_blocks(&nodes[0], TEST_FINAL_CLTV);
 832         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 833                         amount_satoshis: 1_000_000 - 10_000 - 20_000 - commitment_tx_fee - anchor_outputs_value,
 834                         confirmation_height: node_a_commitment_claimable,
 835                 }, htlc_balance_known_preimage.clone(), htlc_balance_unknown_preimage.clone()]),
 836                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 837         if anchors {
 838                 handle_bump_htlc_event(&nodes[0], 2);
 839         }
 840         let timeout_htlc_txn = nodes[0].tx_broadcaster.unique_txn_broadcast();
 841         assert_eq!(timeout_htlc_txn.len(), 2);
 842         check_spends!(timeout_htlc_txn[0], commitment_tx, coinbase_tx);
 843         check_spends!(timeout_htlc_txn[1], commitment_tx, coinbase_tx);
 844
 845         // Now confirm nodes[0]'s HTLC-Timeout transaction, which changes the claimable balance to an
 846         // "awaiting confirmations" one.
 847         let node_a_htlc_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 848         mine_transaction(&nodes[0], &timeout_htlc_txn[0]);
 849         // Note that prior to the fix in the commit which introduced this test, this (and the next
 850         // balance) check failed. With this check removed, the code panicked in the `connect_blocks`
 851         // call, as described, two hunks down.
 852         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 853                         amount_satoshis: 1_000_000 - 10_000 - 20_000 - commitment_tx_fee - anchor_outputs_value,
 854                         confirmation_height: node_a_commitment_claimable,
 855                 }, Balance::ClaimableAwaitingConfirmations {
 856                         amount_satoshis: 10_000,
 857                         confirmation_height: node_a_htlc_claimable,
 858                 }, htlc_balance_unknown_preimage.clone()]),
 859                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 860
 861         // Now confirm nodes[1]'s HTLC claim, giving nodes[0] the preimage. Note that the "maybe
 862         // claimable" balance remains until we see ANTI_REORG_DELAY blocks.
 863         mine_transaction(&nodes[0], &bs_htlc_claim_txn[0]);
 864         expect_payment_sent(&nodes[0], payment_preimage_2, None, true, false);
 865         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 866                         amount_satoshis: 1_000_000 - 10_000 - 20_000 - commitment_tx_fee - anchor_outputs_value,
 867                         confirmation_height: node_a_commitment_claimable,
 868                 }, Balance::ClaimableAwaitingConfirmations {
 869                         amount_satoshis: 10_000,
 870                         confirmation_height: node_a_htlc_claimable,
 871                 }, htlc_balance_unknown_preimage.clone()]),
 872                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 873
 874         // Finally make the HTLC transactions have ANTI_REORG_DELAY blocks. This call previously
 875         // panicked as described in the test introduction. This will remove the "maybe claimable"
 876         // spendable output as nodes[1] has fully claimed the second HTLC.
 877         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 878         expect_payment_failed!(nodes[0], payment_hash, false);
 879
 880         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 881                         amount_satoshis: 1_000_000 - 10_000 - 20_000 - commitment_tx_fee - anchor_outputs_value,
 882                         confirmation_height: node_a_commitment_claimable,
 883                 }, Balance::ClaimableAwaitingConfirmations {
 884                         amount_satoshis: 10_000,
 885                         confirmation_height: node_a_htlc_claimable,
 886                 }]),
 887                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 888
 889         // Connect blocks until the commitment transaction's CSV expires, providing us the relevant
 890         // `SpendableOutputs` event and removing the claimable balance entry.
 891         connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1 - 1);
 892         assert!(get_monitor!(nodes[0], chan_id)
 893                 .get_spendable_outputs(&commitment_tx, commitment_tx_conf_height_a).is_empty());
 894         connect_blocks(&nodes[0], 1);
 895         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
 896                         amount_satoshis: 10_000,
 897                         confirmation_height: node_a_htlc_claimable,
 898                 }],
 899                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 900         let to_self_spendable_output = test_spendable_output(&nodes[0], &commitment_tx, false);
 901         assert_eq!(
 902                 get_monitor!(nodes[0], chan_id).get_spendable_outputs(&commitment_tx, commitment_tx_conf_height_a),
 903                 to_self_spendable_output
 904         );
 905
 906         // Connect blocks until the HTLC-Timeout's CSV expires, providing us the relevant
 907         // `SpendableOutputs` event and removing the claimable balance entry.
 908         connect_blocks(&nodes[0], node_a_htlc_claimable - nodes[0].best_block_info().1);
 909         assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
 910         test_spendable_output(&nodes[0], &timeout_htlc_txn[0], false);
 911
 912         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
 913         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
 914         // monitor events or claimable balances.
 915         connect_blocks(&nodes[0], 6);
 916         connect_blocks(&nodes[0], 6);
 917         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 918         assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
 919 }
 920
 921 #[test]
 922 fn test_balances_on_local_commitment_htlcs() {
 923         do_test_balances_on_local_commitment_htlcs(false);
 924         do_test_balances_on_local_commitment_htlcs(true);
 925 }
 926
 927 #[test]
 928 fn test_no_preimage_inbound_htlc_balances() {
 929         // Tests that MaybePreimageClaimableHTLC are generated for inbound HTLCs for which we do not
 930         // have a preimage.
 931         let chanmon_cfgs = create_chanmon_cfgs(2);
 932         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 933         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 934         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 935
 936         let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000);
 937         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 938
 939         // Send two HTLCs, one from A to B, and one from B to A.
 940         let to_b_failed_payment_hash = route_payment(&nodes[0], &[&nodes[1]], 10_000_000).1;
 941         let to_a_failed_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 20_000_000).1;
 942         let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
 943
 944         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
 945         let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 946
 947         let a_sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {
 948                 amount_satoshis: 10_000,
 949                 claimable_height: htlc_cltv_timeout,
 950                 payment_hash: to_b_failed_payment_hash,
 951         };
 952         let a_received_htlc_balance = Balance::MaybePreimageClaimableHTLC {
 953                 amount_satoshis: 20_000,
 954                 expiry_height: htlc_cltv_timeout,
 955                 payment_hash: to_a_failed_payment_hash,
 956         };
 957         let b_received_htlc_balance = Balance::MaybePreimageClaimableHTLC {
 958                 amount_satoshis: 10_000,
 959                 expiry_height: htlc_cltv_timeout,
 960                 payment_hash: to_b_failed_payment_hash,
 961         };
 962         let b_sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {
 963                 amount_satoshis: 20_000,
 964                 claimable_height: htlc_cltv_timeout,
 965                 payment_hash: to_a_failed_payment_hash,
 966         };
 967
 968         // Both A and B will have an HTLC that's claimable on timeout and one that's claimable if they
 969         // receive the preimage. These will remain the same through the channel closure and until the
 970         // HTLC output is spent.
 971
 972         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 973                         amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
 974                                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 975                 }, a_received_htlc_balance.clone(), a_sent_htlc_balance.clone()]),
 976                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 977
 978         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 979                         amount_satoshis: 500_000 - 20_000,
 980                 }, b_received_htlc_balance.clone(), b_sent_htlc_balance.clone()]),
 981                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 982
 983         // Get nodes[0]'s commitment transaction and HTLC-Timeout transaction
 984         let as_txn = get_local_commitment_txn!(nodes[0], chan_id);
 985         assert_eq!(as_txn.len(), 2);
 986         check_spends!(as_txn[1], as_txn[0]);
 987         check_spends!(as_txn[0], funding_tx);
 988
 989         // Now close the channel by confirming A's commitment transaction on both nodes, checking the
 990         // claimable balances remain the same except for the non-HTLC balance changing variant.
 991         let node_a_commitment_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 992         let as_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 993                         amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
 994                                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 995                         confirmation_height: node_a_commitment_claimable,
 996                 }, a_received_htlc_balance.clone(), a_sent_htlc_balance.clone()]);
 997
 998         mine_transaction(&nodes[0], &as_txn[0]);
 999         nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1000         check_added_monitors!(nodes[0], 1);
1001         check_closed_broadcast!(nodes[0], true);
1002         check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id()], 1000000);
1003
1004         assert_eq!(as_pre_spend_claims,
1005                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1006
1007         mine_transaction(&nodes[1], &as_txn[0]);
1008         check_added_monitors!(nodes[1], 1);
1009         check_closed_broadcast!(nodes[1], true);
1010         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [nodes[0].node.get_our_node_id()], 1000000);
1011
1012         let node_b_commitment_claimable = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1013         let mut bs_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1014                         amount_satoshis: 500_000 - 20_000,
1015                         confirmation_height: node_b_commitment_claimable,
1016                 }, b_received_htlc_balance.clone(), b_sent_htlc_balance.clone()]);
1017         assert_eq!(bs_pre_spend_claims,
1018                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1019
1020         // We'll broadcast the HTLC-Timeout transaction one block prior to the htlc's expiration (as it
1021         // is confirmable in the next block), but will still include the same claimable balances as no
1022         // HTLC has been spent, even after the HTLC expires. We'll also fail the inbound HTLC, but it
1023         // won't do anything as the channel is already closed.
1024
1025         connect_blocks(&nodes[0], TEST_FINAL_CLTV);
1026         let as_htlc_timeout_claim = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1027         assert_eq!(as_htlc_timeout_claim.len(), 1);
1028         check_spends!(as_htlc_timeout_claim[0], as_txn[0]);
1029         expect_pending_htlcs_forwardable_conditions!(nodes[0],
1030                 [HTLCDestination::FailedPayment { payment_hash: to_a_failed_payment_hash }]);
1031
1032         assert_eq!(as_pre_spend_claims,
1033                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1034
1035         connect_blocks(&nodes[0], 1);
1036         assert_eq!(as_pre_spend_claims,
1037                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1038
1039         // For node B, we'll get the non-HTLC funds claimable after ANTI_REORG_DELAY confirmations
1040         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
1041         test_spendable_output(&nodes[1], &as_txn[0], false);
1042         bs_pre_spend_claims.retain(|e| if let Balance::ClaimableAwaitingConfirmations { .. } = e { false } else { true });
1043
1044         // The next few blocks for B look the same as for A, though for the opposite HTLC
1045         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1046         connect_blocks(&nodes[1], TEST_FINAL_CLTV - (ANTI_REORG_DELAY - 1));
1047         expect_pending_htlcs_forwardable_conditions!(nodes[1],
1048                 [HTLCDestination::FailedPayment { payment_hash: to_b_failed_payment_hash }]);
1049         let bs_htlc_timeout_claim = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1050         assert_eq!(bs_htlc_timeout_claim.len(), 1);
1051         check_spends!(bs_htlc_timeout_claim[0], as_txn[0]);
1052
1053         assert_eq!(bs_pre_spend_claims,
1054                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1055
1056         connect_blocks(&nodes[1], 1);
1057         assert_eq!(bs_pre_spend_claims,
1058                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1059
1060         // Now confirm the two HTLC timeout transactions for A, checking that the inbound HTLC resolves
1061         // after ANTI_REORG_DELAY confirmations and the other takes BREAKDOWN_TIMEOUT confirmations.
1062         mine_transaction(&nodes[0], &as_htlc_timeout_claim[0]);
1063         let as_timeout_claimable_height = nodes[0].best_block_info().1 + (BREAKDOWN_TIMEOUT as u32) - 1;
1064         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1065                         amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
1066                                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1067                         confirmation_height: node_a_commitment_claimable,
1068                 }, a_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {
1069                         amount_satoshis: 10_000,
1070                         confirmation_height: as_timeout_claimable_height,
1071                 }]),
1072                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1073
1074         mine_transaction(&nodes[0], &bs_htlc_timeout_claim[0]);
1075         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1076                         amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
1077                                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1078                         confirmation_height: node_a_commitment_claimable,
1079                 }, a_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {
1080                         amount_satoshis: 10_000,
1081                         confirmation_height: as_timeout_claimable_height,
1082                 }]),
1083                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1084
1085         // Once as_htlc_timeout_claim[0] reaches ANTI_REORG_DELAY confirmations, we should get a
1086         // payment failure event.
1087         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
1088         expect_payment_failed!(nodes[0], to_b_failed_payment_hash, false);
1089
1090         connect_blocks(&nodes[0], 1);
1091         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1092                         amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
1093                                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1094                         confirmation_height: node_a_commitment_claimable,
1095                 }, Balance::ClaimableAwaitingConfirmations {
1096                         amount_satoshis: 10_000,
1097                         confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
1098                 }]),
1099                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1100
1101         connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
1102         assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
1103                         amount_satoshis: 10_000,
1104                         confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
1105                 }],
1106                 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
1107         test_spendable_output(&nodes[0], &as_txn[0], false);
1108
1109         connect_blocks(&nodes[0], as_timeout_claimable_height - nodes[0].best_block_info().1);
1110         assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1111         test_spendable_output(&nodes[0], &as_htlc_timeout_claim[0], false);
1112
1113         // The process for B should be completely identical as well, noting that the non-HTLC-balance
1114         // was already claimed.
1115         mine_transaction(&nodes[1], &bs_htlc_timeout_claim[0]);
1116         let bs_timeout_claimable_height = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1117         assert_eq!(sorted_vec(vec![b_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {
1118                         amount_satoshis: 20_000,
1119                         confirmation_height: bs_timeout_claimable_height,
1120                 }]),
1121                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1122
1123         mine_transaction(&nodes[1], &as_htlc_timeout_claim[0]);
1124         assert_eq!(sorted_vec(vec![b_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {
1125                         amount_satoshis: 20_000,
1126                         confirmation_height: bs_timeout_claimable_height,
1127                 }]),
1128                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1129
1130         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 2);
1131         expect_payment_failed!(nodes[1], to_a_failed_payment_hash, false);
1132
1133         assert_eq!(vec![b_received_htlc_balance.clone()],
1134                 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
1135         test_spendable_output(&nodes[1], &bs_htlc_timeout_claim[0], false);
1136
1137         connect_blocks(&nodes[1], 1);
1138         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1139
1140         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
1141         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
1142         // monitor events or claimable balances.
1143         connect_blocks(&nodes[1], 6);
1144         connect_blocks(&nodes[1], 6);
1145         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1146         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1147 }
1148
1149 fn sorted_vec_with_additions<T: Ord + Clone>(v_orig: &Vec<T>, extra_ts: &[&T]) -> Vec<T> {
1150         let mut v = v_orig.clone();
1151         for t in extra_ts {
1152                 v.push((*t).clone());
1153         }
1154         v.sort_unstable();
1155         v
1156 }
1157
1158 fn do_test_revoked_counterparty_commitment_balances(anchors: bool, confirm_htlc_spend_first: bool) {
1159         // Tests `get_claimable_balances` for revoked counterparty commitment transactions.
1160         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1161         // We broadcast a second-to-latest commitment transaction, without providing the revocation
1162         // secret to the counterparty. However, because we always immediately take the revocation
1163         // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
1164         // transaction which, from the point of view of our keys_manager, is revoked.
1165         chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1166         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1167         let mut user_config = test_default_channel_config();
1168         if anchors {
1169                 user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
1170                 user_config.manually_accept_inbound_channels = true;
1171         }
1172         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
1173         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1174
1175         let (_, _, chan_id, funding_tx) =
1176                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 100_000_000);
1177         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1178         assert_eq!(ChannelId::v1_from_funding_outpoint(funding_outpoint), chan_id);
1179
1180         // We create five HTLCs for B to claim against A's revoked commitment transaction:
1181         //
1182         // (1) one for which A is the originator and B knows the preimage
1183         // (2) one for which B is the originator where the HTLC has since timed-out
1184         // (3) one for which B is the originator but where the HTLC has not yet timed-out
1185         // (4) one dust HTLC which is lost in the channel closure
1186         // (5) one that actually isn't in the revoked commitment transaction at all, but was added in
1187         //     later commitment transaction updates
1188         //
1189         // Though they could all be claimed in a single claim transaction, due to CLTV timeouts they
1190         // are all currently claimed in separate transactions, which helps us test as we can claim
1191         // HTLCs individually.
1192
1193         let (claimed_payment_preimage, claimed_payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 3_000_000);
1194         let timeout_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 4_000_000).1;
1195         let dust_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 3_000).1;
1196
1197         let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1198
1199         connect_blocks(&nodes[0], 10);
1200         connect_blocks(&nodes[1], 10);
1201
1202         let live_htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1203         let live_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 5_000_000).1;
1204
1205         // Get the latest commitment transaction from A and then update the fee to revoke it
1206         let as_revoked_txn = get_local_commitment_txn!(nodes[0], chan_id);
1207         let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
1208
1209         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
1210
1211         let missing_htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1212         let missing_htlc_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 2_000_000).1;
1213
1214         nodes[1].node.claim_funds(claimed_payment_preimage);
1215         expect_payment_claimed!(nodes[1], claimed_payment_hash, 3_000_000);
1216         check_added_monitors!(nodes[1], 1);
1217         let _b_htlc_msgs = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
1218
1219         connect_blocks(&nodes[0], htlc_cltv_timeout + 1 - 10);
1220         check_closed_broadcast!(nodes[0], true);
1221         check_added_monitors!(nodes[0], 1);
1222
1223         let mut events = nodes[0].node.get_and_clear_pending_events();
1224         assert_eq!(events.len(), 6);
1225         let mut failed_payments: HashSet<_> =
1226                 [timeout_payment_hash, dust_payment_hash, live_payment_hash, missing_htlc_payment_hash]
1227                 .iter().map(|a| *a).collect();
1228         events.retain(|ev| {
1229                 match ev {
1230                         Event::HTLCHandlingFailed { failed_next_destination: HTLCDestination::NextHopChannel { node_id, channel_id }, .. } => {
1231                                 assert_eq!(*channel_id, chan_id);
1232                                 assert_eq!(*node_id, Some(nodes[1].node.get_our_node_id()));
1233                                 false
1234                         },
1235                         Event::HTLCHandlingFailed { failed_next_destination: HTLCDestination::FailedPayment { payment_hash }, .. } => {
1236                                 assert!(failed_payments.remove(payment_hash));
1237                                 false
1238                         },
1239                         _ => true,
1240                 }
1241         });
1242         assert!(failed_payments.is_empty());
1243         if let Event::PendingHTLCsForwardable { .. } = events[0] {} else { panic!(); }
1244         match &events[1] {
1245                 Event::ChannelClosed { reason: ClosureReason::HTLCsTimedOut, .. } => {},
1246                 _ => panic!(),
1247         }
1248
1249         connect_blocks(&nodes[1], htlc_cltv_timeout + 1 - 10);
1250         check_closed_broadcast!(nodes[1], true);
1251         check_added_monitors!(nodes[1], 1);
1252         check_closed_event!(nodes[1], 1, ClosureReason::HTLCsTimedOut, [nodes[0].node.get_our_node_id()], 1000000);
1253
1254         // Prior to channel closure, B considers the preimage HTLC as its own, and otherwise only
1255         // lists the two on-chain timeout-able HTLCs as claimable balances.
1256         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
1257                         amount_satoshis: 100_000 - 5_000 - 4_000 - 3 - 2_000 + 3_000,
1258                 }, Balance::MaybeTimeoutClaimableHTLC {
1259                         amount_satoshis: 2_000,
1260                         claimable_height: missing_htlc_cltv_timeout,
1261                         payment_hash: missing_htlc_payment_hash,
1262                 }, Balance::MaybeTimeoutClaimableHTLC {
1263                         amount_satoshis: 4_000,
1264                         claimable_height: htlc_cltv_timeout,
1265                         payment_hash: timeout_payment_hash,
1266                 }, Balance::MaybeTimeoutClaimableHTLC {
1267                         amount_satoshis: 5_000,
1268                         claimable_height: live_htlc_cltv_timeout,
1269                         payment_hash: live_payment_hash,
1270                 }]),
1271                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1272
1273         mine_transaction(&nodes[1], &as_revoked_txn[0]);
1274         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();
1275         // Currently the revoked commitment is claimed in four transactions as the HTLCs all expire
1276         // quite soon.
1277         assert_eq!(claim_txn.len(), 4);
1278         claim_txn.sort_unstable_by_key(|tx| tx.output.iter().map(|output| output.value).sum::<u64>());
1279
1280         // The following constants were determined experimentally
1281         const BS_TO_SELF_CLAIM_EXP_WEIGHT: u64 = 483;
1282         let outbound_htlc_claim_exp_weight: u64 = if anchors { 574 } else { 571 };
1283         let inbound_htlc_claim_exp_weight: u64 = if anchors { 582 } else { 578 };
1284
1285         // Check that the weight is close to the expected weight. Note that signature sizes vary
1286         // somewhat so it may not always be exact.
1287         fuzzy_assert_eq(claim_txn[0].weight().to_wu(), outbound_htlc_claim_exp_weight);
1288         fuzzy_assert_eq(claim_txn[1].weight().to_wu(), inbound_htlc_claim_exp_weight);
1289         fuzzy_assert_eq(claim_txn[2].weight().to_wu(), inbound_htlc_claim_exp_weight);
1290         fuzzy_assert_eq(claim_txn[3].weight().to_wu(), BS_TO_SELF_CLAIM_EXP_WEIGHT);
1291
1292         let commitment_tx_fee = chan_feerate *
1293                 (channel::commitment_tx_base_weight(&channel_type_features) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
1294         let anchor_outputs_value = if anchors { channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 };
1295         let inbound_htlc_claim_fee = chan_feerate * inbound_htlc_claim_exp_weight / 1000;
1296         let outbound_htlc_claim_fee = chan_feerate * outbound_htlc_claim_exp_weight / 1000;
1297         let to_self_claim_fee = chan_feerate * claim_txn[3].weight().to_wu() / 1000;
1298
1299         // The expected balance for the next three checks, with the largest-HTLC and to_self output
1300         // claim balances separated out.
1301         let expected_balance = vec![Balance::ClaimableAwaitingConfirmations {
1302                         // to_remote output in A's revoked commitment
1303                         amount_satoshis: 100_000 - 5_000 - 4_000 - 3,
1304                         confirmation_height: nodes[1].best_block_info().1 + 5,
1305                 }, Balance::CounterpartyRevokedOutputClaimable {
1306                         amount_satoshis: 3_000,
1307                 }, Balance::CounterpartyRevokedOutputClaimable {
1308                         amount_satoshis: 4_000,
1309                 }];
1310
1311         let to_self_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {
1312                 amount_satoshis: 1_000_000 - 100_000 - 3_000 - commitment_tx_fee - anchor_outputs_value,
1313         };
1314         let to_self_claimed_avail_height;
1315         let largest_htlc_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {
1316                 amount_satoshis: 5_000,
1317         };
1318         let largest_htlc_claimed_avail_height;
1319
1320         // Once the channel has been closed by A, B now considers all of the commitment transactions'
1321         // outputs as `CounterpartyRevokedOutputClaimable`.
1322         assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_unclaimed_balance, &largest_htlc_unclaimed_balance]),
1323                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1324
1325         if confirm_htlc_spend_first {
1326                 mine_transaction(&nodes[1], &claim_txn[2]);
1327                 largest_htlc_claimed_avail_height = nodes[1].best_block_info().1 + 5;
1328                 to_self_claimed_avail_height = nodes[1].best_block_info().1 + 6; // will be claimed in the next block
1329         } else {
1330                 // Connect the to_self output claim, taking all of A's non-HTLC funds
1331                 mine_transaction(&nodes[1], &claim_txn[3]);
1332                 to_self_claimed_avail_height = nodes[1].best_block_info().1 + 5;
1333                 largest_htlc_claimed_avail_height = nodes[1].best_block_info().1 + 6; // will be claimed in the next block
1334         }
1335
1336         let largest_htlc_claimed_balance = Balance::ClaimableAwaitingConfirmations {
1337                 amount_satoshis: 5_000 - inbound_htlc_claim_fee,
1338                 confirmation_height: largest_htlc_claimed_avail_height,
1339         };
1340         let to_self_claimed_balance = Balance::ClaimableAwaitingConfirmations {
1341                 amount_satoshis: 1_000_000 - 100_000 - 3_000 - commitment_tx_fee - anchor_outputs_value - to_self_claim_fee,
1342                 confirmation_height: to_self_claimed_avail_height,
1343         };
1344
1345         if confirm_htlc_spend_first {
1346                 assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_unclaimed_balance, &largest_htlc_claimed_balance]),
1347                         sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1348         } else {
1349                 assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_claimed_balance, &largest_htlc_unclaimed_balance]),
1350                         sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1351         }
1352
1353         if confirm_htlc_spend_first {
1354                 mine_transaction(&nodes[1], &claim_txn[3]);
1355         } else {
1356                 mine_transaction(&nodes[1], &claim_txn[2]);
1357         }
1358         assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_claimed_balance, &largest_htlc_claimed_balance]),
1359                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1360
1361         // Finally, connect the last two remaining HTLC spends and check that they move to
1362         // `ClaimableAwaitingConfirmations`
1363         mine_transaction(&nodes[1], &claim_txn[0]);
1364         mine_transaction(&nodes[1], &claim_txn[1]);
1365
1366         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1367                         // to_remote output in A's revoked commitment
1368                         amount_satoshis: 100_000 - 5_000 - 4_000 - 3,
1369                         confirmation_height: nodes[1].best_block_info().1 + 1,
1370                 }, Balance::ClaimableAwaitingConfirmations {
1371                         amount_satoshis: 1_000_000 - 100_000 - 3_000 - commitment_tx_fee - anchor_outputs_value - to_self_claim_fee,
1372                         confirmation_height: to_self_claimed_avail_height,
1373                 }, Balance::ClaimableAwaitingConfirmations {
1374                         amount_satoshis: 3_000 - outbound_htlc_claim_fee,
1375                         confirmation_height: nodes[1].best_block_info().1 + 4,
1376                 }, Balance::ClaimableAwaitingConfirmations {
1377                         amount_satoshis: 4_000 - inbound_htlc_claim_fee,
1378                         confirmation_height: nodes[1].best_block_info().1 + 5,
1379                 }, Balance::ClaimableAwaitingConfirmations {
1380                         amount_satoshis: 5_000 - inbound_htlc_claim_fee,
1381                         confirmation_height: largest_htlc_claimed_avail_height,
1382                 }]),
1383                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1384
1385         connect_blocks(&nodes[1], 1);
1386         test_spendable_output(&nodes[1], &as_revoked_txn[0], false);
1387
1388         let mut payment_failed_events = nodes[1].node.get_and_clear_pending_events();
1389         expect_payment_failed_conditions_event(payment_failed_events[..2].to_vec(),
1390                 missing_htlc_payment_hash, false, PaymentFailedConditions::new());
1391         expect_payment_failed_conditions_event(payment_failed_events[2..].to_vec(),
1392                 dust_payment_hash, false, PaymentFailedConditions::new());
1393
1394         connect_blocks(&nodes[1], 1);
1395         test_spendable_output(&nodes[1], &claim_txn[if confirm_htlc_spend_first { 2 } else { 3 }], false);
1396         connect_blocks(&nodes[1], 1);
1397         test_spendable_output(&nodes[1], &claim_txn[if confirm_htlc_spend_first { 3 } else { 2 }], false);
1398         expect_payment_failed!(nodes[1], live_payment_hash, false);
1399         connect_blocks(&nodes[1], 1);
1400         test_spendable_output(&nodes[1], &claim_txn[0], false);
1401         connect_blocks(&nodes[1], 1);
1402         test_spendable_output(&nodes[1], &claim_txn[1], false);
1403         expect_payment_failed!(nodes[1], timeout_payment_hash, false);
1404         assert_eq!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances(), Vec::new());
1405
1406         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
1407         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
1408         // monitor events or claimable balances.
1409         connect_blocks(&nodes[1], 6);
1410         connect_blocks(&nodes[1], 6);
1411         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1412         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1413 }
1414
1415 #[test]
1416 fn test_revoked_counterparty_commitment_balances() {
1417         do_test_revoked_counterparty_commitment_balances(false, true);
1418         do_test_revoked_counterparty_commitment_balances(false, false);
1419         do_test_revoked_counterparty_commitment_balances(true, true);
1420         do_test_revoked_counterparty_commitment_balances(true, false);
1421 }
1422
1423 fn do_test_revoked_counterparty_htlc_tx_balances(anchors: bool) {
1424         // Tests `get_claimable_balances` for revocation spends of HTLC transactions.
1425         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1426         chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1427         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1428         let mut user_config = test_default_channel_config();
1429         if anchors {
1430                 user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
1431                 user_config.manually_accept_inbound_channels = true;
1432         }
1433         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
1434         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1435
1436         let coinbase_tx = Transaction {
1437                 version: 2,
1438                 lock_time: LockTime::ZERO,
1439                 input: vec![TxIn { ..Default::default() }],
1440                 output: vec![
1441                         TxOut {
1442                                 value: Amount::ONE_BTC.to_sat(),
1443                                 script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
1444                         },
1445                         TxOut {
1446                                 value: Amount::ONE_BTC.to_sat(),
1447                                 script_pubkey: nodes[1].wallet_source.get_change_script().unwrap(),
1448                         },
1449                 ],
1450         };
1451         if anchors {
1452                 nodes[0].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, coinbase_tx.output[0].value);
1453                 nodes[1].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 1 }, coinbase_tx.output[1].value);
1454         }
1455
1456         // Create some initial channels
1457         let (_, _, chan_id, funding_tx) =
1458                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 12_000_000);
1459         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1460         assert_eq!(ChannelId::v1_from_funding_outpoint(funding_outpoint), chan_id);
1461
1462         let payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 3_000_000).0;
1463         let failed_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 1_000_000).1;
1464         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_id);
1465         assert_eq!(revoked_local_txn[0].input.len(), 1);
1466         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, funding_tx.txid());
1467         if anchors {
1468                 assert_eq!(revoked_local_txn[0].output[4].value, 11000); // to_self output
1469         } else {
1470                 assert_eq!(revoked_local_txn[0].output[2].value, 11000); // to_self output
1471         }
1472
1473         // The to-be-revoked commitment tx should have two HTLCs, an output for each side, and an
1474         // anchor output for each side if enabled.
1475         assert_eq!(revoked_local_txn[0].output.len(), if anchors { 6 } else { 4 });
1476
1477         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
1478
1479         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
1480         let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
1481
1482         // B will generate an HTLC-Success from its revoked commitment tx
1483         mine_transaction(&nodes[1], &revoked_local_txn[0]);
1484         check_closed_broadcast!(nodes[1], true);
1485         check_added_monitors!(nodes[1], 1);
1486         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [nodes[0].node.get_our_node_id()], 1000000);
1487         if anchors {
1488                 handle_bump_htlc_event(&nodes[1], 1);
1489         }
1490         let revoked_htlc_success = {
1491                 let mut txn = nodes[1].tx_broadcaster.txn_broadcast();
1492                 assert_eq!(txn.len(), 1);
1493                 assert_eq!(txn[0].input.len(), if anchors { 2 } else { 1 });
1494                 assert_eq!(txn[0].input[0].previous_output.vout, if anchors { 3 } else { 1 });
1495                 assert_eq!(txn[0].input[0].witness.last().unwrap().len(),
1496                         if anchors { ACCEPTED_HTLC_SCRIPT_WEIGHT_ANCHORS } else { ACCEPTED_HTLC_SCRIPT_WEIGHT });
1497                 check_spends!(txn[0], revoked_local_txn[0], coinbase_tx);
1498                 txn.pop().unwrap()
1499         };
1500         let revoked_htlc_success_fee = chan_feerate * revoked_htlc_success.weight().to_wu() / 1000;
1501
1502         connect_blocks(&nodes[1], TEST_FINAL_CLTV);
1503         if anchors {
1504                 handle_bump_htlc_event(&nodes[1], 2);
1505         }
1506         let revoked_htlc_timeout = {
1507                 let mut txn = nodes[1].tx_broadcaster.unique_txn_broadcast();
1508                 assert_eq!(txn.len(), 2);
1509                 if txn[0].input[0].previous_output == revoked_htlc_success.input[0].previous_output {
1510                         txn.remove(1)
1511                 } else {
1512                         txn.remove(0)
1513                 }
1514         };
1515         check_spends!(revoked_htlc_timeout, revoked_local_txn[0], coinbase_tx);
1516         assert_ne!(revoked_htlc_success.input[0].previous_output, revoked_htlc_timeout.input[0].previous_output);
1517         assert_eq!(revoked_htlc_success.lock_time, LockTime::ZERO);
1518         assert_ne!(revoked_htlc_timeout.lock_time, LockTime::ZERO);
1519
1520         // A will generate justice tx from B's revoked commitment/HTLC tx
1521         mine_transaction(&nodes[0], &revoked_local_txn[0]);
1522         check_closed_broadcast!(nodes[0], true);
1523         check_added_monitors!(nodes[0], 1);
1524         check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id()], 1000000);
1525         let to_remote_conf_height = nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1;
1526
1527         let revoked_to_self_claim = {
1528                 let mut as_commitment_claim_txn = nodes[0].tx_broadcaster.txn_broadcast();
1529                 assert_eq!(as_commitment_claim_txn.len(), if anchors { 2 } else { 1 });
1530                 if anchors {
1531                         assert_eq!(as_commitment_claim_txn[0].input.len(), 1);
1532                         assert_eq!(as_commitment_claim_txn[0].input[0].previous_output.vout, 4); // Separate to_remote claim
1533                         check_spends!(as_commitment_claim_txn[0], revoked_local_txn[0]);
1534                         assert_eq!(as_commitment_claim_txn[1].input.len(), 2);
1535                         assert_eq!(as_commitment_claim_txn[1].input[0].previous_output.vout, 2);
1536                         assert_eq!(as_commitment_claim_txn[1].input[1].previous_output.vout, 3);
1537                         check_spends!(as_commitment_claim_txn[1], revoked_local_txn[0]);
1538                         Some(as_commitment_claim_txn.remove(0))
1539                 } else {
1540                         assert_eq!(as_commitment_claim_txn[0].input.len(), 3);
1541                         assert_eq!(as_commitment_claim_txn[0].input[0].previous_output.vout, 2);
1542                         assert_eq!(as_commitment_claim_txn[0].input[1].previous_output.vout, 0);
1543                         assert_eq!(as_commitment_claim_txn[0].input[2].previous_output.vout, 1);
1544                         check_spends!(as_commitment_claim_txn[0], revoked_local_txn[0]);
1545                         None
1546                 }
1547         };
1548
1549         // The next two checks have the same balance set for A - even though we confirm a revoked HTLC
1550         // transaction our balance tracking doesn't use the on-chain value so the
1551         // `CounterpartyRevokedOutputClaimable` entry doesn't change.
1552         let commitment_tx_fee = chan_feerate *
1553                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
1554         let anchor_outputs_value = if anchors { channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 };
1555         let as_balances = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1556                         // to_remote output in B's revoked commitment
1557                         amount_satoshis: 1_000_000 - 12_000 - 3_000 - commitment_tx_fee - anchor_outputs_value,
1558                         confirmation_height: to_remote_conf_height,
1559                 }, Balance::CounterpartyRevokedOutputClaimable {
1560                         // to_self output in B's revoked commitment
1561                         amount_satoshis: 11_000,
1562                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1563                         amount_satoshis: 3_000,
1564                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1565                         amount_satoshis: 1_000,
1566                 }]);
1567         assert_eq!(as_balances,
1568                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1569
1570         mine_transaction(&nodes[0], &revoked_htlc_success);
1571         let as_htlc_claim_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1572         assert_eq!(as_htlc_claim_tx.len(), 2);
1573         assert_eq!(as_htlc_claim_tx[0].input.len(), 1);
1574         check_spends!(as_htlc_claim_tx[0], revoked_htlc_success);
1575         // A has to generate a new claim for the remaining revoked outputs (which no longer includes the
1576         // spent HTLC output)
1577         assert_eq!(as_htlc_claim_tx[1].input.len(), if anchors { 1 } else { 2 });
1578         assert_eq!(as_htlc_claim_tx[1].input[0].previous_output.vout, 2);
1579         if !anchors {
1580                 assert_eq!(as_htlc_claim_tx[1].input[1].previous_output.vout, 0);
1581         }
1582         check_spends!(as_htlc_claim_tx[1], revoked_local_txn[0]);
1583
1584         assert_eq!(as_balances,
1585                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1586
1587         assert_eq!(as_htlc_claim_tx[0].output.len(), 1);
1588         let as_revoked_htlc_success_claim_fee = chan_feerate * as_htlc_claim_tx[0].weight().to_wu() / 1000;
1589         if anchors {
1590                 // With anchors, B can pay for revoked_htlc_success's fee with additional inputs, rather
1591                 // than with the HTLC itself.
1592                 fuzzy_assert_eq(as_htlc_claim_tx[0].output[0].value,
1593                         3_000 - as_revoked_htlc_success_claim_fee);
1594         } else {
1595                 fuzzy_assert_eq(as_htlc_claim_tx[0].output[0].value,
1596                         3_000 - revoked_htlc_success_fee - as_revoked_htlc_success_claim_fee);
1597         }
1598
1599         mine_transaction(&nodes[0], &as_htlc_claim_tx[0]);
1600         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1601                         // to_remote output in B's revoked commitment
1602                         amount_satoshis: 1_000_000 - 12_000 - 3_000 - commitment_tx_fee - anchor_outputs_value,
1603                         confirmation_height: to_remote_conf_height,
1604                 }, Balance::CounterpartyRevokedOutputClaimable {
1605                         // to_self output in B's revoked commitment
1606                         amount_satoshis: 11_000,
1607                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1608                         amount_satoshis: 1_000,
1609                 }, Balance::ClaimableAwaitingConfirmations {
1610                         amount_satoshis: as_htlc_claim_tx[0].output[0].value,
1611                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1612                 }]),
1613                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1614
1615         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 3);
1616         test_spendable_output(&nodes[0], &revoked_local_txn[0], false);
1617         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1618                         // to_self output to B
1619                         amount_satoshis: 11_000,
1620                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1621                         amount_satoshis: 1_000,
1622                 }, Balance::ClaimableAwaitingConfirmations {
1623                         amount_satoshis: as_htlc_claim_tx[0].output[0].value,
1624                         confirmation_height: nodes[0].best_block_info().1 + 2,
1625                 }]),
1626                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1627
1628         connect_blocks(&nodes[0], 2);
1629         test_spendable_output(&nodes[0], &as_htlc_claim_tx[0], false);
1630         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1631                         // to_self output in B's revoked commitment
1632                         amount_satoshis: 11_000,
1633                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1634                         amount_satoshis: 1_000,
1635                 }]),
1636                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1637
1638         connect_blocks(&nodes[0], revoked_htlc_timeout.lock_time.to_consensus_u32() - nodes[0].best_block_info().1);
1639         expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(&nodes[0],
1640                 [HTLCDestination::FailedPayment { payment_hash: failed_payment_hash }]);
1641         // As time goes on A may split its revocation claim transaction into multiple.
1642         let as_fewer_input_rbf = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1643         for tx in as_fewer_input_rbf.iter() {
1644                 check_spends!(tx, revoked_local_txn[0]);
1645         }
1646
1647         // Connect a number of additional blocks to ensure we don't forget the HTLC output needs
1648         // claiming.
1649         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
1650         let as_fewer_input_rbf = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1651         for tx in as_fewer_input_rbf.iter() {
1652                 check_spends!(tx, revoked_local_txn[0]);
1653         }
1654
1655         mine_transaction(&nodes[0], &revoked_htlc_timeout);
1656         let (revoked_htlc_timeout_claim, revoked_to_self_claim) = {
1657                 let mut as_second_htlc_claim_tx = nodes[0].tx_broadcaster.txn_broadcast();
1658                 assert_eq!(as_second_htlc_claim_tx.len(), if anchors { 1 } else { 2 });
1659                 if anchors {
1660                         assert_eq!(as_second_htlc_claim_tx[0].input.len(), 1);
1661                         assert_eq!(as_second_htlc_claim_tx[0].input[0].previous_output.vout, 0);
1662                         check_spends!(as_second_htlc_claim_tx[0], revoked_htlc_timeout);
1663                         (as_second_htlc_claim_tx.remove(0), revoked_to_self_claim.unwrap())
1664                 } else {
1665                         assert_eq!(as_second_htlc_claim_tx[0].input.len(), 1);
1666                         assert_eq!(as_second_htlc_claim_tx[0].input[0].previous_output.vout, 0);
1667                         check_spends!(as_second_htlc_claim_tx[0], revoked_htlc_timeout);
1668                         assert_eq!(as_second_htlc_claim_tx[1].input.len(), 1);
1669                         assert_eq!(as_second_htlc_claim_tx[1].input[0].previous_output.vout, 2);
1670                         check_spends!(as_second_htlc_claim_tx[1], revoked_local_txn[0]);
1671                         (as_second_htlc_claim_tx.remove(0), as_second_htlc_claim_tx.remove(0))
1672                 }
1673         };
1674
1675         // Connect blocks to finalize the HTLC resolution with the HTLC-Timeout transaction. In a
1676         // previous iteration of the revoked balance handling this would result in us "forgetting" that
1677         // the revoked HTLC output still needed to be claimed.
1678         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
1679         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1680                         // to_self output in B's revoked commitment
1681                         amount_satoshis: 11_000,
1682                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1683                         amount_satoshis: 1_000,
1684                 }]),
1685                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1686
1687         mine_transaction(&nodes[0], &revoked_htlc_timeout_claim);
1688         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1689                         // to_self output in B's revoked commitment
1690                         amount_satoshis: 11_000,
1691                 }, Balance::ClaimableAwaitingConfirmations {
1692                         amount_satoshis: revoked_htlc_timeout_claim.output[0].value,
1693                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1694                 }]),
1695                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1696
1697         mine_transaction(&nodes[0], &revoked_to_self_claim);
1698         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1699                         // to_self output in B's revoked commitment
1700                         amount_satoshis: revoked_to_self_claim.output[0].value,
1701                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1702                 }, Balance::ClaimableAwaitingConfirmations {
1703                         amount_satoshis: revoked_htlc_timeout_claim.output[0].value,
1704                         confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 2,
1705                 }]),
1706                 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1707
1708         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
1709         test_spendable_output(&nodes[0], &revoked_htlc_timeout_claim, false);
1710         connect_blocks(&nodes[0], 1);
1711         test_spendable_output(&nodes[0], &revoked_to_self_claim, false);
1712
1713         assert_eq!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances(), Vec::new());
1714
1715         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
1716         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
1717         // monitor events or claimable balances.
1718         connect_blocks(&nodes[0], 6);
1719         connect_blocks(&nodes[0], 6);
1720         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
1721         assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
1722 }
1723
1724 #[test]
1725 fn test_revoked_counterparty_htlc_tx_balances() {
1726         do_test_revoked_counterparty_htlc_tx_balances(false);
1727         do_test_revoked_counterparty_htlc_tx_balances(true);
1728 }
1729
1730 fn do_test_revoked_counterparty_aggregated_claims(anchors: bool) {
1731         // Tests `get_claimable_balances` for revoked counterparty commitment transactions when
1732         // claiming with an aggregated claim transaction.
1733         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1734         // We broadcast a second-to-latest commitment transaction, without providing the revocation
1735         // secret to the counterparty. However, because we always immediately take the revocation
1736         // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
1737         // transaction which, from the point of view of our keys_manager, is revoked.
1738         chanmon_cfgs[0].keys_manager.disable_revocation_policy_check = true;
1739         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1740         let mut user_config = test_default_channel_config();
1741         if anchors {
1742                 user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
1743                 user_config.manually_accept_inbound_channels = true;
1744         }
1745         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
1746         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1747
1748         let coinbase_tx = Transaction {
1749                 version: 2,
1750                 lock_time: LockTime::ZERO,
1751                 input: vec![TxIn { ..Default::default() }],
1752                 output: vec![TxOut {
1753                         value: Amount::ONE_BTC.to_sat(),
1754                         script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
1755                 }],
1756         };
1757         nodes[0].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, coinbase_tx.output[0].value);
1758
1759         let (_, _, chan_id, funding_tx) =
1760                 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 100_000_000);
1761         let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1762         assert_eq!(ChannelId::v1_from_funding_outpoint(funding_outpoint), chan_id);
1763
1764         // We create two HTLCs, one which we will give A the preimage to to generate an HTLC-Success
1765         // transaction, and one which we will not, allowing B to claim the HTLC output in an aggregated
1766         // revocation-claim transaction.
1767
1768         let (claimed_payment_preimage, claimed_payment_hash, ..) = route_payment(&nodes[1], &[&nodes[0]], 3_000_000);
1769         let revoked_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 4_000_000).1;
1770
1771         let htlc_cltv_timeout = nodes[1].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1772
1773         // Cheat by giving A's ChannelMonitor the preimage to the to-be-claimed HTLC so that we have an
1774         // HTLC-claim transaction on the to-be-revoked state.
1775         get_monitor!(nodes[0], chan_id).provide_payment_preimage(&claimed_payment_hash, &claimed_payment_preimage,
1776                 &node_cfgs[0].tx_broadcaster, &LowerBoundedFeeEstimator::new(node_cfgs[0].fee_estimator), &nodes[0].logger);
1777
1778         // Now get the latest commitment transaction from A and then update the fee to revoke it
1779         let as_revoked_txn = get_local_commitment_txn!(nodes[0], chan_id);
1780
1781         assert_eq!(as_revoked_txn.len(), if anchors { 1 } else { 2 });
1782         check_spends!(as_revoked_txn[0], funding_tx);
1783         if !anchors {
1784                 check_spends!(as_revoked_txn[1], as_revoked_txn[0]); // The HTLC-Claim transaction
1785         }
1786
1787         let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
1788         let chan_feerate = get_feerate!(nodes[0], nodes[1], chan_id) as u64;
1789
1790         {
1791                 let mut feerate = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap();
1792                 *feerate += 1;
1793         }
1794         nodes[0].node.timer_tick_occurred();
1795         check_added_monitors!(nodes[0], 1);
1796
1797         let fee_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1798         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &fee_update.update_fee.unwrap());
1799         commitment_signed_dance!(nodes[1], nodes[0], fee_update.commitment_signed, false);
1800
1801         nodes[0].node.claim_funds(claimed_payment_preimage);
1802         expect_payment_claimed!(nodes[0], claimed_payment_hash, 3_000_000);
1803         check_added_monitors!(nodes[0], 1);
1804         let _a_htlc_msgs = get_htlc_update_msgs!(&nodes[0], nodes[1].node.get_our_node_id());
1805
1806         assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
1807                         amount_satoshis: 100_000 - 4_000 - 3_000,
1808                 }, Balance::MaybeTimeoutClaimableHTLC {
1809                         amount_satoshis: 4_000,
1810                         claimable_height: htlc_cltv_timeout,
1811                         payment_hash: revoked_payment_hash,
1812                 }, Balance::MaybeTimeoutClaimableHTLC {
1813                         amount_satoshis: 3_000,
1814                         claimable_height: htlc_cltv_timeout,
1815                         payment_hash: claimed_payment_hash,
1816                 }]),
1817                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1818
1819         mine_transaction(&nodes[1], &as_revoked_txn[0]);
1820         check_closed_broadcast!(nodes[1], true);
1821         check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [nodes[0].node.get_our_node_id()], 1000000);
1822         check_added_monitors!(nodes[1], 1);
1823
1824         let mut claim_txn = nodes[1].tx_broadcaster.txn_broadcast();
1825         assert_eq!(claim_txn.len(), if anchors { 2 } else { 1 });
1826         let revoked_to_self_claim = if anchors {
1827                 assert_eq!(claim_txn[0].input.len(), 1);
1828                 assert_eq!(claim_txn[0].input[0].previous_output.vout, 5); // Separate to_remote claim
1829                 check_spends!(claim_txn[0], as_revoked_txn[0]);
1830                 assert_eq!(claim_txn[1].input.len(), 2);
1831                 assert_eq!(claim_txn[1].input[0].previous_output.vout, 2);
1832                 assert_eq!(claim_txn[1].input[1].previous_output.vout, 3);
1833                 check_spends!(claim_txn[1], as_revoked_txn[0]);
1834                 Some(claim_txn.remove(0))
1835         } else {
1836                 assert_eq!(claim_txn[0].input.len(), 3);
1837                 assert_eq!(claim_txn[0].input[0].previous_output.vout, 3);
1838                 assert_eq!(claim_txn[0].input[1].previous_output.vout, 0);
1839                 assert_eq!(claim_txn[0].input[2].previous_output.vout, 1);
1840                 check_spends!(claim_txn[0], as_revoked_txn[0]);
1841                 None
1842         };
1843
1844         let to_remote_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1845
1846         let commitment_tx_fee = chan_feerate *
1847                 (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
1848         let anchor_outputs_value = if anchors { channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 };
1849         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1850                         // to_remote output in A's revoked commitment
1851                         amount_satoshis: 100_000 - 4_000 - 3_000,
1852                         confirmation_height: to_remote_maturity,
1853                 }, Balance::CounterpartyRevokedOutputClaimable {
1854                         // to_self output in A's revoked commitment
1855                         amount_satoshis: 1_000_000 - 100_000 - commitment_tx_fee - anchor_outputs_value,
1856                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1857                         amount_satoshis: 4_000,
1858                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1859                         amount_satoshis: 3_000,
1860                 }]),
1861                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1862
1863         // Confirm A's HTLC-Success transaction which presumably raced B's claim, causing B to create a
1864         // new claim.
1865         if anchors {
1866                 mine_transaction(&nodes[0], &as_revoked_txn[0]);
1867                 check_closed_broadcast(&nodes[0], 1, true);
1868                 check_added_monitors(&nodes[0], 1);
1869                 check_closed_event!(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, false, [nodes[1].node.get_our_node_id()], 1_000_000);
1870                 handle_bump_htlc_event(&nodes[0], 1);
1871         }
1872         let htlc_success_claim = if anchors {
1873                 let mut txn = nodes[0].tx_broadcaster.txn_broadcast();
1874                 assert_eq!(txn.len(), 1);
1875                 check_spends!(txn[0], as_revoked_txn[0], coinbase_tx);
1876                 txn.pop().unwrap()
1877         } else {
1878                 as_revoked_txn[1].clone()
1879         };
1880         mine_transaction(&nodes[1], &htlc_success_claim);
1881         expect_payment_sent(&nodes[1], claimed_payment_preimage, None, true, false);
1882
1883         let mut claim_txn_2 = nodes[1].tx_broadcaster.txn_broadcast();
1884         // Once B sees the HTLC-Success transaction it splits its claim transaction into two, though in
1885         // theory it could re-aggregate the claims as well.
1886         assert_eq!(claim_txn_2.len(), 2);
1887         if anchors {
1888                 assert_eq!(claim_txn_2[0].input.len(), 1);
1889                 assert_eq!(claim_txn_2[0].input[0].previous_output.vout, 0);
1890                 check_spends!(claim_txn_2[0], &htlc_success_claim);
1891                 assert_eq!(claim_txn_2[1].input.len(), 1);
1892                 assert_eq!(claim_txn_2[1].input[0].previous_output.vout, 3);
1893                 check_spends!(claim_txn_2[1], as_revoked_txn[0]);
1894         } else {
1895                 assert_eq!(claim_txn_2[0].input.len(), 1);
1896                 assert_eq!(claim_txn_2[0].input[0].previous_output.vout, 0);
1897                 check_spends!(claim_txn_2[0], as_revoked_txn[1]);
1898                 assert_eq!(claim_txn_2[1].input.len(), 2);
1899                 assert_eq!(claim_txn_2[1].input[0].previous_output.vout, 3);
1900                 assert_eq!(claim_txn_2[1].input[1].previous_output.vout, 1);
1901                 check_spends!(claim_txn_2[1], as_revoked_txn[0]);
1902         }
1903
1904         assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1905                         // to_remote output in A's revoked commitment
1906                         amount_satoshis: 100_000 - 4_000 - 3_000,
1907                         confirmation_height: to_remote_maturity,
1908                 }, Balance::CounterpartyRevokedOutputClaimable {
1909                         // to_self output in A's revoked commitment
1910                         amount_satoshis: 1_000_000 - 100_000 - commitment_tx_fee - anchor_outputs_value,
1911                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1912                         amount_satoshis: 4_000,
1913                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1914                         // The amount here is a bit of a misnomer, really its been reduced by the HTLC
1915                         // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
1916                         // anyway, so its not a big change.
1917                         amount_satoshis: 3_000,
1918                 }]),
1919                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1920
1921         connect_blocks(&nodes[1], 5);
1922         test_spendable_output(&nodes[1], &as_revoked_txn[0], false);
1923
1924         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1925                         // to_self output in A's revoked commitment
1926                         amount_satoshis: 1_000_000 - 100_000 - commitment_tx_fee - anchor_outputs_value,
1927                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1928                         amount_satoshis: 4_000,
1929                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1930                         // The amount here is a bit of a misnomer, really its been reduced by the HTLC
1931                         // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
1932                         // anyway, so its not a big change.
1933                         amount_satoshis: 3_000,
1934                 }]),
1935                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1936
1937         mine_transaction(&nodes[1], &claim_txn_2[0]);
1938         let htlc_2_claim_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1939
1940         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1941                         // to_self output in A's revoked commitment
1942                         amount_satoshis: 1_000_000 - 100_000 - commitment_tx_fee - anchor_outputs_value,
1943                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1944                         amount_satoshis: 4_000,
1945                 }, Balance::ClaimableAwaitingConfirmations { // HTLC 2
1946                         amount_satoshis: claim_txn_2[0].output[0].value,
1947                         confirmation_height: htlc_2_claim_maturity,
1948                 }]),
1949                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1950
1951         connect_blocks(&nodes[1], 5);
1952         test_spendable_output(&nodes[1], &claim_txn_2[0], false);
1953
1954         assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1955                         // to_self output in A's revoked commitment
1956                         amount_satoshis: 1_000_000 - 100_000 - commitment_tx_fee - anchor_outputs_value,
1957                 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1958                         amount_satoshis: 4_000,
1959                 }]),
1960                 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1961
1962         if anchors {
1963                 mine_transactions(&nodes[1], &[&claim_txn_2[1], revoked_to_self_claim.as_ref().unwrap()]);
1964         } else {
1965                 mine_transaction(&nodes[1], &claim_txn_2[1]);
1966         }
1967         let rest_claim_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1968
1969         if anchors {
1970                 assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
1971                                 amount_satoshis: claim_txn_2[1].output[0].value,
1972                                 confirmation_height: rest_claim_maturity,
1973                         }, Balance::ClaimableAwaitingConfirmations {
1974                                 amount_satoshis: revoked_to_self_claim.as_ref().unwrap().output[0].value,
1975                                 confirmation_height: rest_claim_maturity,
1976                         }],
1977                         nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
1978         } else {
1979                 assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
1980                                 amount_satoshis: claim_txn_2[1].output[0].value,
1981                                 confirmation_height: rest_claim_maturity,
1982                         }],
1983                         nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
1984         }
1985
1986         assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); // We shouldn't fail the payment until we spend the output
1987
1988         connect_blocks(&nodes[1], 5);
1989         expect_payment_failed!(nodes[1], revoked_payment_hash, false);
1990         if anchors {
1991                 let events = nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events();
1992                 assert_eq!(events.len(), 2);
1993                 for (i, event) in events.into_iter().enumerate() {
1994                         if let Event::SpendableOutputs { outputs, .. } = event {
1995                                 assert_eq!(outputs.len(), 1);
1996                                 let spend_tx = nodes[1].keys_manager.backing.spend_spendable_outputs(
1997                                         &[&outputs[0]], Vec::new(), Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
1998                                         253, None, &Secp256k1::new()
1999                                 ).unwrap();
2000                                 check_spends!(spend_tx, if i == 0 { &claim_txn_2[1] } else { revoked_to_self_claim.as_ref().unwrap() });
2001                         } else { panic!(); }
2002                 }
2003         } else {
2004                 test_spendable_output(&nodes[1], &claim_txn_2[1], false);
2005         }
2006         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
2007
2008         // Ensure that even if we connect more blocks, potentially replaying the entire chain if we're
2009         // using `ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks`, we don't get new
2010         // monitor events or claimable balances.
2011         connect_blocks(&nodes[1], 6);
2012         connect_blocks(&nodes[1], 6);
2013         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2014         assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
2015 }
2016
2017 #[test]
2018 fn test_revoked_counterparty_aggregated_claims() {
2019         do_test_revoked_counterparty_aggregated_claims(false);
2020         do_test_revoked_counterparty_aggregated_claims(true);
2021 }
2022
2023 fn do_test_restored_packages_retry(check_old_monitor_retries_after_upgrade: bool) {
2024         // Tests that we'll retry packages that were previously timelocked after we've restored them.
2025         let chanmon_cfgs = create_chanmon_cfgs(2);
2026         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2027         let persister;
2028         let new_chain_monitor;
2029
2030         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2031         let node_deserialized;
2032
2033         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2034
2035         // Open a channel, lock in an HTLC, and immediately broadcast the commitment transaction. This
2036         // ensures that the HTLC timeout package is held until we reach its expiration height.
2037         let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 50_000_000);
2038         route_payment(&nodes[0], &[&nodes[1]], 10_000_000);
2039
2040         nodes[0].node.force_close_broadcasting_latest_txn(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
2041         check_added_monitors(&nodes[0], 1);
2042         check_closed_broadcast(&nodes[0], 1, true);
2043         check_closed_event!(&nodes[0], 1, ClosureReason::HolderForceClosed, false,
2044                  [nodes[1].node.get_our_node_id()], 100000);
2045
2046         let commitment_tx = {
2047                 let mut txn = nodes[0].tx_broadcaster.txn_broadcast();
2048                 assert_eq!(txn.len(), 1);
2049                 assert_eq!(txn[0].output.len(), 3);
2050                 check_spends!(txn[0], funding_tx);
2051                 txn.pop().unwrap()
2052         };
2053
2054         mine_transaction(&nodes[0], &commitment_tx);
2055         if nodes[0].connect_style.borrow().updates_best_block_first() {
2056                 let txn = nodes[0].tx_broadcaster.txn_broadcast();
2057                 assert_eq!(txn.len(), 1);
2058                 assert_eq!(txn[0].txid(), commitment_tx.txid());
2059         }
2060
2061         // Connect blocks until the HTLC's expiration is met, expecting a transaction broadcast.
2062         connect_blocks(&nodes[0], TEST_FINAL_CLTV);
2063         let htlc_timeout_tx = {
2064                 let mut txn = nodes[0].tx_broadcaster.txn_broadcast();
2065                 assert_eq!(txn.len(), 1);
2066                 check_spends!(txn[0], commitment_tx);
2067                 txn.pop().unwrap()
2068         };
2069
2070         // Check that we can still rebroadcast these packages/transactions if we're upgrading from an
2071         // old `ChannelMonitor` that did not exercise said rebroadcasting logic.
2072         if check_old_monitor_retries_after_upgrade {
2073                 let serialized_monitor = <Vec<u8>>::from_hex(
2074                         "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",
2075                 ).unwrap();
2076                 reload_node!(nodes[0], &nodes[0].node.encode(), &[&serialized_monitor], persister, new_chain_monitor, node_deserialized);
2077         }
2078
2079         // Connecting more blocks should result in the HTLC transactions being rebroadcast.
2080         connect_blocks(&nodes[0], 6);
2081         if check_old_monitor_retries_after_upgrade {
2082                 check_added_monitors(&nodes[0], 1);
2083         }
2084         {
2085                 let txn = nodes[0].tx_broadcaster.txn_broadcast();
2086                 if !nodes[0].connect_style.borrow().skips_blocks() {
2087                         assert_eq!(txn.len(), 6);
2088                 } else {
2089                         assert!(txn.len() < 6);
2090                 }
2091                 for tx in txn {
2092                         assert_eq!(tx.input.len(), htlc_timeout_tx.input.len());
2093                         assert_eq!(tx.output.len(), htlc_timeout_tx.output.len());
2094                         assert_eq!(tx.input[0].previous_output, htlc_timeout_tx.input[0].previous_output);
2095                         assert_eq!(tx.output[0], htlc_timeout_tx.output[0]);
2096                 }
2097         }
2098 }
2099
2100 #[test]
2101 fn test_restored_packages_retry() {
2102         do_test_restored_packages_retry(false);
2103         do_test_restored_packages_retry(true);
2104 }
2105
2106 fn do_test_monitor_rebroadcast_pending_claims(anchors: bool) {
2107         // Test that we will retry broadcasting pending claims for a force-closed channel on every
2108         // `ChainMonitor::rebroadcast_pending_claims` call.
2109         let mut chanmon_cfgs = create_chanmon_cfgs(2);
2110         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2111         let mut config = test_default_channel_config();
2112         if anchors {
2113                 config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
2114                 config.manually_accept_inbound_channels = true;
2115         }
2116         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(config), Some(config)]);
2117         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2118
2119         let (_, _, _, chan_id, funding_tx) = create_chan_between_nodes_with_value(
2120                 &nodes[0], &nodes[1], 1_000_000, 500_000_000
2121         );
2122         const HTLC_AMT_MSAT: u64 = 1_000_000;
2123         const HTLC_AMT_SAT: u64 = HTLC_AMT_MSAT / 1000;
2124         route_payment(&nodes[0], &[&nodes[1]], HTLC_AMT_MSAT);
2125
2126         let htlc_expiry = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1;
2127
2128         let commitment_txn = get_local_commitment_txn!(&nodes[0], &chan_id);
2129         assert_eq!(commitment_txn.len(), if anchors { 1 /* commitment tx only */} else { 2 /* commitment and htlc timeout tx */ });
2130         check_spends!(&commitment_txn[0], &funding_tx);
2131         mine_transaction(&nodes[0], &commitment_txn[0]);
2132         check_closed_broadcast!(&nodes[0], true);
2133         check_closed_event!(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed,
2134                  false, [nodes[1].node.get_our_node_id()], 1000000);
2135         check_added_monitors(&nodes[0], 1);
2136
2137         let coinbase_tx = Transaction {
2138                 version: 2,
2139                 lock_time: LockTime::ZERO,
2140                 input: vec![TxIn { ..Default::default() }],
2141                 output: vec![TxOut { // UTXO to attach fees to `htlc_tx` on anchors
2142                         value: Amount::ONE_BTC.to_sat(),
2143                         script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
2144                 }],
2145         };
2146         nodes[0].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, coinbase_tx.output[0].value);
2147
2148         // Set up a helper closure we'll use throughout our test. We should only expect retries without
2149         // bumps if fees have not increased after a block has been connected (assuming the height timer
2150         // re-evaluates at every block) or after `ChainMonitor::rebroadcast_pending_claims` is called.
2151         let mut prev_htlc_tx_feerate = None;
2152         let mut check_htlc_retry = |should_retry: bool, should_bump: bool| -> Option<Transaction> {
2153                 let (htlc_tx, htlc_tx_feerate) = if anchors {
2154                         assert!(nodes[0].tx_broadcaster.txn_broadcast().is_empty());
2155                         let events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
2156                         assert_eq!(events.len(), if should_retry { 1 } else { 0 });
2157                         if !should_retry {
2158                                 return None;
2159                         }
2160                         match &events[0] {
2161                                 Event::BumpTransaction(event) => {
2162                                         nodes[0].bump_tx_handler.handle_event(&event);
2163                                         let mut txn = nodes[0].tx_broadcaster.unique_txn_broadcast();
2164                                         assert_eq!(txn.len(), 1);
2165                                         let htlc_tx = txn.pop().unwrap();
2166                                         check_spends!(&htlc_tx, &commitment_txn[0], &coinbase_tx);
2167                                         let htlc_tx_fee = HTLC_AMT_SAT + coinbase_tx.output[0].value -
2168                                                 htlc_tx.output.iter().map(|output| output.value).sum::<u64>();
2169                                         let htlc_tx_weight = htlc_tx.weight().to_wu();
2170                                         (htlc_tx, compute_feerate_sat_per_1000_weight(htlc_tx_fee, htlc_tx_weight))
2171                                 }
2172                                 _ => panic!("Unexpected event"),
2173                         }
2174                 } else {
2175                         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2176                         let mut txn = nodes[0].tx_broadcaster.txn_broadcast();
2177                         assert_eq!(txn.len(), if should_retry { 1 } else { 0 });
2178                         if !should_retry {
2179                                 return None;
2180                         }
2181                         let htlc_tx = txn.pop().unwrap();
2182                         check_spends!(htlc_tx, commitment_txn[0]);
2183                         let htlc_tx_fee = HTLC_AMT_SAT - htlc_tx.output[0].value;
2184                         let htlc_tx_weight = htlc_tx.weight().to_wu();
2185                         (htlc_tx, compute_feerate_sat_per_1000_weight(htlc_tx_fee, htlc_tx_weight))
2186                 };
2187                 if should_bump {
2188                         assert!(htlc_tx_feerate > prev_htlc_tx_feerate.take().unwrap());
2189                 } else if let Some(prev_feerate) = prev_htlc_tx_feerate.take() {
2190                         assert_eq!(htlc_tx_feerate, prev_feerate);
2191                 }
2192                 prev_htlc_tx_feerate = Some(htlc_tx_feerate);
2193                 Some(htlc_tx)
2194         };
2195
2196         // Connect blocks up to one before the HTLC expires. This should not result in a claim/retry.
2197         connect_blocks(&nodes[0], htlc_expiry - nodes[0].best_block_info().1 - 1);
2198         check_htlc_retry(false, false);
2199
2200         // Connect one more block, producing our first claim.
2201         connect_blocks(&nodes[0], 1);
2202         check_htlc_retry(true, false);
2203
2204         // Connect one more block, expecting a retry with a fee bump. Unfortunately, we cannot bump HTLC
2205         // transactions pre-anchors.
2206         connect_blocks(&nodes[0], 1);
2207         check_htlc_retry(true, anchors);
2208
2209         // Trigger a call and we should have another retry, but without a bump.
2210         nodes[0].chain_monitor.chain_monitor.rebroadcast_pending_claims();
2211         check_htlc_retry(true, false);
2212
2213         // Double the feerate and trigger a call, expecting a fee-bumped retry.
2214         *nodes[0].fee_estimator.sat_per_kw.lock().unwrap() *= 2;
2215         nodes[0].chain_monitor.chain_monitor.rebroadcast_pending_claims();
2216         check_htlc_retry(true, anchors);
2217
2218         // Connect one more block, expecting a retry with a fee bump. Unfortunately, we cannot bump HTLC
2219         // transactions pre-anchors.
2220         connect_blocks(&nodes[0], 1);
2221         let htlc_tx = check_htlc_retry(true, anchors).unwrap();
2222
2223         // Mine the HTLC transaction to ensure we don't retry claims while they're confirmed.
2224         mine_transaction(&nodes[0], &htlc_tx);
2225         // If we have a `ConnectStyle` that advertises the new block first without the transactions,
2226         // we'll receive an extra bumped claim.
2227         if nodes[0].connect_style.borrow().updates_best_block_first() {
2228                 nodes[0].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, coinbase_tx.output[0].value);
2229                 nodes[0].wallet_source.remove_utxo(bitcoin::OutPoint { txid: htlc_tx.txid(), vout: 1 });
2230                 check_htlc_retry(true, anchors);
2231         }
2232         nodes[0].chain_monitor.chain_monitor.rebroadcast_pending_claims();
2233         check_htlc_retry(false, false);
2234 }
2235
2236 #[test]
2237 fn test_monitor_timer_based_claim() {
2238         do_test_monitor_rebroadcast_pending_claims(false);
2239         do_test_monitor_rebroadcast_pending_claims(true);
2240 }
2241
2242 #[test]
2243 fn test_yield_anchors_events() {
2244         // Tests that two parties supporting anchor outputs can open a channel, route payments over
2245         // it, and finalize its resolution uncooperatively. Once the HTLCs are locked in, one side will
2246         // force close once the HTLCs expire. The force close should stem from an event emitted by LDK,
2247         // allowing the consumer to provide additional fees to the commitment transaction to be
2248         // broadcast. Once the commitment transaction confirms, events for the HTLC resolution should be
2249         // emitted by LDK, such that the consumer can attach fees to the zero fee HTLC transactions.
2250         let mut chanmon_cfgs = create_chanmon_cfgs(2);
2251         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2252         let mut anchors_config = UserConfig::default();
2253         anchors_config.channel_handshake_config.announced_channel = true;
2254         anchors_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
2255         anchors_config.manually_accept_inbound_channels = true;
2256         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(anchors_config), Some(anchors_config)]);
2257         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2258
2259         let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(
2260                 &nodes, 0, 1, 1_000_000, 500_000_000
2261         );
2262         let (payment_preimage_1, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000);
2263         let (payment_preimage_2, payment_hash_2, ..) = route_payment(&nodes[1], &[&nodes[0]], 2_000_000);
2264
2265         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
2266         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
2267
2268         *nodes[0].fee_estimator.sat_per_kw.lock().unwrap() *= 2;
2269
2270         connect_blocks(&nodes[0], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1);
2271         assert!(nodes[0].tx_broadcaster.txn_broadcast().is_empty());
2272
2273         connect_blocks(&nodes[1], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1);
2274         {
2275                 let txn = nodes[1].tx_broadcaster.txn_broadcast();
2276                 assert_eq!(txn.len(), 1);
2277                 check_spends!(txn[0], funding_tx);
2278         }
2279
2280         get_monitor!(nodes[0], chan_id).provide_payment_preimage(
2281                 &payment_hash_2, &payment_preimage_2, &node_cfgs[0].tx_broadcaster,
2282                 &LowerBoundedFeeEstimator::new(node_cfgs[0].fee_estimator), &nodes[0].logger
2283         );
2284         get_monitor!(nodes[1], chan_id).provide_payment_preimage(
2285                 &payment_hash_1, &payment_preimage_1, &node_cfgs[1].tx_broadcaster,
2286                 &LowerBoundedFeeEstimator::new(node_cfgs[1].fee_estimator), &nodes[1].logger
2287         );
2288
2289         let mut holder_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
2290         assert_eq!(holder_events.len(), 1);
2291         let (commitment_tx, anchor_tx) = match holder_events.pop().unwrap() {
2292                 Event::BumpTransaction(event) => {
2293                         let coinbase_tx = Transaction {
2294                                 version: 2,
2295                                 lock_time: LockTime::ZERO,
2296                                 input: vec![TxIn { ..Default::default() }],
2297                                 output: vec![TxOut { // UTXO to attach fees to `anchor_tx`
2298                                         value: Amount::ONE_BTC.to_sat(),
2299                                         script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
2300                                 }],
2301                         };
2302                         nodes[0].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, coinbase_tx.output[0].value);
2303                         nodes[0].bump_tx_handler.handle_event(&event);
2304                         let mut txn = nodes[0].tx_broadcaster.unique_txn_broadcast();
2305                         assert_eq!(txn.len(), 2);
2306                         let anchor_tx = txn.pop().unwrap();
2307                         let commitment_tx = txn.pop().unwrap();
2308                         check_spends!(commitment_tx, funding_tx);
2309                         check_spends!(anchor_tx, coinbase_tx, commitment_tx);
2310                         (commitment_tx, anchor_tx)
2311                 },
2312                 _ => panic!("Unexpected event"),
2313         };
2314
2315         assert_eq!(commitment_tx.output[2].value, 1_000); // HTLC A -> B
2316         assert_eq!(commitment_tx.output[3].value, 2_000); // HTLC B -> A
2317
2318         mine_transactions(&nodes[0], &[&commitment_tx, &anchor_tx]);
2319         check_added_monitors!(nodes[0], 1);
2320         mine_transactions(&nodes[1], &[&commitment_tx, &anchor_tx]);
2321         check_added_monitors!(nodes[1], 1);
2322
2323         {
2324                 let mut txn = nodes[1].tx_broadcaster.unique_txn_broadcast();
2325                 assert_eq!(txn.len(), if nodes[1].connect_style.borrow().updates_best_block_first() { 3 } else { 2 });
2326
2327                 let htlc_preimage_tx = txn.pop().unwrap();
2328                 assert_eq!(htlc_preimage_tx.input.len(), 1);
2329                 assert_eq!(htlc_preimage_tx.input[0].previous_output.vout, 3);
2330                 check_spends!(htlc_preimage_tx, commitment_tx);
2331
2332                 let htlc_timeout_tx = txn.pop().unwrap();
2333                 assert_eq!(htlc_timeout_tx.input.len(), 1);
2334                 assert_eq!(htlc_timeout_tx.input[0].previous_output.vout, 2);
2335                 check_spends!(htlc_timeout_tx, commitment_tx);
2336
2337                 if let Some(commitment_tx) = txn.pop() {
2338                         check_spends!(commitment_tx, funding_tx);
2339                 }
2340         }
2341
2342         let mut holder_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
2343         // Certain block `ConnectStyle`s cause an extra `ChannelClose` event to be emitted since the
2344         // best block is updated before the confirmed transactions are notified.
2345         if nodes[0].connect_style.borrow().updates_best_block_first() {
2346                 assert_eq!(holder_events.len(), 3);
2347                 if let Event::BumpTransaction(BumpTransactionEvent::ChannelClose { .. }) = holder_events.remove(0) {}
2348                 else { panic!("unexpected event"); }
2349         } else {
2350                 assert_eq!(holder_events.len(), 2);
2351         }
2352         let mut htlc_txs = Vec::with_capacity(2);
2353         for event in holder_events {
2354                 match event {
2355                         Event::BumpTransaction(event) => {
2356                                 nodes[0].bump_tx_handler.handle_event(&event);
2357                                 let mut txn = nodes[0].tx_broadcaster.unique_txn_broadcast();
2358                                 assert_eq!(txn.len(), 1);
2359                                 let htlc_tx = txn.pop().unwrap();
2360                                 check_spends!(htlc_tx, commitment_tx, anchor_tx);
2361                                 htlc_txs.push(htlc_tx);
2362                         },
2363                         _ => panic!("Unexpected event"),
2364                 }
2365         }
2366
2367         mine_transactions(&nodes[0], &[&htlc_txs[0], &htlc_txs[1]]);
2368         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
2369
2370         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2371
2372         connect_blocks(&nodes[0], BREAKDOWN_TIMEOUT as u32);
2373
2374         let holder_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
2375         assert_eq!(holder_events.len(), 3);
2376         for event in holder_events {
2377                 match event {
2378                         Event::SpendableOutputs { .. } => {},
2379                         _ => panic!("Unexpected event"),
2380                 }
2381         }
2382
2383         // Clear the remaining events as they're not relevant to what we're testing.
2384         nodes[0].node.get_and_clear_pending_events();
2385         nodes[1].node.get_and_clear_pending_events();
2386         nodes[0].node.get_and_clear_pending_msg_events();
2387         nodes[1].node.get_and_clear_pending_msg_events();
2388 }
2389
2390 #[test]
2391 fn test_anchors_aggregated_revoked_htlc_tx() {
2392         // Test that `ChannelMonitor`s can properly detect and claim funds from a counterparty claiming
2393         // multiple HTLCs from multiple channels in a single transaction via the success path from a
2394         // revoked commitment.
2395         let secp = Secp256k1::new();
2396         let mut chanmon_cfgs = create_chanmon_cfgs(2);
2397         // Required to sign a revoked commitment transaction
2398         chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
2399         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2400         let bob_persister;
2401         let bob_chain_monitor;
2402
2403         let mut anchors_config = UserConfig::default();
2404         anchors_config.channel_handshake_config.announced_channel = true;
2405         anchors_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
2406         anchors_config.manually_accept_inbound_channels = true;
2407         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(anchors_config), Some(anchors_config)]);
2408         let bob_deserialized;
2409
2410         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2411
2412         let chan_a = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 20_000_000);
2413         let chan_b = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 20_000_000);
2414
2415         // Serialize Bob with the initial state of both channels, which we'll use later.
2416         let bob_serialized = nodes[1].node.encode();
2417
2418         // Route two payments for each channel from Alice to Bob to lock in the HTLCs.
2419         let payment_a = route_payment(&nodes[0], &[&nodes[1]], 50_000_000);
2420         let payment_b = route_payment(&nodes[0], &[&nodes[1]], 50_000_000);
2421         let payment_c = route_payment(&nodes[0], &[&nodes[1]], 50_000_000);
2422         let payment_d = route_payment(&nodes[0], &[&nodes[1]], 50_000_000);
2423
2424         // Serialize Bob's monitors with the HTLCs locked in. We'll restart Bob later on with the state
2425         // at this point such that he broadcasts a revoked commitment transaction with the HTLCs
2426         // present.
2427         let bob_serialized_monitor_a = get_monitor!(nodes[1], chan_a.2).encode();
2428         let bob_serialized_monitor_b = get_monitor!(nodes[1], chan_b.2).encode();
2429
2430         // Bob claims all the HTLCs...
2431         claim_payment(&nodes[0], &[&nodes[1]], payment_a.0);
2432         claim_payment(&nodes[0], &[&nodes[1]], payment_b.0);
2433         claim_payment(&nodes[0], &[&nodes[1]], payment_c.0);
2434         claim_payment(&nodes[0], &[&nodes[1]], payment_d.0);
2435
2436         // ...and sends one back through each channel such that he has a motive to broadcast his
2437         // revoked state.
2438         send_payment(&nodes[1], &[&nodes[0]], 30_000_000);
2439         send_payment(&nodes[1], &[&nodes[0]], 30_000_000);
2440
2441         // Restart Bob with the revoked state and provide the HTLC preimages he claimed.
2442         reload_node!(
2443                 nodes[1], anchors_config, bob_serialized, &[&bob_serialized_monitor_a, &bob_serialized_monitor_b],
2444                 bob_persister, bob_chain_monitor, bob_deserialized
2445         );
2446         for chan_id in [chan_a.2, chan_b.2].iter() {
2447                 let monitor = get_monitor!(nodes[1], chan_id);
2448                 for payment in [payment_a, payment_b, payment_c, payment_d].iter() {
2449                         monitor.provide_payment_preimage(
2450                                 &payment.1, &payment.0, &node_cfgs[1].tx_broadcaster,
2451                                 &LowerBoundedFeeEstimator::new(node_cfgs[1].fee_estimator), &nodes[1].logger
2452                         );
2453                 }
2454         }
2455
2456         // Bob force closes by restarting with the outdated state, prompting the ChannelMonitors to
2457         // broadcast the latest commitment transaction known to them, which in our case is the one with
2458         // the HTLCs still pending.
2459         *nodes[1].fee_estimator.sat_per_kw.lock().unwrap() *= 2;
2460         nodes[1].node.timer_tick_occurred();
2461         check_added_monitors(&nodes[1], 2);
2462         check_closed_event!(&nodes[1], 2, ClosureReason::OutdatedChannelManager, [nodes[0].node.get_our_node_id(); 2], 1000000);
2463
2464         // Bob should now receive two events to bump his revoked commitment transaction fees.
2465         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2466         let events = nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events();
2467         assert_eq!(events.len(), 2);
2468         let mut revoked_commitment_txs = Vec::with_capacity(events.len());
2469         let mut anchor_txs = Vec::with_capacity(events.len());
2470         for (idx, event) in events.into_iter().enumerate() {
2471                 let utxo_value = Amount::ONE_BTC.to_sat() * (idx + 1) as u64;
2472                 let coinbase_tx = Transaction {
2473                         version: 2,
2474                         lock_time: LockTime::ZERO,
2475                         input: vec![TxIn { ..Default::default() }],
2476                         output: vec![TxOut { // UTXO to attach fees to `anchor_tx`
2477                                 value: utxo_value,
2478                                 script_pubkey: nodes[1].wallet_source.get_change_script().unwrap(),
2479                         }],
2480                 };
2481                 nodes[1].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, utxo_value);
2482                 match event {
2483                         Event::BumpTransaction(event) => nodes[1].bump_tx_handler.handle_event(&event),
2484                         _ => panic!("Unexpected event"),
2485                 };
2486                 let txn = nodes[1].tx_broadcaster.txn_broadcast();
2487                 assert_eq!(txn.len(), 2);
2488                 assert_eq!(txn[0].output.len(), 6); // 2 HTLC outputs + 1 to_self output + 1 to_remote output + 2 anchor outputs
2489                 if txn[0].input[0].previous_output.txid == chan_a.3.txid() {
2490                         check_spends!(&txn[0], &chan_a.3);
2491                 } else {
2492                         check_spends!(&txn[0], &chan_b.3);
2493                 }
2494                 let (commitment_tx, anchor_tx) = (&txn[0], &txn[1]);
2495                 check_spends!(anchor_tx, coinbase_tx, commitment_tx);
2496
2497                 revoked_commitment_txs.push(commitment_tx.clone());
2498                 anchor_txs.push(anchor_tx.clone());
2499         };
2500
2501         for node in &nodes {
2502                 mine_transactions(node, &[&revoked_commitment_txs[0], &anchor_txs[0], &revoked_commitment_txs[1], &anchor_txs[1]]);
2503         }
2504         check_added_monitors!(&nodes[0], 2);
2505         check_closed_broadcast(&nodes[0], 2, true);
2506         check_closed_event!(&nodes[0], 2, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id(); 2], 1000000);
2507
2508         // Alice should detect the confirmed revoked commitments, and attempt to claim all of the
2509         // revoked outputs.
2510         {
2511                 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
2512                 assert_eq!(txn.len(), 4);
2513
2514                 let (revoked_htlc_claim_a, revoked_htlc_claim_b) = if txn[0].input[0].previous_output.txid == revoked_commitment_txs[0].txid() {
2515                         (if txn[0].input.len() == 2 { &txn[0] } else { &txn[1] }, if txn[2].input.len() == 2 { &txn[2] } else { &txn[3] })
2516                 } else {
2517                         (if txn[2].input.len() == 2 { &txn[2] } else { &txn[3] }, if txn[0].input.len() == 2 { &txn[0] } else { &txn[1] })
2518                 };
2519
2520                 assert_eq!(revoked_htlc_claim_a.input.len(), 2); // Spends both HTLC outputs
2521                 assert_eq!(revoked_htlc_claim_a.output.len(), 1);
2522                 check_spends!(revoked_htlc_claim_a, revoked_commitment_txs[0]);
2523                 assert_eq!(revoked_htlc_claim_b.input.len(), 2); // Spends both HTLC outputs
2524                 assert_eq!(revoked_htlc_claim_b.output.len(), 1);
2525                 check_spends!(revoked_htlc_claim_b, revoked_commitment_txs[1]);
2526         }
2527
2528         // Since Bob was able to confirm his revoked commitment, he'll now try to claim the HTLCs
2529         // through the success path.
2530         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2531         let mut events = nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events();
2532         // Certain block `ConnectStyle`s cause an extra `ChannelClose` event to be emitted since the
2533         // best block is updated before the confirmed transactions are notified.
2534         match *nodes[1].connect_style.borrow() {
2535                 ConnectStyle::BestBlockFirst|ConnectStyle::BestBlockFirstReorgsOnlyTip|ConnectStyle::BestBlockFirstSkippingBlocks => {
2536                         assert_eq!(events.len(), 4);
2537                         if let Event::BumpTransaction(BumpTransactionEvent::ChannelClose { .. }) = events.remove(0) {}
2538                         else { panic!("unexpected event"); }
2539                         if let Event::BumpTransaction(BumpTransactionEvent::ChannelClose { .. }) = events.remove(1) {}
2540                         else { panic!("unexpected event"); }
2541
2542                 },
2543                 _ => assert_eq!(events.len(), 2),
2544         };
2545         let htlc_tx = {
2546                 let secret_key = SecretKey::from_slice(&[1; 32]).unwrap();
2547                 let public_key = PublicKey::new(secret_key.public_key(&secp));
2548                 let fee_utxo_script = ScriptBuf::new_v0_p2wpkh(&public_key.wpubkey_hash().unwrap());
2549                 let coinbase_tx = Transaction {
2550                         version: 2,
2551                         lock_time: LockTime::ZERO,
2552                         input: vec![TxIn { ..Default::default() }],
2553                         output: vec![TxOut { // UTXO to attach fees to `htlc_tx`
2554                                 value: Amount::ONE_BTC.to_sat(),
2555                                 script_pubkey: fee_utxo_script.clone(),
2556                         }],
2557                 };
2558                 let mut htlc_tx = Transaction {
2559                         version: 2,
2560                         lock_time: LockTime::ZERO,
2561                         input: vec![TxIn { // Fee input
2562                                 previous_output: bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 },
2563                                 ..Default::default()
2564                         }],
2565                         output: vec![TxOut { // Fee input change
2566                                 value: coinbase_tx.output[0].value / 2 ,
2567                                 script_pubkey: ScriptBuf::new_op_return(&[]),
2568                         }],
2569                 };
2570                 let mut descriptors = Vec::with_capacity(4);
2571                 for event in events {
2572                         // We don't use the `BumpTransactionEventHandler` here because it does not support
2573                         // creating one transaction from multiple `HTLCResolution` events.
2574                         if let Event::BumpTransaction(BumpTransactionEvent::HTLCResolution { mut htlc_descriptors, tx_lock_time, .. }) = event {
2575                                 assert_eq!(htlc_descriptors.len(), 2);
2576                                 for htlc_descriptor in &htlc_descriptors {
2577                                         assert!(!htlc_descriptor.htlc.offered);
2578                                         htlc_tx.input.push(htlc_descriptor.unsigned_tx_input());
2579                                         htlc_tx.output.push(htlc_descriptor.tx_output(&secp));
2580                                 }
2581                                 descriptors.append(&mut htlc_descriptors);
2582                                 htlc_tx.lock_time = tx_lock_time;
2583                         } else {
2584                                 panic!("Unexpected event");
2585                         }
2586                 }
2587                 for (idx, htlc_descriptor) in descriptors.into_iter().enumerate() {
2588                         let htlc_input_idx = idx + 1;
2589                         let signer = htlc_descriptor.derive_channel_signer(&nodes[1].keys_manager);
2590                         let our_sig = signer.sign_holder_htlc_transaction(&htlc_tx, htlc_input_idx, &htlc_descriptor, &secp).unwrap();
2591                         let witness_script = htlc_descriptor.witness_script(&secp);
2592                         htlc_tx.input[htlc_input_idx].witness = htlc_descriptor.tx_input_witness(&our_sig, &witness_script);
2593                 }
2594                 let fee_utxo_sig = {
2595                         let witness_script = ScriptBuf::new_p2pkh(&public_key.pubkey_hash());
2596                         let sighash = hash_to_message!(&SighashCache::new(&htlc_tx).segwit_signature_hash(
2597                                 0, &witness_script, coinbase_tx.output[0].value, EcdsaSighashType::All
2598                         ).unwrap()[..]);
2599                         let sig = sign(&secp, &sighash, &secret_key);
2600                         let mut sig = sig.serialize_der().to_vec();
2601                         sig.push(EcdsaSighashType::All as u8);
2602                         sig
2603                 };
2604                 htlc_tx.input[0].witness = Witness::from_slice(&[fee_utxo_sig, public_key.to_bytes()]);
2605                 check_spends!(htlc_tx, coinbase_tx, revoked_commitment_txs[0], revoked_commitment_txs[1]);
2606                 htlc_tx
2607         };
2608
2609         for node in &nodes {
2610                 mine_transaction(node, &htlc_tx);
2611         }
2612
2613         // Alice should see that Bob is trying to claim to HTLCs, so she should now try to claim them at
2614         // the second level instead.
2615         let revoked_claim_transactions = {
2616                 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
2617                 assert_eq!(txn.len(), 2);
2618
2619                 let revoked_htlc_claims = txn.iter().filter(|tx|
2620                         tx.input.len() == 2 &&
2621                         tx.output.len() == 1 &&
2622                         tx.input[0].previous_output.txid == htlc_tx.txid()
2623                 ).collect::<Vec<_>>();
2624                 assert_eq!(revoked_htlc_claims.len(), 2);
2625                 for revoked_htlc_claim in revoked_htlc_claims {
2626                         check_spends!(revoked_htlc_claim, htlc_tx);
2627                 }
2628
2629                 let mut revoked_claim_transaction_map = new_hash_map();
2630                 for current_tx in txn.into_iter() {
2631                         revoked_claim_transaction_map.insert(current_tx.txid(), current_tx);
2632                 }
2633                 revoked_claim_transaction_map
2634         };
2635         for node in &nodes {
2636                 mine_transactions(node, &revoked_claim_transactions.values().collect::<Vec<_>>());
2637         }
2638
2639
2640         // Connect one block to make sure the HTLC events are not yielded while ANTI_REORG_DELAY has not
2641         // been reached.
2642         connect_blocks(&nodes[0], 1);
2643         connect_blocks(&nodes[1], 1);
2644
2645         assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2646         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2647
2648         // Connect the remaining blocks to reach ANTI_REORG_DELAY.
2649         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
2650         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 2);
2651
2652         assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
2653         let spendable_output_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
2654         assert_eq!(spendable_output_events.len(), 4);
2655         for event in spendable_output_events {
2656                 if let Event::SpendableOutputs { outputs, channel_id } = event {
2657                         assert_eq!(outputs.len(), 1);
2658                         assert!(vec![chan_b.2, chan_a.2].contains(&channel_id.unwrap()));
2659                         let spend_tx = nodes[0].keys_manager.backing.spend_spendable_outputs(
2660                                 &[&outputs[0]], Vec::new(), ScriptBuf::new_op_return(&[]), 253, None, &Secp256k1::new(),
2661                         ).unwrap();
2662
2663                         if let SpendableOutputDescriptor::StaticPaymentOutput(_) = &outputs[0] {
2664                                 check_spends!(spend_tx, &revoked_commitment_txs[0], &revoked_commitment_txs[1]);
2665                         } else {
2666                                 check_spends!(spend_tx, revoked_claim_transactions.get(&spend_tx.input[0].previous_output.txid).unwrap());
2667                         }
2668                 } else {
2669                         panic!("unexpected event");
2670                 }
2671         }
2672
2673         assert!(nodes[0].node.list_channels().is_empty());
2674         assert!(nodes[1].node.list_channels().is_empty());
2675         // On the Alice side, the individual to_self_claim are still pending confirmation.
2676         assert_eq!(nodes[0].chain_monitor.chain_monitor.get_claimable_balances(&[]).len(), 2);
2677         // TODO: From Bob's PoV, he still thinks he can claim the outputs from his revoked commitment.
2678         // This needs to be fixed before we enable pruning `ChannelMonitor`s once they don't have any
2679         // balances to claim.
2680         //
2681         // The 6 claimable balances correspond to his `to_self` outputs and the 2 HTLC outputs in each
2682         // revoked commitment which Bob has the preimage for.
2683         assert_eq!(nodes[1].chain_monitor.chain_monitor.get_claimable_balances(&[]).len(), 6);
2684 }
2685
2686 fn do_test_anchors_monitor_fixes_counterparty_payment_script_on_reload(confirm_commitment_before_reload: bool) {
2687         // Tests that we'll fix a ChannelMonitor's `counterparty_payment_script` for an anchor outputs
2688         // channel upon deserialization.
2689         let chanmon_cfgs = create_chanmon_cfgs(2);
2690         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2691         let persister;
2692         let chain_monitor;
2693         let mut user_config = test_default_channel_config();
2694         user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
2695         user_config.manually_accept_inbound_channels = true;
2696         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
2697         let node_deserialized;
2698         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2699
2700         let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 50_000_000);
2701
2702         // Set the monitor's `counterparty_payment_script` to a dummy P2WPKH script.
2703         let secp = Secp256k1::new();
2704         let privkey = bitcoin::PrivateKey::from_slice(&[1; 32], bitcoin::Network::Testnet).unwrap();
2705         let pubkey = bitcoin::PublicKey::from_private_key(&secp, &privkey);
2706         let p2wpkh_script = ScriptBuf::new_v0_p2wpkh(&pubkey.wpubkey_hash().unwrap());
2707         get_monitor!(nodes[1], chan_id).set_counterparty_payment_script(p2wpkh_script.clone());
2708         assert_eq!(get_monitor!(nodes[1], chan_id).get_counterparty_payment_script(), p2wpkh_script);
2709
2710         // Confirm the counterparty's commitment and reload the monitor (either before or after) such
2711         // that we arrive at the correct `counterparty_payment_script` after the reload.
2712         nodes[0].node.force_close_broadcasting_latest_txn(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
2713         check_added_monitors(&nodes[0], 1);
2714         check_closed_broadcast(&nodes[0], 1, true);
2715         check_closed_event!(&nodes[0], 1, ClosureReason::HolderForceClosed, false,
2716                  [nodes[1].node.get_our_node_id()], 100000);
2717
2718         let commitment_tx = {
2719                 let mut txn = nodes[0].tx_broadcaster.unique_txn_broadcast();
2720                 assert_eq!(txn.len(), 1);
2721                 assert_eq!(txn[0].output.len(), 4);
2722                 check_spends!(txn[0], funding_tx);
2723                 txn.pop().unwrap()
2724         };
2725
2726         mine_transaction(&nodes[0], &commitment_tx);
2727         let commitment_tx_conf_height = if confirm_commitment_before_reload {
2728                 // We should expect our round trip serialization check to fail as we're writing the monitor
2729                 // with the incorrect P2WPKH script but reading it with the correct P2WSH script.
2730                 *nodes[1].chain_monitor.expect_monitor_round_trip_fail.lock().unwrap() = Some(chan_id);
2731                 let commitment_tx_conf_height = block_from_scid(mine_transaction(&nodes[1], &commitment_tx));
2732                 let serialized_monitor = get_monitor!(nodes[1], chan_id).encode();
2733                 reload_node!(nodes[1], user_config, &nodes[1].node.encode(), &[&serialized_monitor], persister, chain_monitor, node_deserialized);
2734                 commitment_tx_conf_height
2735         } else {
2736                 let serialized_monitor = get_monitor!(nodes[1], chan_id).encode();
2737                 reload_node!(nodes[1], user_config, &nodes[1].node.encode(), &[&serialized_monitor], persister, chain_monitor, node_deserialized);
2738                 let commitment_tx_conf_height = block_from_scid(mine_transaction(&nodes[1], &commitment_tx));
2739                 check_added_monitors(&nodes[1], 1);
2740                 check_closed_broadcast(&nodes[1], 1, true);
2741                 commitment_tx_conf_height
2742         };
2743         check_closed_event!(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, false,
2744                  [nodes[0].node.get_our_node_id()], 100000);
2745         assert!(get_monitor!(nodes[1], chan_id).get_counterparty_payment_script().is_v0_p2wsh());
2746
2747         connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
2748         connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
2749
2750         if confirm_commitment_before_reload {
2751                 // If we saw the commitment before our `counterparty_payment_script` was fixed, we'll never
2752                 // get the spendable output event for the `to_remote` output, so we'll need to get it
2753                 // manually via `get_spendable_outputs`.
2754                 check_added_monitors(&nodes[1], 1);
2755                 let outputs = get_monitor!(nodes[1], chan_id).get_spendable_outputs(&commitment_tx, commitment_tx_conf_height);
2756                 assert_eq!(outputs.len(), 1);
2757                 let spend_tx = nodes[1].keys_manager.backing.spend_spendable_outputs(
2758                         &[&outputs[0]], Vec::new(), Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
2759                         253, None, &secp
2760                 ).unwrap();
2761                 check_spends!(spend_tx, &commitment_tx);
2762         } else {
2763                 test_spendable_output(&nodes[1], &commitment_tx, false);
2764         }
2765 }
2766
2767 #[test]
2768 fn test_anchors_monitor_fixes_counterparty_payment_script_on_reload() {
2769         do_test_anchors_monitor_fixes_counterparty_payment_script_on_reload(false);
2770         do_test_anchors_monitor_fixes_counterparty_payment_script_on_reload(true);
2771 }
2772
2773 #[cfg(not(feature = "_test_vectors"))]
2774 fn do_test_monitor_claims_with_random_signatures(anchors: bool, confirm_counterparty_commitment: bool) {
2775         // Tests that our monitor claims will always use fresh random signatures (ensuring a unique
2776         // wtxid) to prevent certain classes of transaction replacement at the bitcoin P2P layer.
2777         let chanmon_cfgs = create_chanmon_cfgs(2);
2778         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2779         let mut user_config = test_default_channel_config();
2780         if anchors {
2781                 user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
2782                 user_config.manually_accept_inbound_channels = true;
2783         }
2784         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config), Some(user_config)]);
2785         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2786
2787         let coinbase_tx = Transaction {
2788                 version: 2,
2789                 lock_time: LockTime::ZERO,
2790                 input: vec![TxIn { ..Default::default() }],
2791                 output: vec![
2792                         TxOut {
2793                                 value: Amount::ONE_BTC.to_sat(),
2794                                 script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
2795                         },
2796                 ],
2797         };
2798         if anchors {
2799                 nodes[0].wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.txid(), vout: 0 }, coinbase_tx.output[0].value);
2800         }
2801
2802         // Open a channel and route a payment. We'll let it timeout to claim it.
2803         let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
2804         route_payment(&nodes[0], &[&nodes[1]], 1_000_000);
2805
2806         let (closing_node, other_node) = if confirm_counterparty_commitment {
2807                 (&nodes[1], &nodes[0])
2808         } else {
2809                 (&nodes[0], &nodes[1])
2810         };
2811
2812         get_monitor!(closing_node, chan_id).broadcast_latest_holder_commitment_txn(
2813                 &closing_node.tx_broadcaster, &closing_node.fee_estimator, &closing_node.logger
2814         );
2815
2816         // The commitment transaction comes first.
2817         let commitment_tx = {
2818                 let mut txn = closing_node.tx_broadcaster.unique_txn_broadcast();
2819                 assert_eq!(txn.len(), 1);
2820                 check_spends!(txn[0], funding_tx);
2821                 txn.pop().unwrap()
2822         };
2823
2824         mine_transaction(closing_node, &commitment_tx);
2825         check_added_monitors!(closing_node, 1);
2826         check_closed_broadcast!(closing_node, true);
2827         check_closed_event!(closing_node, 1, ClosureReason::CommitmentTxConfirmed, [other_node.node.get_our_node_id()], 1_000_000);
2828
2829         mine_transaction(other_node, &commitment_tx);
2830         check_added_monitors!(other_node, 1);
2831         check_closed_broadcast!(other_node, true);
2832         check_closed_event!(other_node, 1, ClosureReason::CommitmentTxConfirmed, [closing_node.node.get_our_node_id()], 1_000_000);
2833
2834         // If we update the best block to the new height before providing the confirmed transactions,
2835         // we'll see another broadcast of the commitment transaction.
2836         if !confirm_counterparty_commitment && nodes[0].connect_style.borrow().updates_best_block_first() {
2837                 let _ = nodes[0].tx_broadcaster.txn_broadcast();
2838         }
2839
2840         // Then comes the HTLC timeout transaction.
2841         if confirm_counterparty_commitment {
2842                 connect_blocks(&nodes[0], 5);
2843                 test_spendable_output(&nodes[0], &commitment_tx, false);
2844                 connect_blocks(&nodes[0], TEST_FINAL_CLTV - 5);
2845         } else {
2846                 connect_blocks(&nodes[0], TEST_FINAL_CLTV);
2847         }
2848         if anchors && !confirm_counterparty_commitment {
2849                 handle_bump_htlc_event(&nodes[0], 1);
2850         }
2851         let htlc_timeout_tx = {
2852                 let mut txn = nodes[0].tx_broadcaster.txn_broadcast();
2853                 assert_eq!(txn.len(), 1);
2854                 let tx = txn.pop().unwrap();
2855                 check_spends!(tx, commitment_tx, coinbase_tx);
2856                 tx
2857         };
2858
2859         // Check we rebroadcast it with a different wtxid.
2860         nodes[0].chain_monitor.chain_monitor.rebroadcast_pending_claims();
2861         if anchors && !confirm_counterparty_commitment {
2862                 handle_bump_htlc_event(&nodes[0], 1);
2863         }
2864         {
2865                 let mut txn = nodes[0].tx_broadcaster.txn_broadcast();
2866                 assert_eq!(txn.len(), 1);
2867                 assert_eq!(txn[0].txid(), htlc_timeout_tx.txid());
2868                 assert_ne!(txn[0].wtxid(), htlc_timeout_tx.wtxid());
2869         }
2870 }
2871
2872 #[cfg(not(feature = "_test_vectors"))]
2873 #[test]
2874 fn test_monitor_claims_with_random_signatures() {
2875         do_test_monitor_claims_with_random_signatures(false, false);
2876         do_test_monitor_claims_with_random_signatures(false, true);
2877         do_test_monitor_claims_with_random_signatures(true, false);
2878         do_test_monitor_claims_with_random_signatures(true, true);
2879 }