Handle FeeRateAdjustmentError variants in splice_init acceptor path

Replace the generic error handling in splice_init with explicit
matching on FeeRateAdjustmentError variants:

- FeeRateTooLow: initiator's feerate is below our minimum. Proceed
  without contribution and preserve QuiescentAction for an RBF retry at
  our preferred feerate.
- FeeRateTooHigh: initiator's feerate exceeds our maximum and would
  consume too much of our change output. Reject the splice with
  WarnAndDisconnect.
- BudgetInsufficient: our fee budget can't cover the acceptor's fair
  fee at this feerate. Proceed without contribution.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jkczyz

lightning/src/ln/channel.rs

@@ -55,7 +55,9 @@ use crate::ln::channelmanager::{
 	PendingHTLCStatus, RAACommitmentOrder, SentHTLCId, BREAKDOWN_TIMEOUT,
 	MAX_LOCAL_BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA,
 };
-use crate::ln::funding::{FundingContribution, FundingTemplate, FundingTxInput};
+use crate::ln::funding::{
+	FeeRateAdjustmentError, FundingContribution, FundingTemplate, FundingTxInput,
+};
 use crate::ln::interactivetxs::{
 	AbortReason, HandleTxCompleteValue, InteractiveTxConstructor, InteractiveTxConstructorArgs,
 	InteractiveTxMessageSend, InteractiveTxSigningSession, SharedOwnedInput, SharedOwnedOutput,
@@ -12323,20 +12325,47 @@ where
 			})
 			.ok();
 		let our_funding_contribution =
-			holder_balance.and_then(|_| self.queued_funding_contribution()).and_then(|c| {
-				c.net_value_for_acceptor_at_feerate(feerate, holder_balance.unwrap())
-					.map_err(|e| {
-						log_info!(
-							logger,
-							"Cannot accommodate initiator's feerate ({}) for channel {}: {}; \
+			match holder_balance.and_then(|_| self.queued_funding_contribution()) {
+				Some(c) => {
+					match c.net_value_for_acceptor_at_feerate(feerate, holder_balance.unwrap()) {
+						Ok(net_value) => Some(net_value),
+						Err(e @ FeeRateAdjustmentError::FeeRateTooLow { .. }) => {
+							log_info!(
+								logger,
+								"Initiator's feerate ({}) for channel {} is below our minimum: {}; \
+								 proceeding without contribution, will RBF later",
+								feerate,
+								self.context.channel_id(),
+								e,
+							);
+							None
+						},
+						Err(e @ FeeRateAdjustmentError::FeeRateTooHigh { .. }) => {
+							return Err(ChannelError::WarnAndDisconnect(format!(
+								"Cannot accommodate initiator's feerate ({}) for channel {}: {}",
+								feerate,
+								self.context.channel_id(),
+								e,
+							)));
+						},
+						Err(
+							e @ FeeRateAdjustmentError::FeeBufferInsufficient { .. }
+							| e @ FeeRateAdjustmentError::FeeBufferOverflow { .. },
+						) => {
+							log_info!(
+								logger,
+								"Cannot accommodate initiator's feerate ({}) for channel {}: {}; \
 								 proceeding without contribution",
-							feerate,
-							self.context.channel_id(),
-							e,
-						);
-					})
-					.ok()
-			});
+								feerate,
+								self.context.channel_id(),
+								e,
+							);
+							None
+						},
+					}
+				},
+				None => None,
+			};
 
 		let splice_funding =
 			self.validate_splice_init(msg, our_funding_contribution.unwrap_or(SignedAmount::ZERO))?;

lightning/src/ln/splicing_tests.rs

@@ -1805,6 +1805,91 @@ fn do_test_splice_tiebreak(
 	}
 }
 
+#[test]
+fn test_splice_tiebreak_feerate_too_high_rejected() {
+	// Node 0 (winner) proposes a feerate far above node 1's (loser) max_feerate, and node 1's
+	// fair fee at that feerate exceeds its budget. This triggers FeeRateAdjustmentError::TooHigh,
+	// causing node 1 to reject with WarnAndDisconnect.
+	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);
+
+	provide_utxo_reserves(&nodes, 2, Amount::from_sat(100_000));
+
+	// Node 0 uses an extremely high feerate (100,000 sat/kwu). Node 1 uses the floor feerate
+	// with a moderate splice-in (50,000 sats from a 100,000 sat UTXO) and a low max_feerate
+	// (3,000 sat/kwu). The target (100k) far exceeds node 1's max (3k), and the fair fee at
+	// 100k exceeds node 1's budget, triggering TooHigh.
+	let high_feerate = FeeRate::from_sat_per_kwu(100_000);
+	let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64);
+	let node_0_added_value = Amount::from_sat(50_000);
+	let node_1_added_value = Amount::from_sat(50_000);
+	let node_1_max_feerate = FeeRate::from_sat_per_kwu(3_000);
+
+	// Node 0: very high feerate, moderate splice-in.
+	let funding_template_0 =
+		nodes[0].node.splice_channel(&channel_id, &node_id_1, high_feerate, FeeRate::MAX).unwrap();
+	let wallet_0 = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger);
+	let node_0_funding_contribution =
+		funding_template_0.splice_in_sync(node_0_added_value, &wallet_0).unwrap();
+	nodes[0]
+		.node
+		.funding_contributed(&channel_id, &node_id_1, node_0_funding_contribution.clone(), None)
+		.unwrap();
+
+	// Node 1: floor feerate, moderate splice-in, low max_feerate.
+	let funding_template_1 = nodes[1]
+		.node
+		.splice_channel(&channel_id, &node_id_0, floor_feerate, node_1_max_feerate)
+		.unwrap();
+	let wallet_1 = WalletSync::new(Arc::clone(&nodes[1].wallet_source), nodes[1].logger);
+	let node_1_funding_contribution =
+		funding_template_1.splice_in_sync(node_1_added_value, &wallet_1).unwrap();
+	nodes[1]
+		.node
+		.funding_contributed(&channel_id, &node_id_0, node_1_funding_contribution.clone(), None)
+		.unwrap();
+
+	// Both emit STFU.
+	let stfu_0 = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, node_id_1);
+	let stfu_1 = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0);
+
+	// Tie-break: node 0 wins.
+	nodes[1].node.handle_stfu(node_id_0, &stfu_0);
+	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
+	nodes[0].node.handle_stfu(node_id_1, &stfu_1);
+
+	// Node 0 sends SpliceInit at 100,000 sat/kwu.
+	let splice_init = get_event_msg!(nodes[0], MessageSendEvent::SendSpliceInit, node_id_1);
+
+	// Node 1 handles SpliceInit — TooHigh: target (100k) >> max (3k) and fair fee > budget.
+	nodes[1].node.handle_splice_init(node_id_0, &splice_init);
+
+	let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
+	assert_eq!(msg_events.len(), 1, "{msg_events:?}");
+	match &msg_events[0] {
+		MessageSendEvent::HandleError {
+			action: msgs::ErrorAction::DisconnectPeerWithWarning { msg },
+			..
+		} => {
+			assert!(
+				msg.data.contains("Cannot accommodate initiator's feerate"),
+				"Unexpected warning: {}",
+				msg.data
+			);
+		},
+		other => panic!("Expected HandleError/DisconnectPeerWithWarning, got {:?}", other),
+	}
+}
+
 #[cfg(test)]
 #[derive(PartialEq)]
 enum SpliceStatus {