f - Use max of flat increment and spec's 25/24 rule

The flat +25 sat/kwu increment falls below the spec's 25/24
multiplicative rule for feerates above 600 sat/kwu, which would cause
our RBF attempts to be rejected by spec-compliant counterparties.
Take the max of both to satisfy BIP125 relay requirements at low
feerates and the spec rule at higher feerates.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jkczyz

lightning/src/ln/channel.rs

@@ -6487,11 +6487,14 @@ fn get_v2_channel_reserve_satoshis(channel_value_satoshis: u64, dust_limit_satos
 /// Returns the minimum feerate for our own RBF attempts given a previous feerate.
 ///
 /// The spec (tx_init_rbf) requires the new feerate to be >= 25/24 of the previous feerate.
-/// However, that multiplier doesn't always satisfy BIP125's relay requirement of an absolute fee
-/// increase, so for our own RBFs we use a flat +25 sat/kwu (0.1 sat/vB) increment instead. We
-/// still accept the 25/24 rule from counterparties in [`FundedChannel::validate_tx_init_rbf`].
+/// However, at low feerates that multiplier doesn't always satisfy BIP125's relay requirement of
+/// an absolute fee increase, so we take the max of a flat +25 sat/kwu (0.1 sat/vB) increment
+/// and the spec's multiplicative rule. We still accept the bare 25/24 rule from counterparties
+/// in [`FundedChannel::validate_tx_init_rbf`].
 fn min_rbf_feerate(prev_feerate: u32) -> FeeRate {
-	FeeRate::from_sat_per_kwu((prev_feerate as u64).saturating_add(25))
+	let flat_increment = (prev_feerate as u64).saturating_add(25);
+	let spec_increment = ((prev_feerate as u64) * 25).div_ceil(24);
+	FeeRate::from_sat_per_kwu(cmp::max(flat_increment, spec_increment))
 }
 
 /// Context for negotiating channels (dual-funded V2 open, splicing)

lightning/src/ln/splicing_tests.rs

@@ -4357,6 +4357,70 @@ fn test_splice_rbf_acceptor_basic() {
 	);
 }
 
+#[test]
+fn test_splice_rbf_at_high_feerate() {
+	// Test that min_rbf_feerate satisfies the spec's 25/24 rule at high feerates (above 600
+	// sat/kwu, where a flat +25 increment alone would be insufficient).
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	let node_id_0 = nodes[0].node.get_our_node_id();
+	let node_id_1 = nodes[1].node.get_our_node_id();
+
+	let initial_channel_value_sat = 100_000;
+	let (_, _, channel_id, _) =
+		create_announced_chan_between_nodes_with_value(&nodes, 0, 1, initial_channel_value_sat, 0);
+
+	let added_value = Amount::from_sat(50_000);
+	provide_utxo_reserves(&nodes, 2, added_value * 2);
+
+	// Step 1: Complete a splice-in at floor feerate.
+	let funding_contribution = do_initiate_splice_in(&nodes[0], &nodes[1], channel_id, added_value);
+	let (_first_splice_tx, new_funding_script) =
+		splice_channel(&nodes[0], &nodes[1], channel_id, funding_contribution);
+
+	// Step 2: RBF to a high feerate (1000 sat/kwu, well above the 600 crossover point).
+	provide_utxo_reserves(&nodes, 2, added_value * 2);
+	let high_feerate = FeeRate::from_sat_per_kwu(1000);
+	let contribution =
+		do_initiate_rbf_splice_in(&nodes[0], &nodes[1], channel_id, added_value, high_feerate);
+	complete_rbf_handshake(&nodes[0], &nodes[1]);
+	complete_interactive_funding_negotiation(
+		&nodes[0],
+		&nodes[1],
+		channel_id,
+		contribution,
+		new_funding_script.clone(),
+	);
+	let (_, splice_locked) = sign_interactive_funding_tx(&nodes[0], &nodes[1], false);
+	assert!(splice_locked.is_none());
+	expect_splice_pending_event(&nodes[0], &node_id_1);
+	expect_splice_pending_event(&nodes[1], &node_id_0);
+
+	// Step 3: RBF again using the template's min_rbf_feerate. The counterparty must accept it.
+	provide_utxo_reserves(&nodes, 2, added_value * 2);
+	let rbf_feerate = {
+		let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap();
+		funding_template.min_rbf_feerate().unwrap()
+	};
+	let contribution =
+		do_initiate_rbf_splice_in(&nodes[0], &nodes[1], channel_id, added_value, rbf_feerate);
+	complete_rbf_handshake(&nodes[0], &nodes[1]);
+	complete_interactive_funding_negotiation(
+		&nodes[0],
+		&nodes[1],
+		channel_id,
+		contribution,
+		new_funding_script,
+	);
+	let (_, splice_locked) = sign_interactive_funding_tx(&nodes[0], &nodes[1], false);
+	assert!(splice_locked.is_none());
+	expect_splice_pending_event(&nodes[0], &node_id_1);
+	expect_splice_pending_event(&nodes[1], &node_id_0);
+}
+
 #[test]
 fn test_splice_rbf_insufficient_feerate() {
 	// Test that splice_in_sync rejects a feerate that doesn't satisfy the +25 sat/kwu rule, and that the