Test the accounting of dust exposure due to excess fees

This test checks to a 1msat precision the accounting of dust exposure
due to excess fees on counterparty commmitment and htlc transactions,
for both inbound and outbound htlcs.

Author: tankyleo

lightning/src/ln/functional_tests.rs

@@ -24,7 +24,7 @@ use crate::ln::types::ChannelId;
 use crate::types::payment::{PaymentPreimage, PaymentSecret, PaymentHash};
 use crate::ln::channel::{CONCURRENT_INBOUND_HTLC_FEE_BUFFER, FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE, MIN_AFFORDABLE_HTLC_COUNT, get_holder_selected_channel_reserve_satoshis, OutboundV1Channel, InboundV1Channel, COINBASE_MATURITY, Channel};
 use crate::ln::channelmanager::{self, PaymentId, RAACommitmentOrder, RecipientOnionFields, BREAKDOWN_TIMEOUT, ENABLE_GOSSIP_TICKS, DISABLE_GOSSIP_TICKS, MIN_CLTV_EXPIRY_DELTA};
-use crate::ln::channel::{DISCONNECT_PEER_AWAITING_RESPONSE_TICKS, ChannelError};
+use crate::ln::channel::{DISCONNECT_PEER_AWAITING_RESPONSE_TICKS, ChannelError, MIN_CHAN_DUST_LIMIT_SATOSHIS};
 use crate::ln::{chan_utils, onion_utils};
 use crate::ln::chan_utils::{commitment_tx_base_weight, COMMITMENT_TX_WEIGHT_PER_HTLC, OFFERED_HTLC_SCRIPT_WEIGHT, htlc_success_tx_weight, htlc_timeout_tx_weight, HTLCOutputInCommitment};
 use crate::routing::gossip::{NetworkGraph, NetworkUpdate};
@@ -37,7 +37,7 @@ use crate::util::test_utils::{self, TestLogger, WatchtowerPersister};
 use crate::util::errors::APIError;
 use crate::util::ser::{Writeable, ReadableArgs};
 use crate::util::string::UntrustedString;
-use crate::util::config::{UserConfig, MaxDustHTLCExposure};
+use crate::util::config::{UserConfig, MaxDustHTLCExposure, ChannelConfigUpdate};
 
 use bitcoin::hash_types::BlockHash;
 use bitcoin::locktime::absolute::LockTime;
@@ -10672,6 +10672,204 @@ fn test_nondust_htlc_excess_fees_are_dust() {
 	expect_payment_failed_conditions(&nodes[2], payment_hash, false, PaymentFailedConditions::new());
 }
 
+fn do_test_nondust_htlc_fees_dust_exposure_delta(features: ChannelTypeFeatures) {
+	// Tests the increase in htlc dust exposure due to the excess mining fees of a single non-dust
+	// HTLC on the counterparty commitment transaction, for both incoming and outgoing htlcs.
+	//
+	// Brings the dust exposure up to the base dust exposure using dust htlcs.
+	// Sets the max dust exposure to 1msat below the expected dust exposure given an additional non-dust htlc.
+	// Checks a failed payment for a non-dust htlc.
+	// Sets the max dust exposure equal to the expected dust exposure given an additional non-dust htlc.
+	// Checks a successful payment for a non-dust htlc.
+	//
+	// Runs this sequence for both directions.
+
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+
+	const DEFAULT_FEERATE: u64 = 253;
+	const HIGH_FEERATE: u64 = 275;
+	const EXCESS_FEERATE: u64 = HIGH_FEERATE - DEFAULT_FEERATE;
+
+	const DUST_HTLC_COUNT: usize = 4;
+	// Set dust htlcs to a satoshi value plus a non-zero msat amount to assert that
+	// the dust accounting rounds transaction fees to the lower satoshi, but does not round dust htlc values.
+	const DUST_HTLC_MSAT: u64 = 125_123;
+	const BASE_DUST_EXPOSURE_MSAT: u64 = DUST_HTLC_COUNT as u64 * DUST_HTLC_MSAT;
+
+	const NON_DUST_HTLC_MSAT: u64 = 4_000_000;
+
+	{
+		// Set the feerate of the channel funder above the `dust_exposure_limiting_feerate` of
+		// the fundee. This delta means that the fundee will add the mining fees of the commitment and
+		// htlc transactions in excess of its `dust_exposure_limiting_feerate` to its total dust htlc
+		// exposure.
+		let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap();
+		*feerate_lock = HIGH_FEERATE as u32;
+	}
+
+	// Set `expected_dust_exposure_msat` to match the calculation in `FundedChannel::can_accept_incoming_htlc`
+	// only_static_remote_key: 500_492 + 22 * (724 + 172) / 1000 * 1000 + 22 * 663 / 1000 * 1000 = 533_492
+	// anchors_zero_htlc_fee: 500_492 + 22 * (1_124 + 172) / 1000 * 1000 = 528_492
+	let mut expected_dust_exposure_msat = BASE_DUST_EXPOSURE_MSAT + EXCESS_FEERATE * (commitment_tx_base_weight(&features) + COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000 * 1000;
+	if features == ChannelTypeFeatures::only_static_remote_key() {
+		expected_dust_exposure_msat += EXCESS_FEERATE * htlc_timeout_tx_weight(&features) / 1000 * 1000;
+		assert_eq!(expected_dust_exposure_msat, 533_492);
+	} else {
+		assert_eq!(expected_dust_exposure_msat, 528_492);
+	}
+
+	let mut default_config = test_default_channel_config();
+	if features == ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies() {
+		default_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
+		// in addition to the one above, this setting is also needed to create an anchor channel
+		default_config.manually_accept_inbound_channels = true;
+	}
+
+	// Set node 1's max dust htlc exposure to 1msat below `expected_dust_exposure_msat`
+	let mut fixed_limit_config = default_config.clone();
+	fixed_limit_config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FixedLimitMsat(expected_dust_exposure_msat - 1);
+
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(default_config), Some(fixed_limit_config)]);
+	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	let chan_id = create_chan_between_nodes_with_value(&nodes[0], &nodes[1], 100_000, 50_000_000).3;
+
+	let node_1_dust_buffer_feerate = {
+		let per_peer_state = nodes[1].node.per_peer_state.read().unwrap();
+		let chan_lock = per_peer_state.get(&nodes[0].node.get_our_node_id()).unwrap().lock().unwrap();
+		let chan = chan_lock.channel_by_id.get(&chan_id).unwrap();
+		chan.context().get_dust_buffer_feerate(None) as u64
+	};
+
+	// Skip the router complaint when node 1 will attempt to pay node 0
+	let (route_1_0, payment_hash_1_0, _, payment_secret_1_0) = get_route_and_payment_hash!(nodes[1], nodes[0], NON_DUST_HTLC_MSAT);
+
+	// Bring node 1's dust htlc exposure up to `BASE_DUST_EXPOSURE_MSAT`
+	for _ in 0..DUST_HTLC_COUNT {
+		route_payment(&nodes[0], &[&nodes[1]], DUST_HTLC_MSAT);
+	}
+
+	assert_eq!(nodes[0].node.list_channels().len(), 1);
+	assert_eq!(nodes[1].node.list_channels().len(), 1);
+
+	assert_eq!(nodes[0].node.list_channels()[0].pending_inbound_htlcs.len(), 0);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_outbound_htlcs.len(), 0);
+	assert_eq!(nodes[0].node.list_channels()[0].pending_outbound_htlcs.len(), DUST_HTLC_COUNT);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_inbound_htlcs.len(), DUST_HTLC_COUNT);
+
+	// Send an additional non-dust htlc from 0 to 1, and check the complaint
+	let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], NON_DUST_HTLC_MSAT);
+	nodes[0].node.send_payment_with_route(route, payment_hash,
+		RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap();
+	check_added_monitors!(nodes[0], 1);
+	let mut events = nodes[0].node.get_and_clear_pending_msg_events();
+	assert_eq!(events.len(), 1);
+	let payment_event = SendEvent::from_event(events.remove(0));
+	nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
+	commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
+	expect_pending_htlcs_forwardable!(nodes[1]);
+	expect_htlc_handling_failed_destinations!(nodes[1].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]);
+	nodes[1].logger.assert_log("lightning::ln::channel",
+		format!("Cannot accept value that would put our total dust exposure at {} over the limit {} on counterparty commitment tx",
+			expected_dust_exposure_msat, expected_dust_exposure_msat - 1), 1);
+	check_added_monitors!(nodes[1], 1);
+
+	// Clear the failed htlc
+	let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
+	assert!(updates.update_add_htlcs.is_empty());
+	assert!(updates.update_fulfill_htlcs.is_empty());
+	assert_eq!(updates.update_fail_htlcs.len(), 1);
+	assert!(updates.update_fail_malformed_htlcs.is_empty());
+	assert!(updates.update_fee.is_none());
+	nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
+	commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false);
+	expect_payment_failed!(nodes[0], payment_hash, false);
+
+	assert_eq!(nodes[0].node.list_channels().len(), 1);
+	assert_eq!(nodes[1].node.list_channels().len(), 1);
+
+	assert_eq!(nodes[0].node.list_channels()[0].pending_inbound_htlcs.len(), 0);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_outbound_htlcs.len(), 0);
+	assert_eq!(nodes[0].node.list_channels()[0].pending_outbound_htlcs.len(), DUST_HTLC_COUNT);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_inbound_htlcs.len(), DUST_HTLC_COUNT);
+
+	// Set node 1's max dust htlc exposure equal to the `expected_dust_exposure_msat`
+	nodes[1].node.update_partial_channel_config(&nodes[0].node.get_our_node_id(), &[chan_id], &ChannelConfigUpdate {
+		max_dust_htlc_exposure_msat: Some(MaxDustHTLCExposure::FixedLimitMsat(expected_dust_exposure_msat)),
+		..ChannelConfigUpdate::default()
+	}).unwrap();
+
+	// Check a successful payment
+	send_payment(&nodes[0], &[&nodes[1]], NON_DUST_HTLC_MSAT);
+
+	assert_eq!(nodes[0].node.list_channels().len(), 1);
+	assert_eq!(nodes[1].node.list_channels().len(), 1);
+
+	assert_eq!(nodes[0].node.list_channels()[0].pending_inbound_htlcs.len(), 0);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_outbound_htlcs.len(), 0);
+	assert_eq!(nodes[0].node.list_channels()[0].pending_outbound_htlcs.len(), DUST_HTLC_COUNT);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_inbound_htlcs.len(), DUST_HTLC_COUNT);
+
+	// The `expected_dust_exposure_msat` for the outbound htlc changes in the non-anchor case, as the htlc success and timeout transactions have different weights
+	// only_static_remote_key: 500_492 + 22 * (724 + 172) / 1000 * 1000 + 22 * 703 / 1000 * 1000 = 534_492
+	if features == ChannelTypeFeatures::only_static_remote_key() {
+		expected_dust_exposure_msat = BASE_DUST_EXPOSURE_MSAT + EXCESS_FEERATE * (commitment_tx_base_weight(&features) + COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000 * 1000 + EXCESS_FEERATE * htlc_success_tx_weight(&features) / 1000 * 1000;
+		assert_eq!(expected_dust_exposure_msat, 534_492);
+	} else {
+		assert_eq!(expected_dust_exposure_msat, 528_492);
+	}
+
+	// Set node 1's max dust htlc exposure to 1msat below `expected_dust_exposure_msat`
+	nodes[1].node.update_partial_channel_config(&nodes[0].node.get_our_node_id(), &[chan_id], &ChannelConfigUpdate {
+		max_dust_htlc_exposure_msat: Some(MaxDustHTLCExposure::FixedLimitMsat(expected_dust_exposure_msat - 1)),
+		..ChannelConfigUpdate::default()
+	}).unwrap();
+
+	// Send an additional non-dust htlc from 1 to 0 using the pre-calculated route above, and check the immediate complaint
+	unwrap_send_err!(nodes[1], nodes[1].node.send_payment_with_route(route_1_0, payment_hash_1_0,
+			RecipientOnionFields::secret_only(payment_secret_1_0), PaymentId(payment_hash_1_0.0)
+		), true, APIError::ChannelUnavailable { .. }, {});
+	let dust_limit = if features == ChannelTypeFeatures::only_static_remote_key() {
+		MIN_CHAN_DUST_LIMIT_SATOSHIS * 1000 + htlc_success_tx_weight(&features) * node_1_dust_buffer_feerate / 1000 * 1000
+	} else {
+		MIN_CHAN_DUST_LIMIT_SATOSHIS * 1000
+	};
+	nodes[1].logger.assert_log("lightning::ln::outbound_payment",
+		format!("Failed to send along path due to error: Channel unavailable: Cannot send more than our next-HTLC maximum - {} msat", dust_limit), 1);
+	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
+
+	assert_eq!(nodes[0].node.list_channels().len(), 1);
+	assert_eq!(nodes[1].node.list_channels().len(), 1);
+
+	assert_eq!(nodes[0].node.list_channels()[0].pending_inbound_htlcs.len(), 0);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_outbound_htlcs.len(), 0);
+	assert_eq!(nodes[0].node.list_channels()[0].pending_outbound_htlcs.len(), DUST_HTLC_COUNT);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_inbound_htlcs.len(), DUST_HTLC_COUNT);
+
+	// Set node 1's max dust htlc exposure equal to `expected_dust_exposure_msat`
+	nodes[1].node.update_partial_channel_config(&nodes[0].node.get_our_node_id(), &[chan_id], &ChannelConfigUpdate {
+		max_dust_htlc_exposure_msat: Some(MaxDustHTLCExposure::FixedLimitMsat(expected_dust_exposure_msat)),
+		..ChannelConfigUpdate::default()
+	}).unwrap();
+
+	// Check a successful payment
+	send_payment(&nodes[1], &[&nodes[0]], NON_DUST_HTLC_MSAT);
+
+	assert_eq!(nodes[0].node.list_channels().len(), 1);
+	assert_eq!(nodes[1].node.list_channels().len(), 1);
+
+	assert_eq!(nodes[0].node.list_channels()[0].pending_inbound_htlcs.len(), 0);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_outbound_htlcs.len(), 0);
+	assert_eq!(nodes[0].node.list_channels()[0].pending_outbound_htlcs.len(), DUST_HTLC_COUNT);
+	assert_eq!(nodes[1].node.list_channels()[0].pending_inbound_htlcs.len(), DUST_HTLC_COUNT);
+}
+
+#[test]
+fn test_nondust_htlc_fees_dust_exposure_delta() {
+	do_test_nondust_htlc_fees_dust_exposure_delta(ChannelTypeFeatures::only_static_remote_key());
+	do_test_nondust_htlc_fees_dust_exposure_delta(ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies());
+}
 
 #[test]
 fn test_non_final_funding_tx() {