1 // This file is Copyright its original authors, visible in version control
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
10 //! Further functional tests which test blockchain reorganizations.
12 use chain::channelmonitor::{ANTI_REORG_DELAY, Balance};
13 use chain::transaction::OutPoint;
14 use chain::chaininterface::LowerBoundedFeeEstimator;
16 use ln::channelmanager::{self, BREAKDOWN_TIMEOUT};
17 use ln::msgs::ChannelMessageHandler;
18 use util::events::{Event, MessageSendEvent, MessageSendEventsProvider, ClosureReason, HTLCDestination};
20 use bitcoin::blockdata::script::Builder;
21 use bitcoin::blockdata::opcodes;
22 use bitcoin::secp256k1::Secp256k1;
23 use bitcoin::Transaction;
27 use ln::functional_test_utils::*;
30 fn chanmon_fail_from_stale_commitment() {
31 // If we forward an HTLC to our counterparty, but we force-closed the channel before our
32 // counterparty provides us an updated commitment transaction, we'll end up with a commitment
33 // transaction that does not contain the HTLC which we attempted to forward. In this case, we
34 // need to wait `ANTI_REORG_DELAY` blocks and then fail back the HTLC as there is no way for us
35 // to learn the preimage and the confirmed commitment transaction paid us the value of the
38 // However, previously, we did not do this, ignoring the HTLC entirely.
40 // This could lead to channel closure if the sender we received the HTLC from decides to go on
41 // chain to get their HTLC back before it times out.
43 // Here, we check exactly this case, forwarding a payment from A, through B, to C, before B
44 // broadcasts its latest commitment transaction, which should result in it eventually failing
45 // the HTLC back off-chain to A.
46 let chanmon_cfgs = create_chanmon_cfgs(3);
47 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
48 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
49 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
51 create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features());
52 let (update_a, _, chan_id_2, _) = create_announced_chan_between_nodes(&nodes, 1, 2, channelmanager::provided_init_features(), channelmanager::provided_init_features());
54 let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 1_000_000);
55 nodes[0].node.send_payment(&route, payment_hash, &Some(payment_secret)).unwrap();
56 check_added_monitors!(nodes[0], 1);
58 let bs_txn = get_local_commitment_txn!(nodes[1], chan_id_2);
60 let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
61 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
62 commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
64 expect_pending_htlcs_forwardable!(nodes[1]);
65 get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
66 check_added_monitors!(nodes[1], 1);
68 // Don't bother delivering the new HTLC add/commits, instead confirming the pre-HTLC commitment
69 // transaction for nodes[1].
70 mine_transaction(&nodes[1], &bs_txn[0]);
71 check_added_monitors!(nodes[1], 1);
72 check_closed_broadcast!(nodes[1], true);
73 check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
74 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
76 connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
77 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 }]);
78 check_added_monitors!(nodes[1], 1);
79 let fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
81 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_updates.update_fail_htlcs[0]);
82 commitment_signed_dance!(nodes[0], nodes[1], fail_updates.commitment_signed, true, true);
83 expect_payment_failed_with_update!(nodes[0], payment_hash, false, update_a.contents.short_channel_id, true);
86 fn test_spendable_output<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, spendable_tx: &Transaction) {
87 let mut spendable = node.chain_monitor.chain_monitor.get_and_clear_pending_events();
88 assert_eq!(spendable.len(), 1);
89 if let Event::SpendableOutputs { outputs } = spendable.pop().unwrap() {
90 assert_eq!(outputs.len(), 1);
91 let spend_tx = node.keys_manager.backing.spend_spendable_outputs(&[&outputs[0]], Vec::new(),
92 Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), 253, &Secp256k1::new()).unwrap();
93 check_spends!(spend_tx, spendable_tx);
98 fn revoked_output_htlc_resolution_timing() {
99 // Tests that HTLCs which were present in a broadcasted remote revoked commitment transaction
100 // are resolved only after a spend of the HTLC output reaches six confirmations. Preivously
101 // they would resolve after the revoked commitment transaction itself reaches six
103 let chanmon_cfgs = create_chanmon_cfgs(2);
104 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
105 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
106 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
108 let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features());
110 let payment_hash_1 = route_payment(&nodes[1], &[&nodes[0]], 1_000_000).1;
112 // Get a commitment transaction which contains the HTLC we care about, but which we'll revoke
113 // before forwarding.
114 let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan.2);
115 assert_eq!(revoked_local_txn.len(), 1);
117 // Route a dust payment to revoke the above commitment transaction
118 route_payment(&nodes[0], &[&nodes[1]], 1_000);
120 // Confirm the revoked commitment transaction, closing the channel.
121 mine_transaction(&nodes[1], &revoked_local_txn[0]);
122 check_added_monitors!(nodes[1], 1);
123 check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
124 check_closed_broadcast!(nodes[1], true);
126 let bs_spend_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
127 assert_eq!(bs_spend_txn.len(), 2);
128 check_spends!(bs_spend_txn[0], revoked_local_txn[0]);
129 check_spends!(bs_spend_txn[1], chan.3);
131 // After the commitment transaction confirms, we should still wait on the HTLC spend
132 // transaction to confirm before resolving the HTLC.
133 connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
134 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
135 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
137 // Spend the HTLC output, generating a HTLC failure event after ANTI_REORG_DELAY confirmations.
138 mine_transaction(&nodes[1], &bs_spend_txn[0]);
139 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
140 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
142 connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
143 expect_payment_failed!(nodes[1], payment_hash_1, false);
147 fn chanmon_claim_value_coop_close() {
148 // Tests `get_claimable_balances` returns the correct values across a simple cooperative claim.
149 // Specifically, this tests that the channel non-HTLC balances show up in
150 // `get_claimable_balances` until the cooperative claims have confirmed and generated a
151 // `SpendableOutputs` event, and no longer.
152 let chanmon_cfgs = create_chanmon_cfgs(2);
153 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
154 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
155 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
157 let (_, _, chan_id, funding_tx) =
158 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 1_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features());
159 let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
160 assert_eq!(funding_outpoint.to_channel_id(), chan_id);
162 let chan_feerate = get_feerate!(nodes[0], chan_id) as u64;
163 let opt_anchors = get_opt_anchors!(nodes[0], chan_id);
165 assert_eq!(vec![Balance::ClaimableOnChannelClose {
166 claimable_amount_satoshis: 1_000_000 - 1_000 - chan_feerate * channel::commitment_tx_base_weight(opt_anchors) / 1000
168 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
169 assert_eq!(vec![Balance::ClaimableOnChannelClose { claimable_amount_satoshis: 1_000, }],
170 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
172 nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
173 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
174 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &channelmanager::provided_init_features(), &node_0_shutdown);
175 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
176 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &channelmanager::provided_init_features(), &node_1_shutdown);
178 let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
179 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
180 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
181 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
182 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
183 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
184 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
185 assert!(node_1_none.is_none());
187 let shutdown_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
188 assert_eq!(shutdown_tx, nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0));
189 assert_eq!(shutdown_tx.len(), 1);
191 mine_transaction(&nodes[0], &shutdown_tx[0]);
192 mine_transaction(&nodes[1], &shutdown_tx[0]);
194 assert!(nodes[0].node.list_channels().is_empty());
195 assert!(nodes[1].node.list_channels().is_empty());
197 assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
198 assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
200 assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
201 claimable_amount_satoshis: 1_000_000 - 1_000 - chan_feerate * channel::commitment_tx_base_weight(opt_anchors) / 1000,
202 confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
204 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
205 assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
206 claimable_amount_satoshis: 1000,
207 confirmation_height: nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1,
209 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
211 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
212 connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
214 assert_eq!(Vec::<Balance>::new(),
215 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
216 assert_eq!(Vec::<Balance>::new(),
217 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
219 test_spendable_output(&nodes[0], &shutdown_tx[0]);
220 test_spendable_output(&nodes[1], &shutdown_tx[0]);
222 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
223 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
226 fn sorted_vec<T: Ord>(mut v: Vec<T>) -> Vec<T> {
231 /// Asserts that `a` and `b` are close, but maybe off by up to 5.
232 /// This is useful when checking fees and weights on transactions as things may vary by a few based
233 /// on signature size and signature size estimation being non-exact.
234 fn fuzzy_assert_eq<V: core::convert::TryInto<u64>>(a: V, b: V) {
235 let a_u64 = a.try_into().map_err(|_| ()).unwrap();
236 let b_u64 = b.try_into().map_err(|_| ()).unwrap();
237 eprintln!("Checking {} and {} for fuzzy equality", a_u64, b_u64);
238 assert!(a_u64 >= b_u64 - 5);
239 assert!(b_u64 >= a_u64 - 5);
242 fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
243 // Tests `get_claimable_balances` with an HTLC across a force-close.
244 // We build a channel with an HTLC pending, then force close the channel and check that the
245 // `get_claimable_balances` return value is correct as transactions confirm on-chain.
246 let mut chanmon_cfgs = create_chanmon_cfgs(2);
247 if prev_commitment_tx {
248 // We broadcast a second-to-latest commitment transaction, without providing the revocation
249 // secret to the counterparty. However, because we always immediately take the revocation
250 // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
251 // transaction which, from the point of view of our keys_manager, is revoked.
252 chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
254 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
255 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
256 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
258 let (_, _, chan_id, funding_tx) =
259 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 1_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features());
260 let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
261 assert_eq!(funding_outpoint.to_channel_id(), chan_id);
263 // This HTLC is immediately claimed, giving node B the preimage
264 let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 3_000_000);
265 // This HTLC is allowed to time out, letting A claim it. However, in order to test claimable
266 // balances more fully we also give B the preimage for this HTLC.
267 let (timeout_payment_preimage, timeout_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 4_000_000);
268 // This HTLC will be dust, and not be claimable at all:
269 let (dust_payment_preimage, dust_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 3_000);
271 let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
273 let chan_feerate = get_feerate!(nodes[0], chan_id) as u64;
274 let opt_anchors = get_opt_anchors!(nodes[0], chan_id);
276 let remote_txn = get_local_commitment_txn!(nodes[1], chan_id);
277 // Before B receives the payment preimage, it only suggests the push_msat value of 1_000 sats
278 // as claimable. A lists both its to-self balance and the (possibly-claimable) HTLCs.
279 assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
280 claimable_amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *
281 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
282 }, Balance::MaybeTimeoutClaimableHTLC {
283 claimable_amount_satoshis: 3_000,
284 claimable_height: htlc_cltv_timeout,
285 }, Balance::MaybeTimeoutClaimableHTLC {
286 claimable_amount_satoshis: 4_000,
287 claimable_height: htlc_cltv_timeout,
289 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
290 assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
291 claimable_amount_satoshis: 1_000,
292 }, Balance::MaybePreimageClaimableHTLC {
293 claimable_amount_satoshis: 3_000,
294 expiry_height: htlc_cltv_timeout,
295 }, Balance::MaybePreimageClaimableHTLC {
296 claimable_amount_satoshis: 4_000,
297 expiry_height: htlc_cltv_timeout,
299 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
301 nodes[1].node.claim_funds(payment_preimage);
302 check_added_monitors!(nodes[1], 1);
303 expect_payment_claimed!(nodes[1], payment_hash, 3_000_000);
305 let b_htlc_msgs = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
306 // We claim the dust payment here as well, but it won't impact our claimable balances as its
307 // dust and thus doesn't appear on chain at all.
308 nodes[1].node.claim_funds(dust_payment_preimage);
309 check_added_monitors!(nodes[1], 1);
310 expect_payment_claimed!(nodes[1], dust_payment_hash, 3_000);
312 nodes[1].node.claim_funds(timeout_payment_preimage);
313 check_added_monitors!(nodes[1], 1);
314 expect_payment_claimed!(nodes[1], timeout_payment_hash, 4_000_000);
316 if prev_commitment_tx {
317 // To build a previous commitment transaction, deliver one round of commitment messages.
318 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &b_htlc_msgs.update_fulfill_htlcs[0]);
319 expect_payment_sent_without_paths!(nodes[0], payment_preimage);
320 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &b_htlc_msgs.commitment_signed);
321 check_added_monitors!(nodes[0], 1);
322 let (as_raa, as_cs) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
323 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
324 let _htlc_updates = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
325 check_added_monitors!(nodes[1], 1);
326 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs);
327 let _bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
328 check_added_monitors!(nodes[1], 1);
331 // Once B has received the payment preimage, it includes the value of the HTLC in its
332 // "claimable if you were to close the channel" balance.
333 let mut a_expected_balances = vec![Balance::ClaimableOnChannelClose {
334 claimable_amount_satoshis: 1_000_000 - // Channel funding value in satoshis
335 4_000 - // The to-be-failed HTLC value in satoshis
336 3_000 - // The claimed HTLC value in satoshis
337 1_000 - // The push_msat value in satoshis
338 3 - // The dust HTLC value in satoshis
339 // The commitment transaction fee with two HTLC outputs:
340 chan_feerate * (channel::commitment_tx_base_weight(opt_anchors) +
341 if prev_commitment_tx { 1 } else { 2 } *
342 channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
343 }, Balance::MaybeTimeoutClaimableHTLC {
344 claimable_amount_satoshis: 4_000,
345 claimable_height: htlc_cltv_timeout,
347 if !prev_commitment_tx {
348 a_expected_balances.push(Balance::MaybeTimeoutClaimableHTLC {
349 claimable_amount_satoshis: 3_000,
350 claimable_height: htlc_cltv_timeout,
353 assert_eq!(sorted_vec(a_expected_balances),
354 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
355 assert_eq!(vec![Balance::ClaimableOnChannelClose {
356 claimable_amount_satoshis: 1_000 + 3_000 + 4_000,
358 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
360 // Broadcast the closing transaction (which has both pending HTLCs in it) and get B's
361 // broadcasted HTLC claim transaction with preimage.
362 let node_b_commitment_claimable = nodes[1].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
363 mine_transaction(&nodes[0], &remote_txn[0]);
364 mine_transaction(&nodes[1], &remote_txn[0]);
366 let b_broadcast_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
367 assert_eq!(b_broadcast_txn.len(), if prev_commitment_tx { 4 } else { 5 });
368 if prev_commitment_tx {
369 check_spends!(b_broadcast_txn[3], b_broadcast_txn[2]);
371 assert_eq!(b_broadcast_txn[0], b_broadcast_txn[3]);
372 assert_eq!(b_broadcast_txn[1], b_broadcast_txn[4]);
374 // b_broadcast_txn[0] should spend the HTLC output of the commitment tx for 3_000 sats
375 check_spends!(b_broadcast_txn[0], remote_txn[0]);
376 check_spends!(b_broadcast_txn[1], remote_txn[0]);
377 assert_eq!(b_broadcast_txn[0].input.len(), 1);
378 assert_eq!(b_broadcast_txn[1].input.len(), 1);
379 assert_eq!(remote_txn[0].output[b_broadcast_txn[0].input[0].previous_output.vout as usize].value, 3_000);
380 assert_eq!(remote_txn[0].output[b_broadcast_txn[1].input[0].previous_output.vout as usize].value, 4_000);
381 check_spends!(b_broadcast_txn[2], funding_tx);
383 assert!(nodes[0].node.list_channels().is_empty());
384 check_closed_broadcast!(nodes[0], true);
385 check_added_monitors!(nodes[0], 1);
386 check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
387 assert!(nodes[1].node.list_channels().is_empty());
388 check_closed_broadcast!(nodes[1], true);
389 check_added_monitors!(nodes[1], 1);
390 check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
391 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
392 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
394 // Once the commitment transaction confirms, we will wait until ANTI_REORG_DELAY until we
395 // generate any `SpendableOutputs` events. Thus, the same balances will still be listed
396 // available in `get_claimable_balances`. However, both will swap from `ClaimableOnClose` to
397 // other Balance variants, as close has already happened.
398 assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
399 assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
401 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
402 claimable_amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *
403 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
404 confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
405 }, Balance::MaybeTimeoutClaimableHTLC {
406 claimable_amount_satoshis: 3_000,
407 claimable_height: htlc_cltv_timeout,
408 }, Balance::MaybeTimeoutClaimableHTLC {
409 claimable_amount_satoshis: 4_000,
410 claimable_height: htlc_cltv_timeout,
412 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
413 // The main non-HTLC balance is just awaiting confirmations, but the claimable height is the
414 // CSV delay, not ANTI_REORG_DELAY.
415 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
416 claimable_amount_satoshis: 1_000,
417 confirmation_height: node_b_commitment_claimable,
419 // Both HTLC balances are "contentious" as our counterparty could claim them if we wait too
421 Balance::ContentiousClaimable {
422 claimable_amount_satoshis: 3_000,
423 timeout_height: htlc_cltv_timeout,
424 }, Balance::ContentiousClaimable {
425 claimable_amount_satoshis: 4_000,
426 timeout_height: htlc_cltv_timeout,
428 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
430 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
431 expect_payment_failed!(nodes[0], dust_payment_hash, false);
432 connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
434 // After ANTI_REORG_DELAY, A will consider its balance fully spendable and generate a
435 // `SpendableOutputs` event. However, B still has to wait for the CSV delay.
436 assert_eq!(sorted_vec(vec![Balance::MaybeTimeoutClaimableHTLC {
437 claimable_amount_satoshis: 3_000,
438 claimable_height: htlc_cltv_timeout,
439 }, Balance::MaybeTimeoutClaimableHTLC {
440 claimable_amount_satoshis: 4_000,
441 claimable_height: htlc_cltv_timeout,
443 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
444 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
445 claimable_amount_satoshis: 1_000,
446 confirmation_height: node_b_commitment_claimable,
447 }, Balance::ContentiousClaimable {
448 claimable_amount_satoshis: 3_000,
449 timeout_height: htlc_cltv_timeout,
450 }, Balance::ContentiousClaimable {
451 claimable_amount_satoshis: 4_000,
452 timeout_height: htlc_cltv_timeout,
454 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
456 test_spendable_output(&nodes[0], &remote_txn[0]);
457 assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
459 // After broadcasting the HTLC claim transaction, node A will still consider the HTLC
460 // possibly-claimable up to ANTI_REORG_DELAY, at which point it will drop it.
461 mine_transaction(&nodes[0], &b_broadcast_txn[0]);
462 if prev_commitment_tx {
463 expect_payment_path_successful!(nodes[0]);
465 expect_payment_sent!(nodes[0], payment_preimage);
467 assert_eq!(sorted_vec(vec![Balance::MaybeTimeoutClaimableHTLC {
468 claimable_amount_satoshis: 3_000,
469 claimable_height: htlc_cltv_timeout,
470 }, Balance::MaybeTimeoutClaimableHTLC {
471 claimable_amount_satoshis: 4_000,
472 claimable_height: htlc_cltv_timeout,
474 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
475 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
476 assert_eq!(vec![Balance::MaybeTimeoutClaimableHTLC {
477 claimable_amount_satoshis: 4_000,
478 claimable_height: htlc_cltv_timeout,
480 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
482 // When the HTLC timeout output is spendable in the next block, A should broadcast it
483 connect_blocks(&nodes[0], htlc_cltv_timeout - nodes[0].best_block_info().1 - 1);
484 let a_broadcast_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
485 assert_eq!(a_broadcast_txn.len(), 3);
486 check_spends!(a_broadcast_txn[0], funding_tx);
487 assert_eq!(a_broadcast_txn[1].input.len(), 1);
488 check_spends!(a_broadcast_txn[1], remote_txn[0]);
489 assert_eq!(a_broadcast_txn[2].input.len(), 1);
490 check_spends!(a_broadcast_txn[2], remote_txn[0]);
491 assert_ne!(a_broadcast_txn[1].input[0].previous_output.vout,
492 a_broadcast_txn[2].input[0].previous_output.vout);
493 // a_broadcast_txn [1] and [2] should spend the HTLC outputs of the commitment tx
494 assert_eq!(remote_txn[0].output[a_broadcast_txn[1].input[0].previous_output.vout as usize].value, 3_000);
495 assert_eq!(remote_txn[0].output[a_broadcast_txn[2].input[0].previous_output.vout as usize].value, 4_000);
497 // Once the HTLC-Timeout transaction confirms, A will no longer consider the HTLC
498 // "MaybeClaimable", but instead move it to "AwaitingConfirmations".
499 mine_transaction(&nodes[0], &a_broadcast_txn[2]);
500 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
501 assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
502 claimable_amount_satoshis: 4_000,
503 confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
505 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
506 // After ANTI_REORG_DELAY, A will generate a SpendableOutputs event and drop the claimable
508 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
509 assert_eq!(Vec::<Balance>::new(),
510 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
511 expect_payment_failed!(nodes[0], timeout_payment_hash, false);
513 test_spendable_output(&nodes[0], &a_broadcast_txn[2]);
515 // Node B will no longer consider the HTLC "contentious" after the HTLC claim transaction
516 // confirms, and consider it simply "awaiting confirmations". Note that it has to wait for the
517 // standard revocable transaction CSV delay before receiving a `SpendableOutputs`.
518 let node_b_htlc_claimable = nodes[1].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
519 mine_transaction(&nodes[1], &b_broadcast_txn[0]);
521 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
522 claimable_amount_satoshis: 1_000,
523 confirmation_height: node_b_commitment_claimable,
524 }, Balance::ClaimableAwaitingConfirmations {
525 claimable_amount_satoshis: 3_000,
526 confirmation_height: node_b_htlc_claimable,
527 }, Balance::ContentiousClaimable {
528 claimable_amount_satoshis: 4_000,
529 timeout_height: htlc_cltv_timeout,
531 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
533 // After reaching the commitment output CSV, we'll get a SpendableOutputs event for it and have
534 // only the HTLCs claimable on node B.
535 connect_blocks(&nodes[1], node_b_commitment_claimable - nodes[1].best_block_info().1);
536 test_spendable_output(&nodes[1], &remote_txn[0]);
538 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
539 claimable_amount_satoshis: 3_000,
540 confirmation_height: node_b_htlc_claimable,
541 }, Balance::ContentiousClaimable {
542 claimable_amount_satoshis: 4_000,
543 timeout_height: htlc_cltv_timeout,
545 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
547 // After reaching the claimed HTLC output CSV, we'll get a SpendableOutptus event for it and
548 // have only one HTLC output left spendable.
549 connect_blocks(&nodes[1], node_b_htlc_claimable - nodes[1].best_block_info().1);
550 test_spendable_output(&nodes[1], &b_broadcast_txn[0]);
552 assert_eq!(vec![Balance::ContentiousClaimable {
553 claimable_amount_satoshis: 4_000,
554 timeout_height: htlc_cltv_timeout,
556 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
558 // Finally, mine the HTLC timeout transaction that A broadcasted (even though B should be able
559 // to claim this HTLC with the preimage it knows!). It will remain listed as a claimable HTLC
560 // until ANTI_REORG_DELAY confirmations on the spend.
561 mine_transaction(&nodes[1], &a_broadcast_txn[2]);
562 assert_eq!(vec![Balance::ContentiousClaimable {
563 claimable_amount_satoshis: 4_000,
564 timeout_height: htlc_cltv_timeout,
566 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
567 connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
568 assert_eq!(Vec::<Balance>::new(),
569 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
573 fn test_claim_value_force_close() {
574 do_test_claim_value_force_close(true);
575 do_test_claim_value_force_close(false);
579 fn test_balances_on_local_commitment_htlcs() {
580 // Previously, when handling the broadcast of a local commitment transactions (with associated
581 // CSV delays prior to spendability), we incorrectly handled the CSV delays on HTLC
582 // transactions. This caused us to miss spendable outputs for HTLCs which were awaiting a CSV
583 // delay prior to spendability.
585 // Further, because of this, we could hit an assertion as `get_claimable_balances` asserted
586 // that HTLCs were resolved after the funding spend was resolved, which was not true if the
587 // HTLC did not have a CSV delay attached (due to the above bug or due to it being an HTLC
588 // claim by our counterparty).
589 let chanmon_cfgs = create_chanmon_cfgs(2);
590 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
591 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
592 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
594 // Create a single channel with two pending HTLCs from nodes[0] to nodes[1], one which nodes[1]
595 // knows the preimage for, one which it does not.
596 let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features());
597 let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
599 let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 10_000_000);
600 let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
601 nodes[0].node.send_payment(&route, payment_hash, &Some(payment_secret)).unwrap();
602 check_added_monitors!(nodes[0], 1);
604 let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
605 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
606 commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
608 expect_pending_htlcs_forwardable!(nodes[1]);
609 expect_payment_received!(nodes[1], payment_hash, payment_secret, 10_000_000);
611 let (route_2, payment_hash_2, payment_preimage_2, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[1], 20_000_000);
612 nodes[0].node.send_payment(&route_2, payment_hash_2, &Some(payment_secret_2)).unwrap();
613 check_added_monitors!(nodes[0], 1);
615 let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
616 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
617 commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
619 expect_pending_htlcs_forwardable!(nodes[1]);
620 expect_payment_received!(nodes[1], payment_hash_2, payment_secret_2, 20_000_000);
621 nodes[1].node.claim_funds(payment_preimage_2);
622 get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
623 check_added_monitors!(nodes[1], 1);
624 expect_payment_claimed!(nodes[1], payment_hash_2, 20_000_000);
626 let chan_feerate = get_feerate!(nodes[0], chan_id) as u64;
627 let opt_anchors = get_opt_anchors!(nodes[0], chan_id);
629 // Get nodes[0]'s commitment transaction and HTLC-Timeout transactions
630 let as_txn = get_local_commitment_txn!(nodes[0], chan_id);
631 assert_eq!(as_txn.len(), 3);
632 check_spends!(as_txn[1], as_txn[0]);
633 check_spends!(as_txn[2], as_txn[0]);
634 check_spends!(as_txn[0], funding_tx);
636 // First confirm the commitment transaction on nodes[0], which should leave us with three
637 // claimable balances.
638 let node_a_commitment_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
639 mine_transaction(&nodes[0], &as_txn[0]);
640 check_added_monitors!(nodes[0], 1);
641 check_closed_broadcast!(nodes[0], true);
642 check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
644 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
645 claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
646 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
647 confirmation_height: node_a_commitment_claimable,
648 }, Balance::MaybeTimeoutClaimableHTLC {
649 claimable_amount_satoshis: 10_000,
650 claimable_height: htlc_cltv_timeout,
651 }, Balance::MaybeTimeoutClaimableHTLC {
652 claimable_amount_satoshis: 20_000,
653 claimable_height: htlc_cltv_timeout,
655 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
657 // Get nodes[1]'s HTLC claim tx for the second HTLC
658 mine_transaction(&nodes[1], &as_txn[0]);
659 check_added_monitors!(nodes[1], 1);
660 check_closed_broadcast!(nodes[1], true);
661 check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
662 let bs_htlc_claim_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
663 assert_eq!(bs_htlc_claim_txn.len(), 3);
664 check_spends!(bs_htlc_claim_txn[0], as_txn[0]);
665 check_spends!(bs_htlc_claim_txn[1], funding_tx);
666 check_spends!(bs_htlc_claim_txn[2], bs_htlc_claim_txn[1]);
668 // Connect blocks until the HTLCs expire, allowing us to (validly) broadcast the HTLC-Timeout
670 connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
671 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
672 claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
673 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
674 confirmation_height: node_a_commitment_claimable,
675 }, Balance::MaybeTimeoutClaimableHTLC {
676 claimable_amount_satoshis: 10_000,
677 claimable_height: htlc_cltv_timeout,
678 }, Balance::MaybeTimeoutClaimableHTLC {
679 claimable_amount_satoshis: 20_000,
680 claimable_height: htlc_cltv_timeout,
682 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
683 assert_eq!(as_txn[1].lock_time.0, nodes[0].best_block_info().1 + 1); // as_txn[1] can be included in the next block
685 // Now confirm nodes[0]'s HTLC-Timeout transaction, which changes the claimable balance to an
686 // "awaiting confirmations" one.
687 let node_a_htlc_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
688 mine_transaction(&nodes[0], &as_txn[1]);
689 // Note that prior to the fix in the commit which introduced this test, this (and the next
690 // balance) check failed. With this check removed, the code panicked in the `connect_blocks`
691 // call, as described, two hunks down.
692 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
693 claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
694 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
695 confirmation_height: node_a_commitment_claimable,
696 }, Balance::ClaimableAwaitingConfirmations {
697 claimable_amount_satoshis: 10_000,
698 confirmation_height: node_a_htlc_claimable,
699 }, Balance::MaybeTimeoutClaimableHTLC {
700 claimable_amount_satoshis: 20_000,
701 claimable_height: htlc_cltv_timeout,
703 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
705 // Now confirm nodes[1]'s HTLC claim, giving nodes[0] the preimage. Note that the "maybe
706 // claimable" balance remains until we see ANTI_REORG_DELAY blocks.
707 mine_transaction(&nodes[0], &bs_htlc_claim_txn[0]);
708 expect_payment_sent!(nodes[0], payment_preimage_2);
709 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
710 claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
711 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
712 confirmation_height: node_a_commitment_claimable,
713 }, Balance::ClaimableAwaitingConfirmations {
714 claimable_amount_satoshis: 10_000,
715 confirmation_height: node_a_htlc_claimable,
716 }, Balance::MaybeTimeoutClaimableHTLC {
717 claimable_amount_satoshis: 20_000,
718 claimable_height: htlc_cltv_timeout,
720 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
722 // Finally make the HTLC transactions have ANTI_REORG_DELAY blocks. This call previously
723 // panicked as described in the test introduction. This will remove the "maybe claimable"
724 // spendable output as nodes[1] has fully claimed the second HTLC.
725 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
726 expect_payment_failed!(nodes[0], payment_hash, false);
728 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
729 claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
730 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
731 confirmation_height: node_a_commitment_claimable,
732 }, Balance::ClaimableAwaitingConfirmations {
733 claimable_amount_satoshis: 10_000,
734 confirmation_height: node_a_htlc_claimable,
736 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
738 // Connect blocks until the commitment transaction's CSV expires, providing us the relevant
739 // `SpendableOutputs` event and removing the claimable balance entry.
740 connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
741 assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
742 claimable_amount_satoshis: 10_000,
743 confirmation_height: node_a_htlc_claimable,
745 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
746 test_spendable_output(&nodes[0], &as_txn[0]);
748 // Connect blocks until the HTLC-Timeout's CSV expires, providing us the relevant
749 // `SpendableOutputs` event and removing the claimable balance entry.
750 connect_blocks(&nodes[0], node_a_htlc_claimable - nodes[0].best_block_info().1);
751 assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
752 test_spendable_output(&nodes[0], &as_txn[1]);
756 fn test_no_preimage_inbound_htlc_balances() {
757 // Tests that MaybePreimageClaimableHTLC are generated for inbound HTLCs for which we do not
759 let chanmon_cfgs = create_chanmon_cfgs(2);
760 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
761 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
762 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
764 let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features());
765 let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
767 // Send two HTLCs, one from A to B, and one from B to A.
768 let to_b_failed_payment_hash = route_payment(&nodes[0], &[&nodes[1]], 10_000_000).1;
769 let to_a_failed_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 20_000_000).1;
770 let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
772 let chan_feerate = get_feerate!(nodes[0], chan_id) as u64;
773 let opt_anchors = get_opt_anchors!(nodes[0], chan_id);
775 // Both A and B will have an HTLC that's claimable on timeout and one that's claimable if they
776 // receive the preimage. These will remain the same through the channel closure and until the
777 // HTLC output is spent.
779 assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
780 claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
781 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
782 }, Balance::MaybePreimageClaimableHTLC {
783 claimable_amount_satoshis: 20_000,
784 expiry_height: htlc_cltv_timeout,
785 }, Balance::MaybeTimeoutClaimableHTLC {
786 claimable_amount_satoshis: 10_000,
787 claimable_height: htlc_cltv_timeout,
789 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
791 assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
792 claimable_amount_satoshis: 500_000 - 20_000,
793 }, Balance::MaybePreimageClaimableHTLC {
794 claimable_amount_satoshis: 10_000,
795 expiry_height: htlc_cltv_timeout,
796 }, Balance::MaybeTimeoutClaimableHTLC {
797 claimable_amount_satoshis: 20_000,
798 claimable_height: htlc_cltv_timeout,
800 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
802 // Get nodes[0]'s commitment transaction and HTLC-Timeout transaction
803 let as_txn = get_local_commitment_txn!(nodes[0], chan_id);
804 assert_eq!(as_txn.len(), 2);
805 check_spends!(as_txn[1], as_txn[0]);
806 check_spends!(as_txn[0], funding_tx);
808 // Now close the channel by confirming A's commitment transaction on both nodes, checking the
809 // claimable balances remain the same except for the non-HTLC balance changing variant.
810 let node_a_commitment_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
811 let as_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
812 claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
813 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
814 confirmation_height: node_a_commitment_claimable,
815 }, Balance::MaybePreimageClaimableHTLC {
816 claimable_amount_satoshis: 20_000,
817 expiry_height: htlc_cltv_timeout,
818 }, Balance::MaybeTimeoutClaimableHTLC {
819 claimable_amount_satoshis: 10_000,
820 claimable_height: htlc_cltv_timeout,
823 mine_transaction(&nodes[0], &as_txn[0]);
824 nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
825 check_added_monitors!(nodes[0], 1);
826 check_closed_broadcast!(nodes[0], true);
827 check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
829 assert_eq!(as_pre_spend_claims,
830 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
832 mine_transaction(&nodes[1], &as_txn[0]);
833 check_added_monitors!(nodes[1], 1);
834 check_closed_broadcast!(nodes[1], true);
835 check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
837 let node_b_commitment_claimable = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
838 let mut bs_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
839 claimable_amount_satoshis: 500_000 - 20_000,
840 confirmation_height: node_b_commitment_claimable,
841 }, Balance::MaybePreimageClaimableHTLC {
842 claimable_amount_satoshis: 10_000,
843 expiry_height: htlc_cltv_timeout,
844 }, Balance::MaybeTimeoutClaimableHTLC {
845 claimable_amount_satoshis: 20_000,
846 claimable_height: htlc_cltv_timeout,
848 assert_eq!(bs_pre_spend_claims,
849 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
851 // We'll broadcast the HTLC-Timeout transaction one block prior to the htlc's expiration (as it
852 // is confirmable in the next block), but will still include the same claimable balances as no
853 // HTLC has been spent, even after the HTLC expires. We'll also fail the inbound HTLC, but it
854 // won't do anything as the channel is already closed.
856 connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
857 let as_htlc_timeout_claim = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
858 assert_eq!(as_htlc_timeout_claim.len(), 1);
859 check_spends!(as_htlc_timeout_claim[0], as_txn[0]);
860 expect_pending_htlcs_forwardable_conditions!(nodes[0],
861 [HTLCDestination::FailedPayment { payment_hash: to_a_failed_payment_hash }]);
863 assert_eq!(as_pre_spend_claims,
864 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
866 connect_blocks(&nodes[0], 1);
867 assert_eq!(as_pre_spend_claims,
868 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
870 // For node B, we'll get the non-HTLC funds claimable after ANTI_REORG_DELAY confirmations
871 connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
872 test_spendable_output(&nodes[1], &as_txn[0]);
873 bs_pre_spend_claims.retain(|e| if let Balance::ClaimableAwaitingConfirmations { .. } = e { false } else { true });
875 // The next few blocks for B look the same as for A, though for the opposite HTLC
876 nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
877 connect_blocks(&nodes[1], TEST_FINAL_CLTV - (ANTI_REORG_DELAY - 1) - 1);
878 expect_pending_htlcs_forwardable_conditions!(nodes[1],
879 [HTLCDestination::FailedPayment { payment_hash: to_b_failed_payment_hash }]);
880 let bs_htlc_timeout_claim = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
881 assert_eq!(bs_htlc_timeout_claim.len(), 1);
882 check_spends!(bs_htlc_timeout_claim[0], as_txn[0]);
884 assert_eq!(bs_pre_spend_claims,
885 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
887 connect_blocks(&nodes[1], 1);
888 assert_eq!(bs_pre_spend_claims,
889 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
891 // Now confirm the two HTLC timeout transactions for A, checking that the inbound HTLC resolves
892 // after ANTI_REORG_DELAY confirmations and the other takes BREAKDOWN_TIMEOUT confirmations.
893 mine_transaction(&nodes[0], &as_htlc_timeout_claim[0]);
894 let as_timeout_claimable_height = nodes[0].best_block_info().1 + (BREAKDOWN_TIMEOUT as u32) - 1;
895 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
896 claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
897 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
898 confirmation_height: node_a_commitment_claimable,
899 }, Balance::MaybePreimageClaimableHTLC {
900 claimable_amount_satoshis: 20_000,
901 expiry_height: htlc_cltv_timeout,
902 }, Balance::ClaimableAwaitingConfirmations {
903 claimable_amount_satoshis: 10_000,
904 confirmation_height: as_timeout_claimable_height,
906 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
908 mine_transaction(&nodes[0], &bs_htlc_timeout_claim[0]);
909 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
910 claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
911 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
912 confirmation_height: node_a_commitment_claimable,
913 }, Balance::MaybePreimageClaimableHTLC {
914 claimable_amount_satoshis: 20_000,
915 expiry_height: htlc_cltv_timeout,
916 }, Balance::ClaimableAwaitingConfirmations {
917 claimable_amount_satoshis: 10_000,
918 confirmation_height: as_timeout_claimable_height,
920 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
922 // Once as_htlc_timeout_claim[0] reaches ANTI_REORG_DELAY confirmations, we should get a
923 // payment failure event.
924 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
925 expect_payment_failed!(nodes[0], to_b_failed_payment_hash, false);
927 connect_blocks(&nodes[0], 1);
928 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
929 claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
930 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
931 confirmation_height: node_a_commitment_claimable,
932 }, Balance::ClaimableAwaitingConfirmations {
933 claimable_amount_satoshis: 10_000,
934 confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
936 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
938 connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
939 assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
940 claimable_amount_satoshis: 10_000,
941 confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
943 nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
944 test_spendable_output(&nodes[0], &as_txn[0]);
946 connect_blocks(&nodes[0], as_timeout_claimable_height - nodes[0].best_block_info().1);
947 assert!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
948 test_spendable_output(&nodes[0], &as_htlc_timeout_claim[0]);
950 // The process for B should be completely identical as well, noting that the non-HTLC-balance
951 // was already claimed.
952 mine_transaction(&nodes[1], &bs_htlc_timeout_claim[0]);
953 let bs_timeout_claimable_height = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
954 assert_eq!(sorted_vec(vec![Balance::MaybePreimageClaimableHTLC {
955 claimable_amount_satoshis: 10_000,
956 expiry_height: htlc_cltv_timeout,
957 }, Balance::ClaimableAwaitingConfirmations {
958 claimable_amount_satoshis: 20_000,
959 confirmation_height: bs_timeout_claimable_height,
961 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
963 mine_transaction(&nodes[1], &as_htlc_timeout_claim[0]);
964 assert_eq!(sorted_vec(vec![Balance::MaybePreimageClaimableHTLC {
965 claimable_amount_satoshis: 10_000,
966 expiry_height: htlc_cltv_timeout,
967 }, Balance::ClaimableAwaitingConfirmations {
968 claimable_amount_satoshis: 20_000,
969 confirmation_height: bs_timeout_claimable_height,
971 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
973 connect_blocks(&nodes[1], ANTI_REORG_DELAY - 2);
974 expect_payment_failed!(nodes[1], to_a_failed_payment_hash, false);
976 assert_eq!(vec![Balance::MaybePreimageClaimableHTLC {
977 claimable_amount_satoshis: 10_000,
978 expiry_height: htlc_cltv_timeout,
980 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
981 test_spendable_output(&nodes[1], &bs_htlc_timeout_claim[0]);
983 connect_blocks(&nodes[1], 1);
984 assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());
987 fn sorted_vec_with_additions<T: Ord + Clone>(v_orig: &Vec<T>, extra_ts: &[&T]) -> Vec<T> {
988 let mut v = v_orig.clone();
990 v.push((*t).clone());
996 fn do_test_revoked_counterparty_commitment_balances(confirm_htlc_spend_first: bool) {
997 // Tests `get_claimable_balances` for revoked counterparty commitment transactions.
998 let mut chanmon_cfgs = create_chanmon_cfgs(2);
999 // We broadcast a second-to-latest commitment transaction, without providing the revocation
1000 // secret to the counterparty. However, because we always immediately take the revocation
1001 // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
1002 // transaction which, from the point of view of our keys_manager, is revoked.
1003 chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1004 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1005 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1006 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1008 let (_, _, chan_id, funding_tx) =
1009 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 100_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features());
1010 let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1011 assert_eq!(funding_outpoint.to_channel_id(), chan_id);
1013 // We create five HTLCs for B to claim against A's revoked commitment transaction:
1015 // (1) one for which A is the originator and B knows the preimage
1016 // (2) one for which B is the originator where the HTLC has since timed-out
1017 // (3) one for which B is the originator but where the HTLC has not yet timed-out
1018 // (4) one dust HTLC which is lost in the channel closure
1019 // (5) one that actually isn't in the revoked commitment transaction at all, but was added in
1020 // later commitment transaction updates
1022 // Though they could all be claimed in a single claim transaction, due to CLTV timeouts they
1023 // are all currently claimed in separate transactions, which helps us test as we can claim
1024 // HTLCs individually.
1026 let (claimed_payment_preimage, claimed_payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 3_000_000);
1027 let timeout_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 4_000_000).1;
1028 let dust_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 3_000).1;
1030 let htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1032 connect_blocks(&nodes[0], 10);
1033 connect_blocks(&nodes[1], 10);
1035 let live_htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1036 let live_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 5_000_000).1;
1038 // Get the latest commitment transaction from A and then update the fee to revoke it
1039 let as_revoked_txn = get_local_commitment_txn!(nodes[0], chan_id);
1040 let opt_anchors = get_opt_anchors!(nodes[0], chan_id);
1042 let chan_feerate = get_feerate!(nodes[0], chan_id) as u64;
1044 let missing_htlc_cltv_timeout = nodes[0].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1045 let missing_htlc_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 2_000_000).1;
1047 nodes[1].node.claim_funds(claimed_payment_preimage);
1048 expect_payment_claimed!(nodes[1], claimed_payment_hash, 3_000_000);
1049 check_added_monitors!(nodes[1], 1);
1050 let _b_htlc_msgs = get_htlc_update_msgs!(&nodes[1], nodes[0].node.get_our_node_id());
1052 connect_blocks(&nodes[0], htlc_cltv_timeout + 1 - 10);
1053 check_closed_broadcast!(nodes[0], true);
1054 check_added_monitors!(nodes[0], 1);
1056 let mut events = nodes[0].node.get_and_clear_pending_events();
1057 assert_eq!(events.len(), 6);
1058 let mut failed_payments: HashSet<_> =
1059 [timeout_payment_hash, dust_payment_hash, live_payment_hash, missing_htlc_payment_hash]
1060 .iter().map(|a| *a).collect();
1061 events.retain(|ev| {
1063 Event::HTLCHandlingFailed { failed_next_destination: HTLCDestination::NextHopChannel { node_id, channel_id }, .. } => {
1064 assert_eq!(*channel_id, chan_id);
1065 assert_eq!(*node_id, Some(nodes[1].node.get_our_node_id()));
1068 Event::HTLCHandlingFailed { failed_next_destination: HTLCDestination::FailedPayment { payment_hash }, .. } => {
1069 assert!(failed_payments.remove(payment_hash));
1075 assert!(failed_payments.is_empty());
1076 if let Event::PendingHTLCsForwardable { .. } = events[0] {} else { panic!(); }
1078 Event::ChannelClosed { reason: ClosureReason::CommitmentTxConfirmed, .. } => {},
1082 connect_blocks(&nodes[1], htlc_cltv_timeout + 1 - 10);
1083 check_closed_broadcast!(nodes[1], true);
1084 check_added_monitors!(nodes[1], 1);
1085 check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
1087 // Prior to channel closure, B considers the preimage HTLC as its own, and otherwise only
1088 // lists the two on-chain timeout-able HTLCs as claimable balances.
1089 assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
1090 claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3 - 2_000 + 3_000,
1091 }, Balance::MaybeTimeoutClaimableHTLC {
1092 claimable_amount_satoshis: 2_000,
1093 claimable_height: missing_htlc_cltv_timeout,
1094 }, Balance::MaybeTimeoutClaimableHTLC {
1095 claimable_amount_satoshis: 4_000,
1096 claimable_height: htlc_cltv_timeout,
1097 }, Balance::MaybeTimeoutClaimableHTLC {
1098 claimable_amount_satoshis: 5_000,
1099 claimable_height: live_htlc_cltv_timeout,
1101 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1103 mine_transaction(&nodes[1], &as_revoked_txn[0]);
1104 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();
1105 // Currently the revoked commitment is claimed in four transactions as the HTLCs all expire
1107 assert_eq!(claim_txn.len(), 4);
1108 claim_txn.sort_unstable_by_key(|tx| tx.output.iter().map(|output| output.value).sum::<u64>());
1110 // The following constants were determined experimentally
1111 const BS_TO_SELF_CLAIM_EXP_WEIGHT: usize = 483;
1112 const OUTBOUND_HTLC_CLAIM_EXP_WEIGHT: usize = 571;
1113 const INBOUND_HTLC_CLAIM_EXP_WEIGHT: usize = 578;
1115 // Check that the weight is close to the expected weight. Note that signature sizes vary
1116 // somewhat so it may not always be exact.
1117 fuzzy_assert_eq(claim_txn[0].weight(), OUTBOUND_HTLC_CLAIM_EXP_WEIGHT);
1118 fuzzy_assert_eq(claim_txn[1].weight(), INBOUND_HTLC_CLAIM_EXP_WEIGHT);
1119 fuzzy_assert_eq(claim_txn[2].weight(), INBOUND_HTLC_CLAIM_EXP_WEIGHT);
1120 fuzzy_assert_eq(claim_txn[3].weight(), BS_TO_SELF_CLAIM_EXP_WEIGHT);
1122 // The expected balance for the next three checks, with the largest-HTLC and to_self output
1123 // claim balances separated out.
1124 let expected_balance = vec![Balance::ClaimableAwaitingConfirmations {
1125 // to_remote output in A's revoked commitment
1126 claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3,
1127 confirmation_height: nodes[1].best_block_info().1 + 5,
1128 }, Balance::CounterpartyRevokedOutputClaimable {
1129 claimable_amount_satoshis: 3_000,
1130 }, Balance::CounterpartyRevokedOutputClaimable {
1131 claimable_amount_satoshis: 4_000,
1134 let to_self_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {
1135 claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
1136 (channel::commitment_tx_base_weight(opt_anchors) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1138 let to_self_claimed_avail_height;
1139 let largest_htlc_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {
1140 claimable_amount_satoshis: 5_000,
1142 let largest_htlc_claimed_avail_height;
1144 // Once the channel has been closed by A, B now considers all of the commitment transactions'
1145 // outputs as `CounterpartyRevokedOutputClaimable`.
1146 assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_unclaimed_balance, &largest_htlc_unclaimed_balance]),
1147 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1149 if confirm_htlc_spend_first {
1150 mine_transaction(&nodes[1], &claim_txn[2]);
1151 largest_htlc_claimed_avail_height = nodes[1].best_block_info().1 + 5;
1152 to_self_claimed_avail_height = nodes[1].best_block_info().1 + 6; // will be claimed in the next block
1154 // Connect the to_self output claim, taking all of A's non-HTLC funds
1155 mine_transaction(&nodes[1], &claim_txn[3]);
1156 to_self_claimed_avail_height = nodes[1].best_block_info().1 + 5;
1157 largest_htlc_claimed_avail_height = nodes[1].best_block_info().1 + 6; // will be claimed in the next block
1160 let largest_htlc_claimed_balance = Balance::ClaimableAwaitingConfirmations {
1161 claimable_amount_satoshis: 5_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
1162 confirmation_height: largest_htlc_claimed_avail_height,
1164 let to_self_claimed_balance = Balance::ClaimableAwaitingConfirmations {
1165 claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
1166 (channel::commitment_tx_base_weight(opt_anchors) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
1167 - chan_feerate * claim_txn[3].weight() as u64 / 1000,
1168 confirmation_height: to_self_claimed_avail_height,
1171 if confirm_htlc_spend_first {
1172 assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_unclaimed_balance, &largest_htlc_claimed_balance]),
1173 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1175 assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_claimed_balance, &largest_htlc_unclaimed_balance]),
1176 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1179 if confirm_htlc_spend_first {
1180 mine_transaction(&nodes[1], &claim_txn[3]);
1182 mine_transaction(&nodes[1], &claim_txn[2]);
1184 assert_eq!(sorted_vec_with_additions(&expected_balance, &[&to_self_claimed_balance, &largest_htlc_claimed_balance]),
1185 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1187 // Finally, connect the last two remaining HTLC spends and check that they move to
1188 // `ClaimableAwaitingConfirmations`
1189 mine_transaction(&nodes[1], &claim_txn[0]);
1190 mine_transaction(&nodes[1], &claim_txn[1]);
1192 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1193 // to_remote output in A's revoked commitment
1194 claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3,
1195 confirmation_height: nodes[1].best_block_info().1 + 1,
1196 }, Balance::ClaimableAwaitingConfirmations {
1197 claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
1198 (channel::commitment_tx_base_weight(opt_anchors) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
1199 - chan_feerate * claim_txn[3].weight() as u64 / 1000,
1200 confirmation_height: to_self_claimed_avail_height,
1201 }, Balance::ClaimableAwaitingConfirmations {
1202 claimable_amount_satoshis: 3_000 - chan_feerate * OUTBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
1203 confirmation_height: nodes[1].best_block_info().1 + 4,
1204 }, Balance::ClaimableAwaitingConfirmations {
1205 claimable_amount_satoshis: 4_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
1206 confirmation_height: nodes[1].best_block_info().1 + 5,
1207 }, Balance::ClaimableAwaitingConfirmations {
1208 claimable_amount_satoshis: 5_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
1209 confirmation_height: largest_htlc_claimed_avail_height,
1211 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1213 connect_blocks(&nodes[1], 1);
1214 test_spendable_output(&nodes[1], &as_revoked_txn[0]);
1216 let mut payment_failed_events = nodes[1].node.get_and_clear_pending_events();
1217 expect_payment_failed_conditions_event(&nodes[1], payment_failed_events.pop().unwrap(),
1218 dust_payment_hash, false, PaymentFailedConditions::new());
1219 expect_payment_failed_conditions_event(&nodes[1], payment_failed_events.pop().unwrap(),
1220 missing_htlc_payment_hash, false, PaymentFailedConditions::new());
1221 assert!(payment_failed_events.is_empty());
1223 connect_blocks(&nodes[1], 1);
1224 test_spendable_output(&nodes[1], &claim_txn[if confirm_htlc_spend_first { 2 } else { 3 }]);
1225 connect_blocks(&nodes[1], 1);
1226 test_spendable_output(&nodes[1], &claim_txn[if confirm_htlc_spend_first { 3 } else { 2 }]);
1227 expect_payment_failed!(nodes[1], live_payment_hash, false);
1228 connect_blocks(&nodes[1], 1);
1229 test_spendable_output(&nodes[1], &claim_txn[0]);
1230 connect_blocks(&nodes[1], 1);
1231 test_spendable_output(&nodes[1], &claim_txn[1]);
1232 expect_payment_failed!(nodes[1], timeout_payment_hash, false);
1233 assert_eq!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances(), Vec::new());
1237 fn test_revoked_counterparty_commitment_balances() {
1238 do_test_revoked_counterparty_commitment_balances(true);
1239 do_test_revoked_counterparty_commitment_balances(false);
1243 fn test_revoked_counterparty_htlc_tx_balances() {
1244 // Tests `get_claimable_balances` for revocation spends of HTLC transactions.
1245 let mut chanmon_cfgs = create_chanmon_cfgs(2);
1246 chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1247 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1248 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1249 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1251 // Create some initial channels
1252 let (_, _, chan_id, funding_tx) =
1253 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 11_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features());
1254 let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1255 assert_eq!(funding_outpoint.to_channel_id(), chan_id);
1257 let payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 3_000_000).0;
1258 let failed_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 1_000_000).1;
1259 let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_id);
1260 assert_eq!(revoked_local_txn[0].input.len(), 1);
1261 assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, funding_tx.txid());
1263 // The to-be-revoked commitment tx should have two HTLCs and an output for both sides
1264 assert_eq!(revoked_local_txn[0].output.len(), 4);
1266 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
1268 let chan_feerate = get_feerate!(nodes[0], chan_id) as u64;
1269 let opt_anchors = get_opt_anchors!(nodes[0], chan_id);
1271 // B will generate an HTLC-Success from its revoked commitment tx
1272 mine_transaction(&nodes[1], &revoked_local_txn[0]);
1273 check_closed_broadcast!(nodes[1], true);
1274 check_added_monitors!(nodes[1], 1);
1275 check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
1276 let revoked_htlc_success_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1278 assert_eq!(revoked_htlc_success_txn.len(), 2);
1279 assert_eq!(revoked_htlc_success_txn[0].input.len(), 1);
1280 assert_eq!(revoked_htlc_success_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
1281 check_spends!(revoked_htlc_success_txn[0], revoked_local_txn[0]);
1282 check_spends!(revoked_htlc_success_txn[1], funding_tx);
1284 connect_blocks(&nodes[1], TEST_FINAL_CLTV);
1285 let revoked_htlc_timeout_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1286 assert_eq!(revoked_htlc_timeout_txn.len(), 1);
1287 check_spends!(revoked_htlc_timeout_txn[0], revoked_local_txn[0]);
1288 assert_ne!(revoked_htlc_success_txn[0].input[0].previous_output, revoked_htlc_timeout_txn[0].input[0].previous_output);
1289 assert_eq!(revoked_htlc_success_txn[0].lock_time.0, 0);
1290 assert_ne!(revoked_htlc_timeout_txn[0].lock_time.0, 0);
1292 // A will generate justice tx from B's revoked commitment/HTLC tx
1293 mine_transaction(&nodes[0], &revoked_local_txn[0]);
1294 check_closed_broadcast!(nodes[0], true);
1295 check_added_monitors!(nodes[0], 1);
1296 check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
1297 let to_remote_conf_height = nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1;
1299 let as_commitment_claim_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1300 assert_eq!(as_commitment_claim_txn.len(), 2);
1301 check_spends!(as_commitment_claim_txn[0], revoked_local_txn[0]);
1302 check_spends!(as_commitment_claim_txn[1], funding_tx);
1304 // The next two checks have the same balance set for A - even though we confirm a revoked HTLC
1305 // transaction our balance tracking doesn't use the on-chain value so the
1306 // `CounterpartyRevokedOutputClaimable` entry doesn't change.
1307 let as_balances = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1308 // to_remote output in B's revoked commitment
1309 claimable_amount_satoshis: 1_000_000 - 11_000 - 3_000 - chan_feerate *
1310 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1311 confirmation_height: to_remote_conf_height,
1312 }, Balance::CounterpartyRevokedOutputClaimable {
1313 // to_self output in B's revoked commitment
1314 claimable_amount_satoshis: 10_000,
1315 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1316 claimable_amount_satoshis: 3_000,
1317 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1318 claimable_amount_satoshis: 1_000,
1320 assert_eq!(as_balances,
1321 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1323 mine_transaction(&nodes[0], &revoked_htlc_success_txn[0]);
1324 let as_htlc_claim_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1325 assert_eq!(as_htlc_claim_tx.len(), 2);
1326 check_spends!(as_htlc_claim_tx[0], revoked_htlc_success_txn[0]);
1327 check_spends!(as_htlc_claim_tx[1], revoked_local_txn[0]); // A has to generate a new claim for the remaining revoked
1328 // outputs (which no longer includes the spent HTLC output)
1330 assert_eq!(as_balances,
1331 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1333 assert_eq!(as_htlc_claim_tx[0].output.len(), 1);
1334 fuzzy_assert_eq(as_htlc_claim_tx[0].output[0].value,
1335 3_000 - chan_feerate * (revoked_htlc_success_txn[0].weight() + as_htlc_claim_tx[0].weight()) as u64 / 1000);
1337 mine_transaction(&nodes[0], &as_htlc_claim_tx[0]);
1338 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1339 // to_remote output in B's revoked commitment
1340 claimable_amount_satoshis: 1_000_000 - 11_000 - 3_000 - chan_feerate *
1341 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1342 confirmation_height: to_remote_conf_height,
1343 }, Balance::CounterpartyRevokedOutputClaimable {
1344 // to_self output in B's revoked commitment
1345 claimable_amount_satoshis: 10_000,
1346 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1347 claimable_amount_satoshis: 1_000,
1348 }, Balance::ClaimableAwaitingConfirmations {
1349 claimable_amount_satoshis: as_htlc_claim_tx[0].output[0].value,
1350 confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1352 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1354 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 3);
1355 test_spendable_output(&nodes[0], &revoked_local_txn[0]);
1356 assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1357 // to_self output to B
1358 claimable_amount_satoshis: 10_000,
1359 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1360 claimable_amount_satoshis: 1_000,
1361 }, Balance::ClaimableAwaitingConfirmations {
1362 claimable_amount_satoshis: as_htlc_claim_tx[0].output[0].value,
1363 confirmation_height: nodes[0].best_block_info().1 + 2,
1365 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1367 connect_blocks(&nodes[0], 2);
1368 test_spendable_output(&nodes[0], &as_htlc_claim_tx[0]);
1369 assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1370 // to_self output in B's revoked commitment
1371 claimable_amount_satoshis: 10_000,
1372 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1373 claimable_amount_satoshis: 1_000,
1375 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1377 connect_blocks(&nodes[0], revoked_htlc_timeout_txn[0].lock_time.0 - nodes[0].best_block_info().1);
1378 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(&nodes[0],
1379 [HTLCDestination::FailedPayment { payment_hash: failed_payment_hash }]);
1380 // As time goes on A may split its revocation claim transaction into multiple.
1381 let as_fewer_input_rbf = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1382 for tx in as_fewer_input_rbf.iter() {
1383 check_spends!(tx, revoked_local_txn[0]);
1386 // Connect a number of additional blocks to ensure we don't forget the HTLC output needs
1388 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
1389 let as_fewer_input_rbf = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1390 for tx in as_fewer_input_rbf.iter() {
1391 check_spends!(tx, revoked_local_txn[0]);
1394 mine_transaction(&nodes[0], &revoked_htlc_timeout_txn[0]);
1395 let as_second_htlc_claim_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1396 assert_eq!(as_second_htlc_claim_tx.len(), 2);
1398 check_spends!(as_second_htlc_claim_tx[0], revoked_htlc_timeout_txn[0]);
1399 check_spends!(as_second_htlc_claim_tx[1], revoked_local_txn[0]);
1401 // Connect blocks to finalize the HTLC resolution with the HTLC-Timeout transaction. In a
1402 // previous iteration of the revoked balance handling this would result in us "forgetting" that
1403 // the revoked HTLC output still needed to be claimed.
1404 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
1405 assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1406 // to_self output in B's revoked commitment
1407 claimable_amount_satoshis: 10_000,
1408 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1409 claimable_amount_satoshis: 1_000,
1411 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1413 mine_transaction(&nodes[0], &as_second_htlc_claim_tx[0]);
1414 assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1415 // to_self output in B's revoked commitment
1416 claimable_amount_satoshis: 10_000,
1417 }, Balance::ClaimableAwaitingConfirmations {
1418 claimable_amount_satoshis: as_second_htlc_claim_tx[0].output[0].value,
1419 confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1421 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1423 mine_transaction(&nodes[0], &as_second_htlc_claim_tx[1]);
1424 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1425 // to_self output in B's revoked commitment
1426 claimable_amount_satoshis: as_second_htlc_claim_tx[1].output[0].value,
1427 confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
1428 }, Balance::ClaimableAwaitingConfirmations {
1429 claimable_amount_satoshis: as_second_htlc_claim_tx[0].output[0].value,
1430 confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 2,
1432 sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1434 connect_blocks(&nodes[0], ANTI_REORG_DELAY - 2);
1435 test_spendable_output(&nodes[0], &as_second_htlc_claim_tx[0]);
1436 connect_blocks(&nodes[0], 1);
1437 test_spendable_output(&nodes[0], &as_second_htlc_claim_tx[1]);
1439 assert_eq!(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances(), Vec::new());
1443 fn test_revoked_counterparty_aggregated_claims() {
1444 // Tests `get_claimable_balances` for revoked counterparty commitment transactions when
1445 // claiming with an aggregated claim transaction.
1446 let mut chanmon_cfgs = create_chanmon_cfgs(2);
1447 // We broadcast a second-to-latest commitment transaction, without providing the revocation
1448 // secret to the counterparty. However, because we always immediately take the revocation
1449 // secret from the keys_manager, we would panic at broadcast as we're trying to sign a
1450 // transaction which, from the point of view of our keys_manager, is revoked.
1451 chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
1452 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1453 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1454 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1456 let (_, _, chan_id, funding_tx) =
1457 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 100_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features());
1458 let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
1459 assert_eq!(funding_outpoint.to_channel_id(), chan_id);
1461 // We create two HTLCs, one which we will give A the preimage to to generate an HTLC-Success
1462 // transaction, and one which we will not, allowing B to claim the HTLC output in an aggregated
1463 // revocation-claim transaction.
1465 let (claimed_payment_preimage, claimed_payment_hash, ..) = route_payment(&nodes[1], &[&nodes[0]], 3_000_000);
1466 let revoked_payment_hash = route_payment(&nodes[1], &[&nodes[0]], 4_000_000).1;
1468 let htlc_cltv_timeout = nodes[1].best_block_info().1 + TEST_FINAL_CLTV + 1; // Note ChannelManager adds one to CLTV timeouts for safety
1470 // Cheat by giving A's ChannelMonitor the preimage to the to-be-claimed HTLC so that we have an
1471 // HTLC-claim transaction on the to-be-revoked state.
1472 get_monitor!(nodes[0], chan_id).provide_payment_preimage(&claimed_payment_hash, &claimed_payment_preimage,
1473 &node_cfgs[0].tx_broadcaster, &LowerBoundedFeeEstimator::new(node_cfgs[0].fee_estimator), &nodes[0].logger);
1475 // Now get the latest commitment transaction from A and then update the fee to revoke it
1476 let as_revoked_txn = get_local_commitment_txn!(nodes[0], chan_id);
1478 assert_eq!(as_revoked_txn.len(), 2);
1479 check_spends!(as_revoked_txn[0], funding_tx);
1480 check_spends!(as_revoked_txn[1], as_revoked_txn[0]); // The HTLC-Claim transaction
1482 let opt_anchors = get_opt_anchors!(nodes[0], chan_id);
1483 let chan_feerate = get_feerate!(nodes[0], chan_id) as u64;
1486 let mut feerate = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap();
1489 nodes[0].node.timer_tick_occurred();
1490 check_added_monitors!(nodes[0], 1);
1492 let fee_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1493 nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &fee_update.update_fee.unwrap());
1494 commitment_signed_dance!(nodes[1], nodes[0], fee_update.commitment_signed, false);
1496 nodes[0].node.claim_funds(claimed_payment_preimage);
1497 expect_payment_claimed!(nodes[0], claimed_payment_hash, 3_000_000);
1498 check_added_monitors!(nodes[0], 1);
1499 let _a_htlc_msgs = get_htlc_update_msgs!(&nodes[0], nodes[1].node.get_our_node_id());
1501 assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
1502 claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
1503 }, Balance::MaybeTimeoutClaimableHTLC {
1504 claimable_amount_satoshis: 4_000,
1505 claimable_height: htlc_cltv_timeout,
1506 }, Balance::MaybeTimeoutClaimableHTLC {
1507 claimable_amount_satoshis: 3_000,
1508 claimable_height: htlc_cltv_timeout,
1510 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1512 mine_transaction(&nodes[1], &as_revoked_txn[0]);
1513 check_closed_broadcast!(nodes[1], true);
1514 check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
1515 check_added_monitors!(nodes[1], 1);
1517 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();
1518 // Currently the revoked commitment outputs are all claimed in one aggregated transaction
1519 assert_eq!(claim_txn.len(), 1);
1520 assert_eq!(claim_txn[0].input.len(), 3);
1521 check_spends!(claim_txn[0], as_revoked_txn[0]);
1523 let to_remote_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1525 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1526 // to_remote output in A's revoked commitment
1527 claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
1528 confirmation_height: to_remote_maturity,
1529 }, Balance::CounterpartyRevokedOutputClaimable {
1530 // to_self output in A's revoked commitment
1531 claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1532 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1533 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1534 claimable_amount_satoshis: 4_000,
1535 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1536 claimable_amount_satoshis: 3_000,
1538 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1540 // Confirm A's HTLC-Success tranasction which presumably raced B's claim, causing B to create a
1542 mine_transaction(&nodes[1], &as_revoked_txn[1]);
1543 expect_payment_sent!(nodes[1], claimed_payment_preimage);
1544 let mut claim_txn_2: Vec<_> = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
1545 claim_txn_2.sort_unstable_by_key(|tx| if tx.input.iter().any(|inp| inp.previous_output.txid == as_revoked_txn[0].txid()) { 0 } else { 1 });
1546 // Once B sees the HTLC-Success transaction it splits its claim transaction into two, though in
1547 // theory it could re-aggregate the claims as well.
1548 assert_eq!(claim_txn_2.len(), 2);
1549 assert_eq!(claim_txn_2[0].input.len(), 2);
1550 check_spends!(claim_txn_2[0], as_revoked_txn[0]);
1551 assert_eq!(claim_txn_2[1].input.len(), 1);
1552 check_spends!(claim_txn_2[1], as_revoked_txn[1]);
1554 assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
1555 // to_remote output in A's revoked commitment
1556 claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
1557 confirmation_height: to_remote_maturity,
1558 }, Balance::CounterpartyRevokedOutputClaimable {
1559 // to_self output in A's revoked commitment
1560 claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1561 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1562 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1563 claimable_amount_satoshis: 4_000,
1564 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1565 // The amount here is a bit of a misnomer, really its been reduced by the HTLC
1566 // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
1567 // anyway, so its not a big change.
1568 claimable_amount_satoshis: 3_000,
1570 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1572 connect_blocks(&nodes[1], 5);
1573 test_spendable_output(&nodes[1], &as_revoked_txn[0]);
1575 assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1576 // to_self output in A's revoked commitment
1577 claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1578 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1579 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1580 claimable_amount_satoshis: 4_000,
1581 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
1582 // The amount here is a bit of a misnomer, really its been reduced by the HTLC
1583 // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
1584 // anyway, so its not a big change.
1585 claimable_amount_satoshis: 3_000,
1587 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1589 mine_transaction(&nodes[1], &claim_txn_2[1]);
1590 let htlc_2_claim_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1592 assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1593 // to_self output in A's revoked commitment
1594 claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1595 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1596 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1597 claimable_amount_satoshis: 4_000,
1598 }, Balance::ClaimableAwaitingConfirmations { // HTLC 2
1599 claimable_amount_satoshis: claim_txn_2[1].output[0].value,
1600 confirmation_height: htlc_2_claim_maturity,
1602 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1604 connect_blocks(&nodes[1], 5);
1605 test_spendable_output(&nodes[1], &claim_txn_2[1]);
1607 assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
1608 // to_self output in A's revoked commitment
1609 claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
1610 (channel::commitment_tx_base_weight(opt_anchors) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
1611 }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
1612 claimable_amount_satoshis: 4_000,
1614 sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
1616 mine_transaction(&nodes[1], &claim_txn_2[0]);
1617 let rest_claim_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
1619 assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
1620 claimable_amount_satoshis: claim_txn_2[0].output[0].value,
1621 confirmation_height: rest_claim_maturity,
1623 nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
1625 assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); // We shouldn't fail the payment until we spend the output
1627 connect_blocks(&nodes[1], 5);
1628 expect_payment_failed!(nodes[1], revoked_payment_hash, false);
1629 test_spendable_output(&nodes[1], &claim_txn_2[0]);
1630 assert!(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances().is_empty());