[wip] Port monitor_tests to P2A anchors

Author: tankyleo

lightning/src/chain/channelmonitor.rs

@@ -5800,6 +5800,8 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 								assert_eq!(&bitcoin::Address::p2wsh(&ScriptBuf::from(input.witness.last().unwrap().to_vec()), bitcoin::Network::Bitcoin).script_pubkey(), _script_pubkey);
 							} else if _script_pubkey.is_p2wpkh() {
 								assert_eq!(&bitcoin::Address::p2wpkh(&bitcoin::CompressedPublicKey(bitcoin::PublicKey::from_slice(&input.witness.last().unwrap()).unwrap().inner), bitcoin::Network::Bitcoin).script_pubkey(), _script_pubkey);
+							} else if _script_pubkey == &chan_utils::shared_anchor_script_pubkey() {
+								assert!(input.witness.is_empty());
 							} else { panic!(); }
 						}
 						return true;

lightning/src/ln/functional_test_utils.rs

@@ -1941,11 +1941,15 @@ pub fn update_nodes_with_chan_announce<'a, 'b, 'c, 'd>(
 pub fn do_check_spends<F: Fn(&bitcoin::transaction::OutPoint) -> Option<TxOut>>(
 	tx: &Transaction, get_output: F,
 ) {
+	let mut single_output_below_dust = false;
 	for outp in tx.output.iter() {
-		assert!(
-			outp.value >= outp.script_pubkey.minimal_non_dust(),
-			"Spending tx output didn't meet dust limit"
-		);
+		if outp.value < outp.script_pubkey.minimal_non_dust() {
+			if single_output_below_dust {
+				panic!("Spending tx output didn't meet dust limit");
+			} else {
+				single_output_below_dust = true;
+			}
+		};
 	}
 	let mut total_value_in = 0;
 	for input in tx.input.iter() {
@@ -1955,9 +1959,15 @@ pub fn do_check_spends<F: Fn(&bitcoin::transaction::OutPoint) -> Option<TxOut>>(
 	for output in tx.output.iter() {
 		total_value_out += output.value.to_sat();
 	}
-	let min_fee = (tx.weight().to_wu() as u64 + 3) / 4; // One sat per vbyte (ie per weight/4, rounded up)
-													// Input amount - output amount = fee, so check that out + min_fee is smaller than input
-	assert!(total_value_out + min_fee <= total_value_in);
+	if single_output_below_dust {
+		assert_eq!(
+			total_value_in, total_value_out,
+			"Spending tx has one output below dust, while not zero fee"
+		);
+	} else {
+		let min_fee = (tx.weight().to_wu() as u64 + 3) / 4; // One sat per vbyte (ie per weight/4, rounded up)
+		assert!(total_value_out + min_fee <= total_value_in);
+	}
 	tx.verify(get_output).unwrap();
 }
 
@@ -1966,8 +1976,15 @@ macro_rules! check_spends {
 	($tx: expr, $($spends_txn: expr),*) => {
 		{
 			$(
+			let mut single_output_below_dust = false;
 			for outp in $spends_txn.output.iter() {
-				assert!(outp.value >= outp.script_pubkey.minimal_non_dust(), "Input tx output didn't meet dust limit");
+				if outp.value.lt(&outp.script_pubkey.minimal_non_dust()) {
+					if single_output_below_dust || outp.script_pubkey != crate::ln::chan_utils::shared_anchor_script_pubkey() {
+						panic!("Input tx output didn't meet dust limit");
+					} else {
+						single_output_below_dust = true;
+					}
+				}
 			}
 			)*
 			let get_output = |out_point: &bitcoin::transaction::OutPoint| {
@@ -1980,7 +1997,10 @@ macro_rules! check_spends {
 			};
 			$crate::ln::functional_test_utils::do_check_spends(&$tx, get_output);
 		}
-	}
+	};
+	($tx: expr, $($spends_txn: expr),*) => {
+		check_spends!($tx, $($spends_txn; false),*)
+	};
 }
 
 macro_rules! get_closing_signed_broadcast {

lightning/src/ln/monitor_tests.rs

@@ -309,17 +309,20 @@ fn archive_fully_resolved_monitors() {
 	}
 }
 
-fn do_chanmon_claim_value_coop_close(anchors: bool) {
+fn do_chanmon_claim_value_coop_close(keyed_anchors: bool, p2a_anchor: bool) {
 	// Tests `get_claimable_balances` returns the correct values across a simple cooperative claim.
 	// Specifically, this tests that the channel non-HTLC balances show up in
 	// `get_claimable_balances` until the cooperative claims have confirmed and generated a
 	// `SpendableOutputs` event, and no longer.
 	let chanmon_cfgs = create_chanmon_cfgs(2);
 	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 	let mut user_config = test_default_channel_config();
-	if anchors {
+	if keyed_anchors {
 		user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
 		user_config.manually_accept_inbound_channels = true;
+	} else if p2a_anchor {
+		user_config.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
+		user_config.manually_accept_inbound_channels = true;
 	}
 	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config.clone()), Some(user_config)]);
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
@@ -333,7 +336,7 @@ fn do_chanmon_claim_value_coop_close(anchors: bool) {
 	let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 
 	let commitment_tx_fee = chan_feerate * chan_utils::commitment_tx_base_weight(&channel_type_features) / 1000;
-	let anchor_outputs_value = if anchors { channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 };
+	let anchor_outputs_value = if keyed_anchors { channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 };
 	assert_eq!(vec![Balance::ClaimableOnChannelClose {
 			balance_candidates: vec![HolderCommitmentTransactionBalance {
 				amount_satoshis: 1_000_000 - 1_000 - commitment_tx_fee - anchor_outputs_value,
@@ -434,8 +437,9 @@ fn do_chanmon_claim_value_coop_close(anchors: bool) {
 
 #[test]
 fn chanmon_claim_value_coop_close() {
-	do_chanmon_claim_value_coop_close(false);
-	do_chanmon_claim_value_coop_close(true);
+	do_chanmon_claim_value_coop_close(false, false);
+	do_chanmon_claim_value_coop_close(true, false);
+	do_chanmon_claim_value_coop_close(false, true);
 }
 
 fn sorted_vec<T: Ord>(mut v: Vec<T>) -> Vec<T> {
@@ -454,7 +458,7 @@ fn fuzzy_assert_eq<V: core::convert::TryInto<u64>>(a: V, b: V) {
 	assert!(b_u64 >= a_u64 - 5);
 }
 
-fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
+fn do_test_claim_value_force_close(keyed_anchors: bool, p2a_anchor: bool, prev_commitment_tx: bool) {
 	// Tests `get_claimable_balances` with an HTLC across a force-close.
 	// We build a channel with an HTLC pending, then force close the channel and check that the
 	// `get_claimable_balances` return value is correct as transactions confirm on-chain.
@@ -468,9 +472,12 @@ fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 	}
 	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 	let mut user_config = test_default_channel_config();
-	if anchors {
+	if keyed_anchors {
 		user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
 		user_config.manually_accept_inbound_channels = true;
+	} else if p2a_anchor {
+		user_config.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
+		user_config.manually_accept_inbound_channels = true;
 	}
 	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(user_config.clone()), Some(user_config)]);
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
@@ -535,13 +542,13 @@ fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 	// as claimable. A lists both its to-self balance and the (possibly-claimable) HTLCs.
 	let commitment_tx_fee = chan_feerate as u64 *
 		(chan_utils::commitment_tx_base_weight(&channel_type_features) + 2 * chan_utils::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
-	let anchor_outputs_value = if anchors { 2 * channel::ANCHOR_OUTPUT_VALUE_SATOSHI } else { 0 };
+	let anchor_outputs_value = if keyed_anchors { 2 * channel::ANCHOR_OUTPUT_VALUE_SATOSHI } else { 0 };
 	let amount_satoshis = 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - commitment_tx_fee - anchor_outputs_value - 1; /* msat amount that is burned to fees */
 	assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
 			balance_candidates: vec![HolderCommitmentTransactionBalance {
 				amount_satoshis,
 				// In addition to `commitment_tx_fee`, this also includes the dust HTLC, and the total msat amount rounded down from non-dust HTLCs
-				transaction_fee_satoshis: 1_000_000 - 4_000 - 3_000 - 1_000 - amount_satoshis - anchor_outputs_value,
+				transaction_fee_satoshis: if p2a_anchor { 0 } else { 1_000_000 - 4_000 - 3_000 - 1_000 - amount_satoshis - anchor_outputs_value },
 			}],
 			confirmed_balance_candidate_index: 0,
 			outbound_payment_htlc_rounded_msat: 3300,
@@ -611,7 +618,7 @@ fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 			balance_candidates: vec![HolderCommitmentTransactionBalance {
 				amount_satoshis, // Channel funding value in satoshis
 				// In addition to `commitment_tx_fee`, this also includes the dust HTLC, and the total msat amount rounded down from non-dust HTLCs
-				transaction_fee_satoshis: 1_000_000 - 4_000 - 3_000 - 1_000 - amount_satoshis - anchor_outputs_value,
+				transaction_fee_satoshis: if p2a_anchor { 0 } else { 1_000_000 - 4_000 - 3_000 - 1_000 - amount_satoshis - anchor_outputs_value },
 			}],
 			confirmed_balance_candidate_index: 0,
 			outbound_payment_htlc_rounded_msat: 3000 + if prev_commitment_tx {
@@ -645,7 +652,7 @@ fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 	mine_transaction(&nodes[0], &remote_txn[0]);
 	mine_transaction(&nodes[1], &remote_txn[0]);
 
-	if anchors {
+	if keyed_anchors || p2a_anchor {
 		let mut events = nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events();
 		assert_eq!(events.len(), 1);
 		match events.pop().unwrap() {
@@ -674,8 +681,8 @@ fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 	// b_broadcast_txn should spend the HTLCs output of the commitment tx for 3_000 and 4_000 sats
 	check_spends!(b_broadcast_txn[0], remote_txn[0], coinbase_tx);
 	check_spends!(b_broadcast_txn[1], remote_txn[0], coinbase_tx);
-	assert_eq!(b_broadcast_txn[0].input.len(), if anchors { 2 } else { 1 });
-	assert_eq!(b_broadcast_txn[1].input.len(), if anchors { 2 } else { 1 });
+	assert_eq!(b_broadcast_txn[0].input.len(), if keyed_anchors || p2a_anchor { 2 } else { 1 });
+	assert_eq!(b_broadcast_txn[1].input.len(), if keyed_anchors || p2a_anchor { 2 } else { 1 });
 	assert_eq!(remote_txn[0].output[b_broadcast_txn[0].input[0].previous_output.vout as usize].value.to_sat(), 3_000);
 	assert_eq!(remote_txn[0].output[b_broadcast_txn[1].input[0].previous_output.vout as usize].value.to_sat(), 4_000);
 
@@ -807,7 +814,7 @@ fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 	// After reaching the commitment output CSV, we'll get a SpendableOutputs event for it and have
 	// only the HTLCs claimable on node B.
 	connect_blocks(&nodes[1], node_b_commitment_claimable - nodes[1].best_block_info().1);
-	test_spendable_output(&nodes[1], &remote_txn[0], anchors);
+	test_spendable_output(&nodes[1], &remote_txn[0], keyed_anchors || p2a_anchor);
 
 	assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 			amount_satoshis: 3_000,
@@ -819,7 +826,7 @@ fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 	// After reaching the claimed HTLC output CSV, we'll get a SpendableOutptus event for it and
 	// have only one HTLC output left spendable.
 	connect_blocks(&nodes[1], node_b_htlc_claimable - nodes[1].best_block_info().1);
-	test_spendable_output(&nodes[1], &b_broadcast_txn[0], anchors);
+	test_spendable_output(&nodes[1], &b_broadcast_txn[0], keyed_anchors || p2a_anchor);
 
 	assert_eq!(vec![received_htlc_timeout_claiming_balance.clone()],
 		nodes[1].chain_monitor.chain_monitor.get_monitor(chan_id).unwrap().get_claimable_balances());
@@ -847,10 +854,12 @@ fn do_test_claim_value_force_close(anchors: bool, prev_commitment_tx: bool) {
 
 #[test]
 fn test_claim_value_force_close() {
-	do_test_claim_value_force_close(false, true);
-	do_test_claim_value_force_close(false, false);
-	do_test_claim_value_force_close(true, true);
-	do_test_claim_value_force_close(true, false);
+	do_test_claim_value_force_close(false, false, true);
+	do_test_claim_value_force_close(false, false, false);
+	do_test_claim_value_force_close(true, false, true);
+	do_test_claim_value_force_close(true, false, false);
+	do_test_claim_value_force_close(false, true, true);
+	do_test_claim_value_force_close(false, true, false);
 }
 
 fn do_test_balances_on_local_commitment_htlcs(anchors: bool) {
@@ -2496,7 +2505,7 @@ fn test_monitor_timer_based_claim() {
 	do_test_monitor_rebroadcast_pending_claims(true);
 }
 
-fn do_test_yield_anchors_events(have_htlcs: bool) {
+fn do_test_yield_anchors_events(have_htlcs: bool, p2a_anchor: bool) {
 	// Tests that two parties supporting anchor outputs can open a channel, route payments over
 	// it, and finalize its resolution uncooperatively. Once the HTLCs are locked in, one side will
 	// force close once the HTLCs expire. The force close should stem from an event emitted by LDK,
@@ -2508,6 +2517,7 @@ fn do_test_yield_anchors_events(have_htlcs: bool) {
 	let mut anchors_config = test_default_channel_config();
 	anchors_config.channel_handshake_config.announce_for_forwarding = true;
 	anchors_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
+	anchors_config.channel_handshake_config.negotiate_anchor_zero_fee_commitments = p2a_anchor;
 	anchors_config.manually_accept_inbound_channels = true;
 	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(anchors_config.clone()), Some(anchors_config)]);
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
@@ -2551,7 +2561,7 @@ fn do_test_yield_anchors_events(have_htlcs: bool) {
 	{
 		handle_bump_close_event(&nodes[1]);
 		let txn = nodes[1].tx_broadcaster.txn_broadcast();
-		assert_eq!(txn.len(), 1);
+		if p2a_anchor { assert_eq!(txn.len(), 2) } else { assert_eq!(txn.len(), 1) };
 		check_spends!(txn[0], funding_tx);
 	}
 
@@ -2601,7 +2611,10 @@ fn do_test_yield_anchors_events(have_htlcs: bool) {
 	};
 	check_spends!(commitment_tx, funding_tx);
 
-	if have_htlcs {
+	if have_htlcs && p2a_anchor {
+		assert_eq!(commitment_tx.output[1].value.to_sat(), 1_000); // HTLC A -> B
+		assert_eq!(commitment_tx.output[2].value.to_sat(), 2_000); // HTLC B -> A
+	} else if have_htlcs {
 		assert_eq!(commitment_tx.output[2].value.to_sat(), 1_000); // HTLC A -> B
 		assert_eq!(commitment_tx.output[3].value.to_sat(), 2_000); // HTLC B -> A
 	}
@@ -2626,12 +2639,12 @@ fn do_test_yield_anchors_events(have_htlcs: bool) {
 		assert_eq!(txn.len(), if nodes[1].connect_style.borrow().updates_best_block_first() { 3 } else { 1 });
 		if nodes[1].connect_style.borrow().updates_best_block_first() {
 			check_spends!(txn[1], funding_tx);
-			check_spends!(txn[2], txn[1]);  // Anchor output spend.
+			check_spends!(txn[2], txn[1], coinbase_tx); // Anchor output spend.
 		}
 		let htlc_claim_tx = &txn[0];
 		assert_eq!(htlc_claim_tx.input.len(), 2);
-		assert_eq!(htlc_claim_tx.input[0].previous_output.vout, 2);
-		assert_eq!(htlc_claim_tx.input[1].previous_output.vout, 3);
+		assert_eq!(htlc_claim_tx.input[0].previous_output.vout, if p2a_anchor { 1 } else { 2 });
+		assert_eq!(htlc_claim_tx.input[1].previous_output.vout, if p2a_anchor { 2 } else { 3 });
 		check_spends!(htlc_claim_tx, commitment_tx);
 	}
 
@@ -2681,8 +2694,10 @@ fn do_test_yield_anchors_events(have_htlcs: bool) {
 
 #[test]
 fn test_yield_anchors_events() {
-	do_test_yield_anchors_events(true);
-	do_test_yield_anchors_events(false);
+	do_test_yield_anchors_events(true, false);
+	do_test_yield_anchors_events(false, false);
+	do_test_yield_anchors_events(true, true);
+	do_test_yield_anchors_events(false, true);
 }
 
 #[test]