f - Skip RBF feerate for zero-conf channels in splice_channel

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

Author: jkczyz

lightning/src/ln/channel.rs

@@ -11950,31 +11950,33 @@ where
 			});
 		}
 
-		let (min_rbf_feerate, prior_contribution) =
-			if let Ok(min_rbf_feerate) = self.can_initiate_rbf() {
-				// A previous splice was negotiated but not yet locked. The user's splice
-				// will be an RBF, so provide the minimum RBF feerate and prior contribution.
-				let prior = self.build_prior_contribution();
-				(Some(min_rbf_feerate), prior)
-			} else if let Some(negotiation) = self
-				.pending_splice
-				.as_ref()
-				.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
-			{
-				// A splice is currently being negotiated.
-				// - If the negotiation succeeds, the user's splice will need to satisfy the RBF
-				//   feerate requirement. Derive the minimum RBF feerate from the negotiation's
-				//   feerate so the user can choose an appropriate feerate.
-				// - If the negotiation fails (e.g., tx_abort), the splice will proceed as a fresh
-				//   splice instead.
-				let prev_feerate = negotiation.funding_feerate_sat_per_1000_weight();
-				let min_feerate_kwu = ((prev_feerate as u64) * 25).div_ceil(24);
-				(Some(FeeRate::from_sat_per_kwu(min_feerate_kwu)), None)
-			} else {
-				// No RBF feerate to derive — either a fresh splice or a pending splice that
-				// can't be RBF'd (e.g., splice_locked already exchanged).
-				(None, None)
-			};
+		let (min_rbf_feerate, prior_contribution) = if self.is_rbf_compatible().is_err() {
+			// Channel can never RBF (e.g., zero-conf).
+			(None, None)
+		} else if let Ok(min_rbf_feerate) = self.can_initiate_rbf() {
+			// A previous splice was negotiated but not yet locked. The user's splice
+			// will be an RBF, so provide the minimum RBF feerate and prior contribution.
+			let prior = self.build_prior_contribution();
+			(Some(min_rbf_feerate), prior)
+		} else if let Some(negotiation) = self
+			.pending_splice
+			.as_ref()
+			.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
+		{
+			// A splice is currently being negotiated.
+			// - If the negotiation succeeds, the user's splice will need to satisfy the RBF
+			//   feerate requirement. Derive the minimum RBF feerate from the negotiation's
+			//   feerate so the user can choose an appropriate feerate.
+			// - If the negotiation fails (e.g., tx_abort), the splice will proceed as a fresh
+			//   splice instead.
+			let prev_feerate = negotiation.funding_feerate_sat_per_1000_weight();
+			let min_feerate_kwu = ((prev_feerate as u64) * 25).div_ceil(24);
+			(Some(FeeRate::from_sat_per_kwu(min_feerate_kwu)), None)
+		} else {
+			// No RBF feerate to derive — either a fresh splice or a pending splice that
+			// can't be RBF'd (e.g., splice_locked already exchanged).
+			(None, None)
+		};
 
 		let funding_txo = self.funding.get_funding_txo().expect("funding_txo should be set");
 		let previous_utxo =
@@ -12000,13 +12002,19 @@ where
 		Some(PriorContribution::new(prior.clone(), holder_balance))
 	}
 
-	fn can_initiate_rbf(&self) -> Result<FeeRate, String> {
+	/// Returns whether this channel can ever RBF, independent of splice state.
+	fn is_rbf_compatible(&self) -> Result<(), String> {
 		if self.context.minimum_depth(&self.funding) == Some(0) {
 			return Err(format!(
-				"Channel {} has option_zeroconf, cannot RBF splice",
+				"Channel {} has option_zeroconf, cannot RBF",
 				self.context.channel_id(),
 			));
 		}
+		Ok(())
+	}
+
+	fn can_initiate_rbf(&self) -> Result<FeeRate, String> {
+		self.is_rbf_compatible()?;
 
 		let pending_splice = match &self.pending_splice {
 			Some(pending_splice) => pending_splice,
@@ -12586,12 +12594,7 @@ where
 			return Err(ChannelError::WarnAndDisconnect("Quiescence needed for RBF".to_owned()));
 		}
 
-		if self.context.minimum_depth(&self.funding) == Some(0) {
-			return Err(ChannelError::WarnAndDisconnect(format!(
-				"Channel {} has option_zeroconf, cannot RBF splice",
-				self.context.channel_id(),
-			)));
-		}
+		self.is_rbf_compatible().map_err(|msg| ChannelError::WarnAndDisconnect(msg))?;
 
 		let pending_splice = match &self.pending_splice {
 			Some(pending_splice) => pending_splice,

lightning/src/ln/splicing_tests.rs

@@ -4580,6 +4580,43 @@ fn test_splice_rbf_after_splice_locked() {
 	}
 }
 
+#[test]
+fn test_splice_zeroconf_no_rbf_feerate() {
+	// Test that splice_channel returns a FundingTemplate with min_rbf_feerate = None for a
+	// zero-conf channel, even when a splice negotiation is in progress.
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let mut config = test_default_channel_config();
+	config.channel_handshake_limits.trust_own_funding_0conf = true;
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(config.clone()), Some(config)]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	let node_id_0 = nodes[0].node.get_our_node_id();
+
+	let initial_channel_value_sat = 100_000;
+	let (funding_tx, channel_id) =
+		open_zero_conf_channel_with_value(&nodes[0], &nodes[1], None, initial_channel_value_sat, 0);
+	mine_transaction(&nodes[0], &funding_tx);
+	mine_transaction(&nodes[1], &funding_tx);
+
+	let added_value = Amount::from_sat(50_000);
+	provide_utxo_reserves(&nodes, 1, added_value * 2);
+
+	// Initiate a splice (node 0) and complete the handshake so a funding negotiation is in
+	// progress.
+	let _funding_contribution =
+		do_initiate_splice_in(&nodes[0], &nodes[1], channel_id, added_value);
+	let _new_funding_script = complete_splice_handshake(&nodes[0], &nodes[1]);
+
+	// The acceptor (node 1) calling splice_channel should return no RBF feerate since
+	// zero-conf channels cannot RBF.
+	let funding_template = nodes[1].node.splice_channel(&channel_id, &node_id_0).unwrap();
+	assert!(funding_template.min_rbf_feerate().is_none());
+
+	// Drain pending interactive tx messages from the splice handshake.
+	nodes[0].node.get_and_clear_pending_msg_events();
+}
+
 #[test]
 fn test_splice_rbf_zeroconf_rejected() {
 	// Test that tx_init_rbf is rejected when option_zeroconf is negotiated.
@@ -4622,10 +4659,7 @@ fn test_splice_rbf_zeroconf_rejected() {
 				msgs::ErrorAction::DisconnectPeerWithWarning {
 					msg: msgs::WarningMessage {
 						channel_id,
-						data: format!(
-							"Channel {} has option_zeroconf, cannot RBF splice",
-							channel_id,
-						),
+						data: format!("Channel {} has option_zeroconf, cannot RBF", channel_id,),
 					},
 				}
 			);