basic dust complaint

temp: alice and bob

Author: tankyleo

lightning/src/ln/functional_tests.rs

@@ -10604,6 +10604,110 @@ fn test_nondust_htlc_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 commitment transaction.
+	// Node 0 (funder) brings the dust exposure up to the threshold exactly using dust htlcs, then
+	// sends one single non-dust htlc. Node 1 (fundee) should complain about too much dust exposure.
+
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+
+	const BASE_FEERATE: u64 = 253;
+	const EXCESS_FEERATE: u64 = 275;
+	const DELTA_FEERATE: u64 = EXCESS_FEERATE - BASE_FEERATE;
+
+	const DUST_HTLC_COUNT: u64 = 4;
+	const DUST_HTLC_MSAT: u64 = 125_000;
+	const BASE_DUST_LIMIT_MSAT: u64 = DUST_HTLC_COUNT * DUST_HTLC_MSAT;
+
+	const NON_DUST_HTLC_MSAT: u64 = 4_000_000;
+
+	// only_static_remote_key: 500_000 + 22 * 724 / 1_000 * 1_000 = 515_000
+	// anchors_zero_htlc_fee: 500_000 + 22 * 1_124 / 1_000 * 1_000 = 524_000
+	let threshold_dust_exposure_msat = BASE_DUST_LIMIT_MSAT + DELTA_FEERATE * commitment_tx_base_weight(&features) / 1000 * 1000;
+
+	// only_static_remote_key: 500_000 + 22 * (724 + 172) / 1000 * 1000 + 22 * 663 = 533_586
+	// anchors_zero_htlc_fee: 500_000 + 22 * (1_124 + 172) / 1000 * 1000 = 528_000
+	let mut expected_dust_exposure_msat = BASE_DUST_LIMIT_MSAT + DELTA_FEERATE * (commitment_tx_base_weight(&features) + COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000 * 1000;
+
+	if features == ChannelTypeFeatures::only_static_remote_key() {
+		expected_dust_exposure_msat += DELTA_FEERATE * htlc_timeout_tx_weight(&features);
+		assert_eq!(threshold_dust_exposure_msat, 515_000);
+		assert_eq!(expected_dust_exposure_msat, 533_586);
+	} else {
+		assert_eq!(threshold_dust_exposure_msat, 524_000);
+		assert_eq!(expected_dust_exposure_msat, 528_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 = EXCESS_FEERATE as u32;
+	}
+
+	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;
+	}
+	let mut fixed_limit_config = default_config.clone();
+	fixed_limit_config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FixedLimitMsat(threshold_dust_exposure_msat);
+
+	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);
+
+	//create_announced_chan_between_nodes(&nodes, 0, 1);
+	create_chan_between_nodes_with_value(&nodes[0], &nodes[1], 100_000, 50_000_000);
+
+	// 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 right up to its limit
+	for _ in 0..DUST_HTLC_COUNT {
+		route_payment(&nodes[0], &[&nodes[1]], DUST_HTLC_MSAT);
+	}
+
+	// Send an additional non-dust htlc, and check for the complaint exactly
+	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 exposure to tx fee dust at {} over the limit {} on counterparty commitment tx",
+			expected_dust_exposure_msat, threshold_dust_exposure_msat), 1);
+	let _ = nodes[1].node.get_and_clear_pending_msg_events();
+
+	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 { .. }, {});
+	// only_static_remote_key: counterparty_dust_limit_satoshis + dust_buffer_feerate * htlc_success_weight = 354000 + (2530 + 275) * 703 / 1000 * 1000 = 2325000
+	// anchors_zero_htlc_fee: counterparty_dust_limit_satoshis = 354000
+	let htlc_max = if features == ChannelTypeFeatures::only_static_remote_key() { 2325000 } else { 354000 };
+	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", htlc_max), 1);
+	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
+
+	let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
+	added_monitors.clear();
+}
+
+#[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() {