From: Matt Corallo <649246+TheBlueMatt@users.noreply.github.com>
Date: Fri, 14 Jan 2022 16:59:42 +0000 (+0000)
Subject: Merge pull request #1238 from TheBlueMatt/2022-01-lockorder-checks
X-Git-Tag: v0.0.105~39
X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;ds=inline;h=34cdca91baa0187d13969855129073c764f4c895;hp=-c;p=rust-lightning

Merge pull request #1238 from TheBlueMatt/2022-01-lockorder-checks

Fix and test lockorder
---

34cdca91baa0187d13969855129073c764f4c895
diff --combined lightning/src/ln/functional_tests.rs
index fe67188f,0999d6ec..0993caf4
--- a/lightning/src/ln/functional_tests.rs
+++ b/lightning/src/ln/functional_tests.rs
@@@ -18,11 -18,11 +18,11 @@@ use chain::channelmonitor::{ChannelMoni
  use chain::transaction::OutPoint;
  use chain::keysinterface::BaseSign;
  use ln::{PaymentPreimage, PaymentSecret, PaymentHash};
 -use ln::channel::{COMMITMENT_TX_BASE_WEIGHT, COMMITMENT_TX_WEIGHT_PER_HTLC, CONCURRENT_INBOUND_HTLC_FEE_BUFFER, FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE, MIN_AFFORDABLE_HTLC_COUNT};
 +use ln::channel::{commitment_tx_base_weight, COMMITMENT_TX_WEIGHT_PER_HTLC, CONCURRENT_INBOUND_HTLC_FEE_BUFFER, FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE, MIN_AFFORDABLE_HTLC_COUNT};
  use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, PaymentId, RAACommitmentOrder, PaymentSendFailure, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, PAYMENT_EXPIRY_BLOCKS };
  use ln::channel::{Channel, ChannelError};
  use ln::{chan_utils, onion_utils};
 -use ln::chan_utils::{HTLC_SUCCESS_TX_WEIGHT, HTLC_TIMEOUT_TX_WEIGHT, HTLCOutputInCommitment};
 +use ln::chan_utils::{htlc_success_tx_weight, htlc_timeout_tx_weight, HTLCOutputInCommitment};
  use routing::network_graph::RoutingFees;
  use routing::router::{Payee, Route, RouteHop, RouteHint, RouteHintHop, RouteParameters, find_route, get_route};
  use ln::features::{ChannelFeatures, InitFeatures, InvoiceFeatures, NodeFeatures};
@@@ -127,8 -127,7 +127,8 @@@ fn do_test_counterparty_no_reserve(send
  	// Have node0 initiate a channel to node1 with aforementioned parameters
  	let mut push_amt = 100_000_000;
  	let feerate_per_kw = 253;
 -	push_amt -= feerate_per_kw as u64 * (COMMITMENT_TX_BASE_WEIGHT + 4 * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000 * 1000;
 +	let opt_anchors = false;
 +	push_amt -= feerate_per_kw as u64 * (commitment_tx_base_weight(opt_anchors) + 4 * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000 * 1000;
  	push_amt -= Channel::<EnforcingSigner>::get_holder_selected_channel_reserve_satoshis(100_000) * 1000;
  
  	let temp_channel_id = nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, if send_from_initiator { 0 } else { push_amt }, 42, None).unwrap();
@@@ -164,7 -163,7 +164,7 @@@
  			// Note that for outbound channels we have to consider the commitment tx fee and the
  			// "fee spike buffer", which is currently a multiple of the total commitment tx fee as
  			// well as an additional HTLC.
 -			- FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE * commit_tx_fee_msat(feerate_per_kw, 2));
 +			- FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE * commit_tx_fee_msat(feerate_per_kw, 2, opt_anchors));
  	} else {
  		send_payment(&nodes[1], &[&nodes[0]], push_amt);
  	}
@@@ -648,14 -647,12 +648,14 @@@ fn test_update_fee_that_funder_cannot_a
  	let secp_ctx = Secp256k1::new();
  	let bs_channel_reserve_sats = Channel::<EnforcingSigner>::get_holder_selected_channel_reserve_satoshis(channel_value);
  
 +	let opt_anchors = false;
 +
  	// Calculate the maximum feerate that A can afford. Note that we don't send an update_fee
  	// CONCURRENT_INBOUND_HTLC_FEE_BUFFER HTLCs before actually running out of local balance, so we
  	// calculate two different feerates here - the expected local limit as well as the expected
  	// remote limit.
 -	let feerate = ((channel_value - bs_channel_reserve_sats - push_sats) * 1000 / (COMMITMENT_TX_BASE_WEIGHT + CONCURRENT_INBOUND_HTLC_FEE_BUFFER as u64 * COMMITMENT_TX_WEIGHT_PER_HTLC)) as u32;
 -	let non_buffer_feerate = ((channel_value - bs_channel_reserve_sats - push_sats) * 1000 / COMMITMENT_TX_BASE_WEIGHT) as u32;
 +	let feerate = ((channel_value - bs_channel_reserve_sats - push_sats) * 1000 / (commitment_tx_base_weight(opt_anchors) + CONCURRENT_INBOUND_HTLC_FEE_BUFFER as u64 * COMMITMENT_TX_WEIGHT_PER_HTLC)) as u32;
 +	let non_buffer_feerate = ((channel_value - bs_channel_reserve_sats - push_sats) * 1000 / commitment_tx_base_weight(opt_anchors)) as u32;
  	{
  		let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap();
  		*feerate_lock = feerate;
@@@ -674,7 -671,7 +674,7 @@@
  
  		//We made sure neither party's funds are below the dust limit and there are no HTLCs here
  		assert_eq!(commitment_tx.output.len(), 2);
 -		let total_fee: u64 = commit_tx_fee_msat(feerate, 0) / 1000;
 +		let total_fee: u64 = commit_tx_fee_msat(feerate, 0, opt_anchors) / 1000;
  		let mut actual_fee = commitment_tx.output.iter().fold(0, |acc, output| acc + output.value);
  		actual_fee = channel_value - actual_fee;
  		assert_eq!(total_fee, actual_fee);
@@@ -723,8 -720,8 +723,8 @@@
  		let commitment_tx = CommitmentTransaction::new_with_auxiliary_htlc_data(
  			INITIAL_COMMITMENT_NUMBER - 1,
  			push_sats,
 -			channel_value - push_sats - commit_tx_fee_msat(non_buffer_feerate + 4, 0) / 1000,
 -			false, local_funding, remote_funding,
 +			channel_value - push_sats - commit_tx_fee_msat(non_buffer_feerate + 4, 0, opt_anchors) / 1000,
 +			opt_anchors, local_funding, remote_funding,
  			commit_tx_keys.clone(),
  			non_buffer_feerate + 4,
  			&mut htlcs,
@@@ -1352,7 -1349,7 +1352,7 @@@ fn test_basic_channel_reserve() 
  	let channel_reserve = chan_stat.channel_reserve_msat;
  
  	// The 2* and +1 are for the fee spike reserve.
 -	let commit_tx_fee = 2 * commit_tx_fee_msat(get_feerate!(nodes[0], chan.2), 1 + 1);
 +	let commit_tx_fee = 2 * commit_tx_fee_msat(get_feerate!(nodes[0], chan.2), 1 + 1, get_opt_anchors!(nodes[0], chan.2));
  	let max_can_send = 5000000 - channel_reserve - commit_tx_fee;
  	let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], max_can_send + 1);
  	let err = nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).err().unwrap();
@@@ -1460,7 -1457,7 +1460,7 @@@ fn test_fee_spike_violation_fails_htlc(
  			commitment_number,
  			95000,
  			local_chan_balance,
 -			false, local_funding, remote_funding,
 +			local_chan.opt_anchors(), local_funding, remote_funding,
  			commit_tx_keys.clone(),
  			feerate_per_kw,
  			&mut vec![(accepted_htlc_info, ())],
@@@ -1515,10 -1512,8 +1515,10 @@@ fn test_chan_reserve_violation_outbound
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
 +	let opt_anchors = false;
 +
  	let mut push_amt = 100_000_000;
 -	push_amt -= commit_tx_fee_msat(feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT as u64);
 +	push_amt -= commit_tx_fee_msat(feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT as u64, opt_anchors);
  	push_amt -= Channel::<EnforcingSigner>::get_holder_selected_channel_reserve_satoshis(100_000) * 1000;
  
  	let _ = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, push_amt, InitFeatures::known(), InitFeatures::known());
@@@ -1544,13 -1539,11 +1544,13 @@@ fn test_chan_reserve_violation_inbound_
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
 +	let opt_anchors = false;
 +
  	// Set nodes[0]'s balance such that they will consider any above-dust received HTLC to be a
  	// channel reserve violation (so their balance is channel reserve (1000 sats) + commitment
  	// transaction fee with 0 HTLCs (183 sats)).
  	let mut push_amt = 100_000_000;
 -	push_amt -= commit_tx_fee_msat(feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT as u64);
 +	push_amt -= commit_tx_fee_msat(feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT as u64, opt_anchors);
  	push_amt -= Channel::<EnforcingSigner>::get_holder_selected_channel_reserve_satoshis(100_000) * 1000;
  	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, push_amt, InitFeatures::known(), InitFeatures::known());
  
@@@ -1597,18 -1590,16 +1597,18 @@@ fn test_chan_reserve_dust_inbound_htlcs
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None, None]);
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
 +	let opt_anchors = false;
 +
  	// Set nodes[0]'s balance such that they will consider any above-dust received HTLC to be a
  	// channel reserve violation (so their balance is channel reserve (1000 sats) + commitment
  	// transaction fee with 0 HTLCs (183 sats)).
  	let mut push_amt = 100_000_000;
 -	push_amt -= commit_tx_fee_msat(feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT as u64);
 +	push_amt -= commit_tx_fee_msat(feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT as u64, opt_anchors);
  	push_amt -= Channel::<EnforcingSigner>::get_holder_selected_channel_reserve_satoshis(100_000) * 1000;
  	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, push_amt, InitFeatures::known(), InitFeatures::known());
  
  	let dust_amt = crate::ln::channel::MIN_CHAN_DUST_LIMIT_SATOSHIS * 1000
 -		+ feerate_per_kw as u64 * HTLC_SUCCESS_TX_WEIGHT / 1000 * 1000 - 1;
 +		+ feerate_per_kw as u64 * htlc_success_tx_weight(opt_anchors) / 1000 * 1000 - 1;
  	// In the previous code, routing this dust payment would cause nodes[0] to perceive a channel
  	// reserve violation even though it's a dust HTLC and therefore shouldn't count towards the
  	// commitment transaction fee.
@@@ -1635,12 -1626,10 +1635,12 @@@ fn test_chan_init_feerate_unaffordabili
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
 +	let opt_anchors = false;
 +
  	// Set the push_msat amount such that nodes[0] will not be able to afford to add even a single
  	// HTLC.
  	let mut push_amt = 100_000_000;
 -	push_amt -= commit_tx_fee_msat(feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT as u64);
 +	push_amt -= commit_tx_fee_msat(feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT as u64, opt_anchors);
  	assert_eq!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, push_amt + 1, 42, None).unwrap_err(),
  		APIError::APIMisuseError { err: "Funding amount (356) can't even pay fee for initial commitment transaction fee of 357.".to_string() });
  
@@@ -1705,10 -1694,9 +1705,10 @@@ fn test_chan_reserve_violation_inbound_
  	let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat;
  	let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
  	let feerate = get_feerate!(nodes[0], chan.2);
 +	let opt_anchors = get_opt_anchors!(nodes[0], chan.2);
  
  	// Add a 2* and +1 for the fee spike reserve.
 -	let commit_tx_fee_2_htlc = 2*commit_tx_fee_msat(feerate, 2 + 1);
 +	let commit_tx_fee_2_htlc = 2*commit_tx_fee_msat(feerate, 2 + 1, opt_anchors);
  	let recv_value_1 = (chan_stat.value_to_self_msat - chan_stat.channel_reserve_msat - total_routing_fee_msat - commit_tx_fee_2_htlc)/2;
  	let amt_msat_1 = recv_value_1 + total_routing_fee_msat;
  
@@@ -1725,7 -1713,7 +1725,7 @@@
  	nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_1.msgs[0]);
  
  	// Attempt to trigger a channel reserve violation --> payment failure.
 -	let commit_tx_fee_2_htlcs = commit_tx_fee_msat(feerate, 2);
 +	let commit_tx_fee_2_htlcs = commit_tx_fee_msat(feerate, 2, opt_anchors);
  	let recv_value_2 = chan_stat.value_to_self_msat - amt_msat_1 - chan_stat.channel_reserve_msat - total_routing_fee_msat - commit_tx_fee_2_htlcs + 1;
  	let amt_msat_2 = recv_value_2 + total_routing_fee_msat;
  	let (route_2, _, _, _) = get_route_and_payment_hash!(nodes[0], nodes[2], amt_msat_2);
@@@ -1776,8 -1764,8 +1776,8 @@@ fn test_inbound_outbound_capacity_is_no
  	assert_eq!(channels1[0].inbound_capacity_msat, 100000 * 1000 - 95000000 - reserve*1000);
  }
  
 -fn commit_tx_fee_msat(feerate: u32, num_htlcs: u64) -> u64 {
 -	(COMMITMENT_TX_BASE_WEIGHT + num_htlcs * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate as u64 / 1000 * 1000
 +fn commit_tx_fee_msat(feerate: u32, num_htlcs: u64, opt_anchors: bool) -> u64 {
 +	(commitment_tx_base_weight(opt_anchors) + num_htlcs * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate as u64 / 1000 * 1000
  }
  
  #[test]
@@@ -1812,7 -1800,6 +1812,7 @@@ fn test_channel_reserve_holding_cell_ht
  	let feemsat = 239; // set above
  	let total_fee_msat = (nodes.len() - 2) as u64 * feemsat;
  	let feerate = get_feerate!(nodes[0], chan_1.2);
 +	let opt_anchors = get_opt_anchors!(nodes[0], chan_1.2);
  
  	let recv_value_0 = stat01.counterparty_max_htlc_value_in_flight_msat - total_fee_msat;
  
@@@ -1834,7 -1821,7 +1834,7 @@@
  		// 3 for the 3 HTLCs that will be sent, 2* and +1 for the fee spike reserve.
  		// Also, ensure that each payment has enough to be over the dust limit to
  		// ensure it'll be included in each commit tx fee calculation.
 -		let commit_tx_fee_all_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1);
 +		let commit_tx_fee_all_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1, opt_anchors);
  		let ensure_htlc_amounts_above_dust_buffer = 3 * (stat01.counterparty_dust_limit_msat + 1000);
  		if stat01.value_to_self_msat < stat01.channel_reserve_msat + commit_tx_fee_all_htlcs + ensure_htlc_amounts_above_dust_buffer + amt_msat {
  			break;
@@@ -1866,7 -1853,7 +1866,7 @@@
  	// the amount of the first of these aforementioned 3 payments. The reason we split into 3 payments
  	// is to test the behavior of the holding cell with respect to channel reserve and commit tx fee
  	// policy.
 -	let commit_tx_fee_2_htlcs = 2*commit_tx_fee_msat(feerate, 2 + 1);
 +	let commit_tx_fee_2_htlcs = 2*commit_tx_fee_msat(feerate, 2 + 1, opt_anchors);
  	let recv_value_1 = (stat01.value_to_self_msat - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs)/2;
  	let amt_msat_1 = recv_value_1 + total_fee_msat;
  
@@@ -1891,7 -1878,7 +1891,7 @@@
  	}
  
  	// split the rest to test holding cell
 -	let commit_tx_fee_3_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1);
 +	let commit_tx_fee_3_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1, opt_anchors);
  	let additional_htlc_cost_msat = commit_tx_fee_3_htlcs - commit_tx_fee_2_htlcs;
  	let recv_value_21 = recv_value_2/2 - additional_htlc_cost_msat/2;
  	let recv_value_22 = recv_value_2 - recv_value_21 - total_fee_msat - additional_htlc_cost_msat;
@@@ -2002,11 -1989,11 +2002,11 @@@
  	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21);
  	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22);
  
 -	let commit_tx_fee_0_htlcs = 2*commit_tx_fee_msat(feerate, 1);
 +	let commit_tx_fee_0_htlcs = 2*commit_tx_fee_msat(feerate, 1, opt_anchors);
  	let recv_value_3 = commit_tx_fee_2_htlcs - commit_tx_fee_0_htlcs - total_fee_msat;
  	send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3);
  
 -	let commit_tx_fee_1_htlc = 2*commit_tx_fee_msat(feerate, 1 + 1);
 +	let commit_tx_fee_1_htlc = 2*commit_tx_fee_msat(feerate, 1 + 1, opt_anchors);
  	let expected_value_to_self = stat01.value_to_self_msat - (recv_value_1 + total_fee_msat) - (recv_value_21 + total_fee_msat) - (recv_value_22 + total_fee_msat) - (recv_value_3 + total_fee_msat);
  	let stat0 = get_channel_value_stat!(nodes[0], chan_1.2);
  	assert_eq!(stat0.value_to_self_msat, expected_value_to_self);
@@@ -2481,7 -2468,7 +2481,7 @@@ fn revoked_output_claim() 
  	mine_transaction(&nodes[1], &revoked_local_txn[0]);
  	check_added_monitors!(nodes[1], 1);
  	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
- 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  	assert_eq!(node_txn.len(), 2); // ChannelMonitor: justice tx against revoked to_local output, ChannelManager: local commitment tx
  
  	check_spends!(node_txn[0], revoked_local_txn[0]);
@@@ -4645,7 -4632,7 +4645,7 @@@ fn test_claim_sizeable_push_msat() 
  	check_closed_broadcast!(nodes[1], true);
  	check_added_monitors!(nodes[1], 1);
  	check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed);
- 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  	assert_eq!(node_txn.len(), 1);
  	check_spends!(node_txn[0], chan.3);
  	assert_eq!(node_txn[0].output.len(), 2); // We can't force trimming of to_remote output as channel_reserve_satoshis block us to do so at channel opening
@@@ -4713,7 -4700,7 +4713,7 @@@ fn test_claim_on_remote_revoked_sizeabl
  	check_added_monitors!(nodes[1], 1);
  	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
  
- 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  	mine_transaction(&nodes[1], &node_txn[0]);
  	connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
  
@@@ -4756,7 -4743,7 +4756,7 @@@ fn test_static_spendable_outputs_preima
  	}
  
  	// Check B's monitor was able to send back output descriptor event for preimage tx on A's commitment tx
- 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelManager : 2 (local commitment tx + HTLC-Success), ChannelMonitor: preimage tx
+ 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (local commitment tx + HTLC-Success), ChannelMonitor: preimage tx
  	assert_eq!(node_txn.len(), 3);
  	check_spends!(node_txn[0], commitment_tx[0]);
  	assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
@@@ -4842,7 -4829,7 +4842,7 @@@ fn test_static_spendable_outputs_justic
  	check_added_monitors!(nodes[1], 1);
  	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
  
- 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  	assert_eq!(node_txn.len(), 2);
  	assert_eq!(node_txn[0].input.len(), 2);
  	check_spends!(node_txn[0], revoked_local_txn[0]);
@@@ -4895,7 -4882,7 +4895,7 @@@ fn test_static_spendable_outputs_justic
  	check_added_monitors!(nodes[1], 1);
  	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
  
- 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  	assert_eq!(node_txn.len(), 3); // ChannelMonitor: bogus justice tx, justice tx on revoked outputs, ChannelManager: local commitment tx
  	// The first transaction generated is bogus - it spends both outputs of revoked_local_txn[0]
  	// including the one already spent by revoked_htlc_txn[1]. That's OK, we'll spend with valid
@@@ -4951,7 -4938,7 +4951,7 @@@ fn test_static_spendable_outputs_justic
  	check_closed_broadcast!(nodes[1], true);
  	check_added_monitors!(nodes[1], 1);
  	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
- 	let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 	let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  
  	assert_eq!(revoked_htlc_txn.len(), 2);
  	assert_eq!(revoked_htlc_txn[0].input.len(), 1);
@@@ -4969,7 -4956,7 +4969,7 @@@
  	check_added_monitors!(nodes[0], 1);
  	check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
  
- 	let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 	let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  	assert_eq!(node_txn.len(), 3); // ChannelMonitor: justice tx on revoked commitment, justice tx on revoked HTLC-success, ChannelManager: local commitment tx
  
  	// The first transaction generated is bogus - it spends both outputs of revoked_local_txn[0]
@@@ -5110,7 -5097,7 +5110,7 @@@ fn test_onchain_to_onchain_claim() 
  	let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
  	mine_transaction(&nodes[1], &commitment_tx[0]);
  	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
- 	let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 	let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  	// ChannelMonitor: HTLC-Success tx, ChannelManager: local commitment tx + HTLC-Success tx
  	assert_eq!(b_txn.len(), 3);
  	check_spends!(b_txn[1], chan_1.3);
@@@ -6031,10 -6018,9 +6031,10 @@@ fn test_fail_holding_cell_htlc_upon_fre
  	let mut chan_stat = get_channel_value_stat!(nodes[0], chan.2);
  	let channel_reserve = chan_stat.channel_reserve_msat;
  	let feerate = get_feerate!(nodes[0], chan.2);
 +	let opt_anchors = get_opt_anchors!(nodes[0], chan.2);
  
  	// 2* and +1 HTLCs on the commit tx fee calculation for the fee spike reserve.
 -	let max_can_send = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 1 + 1);
 +	let max_can_send = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 1 + 1, opt_anchors);
  	let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], max_can_send);
  
  	// Send a payment which passes reserve checks but gets stuck in the holding cell.
@@@ -6111,11 -6097,10 +6111,11 @@@ fn test_free_and_fail_holding_cell_htlc
  	let mut chan_stat = get_channel_value_stat!(nodes[0], chan.2);
  	let channel_reserve = chan_stat.channel_reserve_msat;
  	let feerate = get_feerate!(nodes[0], chan.2);
 +	let opt_anchors = get_opt_anchors!(nodes[0], chan.2);
  
  	// 2* and +1 HTLCs on the commit tx fee calculation for the fee spike reserve.
  	let amt_1 = 20000;
 -	let amt_2 = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 2 + 1) - amt_1;
 +	let amt_2 = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 2 + 1, opt_anchors) - amt_1;
  	let (route_1, payment_hash_1, payment_preimage_1, payment_secret_1) = get_route_and_payment_hash!(nodes[0], nodes[1], amt_1);
  	let (route_2, payment_hash_2, _, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[1], amt_2);
  
@@@ -6237,12 -6222,11 +6237,12 @@@ fn test_fail_holding_cell_htlc_upon_fre
  	let mut chan_stat = get_channel_value_stat!(nodes[0], chan_0_1.2);
  	let channel_reserve = chan_stat.channel_reserve_msat;
  	let feerate = get_feerate!(nodes[0], chan_0_1.2);
 +	let opt_anchors = get_opt_anchors!(nodes[0], chan_0_1.2);
  
  	// Send a payment which passes reserve checks but gets stuck in the holding cell.
  	let feemsat = 239;
  	let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat;
 -	let max_can_send = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 1 + 1) - total_routing_fee_msat;
 +	let max_can_send = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 1 + 1, opt_anchors) - total_routing_fee_msat;
  	let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], max_can_send);
  	let payment_event = {
  		nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
@@@ -6517,9 -6501,8 +6517,9 @@@ fn test_update_add_htlc_bolt2_receiver_
  	let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
  	let channel_reserve = chan_stat.channel_reserve_msat;
  	let feerate = get_feerate!(nodes[0], chan.2);
 +	let opt_anchors = get_opt_anchors!(nodes[0], chan.2);
  	// The 2* and +1 are for the fee spike reserve.
 -	let commit_tx_fee_outbound = 2 * commit_tx_fee_msat(feerate, 1 + 1);
 +	let commit_tx_fee_outbound = 2 * commit_tx_fee_msat(feerate, 1 + 1, opt_anchors);
  
  	let max_can_send = 5000000 - channel_reserve - commit_tx_fee_outbound;
  	let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], max_can_send);
@@@ -8685,7 -8668,7 +8685,7 @@@ fn do_test_onchain_htlc_settlement_afte
  		};
  		let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
  		connect_block(&nodes[1], &Block { header, txdata: vec![txn_to_broadcast[0].clone()]});
- 		let mut bob_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ 		let mut bob_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
  		if broadcast_alice {
  			check_closed_broadcast!(nodes[1], true);
  			check_added_monitors!(nodes[1], 1);
@@@ -9383,8 -9366,6 +9383,8 @@@ fn do_test_max_dust_htlc_exposure(dust_
  	let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
  	nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
  
 +	let opt_anchors = false;
 +
  	let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], 1_000_000, 42);
  
  	if on_holder_tx {
@@@ -9409,10 -9390,10 +9409,10 @@@
  		let chan = chan_lock.by_id.get(&channel_id).unwrap();
  		chan.get_dust_buffer_feerate(None) as u64
  	};
 -	let dust_outbound_htlc_on_holder_tx_msat: u64 = (dust_buffer_feerate * HTLC_TIMEOUT_TX_WEIGHT / 1000 + open_channel.dust_limit_satoshis - 1) * 1000;
 +	let dust_outbound_htlc_on_holder_tx_msat: u64 = (dust_buffer_feerate * htlc_timeout_tx_weight(opt_anchors) / 1000 + open_channel.dust_limit_satoshis - 1) * 1000;
  	let dust_outbound_htlc_on_holder_tx: u64 = config.channel_options.max_dust_htlc_exposure_msat / dust_outbound_htlc_on_holder_tx_msat;
  
 -	let dust_inbound_htlc_on_holder_tx_msat: u64 = (dust_buffer_feerate * HTLC_SUCCESS_TX_WEIGHT / 1000 + open_channel.dust_limit_satoshis - 1) * 1000;
 +	let dust_inbound_htlc_on_holder_tx_msat: u64 = (dust_buffer_feerate * htlc_success_tx_weight(opt_anchors) / 1000 + open_channel.dust_limit_satoshis - 1) * 1000;
  	let dust_inbound_htlc_on_holder_tx: u64 = config.channel_options.max_dust_htlc_exposure_msat / dust_inbound_htlc_on_holder_tx_msat;
  
  	let dust_htlc_on_counterparty_tx: u64 = 25;