f test remote commitment HTLC timeout claim balances as well

Author: TheBlueMatt

lightning/src/ln/monitor_tests.rs

@@ -9,7 +9,7 @@
 
 //! Further functional tests which test blockchain reorganizations.
 
-use chain::channelmonitor::{ANTI_REORG_DELAY, ClaimableBalance};
+use chain::channelmonitor::{ANTI_REORG_DELAY, ClaimableBalance, HTLC_FAIL_BACK_BUFFER};
 use chain::transaction::OutPoint;
 use ln::{channel, PaymentPreimage, PaymentHash};
 use ln::channelmanager::BREAKDOWN_TIMEOUT;
@@ -197,7 +197,10 @@ fn test_claim_value_force_close() {
 	let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 };
 	assert_eq!(funding_outpoint.to_channel_id(), chan_id);
 
+	// This HTLC is immediately claimed, giving node B the preimage
 	let payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 3_000_000).0;
+	// This HTLC is allowed to time out, letting A claim it.
+	let timeout_payment_hash = route_payment(&nodes[0], &[&nodes[1]], 4_000_000).1;
 	// This HTLC will be dust, and not be claimable at all:
 	let (dust_payment_preimage, dust_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 3_000);
 
@@ -207,13 +210,16 @@ fn test_claim_value_force_close() {
 
 	let remote_txn = get_local_commitment_txn!(nodes[1], chan_id);
 	// Before B receives the payment preimage, it only suggests the push_msat value of 1_000 sats
-	// as claimable. A lists both its to-self balance and the (possibly-claimable) HTLC.
+	// as claimable. A lists both its to-self balance and the (possibly-claimable) HTLCs.
 	assert_eq!(sorted_vec(vec![ClaimableBalance::ClaimableOnChannelClose {
-			claimable_amount_satoshis: 1_000_000 - 3_000 - 1_000 - 3 - chan_feerate *
-				(channel::COMMITMENT_TX_BASE_WEIGHT + channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
+			claimable_amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *
+				(channel::COMMITMENT_TX_BASE_WEIGHT + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 		}, ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
 			claimable_amount_satoshis: 3_000,
 			claimable_height: htlc_cltv_timeout,
+		}, ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
+			claimable_amount_satoshis: 4_000,
+			claimable_height: htlc_cltv_timeout,
 		}]),
 		sorted_vec(nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances()));
 	assert_eq!(vec![ClaimableBalance::ClaimableOnChannelClose {
@@ -233,23 +239,27 @@ fn test_claim_value_force_close() {
 	// "claimable if you were to close the channel" balance.
 	assert_eq!(sorted_vec(vec![ClaimableBalance::ClaimableOnChannelClose {
 			claimable_amount_satoshis: 1_000_000 - // Channel funding value in satoshis
-				3_000 - // The larger HTLC value in satoshis
+				4_000 - // The to-be-failed HTLC value in satoshis
+				3_000 - // The claimed HTLC value in satoshis
 				1_000 - // The push_msat value in satoshis
 				3 - // The dust HTLC value in satoshis
-				// The commitment transaction fee with one HTLC output:
-				chan_feerate * (channel::COMMITMENT_TX_BASE_WEIGHT + channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
+				// The commitment transaction fee with two HTLC outputs:
+				chan_feerate * (channel::COMMITMENT_TX_BASE_WEIGHT + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 		}, ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
 			claimable_amount_satoshis: 3_000,
 			claimable_height: htlc_cltv_timeout,
+		}, ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
+			claimable_amount_satoshis: 4_000,
+			claimable_height: htlc_cltv_timeout,
 		}]),
 		sorted_vec(nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances()));
 	assert_eq!(vec![ClaimableBalance::ClaimableOnChannelClose {
 			claimable_amount_satoshis: 1_000 + 3_000,
 		}],
 		nodes[1].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances());
 
-	// Broadcast the closing transaction (which has the pending HTLC in it) and get B's broadcasted
-	// HTLC claim transaction with preimage.
+	// Broadcast the closing transaction (which has both pending HTLCs in it) and get B's
+	// broadcasted HTLC claim transaction with preimage.
 	let node_b_commitment_claimable = nodes[1].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
 	mine_transaction(&nodes[0], &remote_txn[0]);
 	mine_transaction(&nodes[1], &remote_txn[0]);
@@ -280,12 +290,15 @@ fn test_claim_value_force_close() {
 	assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 
 	assert_eq!(sorted_vec(vec![ClaimableBalance::ClaimableAwaitingConfirmations {
-			claimable_amount_satoshis: 1_000_000 - 3_000 - 1_000 - 3 - chan_feerate *
-				(channel::COMMITMENT_TX_BASE_WEIGHT + channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
+			claimable_amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *
+				(channel::COMMITMENT_TX_BASE_WEIGHT + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
 			confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
 		}, ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
 			claimable_amount_satoshis: 3_000,
 			claimable_height: htlc_cltv_timeout,
+		}, ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
+			claimable_amount_satoshis: 4_000,
+			claimable_height: htlc_cltv_timeout,
 		}]),
 		sorted_vec(nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances()));
 	// The main non-HTLC balance is just awaiting confirmations, but the claimable height is the
@@ -308,11 +321,14 @@ fn test_claim_value_force_close() {
 
 	// After ANTI_REORG_DELAY, A will consider its balance fully spendable and generate a
 	// `SpendableOutputs` event. However, B still has to wait for the CSV delay.
-	assert_eq!(vec![ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
+	assert_eq!(sorted_vec(vec![ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
 			claimable_amount_satoshis: 3_000,
 			claimable_height: htlc_cltv_timeout,
-		}],
-		nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances());
+		}, ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
+			claimable_amount_satoshis: 4_000,
+			claimable_height: htlc_cltv_timeout,
+		}]),
+		sorted_vec(nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances()));
 	assert_eq!(sorted_vec(vec![ClaimableBalance::ClaimableAwaitingConfirmations {
 			claimable_amount_satoshis: 1_000,
 			confirmation_height: node_b_commitment_claimable,
@@ -337,14 +353,60 @@ fn test_claim_value_force_close() {
 	// possibly-claimable up to ANTI_REORG_DELAY, at which point it will drop it.
 	mine_transaction(&nodes[0], &b_broadcast_txn[0]);
 	expect_payment_sent!(nodes[0], payment_preimage);
-	assert_eq!(vec![ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
+	assert_eq!(sorted_vec(vec![ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
 			claimable_amount_satoshis: 3_000,
 			claimable_height: htlc_cltv_timeout,
+		}, ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
+			claimable_amount_satoshis: 4_000,
+			claimable_height: htlc_cltv_timeout,
+		}]),
+		sorted_vec(nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances()));
+	connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
+	assert_eq!(vec![ClaimableBalance::MaybeClaimableHTLCAwaitingTimeout {
+			claimable_amount_satoshis: 4_000,
+			claimable_height: htlc_cltv_timeout,
 		}],
 		nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances());
+
+	// When the HTLC timeout output is spendable in the next block, A should broadcast it
+	connect_blocks(&nodes[0], htlc_cltv_timeout - nodes[0].best_block_info().1 - 1);
+	let a_broadcast_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
+	assert_eq!(a_broadcast_txn.len(), 3);
+	check_spends!(a_broadcast_txn[0], funding_tx);
+	assert_eq!(a_broadcast_txn[1].input.len(), 1);
+	check_spends!(a_broadcast_txn[1], remote_txn[0]);
+	assert_eq!(a_broadcast_txn[2].input.len(), 1);
+	check_spends!(a_broadcast_txn[2], remote_txn[0]);
+	assert_ne!(a_broadcast_txn[1].input[0].previous_output.vout,
+	           a_broadcast_txn[2].input[0].previous_output.vout);
+	// a_broadcast_txn [1] and [2] should spend the HTLC outputs of the commitment tx
+	assert_eq!(remote_txn[0].output[a_broadcast_txn[1].input[0].previous_output.vout as usize].value, 3_000);
+	assert_eq!(remote_txn[0].output[a_broadcast_txn[2].input[0].previous_output.vout as usize].value, 4_000);
+
+	// Once the HTLC-Timeout transaction confirms, A will no longer consider the HTLC
+	// "MaybeClaimable", but instead move it to "AwaitingConfirmations".
+	mine_transaction(&nodes[0], &a_broadcast_txn[2]);
+	assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
+	assert_eq!(vec![ClaimableBalance::ClaimableAwaitingConfirmations {
+			claimable_amount_satoshis: 4_000,
+			confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
+		}],
+		nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances());
+	// After ANTI_REORG_DELAY, A will generate a SpendableOutputs event and drop the claimable
+	// balance entry.
 	connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
 	assert_eq!(Vec::<ClaimableBalance>::new(),
 		nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances());
+	expect_payment_failed!(nodes[0], timeout_payment_hash, true);
+
+	let mut node_a_spendable = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
+	assert_eq!(node_a_spendable.len(), 1);
+	if let Event::SpendableOutputs { outputs } = node_a_spendable.pop().unwrap() {
+		assert_eq!(outputs.len(), 1);
+		let spend_tx = nodes[0].keys_manager.backing.spend_spendable_outputs(&[&outputs[0]], Vec::new(),
+			Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), 253, &Secp256k1::new()).unwrap();
+		check_spends!(spend_tx, a_broadcast_txn[2]);
+	} else { panic!(); }
 
 	// Node B will no longer consider the HTLC "contentious" after the HTLC claim transaction
 	// confirms, and consider it simply "awaiting confirmations". Note that it has to wait for the
@@ -361,6 +423,12 @@ fn test_claim_value_force_close() {
 		}]),
 		sorted_vec(nodes[1].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances()));
 
+	// nodes[1] will generate an event to fail-back the to-time-out HTLC at HTLC_FAIL_BACK_BUFFER
+	// blocks before it times out, though since the channel has already hit the chain no action
+	// will be taken.
+	connect_blocks(&nodes[1], node_b_htlc_claimable - HTLC_FAIL_BACK_BUFFER - nodes[1].best_block_info().1);
+	expect_pending_htlcs_forwardable!(nodes[1]);
+
 	// After reaching the commitment output CSV, we'll get a SpendableOutputs event for it and have
 	// only the HTLC claimable on node B.
 	connect_blocks(&nodes[1], node_b_commitment_claimable - nodes[1].best_block_info().1);