Merge pull request #4529 from tankyleo/2026-04-add-max-inflight-knob-for-unannounced-channels

Add `unannounced_channel_max_inbound_htlc_value_in_flight_percentage`

Author: TheBlueMatt

lightning/src/ln/async_payments_tests.rs

@@ -504,6 +504,9 @@ fn often_offline_node_cfg() -> UserConfig {
 	cfg.channel_handshake_config.announce_for_forwarding = false;
 	cfg.channel_handshake_limits.force_announced_channel_preference = true;
 	cfg.hold_outbound_htlcs_at_next_hop = true;
+	// Use the setting that matches the default at the time these tests were written
+	cfg.channel_handshake_config.unannounced_channel_max_inbound_htlc_value_in_flight_percentage =
+		10;
 	cfg
 }
 
@@ -1310,6 +1313,10 @@ fn async_receive_mpp() {
 
 	let mut allow_priv_chan_fwds_cfg = test_default_channel_config();
 	allow_priv_chan_fwds_cfg.accept_forwards_to_priv_channels = true;
+	// Set the percentage to the default value at the time this test was written
+	allow_priv_chan_fwds_cfg
+		.channel_handshake_config
+		.announced_channel_max_inbound_htlc_value_in_flight_percentage = 10;
 
 	let node_chanmgrs = create_node_chanmgrs(
 		4,

lightning/src/ln/blinded_payment_tests.rs

@@ -269,7 +269,11 @@ fn one_hop_blinded_path_with_dummy_hops() {
 fn mpp_to_one_hop_blinded_path() {
 	let chanmon_cfgs = create_chanmon_cfgs(4);
 	let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
-	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
+	let mut config = test_default_channel_config();
+	// Set the percentage to the default value at the time this test was written
+	config.channel_handshake_config.announced_channel_max_inbound_htlc_value_in_flight_percentage = 10;
+	let configs: [Option<UserConfig>; 4] = core::array::from_fn(|_| Some(config.clone()));
+	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &configs);
 	let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
 	let mut secp_ctx = Secp256k1::new();
 
@@ -349,7 +353,11 @@ fn mpp_to_one_hop_blinded_path() {
 fn mpp_to_three_hop_blinded_paths() {
 	let chanmon_cfgs = create_chanmon_cfgs(6);
 	let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
-	let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
+	let mut config = test_default_channel_config();
+	// Set the percentage to the default value at the time this test was written
+	config.channel_handshake_config.announced_channel_max_inbound_htlc_value_in_flight_percentage = 10;
+	let configs: [Option<UserConfig>; 6] = core::array::from_fn(|_| Some(config.clone()));
+	let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &configs);
 	let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
 
 	// Create this network topology so node 0 MPP's over 2 3-hop blinded paths:

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -4656,6 +4656,7 @@ fn test_claim_to_closed_channel_blocks_claimed_event() {
 #[test]
 #[cfg(all(feature = "std", not(target_os = "windows")))]
 fn test_single_channel_multiple_mpp() {
+	use crate::util::config::UserConfig;
 	use std::sync::atomic::{AtomicBool, Ordering};
 
 	// Test what happens when we attempt to claim an MPP with many parts that came to us through
@@ -4667,7 +4668,11 @@ fn test_single_channel_multiple_mpp() {
 	// for more info.
 	let chanmon_cfgs = create_chanmon_cfgs(9);
 	let node_cfgs = create_node_cfgs(9, &chanmon_cfgs);
-	let configs = [None, None, None, None, None, None, None, None, None];
+	let mut config = test_default_channel_config();
+	// Set the percentage to the default value at the time this test was written
+	config.channel_handshake_config.announced_channel_max_inbound_htlc_value_in_flight_percentage =
+		10;
+	let configs: [Option<UserConfig>; 9] = core::array::from_fn(|_| Some(config.clone()));
 	let node_chanmgrs = create_node_chanmgrs(9, &node_cfgs, &configs);
 	let mut nodes = create_network(9, &node_cfgs, &node_chanmgrs);
 

lightning/src/ln/channel.rs

@@ -4102,6 +4102,7 @@ impl<SP: SignerProvider> ChannelContext<SP> {
 			),
 			holder_max_htlc_value_in_flight_msat: get_holder_max_htlc_value_in_flight_msat(
 				channel_value_satoshis,
+				announce_for_forwarding,
 				&config.channel_handshake_config,
 			),
 			counterparty_htlc_minimum_msat: open_channel_fields.htlc_minimum_msat,
@@ -4405,6 +4406,7 @@ impl<SP: SignerProvider> ChannelContext<SP> {
 			// receive `accept_channel2`.
 			holder_max_htlc_value_in_flight_msat: get_holder_max_htlc_value_in_flight_msat(
 				channel_value_satoshis,
+				config.channel_handshake_config.announce_for_forwarding,
 				&config.channel_handshake_config,
 			),
 			counterparty_htlc_minimum_msat: 0,
@@ -6678,24 +6680,41 @@ impl<SP: SignerProvider> ChannelContext<SP> {
 
 /// Returns the value to use for `holder_max_htlc_value_in_flight_msat` as a percentage of the
 /// `channel_value_satoshis` in msat, set through
-/// [`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`]
+/// [`ChannelHandshakeConfig::announced_channel_max_inbound_htlc_value_in_flight_percentage`]
+/// or [`ChannelHandshakeConfig::unannounced_channel_max_inbound_htlc_value_in_flight_percentage`]
+/// depending on the value of [`ChannelHandshakeConfig::announce_for_forwarding`].
 ///
 /// The effective percentage is lower bounded by 1% and upper bounded by 100%.
 ///
-/// [`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`]: crate::util::config::ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel
+/// [`ChannelHandshakeConfig::announced_channel_max_inbound_htlc_value_in_flight_percentage`]: crate::util::config::ChannelHandshakeConfig::announced_channel_max_inbound_htlc_value_in_flight_percentage
+/// [`ChannelHandshakeConfig::unannounced_channel_max_inbound_htlc_value_in_flight_percentage`]: crate::util::config::ChannelHandshakeConfig::unannounced_channel_max_inbound_htlc_value_in_flight_percentage
+/// [`ChannelHandshakeConfig::announce_for_forwarding`]: crate::util::config::ChannelHandshakeConfig::announce_for_forwarding
 fn get_holder_max_htlc_value_in_flight_msat(
-	channel_value_satoshis: u64, config: &ChannelHandshakeConfig,
+	channel_value_satoshis: u64, is_announced_channel: bool, config: &ChannelHandshakeConfig,
 ) -> u64 {
-	let configured_percent = if config.max_inbound_htlc_value_in_flight_percent_of_channel < 1 {
+	let config_setting = if is_announced_channel {
+		config.announced_channel_max_inbound_htlc_value_in_flight_percentage
+	} else {
+		config.unannounced_channel_max_inbound_htlc_value_in_flight_percentage
+	};
+	let configured_percent = if config_setting < 1 {
 		1
-	} else if config.max_inbound_htlc_value_in_flight_percent_of_channel > 100 {
+	} else if config_setting > 100 {
 		100
 	} else {
-		config.max_inbound_htlc_value_in_flight_percent_of_channel as u64
+		config_setting as u64
 	};
 	channel_value_satoshis * 10 * configured_percent
 }
 
+/// This is for legacy reasons, present for forward-compatibility.
+/// LDK versions older than 0.0.104 don't know how read/handle values other than the legacy
+/// percentage from storage. Hence, we use this function to not persist legacy values of
+/// `holder_max_htlc_value_in_flight_msat` for channels into storage.
+fn get_legacy_default_holder_max_htlc_value_in_flight_msat(channel_value_satoshis: u64) -> u64 {
+	channel_value_satoshis * 10 * MAX_IN_FLIGHT_PERCENT_LEGACY as u64
+}
+
 /// Returns a minimum channel reserve value the remote needs to maintain,
 /// required by us according to the configured or default
 /// [`ChannelHandshakeConfig::their_channel_reserve_proportional_millionths`]
@@ -15698,15 +15717,11 @@ impl<SP: SignerProvider> Writeable for FundedChannel<SP> {
 				None
 			};
 
-		let mut old_max_in_flight_percent_config = UserConfig::default().channel_handshake_config;
-		old_max_in_flight_percent_config.max_inbound_htlc_value_in_flight_percent_of_channel =
-			MAX_IN_FLIGHT_PERCENT_LEGACY;
-		let max_in_flight_msat = get_holder_max_htlc_value_in_flight_msat(
+		let legacy_max_in_flight_msat = get_legacy_default_holder_max_htlc_value_in_flight_msat(
 			self.funding.get_value_satoshis(),
-			&old_max_in_flight_percent_config,
 		);
 		let serialized_holder_htlc_max_in_flight =
-			if self.context.holder_max_htlc_value_in_flight_msat != max_in_flight_msat {
+			if self.context.holder_max_htlc_value_in_flight_msat != legacy_max_in_flight_msat {
 				Some(self.context.holder_max_htlc_value_in_flight_msat)
 			} else {
 				None
@@ -16138,11 +16153,9 @@ impl<'a, 'b, 'c, ES: EntropySource, SP: SignerProvider>
 		let mut holder_selected_channel_reserve_satoshis = Some(
 			get_legacy_default_holder_selected_channel_reserve_satoshis(channel_value_satoshis),
 		);
+
 		let mut holder_max_htlc_value_in_flight_msat =
-			Some(get_holder_max_htlc_value_in_flight_msat(
-				channel_value_satoshis,
-				&UserConfig::default().channel_handshake_config,
-			));
+			Some(get_legacy_default_holder_max_htlc_value_in_flight_msat(channel_value_satoshis));
 		// Prior to supporting channel type negotiation, all of our channels were static_remotekey
 		// only, so we default to that if none was written.
 		let mut channel_type = Some(ChannelTypeFeatures::only_static_remote_key());
@@ -17148,8 +17161,13 @@ mod tests {
 	}
 
 	#[test]
-	#[rustfmt::skip]
 	fn test_configured_holder_max_htlc_value_in_flight() {
+		do_test_configured_holder_max_htlc_value_in_flight(true);
+		do_test_configured_holder_max_htlc_value_in_flight(false);
+	}
+
+	#[rustfmt::skip]
+	fn do_test_configured_holder_max_htlc_value_in_flight(announce_channel: bool) {
 		let test_est = TestFeeEstimator::new(15000);
 		let feeest = LowerBoundedFeeEstimator::new(&test_est);
 		let logger = TestLogger::new();
@@ -17161,13 +17179,49 @@ mod tests {
 		let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
 
 		let mut config_2_percent = UserConfig::default();
-		config_2_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 2;
+		config_2_percent.channel_handshake_config.announce_for_forwarding = announce_channel;
+		if announce_channel {
+			config_2_percent
+				.channel_handshake_config
+				.announced_channel_max_inbound_htlc_value_in_flight_percentage = 2;
+		} else {
+			config_2_percent
+				.channel_handshake_config
+				.unannounced_channel_max_inbound_htlc_value_in_flight_percentage = 2;
+		}
 		let mut config_99_percent = UserConfig::default();
-		config_99_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 99;
+		config_99_percent.channel_handshake_config.announce_for_forwarding = announce_channel;
+		if announce_channel {
+			config_99_percent
+				.channel_handshake_config
+				.announced_channel_max_inbound_htlc_value_in_flight_percentage = 99;
+		} else {
+			config_99_percent
+				.channel_handshake_config
+				.unannounced_channel_max_inbound_htlc_value_in_flight_percentage = 99;
+		}
 		let mut config_0_percent = UserConfig::default();
-		config_0_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 0;
+		config_0_percent.channel_handshake_config.announce_for_forwarding = announce_channel;
+		if announce_channel {
+			config_0_percent
+				.channel_handshake_config
+				.announced_channel_max_inbound_htlc_value_in_flight_percentage = 0;
+		} else {
+			config_0_percent
+				.channel_handshake_config
+				.unannounced_channel_max_inbound_htlc_value_in_flight_percentage = 0;
+		}
 		let mut config_101_percent = UserConfig::default();
-		config_101_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 101;
+		config_101_percent.channel_handshake_config.announce_for_forwarding = announce_channel;
+		if announce_channel {
+			config_101_percent
+				.channel_handshake_config
+				.announced_channel_max_inbound_htlc_value_in_flight_percentage = 101;
+		} else {
+			config_101_percent
+				.channel_handshake_config
+				.unannounced_channel_max_inbound_htlc_value_in_flight_percentage = 101;
+		}
 
 		// Test that `OutboundV1Channel::new` creates a channel with the correct value for
 		// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
@@ -17196,26 +17250,26 @@ mod tests {
 		assert_eq!(chan_4.context.holder_max_htlc_value_in_flight_msat, (chan_4_value_msat as f64 * 0.99) as u64);
 
 		// Test that `OutboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
-		// if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
+		// if `(un)announced_channel_max_inbound_htlc_value_in_flight_percentage` is set to a value less than 1.
 		let chan_5 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_0_percent), 10000000, 100000, 42, &config_0_percent, 0, 42, None, &logger, None).unwrap();
 		let chan_5_value_msat = chan_5.funding.get_value_satoshis() * 1000;
 		assert_eq!(chan_5.context.holder_max_htlc_value_in_flight_msat, (chan_5_value_msat as f64 * 0.01) as u64);
 
 		// Test that `OutboundV1Channel::new` uses the upper bound of the configurable percentage values
-		// (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
+		// (100%) if `(un)announced_channel_max_inbound_htlc_value_in_flight_percentage` is set to a larger value
 		// than 100.
 		let chan_6 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_101_percent), 10000000, 100000, 42, &config_101_percent, 0, 42, None, &logger, None).unwrap();
 		let chan_6_value_msat = chan_6.funding.get_value_satoshis() * 1000;
 		assert_eq!(chan_6.context.holder_max_htlc_value_in_flight_msat, chan_6_value_msat);
 
 		// Test that `InboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
-		// if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
+		// if `(un)announced_channel_max_inbound_htlc_value_in_flight_percentage` is set to a value less than 1.
 		let chan_7 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_0_percent), &channelmanager::provided_init_features(&config_0_percent), &chan_1_open_channel_msg, 7, &config_0_percent, 0, &&logger, None).unwrap();
 		let chan_7_value_msat = chan_7.funding.get_value_satoshis() * 1000;
 		assert_eq!(chan_7.context.holder_max_htlc_value_in_flight_msat, (chan_7_value_msat as f64 * 0.01) as u64);
 
 		// Test that `InboundV1Channel::new` uses the upper bound of the configurable percentage values
-		// (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
+		// (100%) if `(un)announced_channel_max_inbound_htlc_value_in_flight_percentage` is set to a larger value
 		// than 100.
 		let chan_8 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_101_percent), &channelmanager::provided_init_features(&config_101_percent), &chan_1_open_channel_msg, 7, &config_101_percent, 0, &&logger, None).unwrap();
 		let chan_8_value_msat = chan_8.funding.get_value_satoshis() * 1000;

lightning/src/ln/channel_open_tests.rs

@@ -182,7 +182,8 @@ fn test_inbound_anchors_manual_acceptance() {
 fn test_inbound_anchors_config_overridden() {
 	let overrides = ChannelConfigOverrides {
 		handshake_overrides: Some(ChannelHandshakeConfigUpdate {
-			max_inbound_htlc_value_in_flight_percent_of_channel: Some(5),
+			announced_channel_max_inbound_htlc_value_in_flight_percentage: Some(5),
+			unannounced_channel_max_inbound_htlc_value_in_flight_percentage: None,
 			htlc_minimum_msat: Some(1000),
 			minimum_depth: Some(2),
 			to_self_delay: Some(200),
@@ -1070,7 +1071,8 @@ pub fn test_accept_inbound_channel_config_override() {
 
 	let config_overrides = ChannelConfigOverrides {
 		handshake_overrides: Some(ChannelHandshakeConfigUpdate {
-			max_inbound_htlc_value_in_flight_percent_of_channel: None,
+			announced_channel_max_inbound_htlc_value_in_flight_percentage: None,
+			unannounced_channel_max_inbound_htlc_value_in_flight_percentage: None,
 			htlc_minimum_msat: None,
 			minimum_depth: None,
 			to_self_delay: None,

lightning/src/ln/functional_tests.rs

@@ -6903,22 +6903,22 @@ pub fn test_channel_update_has_correct_htlc_maximum_msat() {
 	config_30_percent.channel_handshake_config.announce_for_forwarding = true;
 	config_30_percent
 		.channel_handshake_config
-		.max_inbound_htlc_value_in_flight_percent_of_channel = 30;
+		.announced_channel_max_inbound_htlc_value_in_flight_percentage = 30;
 	let mut config_50_percent = UserConfig::default();
 	config_50_percent.channel_handshake_config.announce_for_forwarding = true;
 	config_50_percent
 		.channel_handshake_config
-		.max_inbound_htlc_value_in_flight_percent_of_channel = 50;
+		.announced_channel_max_inbound_htlc_value_in_flight_percentage = 50;
 	let mut config_95_percent = UserConfig::default();
 	config_95_percent.channel_handshake_config.announce_for_forwarding = true;
 	config_95_percent
 		.channel_handshake_config
-		.max_inbound_htlc_value_in_flight_percent_of_channel = 95;
+		.announced_channel_max_inbound_htlc_value_in_flight_percentage = 95;
 	let mut config_100_percent = UserConfig::default();
 	config_100_percent.channel_handshake_config.announce_for_forwarding = true;
 	config_100_percent
 		.channel_handshake_config
-		.max_inbound_htlc_value_in_flight_percent_of_channel = 100;
+		.announced_channel_max_inbound_htlc_value_in_flight_percentage = 100;
 
 	let chanmon_cfgs = create_chanmon_cfgs(4);
 	let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
@@ -8436,7 +8436,12 @@ pub fn test_inconsistent_mpp_params() {
 	// such HTLC and allow the second to stay.
 	let chanmon_cfgs = create_chanmon_cfgs(4);
 	let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
-	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
+	let mut config = test_default_channel_config();
+	// Set the percentage to the default value at the time this test was written
+	config.channel_handshake_config.announced_channel_max_inbound_htlc_value_in_flight_percentage =
+		10;
+	let configs: [Option<UserConfig>; 4] = core::array::from_fn(|_| Some(config.clone()));
+	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &configs);
 	let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
 
 	let node_a_id = nodes[0].node.get_our_node_id();
@@ -8580,7 +8585,12 @@ pub fn test_double_partial_claim() {
 	// amount.
 	let chanmon_cfgs = create_chanmon_cfgs(4);
 	let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
-	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
+	let mut config = test_default_channel_config();
+	// Set the percentage to the default value at the time this test was written
+	config.channel_handshake_config.announced_channel_max_inbound_htlc_value_in_flight_percentage =
+		10;
+	let configs: [Option<UserConfig>; 4] = core::array::from_fn(|_| Some(config.clone()));
+	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &configs);
 	let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
 
 	let node_b_id = nodes[1].node.get_our_node_id();
@@ -9067,7 +9077,8 @@ pub fn test_nondust_htlc_excess_fees_are_dust() {
 	config.channel_handshake_limits.min_max_accepted_htlcs = chan_utils::max_htlcs(&chan_ty);
 	config.channel_handshake_config.our_max_accepted_htlcs = chan_utils::max_htlcs(&chan_ty);
 	config.channel_handshake_config.our_htlc_minimum_msat = 1;
-	config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 100;
+	config.channel_handshake_config.announced_channel_max_inbound_htlc_value_in_flight_percentage =
+		100;
 
 	let node_chanmgrs = create_node_chanmgrs(
 		3,
@@ -10039,7 +10050,8 @@ pub fn test_dust_exposure_holding_cell_assertion() {
 	// Use a fixed dust exposure limit to make the test simpler
 	const DUST_HTLC_VALUE_MSAT: u64 = 500_000;
 	config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FixedLimitMsat(5_000_000);
-	config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 100;
+	config.channel_handshake_config.announced_channel_max_inbound_htlc_value_in_flight_percentage =
+		100;
 
 	let configs = [Some(config.clone()), Some(config.clone()), Some(config.clone())];
 	let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &configs);