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/funding.rs

@@ -218,8 +218,9 @@ impl PriorContribution {
 /// prior contribution logic internally — reusing an adjusted prior when possible, re-running
 /// coin selection when needed, or creating a fee-bump-only contribution.
 ///
-/// Check [`FundingTemplate::min_rbf_feerate`] for the minimum feerate required (previous
-/// feerate + 25 sat/kwu). Use [`FundingTemplate::prior_contribution`] to inspect the prior
+/// Check [`FundingTemplate::min_rbf_feerate`] for the minimum feerate required (the greater of
+/// the previous feerate + 25 sat/kwu and the spec's 25/24 rule). Use
+/// [`FundingTemplate::prior_contribution`] to inspect the prior
 /// contribution's parameters (e.g., [`FundingContribution::value_added`],
 /// [`FundingContribution::outputs`]) before deciding whether to reuse it via the RBF methods
 /// or build a fresh contribution with different parameters using the splice methods above.
@@ -232,8 +233,9 @@ pub struct FundingTemplate {
 	/// transaction.
 	shared_input: Option<Input>,
 
-	/// The minimum RBF feerate (previous feerate + 25 sat/kwu), if this template is for an
-	/// RBF attempt. `None` for fresh splices with no pending splice candidates.
+	/// The minimum RBF feerate (the greater of previous feerate + 25 sat/kwu and the spec's
+	/// 25/24 rule), if this template is for an RBF attempt. `None` for fresh splices with no
+	/// pending splice candidates.
 	min_rbf_feerate: Option<FeeRate>,
 
 	/// The user's prior contribution from a previous splice negotiation, if available.

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
@@ -5984,7 +6048,8 @@ fn test_funding_contributed_rbf_adjustment_insufficient_budget() {
 		funding_template.splice_in_sync(added_value, floor_feerate, FeeRate::MAX, &wallet).unwrap();
 
 	// Node 1 initiates a splice at a HIGH feerate (10,000 sat/kwu). The minimum RBF feerate will be
-	// 10,000 + 25 = 10,025 sat/kwu — far above what node 0's tight budget can handle.
+	// max(10,000 + 25, ceil(10,000 * 25/24)) = 10,417 sat/kwu — far above what node 0's tight
+	// budget can handle.
 	let high_feerate = FeeRate::from_sat_per_kwu(10_000);
 	let node_1_template = nodes[1].node.splice_channel(&channel_id, &node_id_0).unwrap();
 	let node_1_wallet = WalletSync::new(Arc::clone(&nodes[1].wallet_source), nodes[1].logger);