diff --git a/fuzz/src/chanmon_consistency.rs b/fuzz/src/chanmon_consistency.rs index 22006897a0f..5d46cf26031 100644 --- a/fuzz/src/chanmon_consistency.rs +++ b/fuzz/src/chanmon_consistency.rs @@ -1391,14 +1391,8 @@ pub fn do_test( let splice_channel = |node: &ChanMan, counterparty_node_id: &PublicKey, channel_id: &ChannelId, - f: &dyn Fn(FundingTemplate) -> Result, - funding_feerate_sat_per_kw: FeeRate| { - match node.splice_channel( - channel_id, - counterparty_node_id, - funding_feerate_sat_per_kw, - FeeRate::MAX, - ) { + f: &dyn Fn(FundingTemplate) -> Result| { + match node.splice_channel(channel_id, counterparty_node_id) { Ok(funding_template) => { if let Ok(contribution) = f(funding_template) { let _ = node.funding_contributed( @@ -1425,15 +1419,10 @@ pub fn do_test( channel_id: &ChannelId, wallet: &WalletSync<&TestWalletSource, Arc>, funding_feerate_sat_per_kw: FeeRate| { - splice_channel( - node, - counterparty_node_id, - channel_id, - &move |funding_template: FundingTemplate| { - funding_template.splice_in_sync(Amount::from_sat(10_000), wallet) - }, - funding_feerate_sat_per_kw, - ); + splice_channel(node, counterparty_node_id, channel_id, &move |funding_template: FundingTemplate| { + let feerate = funding_template.min_rbf_feerate().unwrap_or(funding_feerate_sat_per_kw); + funding_template.splice_in_sync(Amount::from_sat(10_000), feerate, FeeRate::MAX, wallet) + }); }; let splice_out = |node: &ChanMan, @@ -1454,19 +1443,20 @@ pub fn do_test( if outbound_capacity_msat < 20_000_000 { return; } - splice_channel( - node, - counterparty_node_id, - channel_id, - &move |funding_template| { - let outputs = vec![TxOut { - value: Amount::from_sat(MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS), - script_pubkey: wallet.get_change_script().unwrap(), - }]; - funding_template.splice_out_sync(outputs, &WalletSync::new(wallet, logger.clone())) - }, - funding_feerate_sat_per_kw, - ); + splice_channel(node, counterparty_node_id, channel_id, &move |funding_template| { + let feerate = + funding_template.min_rbf_feerate().unwrap_or(funding_feerate_sat_per_kw); + let outputs = vec![TxOut { + value: Amount::from_sat(MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS), + script_pubkey: wallet.get_change_script().unwrap(), + }]; + funding_template.splice_out_sync( + outputs, + feerate, + FeeRate::MAX, + &WalletSync::new(wallet, logger.clone()), + ) + }); }; loop { diff --git a/fuzz/src/full_stack.rs b/fuzz/src/full_stack.rs index 5dfa51079d8..9700390f8ef 100644 --- a/fuzz/src/full_stack.rs +++ b/fuzz/src/full_stack.rs @@ -1032,16 +1032,19 @@ pub fn do_test(mut data: &[u8], logger: &Arc } let chan_id = chan.channel_id; let counterparty = chan.counterparty.node_id; - if let Ok(funding_template) = channelmanager.splice_channel( - &chan_id, - &counterparty, - FeeRate::from_sat_per_kwu(253), - FeeRate::MAX, - ) { + if let Ok(funding_template) = + channelmanager.splice_channel(&chan_id, &counterparty) + { + let feerate = funding_template + .min_rbf_feerate() + .unwrap_or(FeeRate::from_sat_per_kwu(253)); let wallet_sync = WalletSync::new(&wallet, Arc::clone(&logger)); - if let Ok(contribution) = funding_template - .splice_in_sync(Amount::from_sat(splice_in_sats.min(900_000)), &wallet_sync) - { + if let Ok(contribution) = funding_template.splice_in_sync( + Amount::from_sat(splice_in_sats.min(900_000)), + feerate, + FeeRate::MAX, + &wallet_sync, + ) { let _ = channelmanager.funding_contributed( &chan_id, &counterparty, @@ -1073,19 +1076,19 @@ pub fn do_test(mut data: &[u8], logger: &Arc let splice_out_sats = splice_out_sats.min(max_splice_out).max(546); // At least dust limit let chan_id = chan.channel_id; let counterparty = chan.counterparty.node_id; - if let Ok(funding_template) = channelmanager.splice_channel( - &chan_id, - &counterparty, - FeeRate::from_sat_per_kwu(253), - FeeRate::MAX, - ) { + if let Ok(funding_template) = + channelmanager.splice_channel(&chan_id, &counterparty) + { + let feerate = funding_template + .min_rbf_feerate() + .unwrap_or(FeeRate::from_sat_per_kwu(253)); let outputs = vec![TxOut { value: Amount::from_sat(splice_out_sats), script_pubkey: wallet.get_change_script().unwrap(), }]; let wallet_sync = WalletSync::new(&wallet, Arc::clone(&logger)); if let Ok(contribution) = - funding_template.splice_out_sync(outputs, &wallet_sync) + funding_template.splice_out_sync(outputs, feerate, FeeRate::MAX, &wallet_sync) { let _ = channelmanager.funding_contributed( &chan_id, diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs index 82d7d3bb92f..7ee87bb33ab 100644 --- a/lightning/src/ln/channel.rs +++ b/lightning/src/ln/channel.rs @@ -56,7 +56,7 @@ use crate::ln::channelmanager::{ MAX_LOCAL_BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, }; use crate::ln::funding::{ - FeeRateAdjustmentError, FundingContribution, FundingTemplate, FundingTxInput, + FeeRateAdjustmentError, FundingContribution, FundingTemplate, FundingTxInput, PriorContribution, }; use crate::ln::interactivetxs::{ AbortReason, HandleTxCompleteValue, InteractiveTxConstructor, InteractiveTxConstructorArgs, @@ -2973,6 +2973,21 @@ impl FundingNegotiation { } } + fn funding_feerate_sat_per_1000_weight(&self) -> u32 { + match self { + FundingNegotiation::AwaitingAck { context, .. } => { + context.funding_feerate_sat_per_1000_weight + }, + FundingNegotiation::ConstructingTransaction { + funding_feerate_sat_per_1000_weight, + .. + } => *funding_feerate_sat_per_1000_weight, + FundingNegotiation::AwaitingSignatures { + funding_feerate_sat_per_1000_weight, .. + } => *funding_feerate_sat_per_1000_weight, + } + } + fn is_initiator(&self) -> bool { match self { FundingNegotiation::AwaitingAck { context, .. } => context.is_initiator, @@ -11892,10 +11907,8 @@ where } } - /// Initiate splicing. - pub fn splice_channel( - &self, min_feerate: FeeRate, max_feerate: FeeRate, - ) -> Result { + /// Builds a [`FundingTemplate`] for splicing or RBF, if the channel state allows it. + pub fn splice_channel(&self) -> Result { if self.holder_commitment_point.current_point().is_none() { return Err(APIError::APIMisuseError { err: format!( @@ -11937,16 +11950,31 @@ where }); } - if min_feerate > max_feerate { - return Err(APIError::APIMisuseError { - err: format!( - "Channel {} min_feerate {} exceeds max_feerate {}", - self.context.channel_id(), - min_feerate, - max_feerate, - ), - }); - } + 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(min_rbf_feerate); + (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 = @@ -11957,75 +11985,41 @@ where satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT + FUNDING_TRANSACTION_WITNESS_WEIGHT, }; - Ok(FundingTemplate::new(Some(shared_input), min_feerate, max_feerate)) + Ok(FundingTemplate::new(Some(shared_input), min_rbf_feerate, prior_contribution)) } - /// Initiate an RBF of a pending splice transaction. - pub fn rbf_channel( - &self, min_feerate: FeeRate, max_feerate: FeeRate, - ) -> Result { - if self.holder_commitment_point.current_point().is_none() { - return Err(APIError::APIMisuseError { - err: format!( - "Channel {} cannot RBF until a payment is routed", - self.context.channel_id(), - ), - }); - } - - if self.quiescent_action.is_some() { - return Err(APIError::APIMisuseError { - err: format!( - "Channel {} cannot RBF as one is waiting to be negotiated", - self.context.channel_id(), - ), - }); + /// Clones the prior contribution and attempts to adjust its feerate to the minimum RBF feerate. + /// Returns `Adjusted` if the feerate meets the minimum (either already or after adjustment), + /// `Unadjusted` if the adjustment fails, or `None` if there is no prior contribution. + fn build_prior_contribution(&self, min_rbf_feerate: FeeRate) -> Option { + debug_assert!(self.pending_splice.is_some(), "can_initiate_rbf requires pending_splice"); + let prior = self.pending_splice.as_ref()?.contributions.last()?; + if prior.feerate() >= min_rbf_feerate { + return Some(PriorContribution::Adjusted(prior.clone())); } - - if !self.context.is_usable() { - return Err(APIError::APIMisuseError { - err: format!( - "Channel {} cannot RBF as it is either pending open/close", - self.context.channel_id() - ), - }); + let holder_balance = self + .get_holder_counterparty_balances_floor_incl_fee(&self.funding) + .map(|(h, _)| h) + .ok()?; + match prior.net_value_for_initiator_at_feerate(min_rbf_feerate, holder_balance) { + Ok(_) => Some(PriorContribution::Adjusted( + prior + .clone() + .for_initiator_at_feerate(min_rbf_feerate, holder_balance) + .expect("feerate compatibility already checked"), + )), + Err(_) => Some(PriorContribution::Unadjusted(prior.clone())), } + } + fn can_initiate_rbf(&self) -> Result { if self.context.minimum_depth(&self.funding) == Some(0) { - return Err(APIError::APIMisuseError { - err: format!( - "Channel {} has option_zeroconf, cannot RBF splice", - self.context.channel_id(), - ), - }); - } - - if min_feerate > max_feerate { - return Err(APIError::APIMisuseError { - err: format!( - "Channel {} min_feerate {} exceeds max_feerate {}", - self.context.channel_id(), - min_feerate, - max_feerate, - ), - }); + return Err(format!( + "Channel {} has option_zeroconf, cannot RBF splice", + self.context.channel_id(), + )); } - self.can_initiate_rbf(min_feerate).map_err(|err| APIError::APIMisuseError { err })?; - - let funding_txo = self.funding.get_funding_txo().expect("funding_txo should be set"); - let previous_utxo = - self.funding.get_funding_output().expect("funding_output should be set"); - let shared_input = Input { - outpoint: funding_txo.into_bitcoin_outpoint(), - previous_utxo, - satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT + FUNDING_TRANSACTION_WITNESS_WEIGHT, - }; - - Ok(FundingTemplate::new(Some(shared_input), min_feerate, max_feerate)) - } - - fn can_initiate_rbf(&self, feerate: FeeRate) -> Result<(), String> { let pending_splice = match &self.pending_splice { Some(pending_splice) => pending_splice, None => { @@ -12064,20 +12058,57 @@ where )); } - // Check the 25/24 feerate increase rule - let new_feerate = feerate.to_sat_per_kwu() as u32; - if let Some(prev_feerate) = pending_splice.last_funding_feerate_sat_per_1000_weight { - if (new_feerate as u64) * 24 < (prev_feerate as u64) * 25 { - return Err(format!( - "Channel {} RBF feerate {} is less than 25/24 of the previous feerate {}", - self.context.channel_id(), - new_feerate, - prev_feerate, - )); - } + match pending_splice.last_funding_feerate_sat_per_1000_weight { + Some(prev_feerate) => { + let min_feerate_kwu = ((prev_feerate as u64) * 25).div_ceil(24); + Ok(FeeRate::from_sat_per_kwu(min_feerate_kwu)) + }, + None => Err(format!( + "Channel {} has no prior feerate to compute RBF minimum", + self.context.channel_id(), + )), } + } - Ok(()) + /// Attempts to adjust the contribution's feerate to the minimum RBF feerate so the splice can + /// proceed as an RBF immediately rather than waiting for the pending splice to lock. + /// Returns the adjusted contribution on success, or the original on failure. + fn maybe_adjust_for_rbf( + &self, contribution: FundingContribution, min_rbf_feerate: FeeRate, logger: &L, + ) -> FundingContribution { + if contribution.feerate() >= min_rbf_feerate { + return contribution; + } + + let holder_balance = match self + .get_holder_counterparty_balances_floor_incl_fee(&self.funding) + .map(|(holder, _)| holder) + { + Ok(balance) => balance, + Err(_) => return contribution, + }; + + if let Err(e) = + contribution.net_value_for_initiator_at_feerate(min_rbf_feerate, holder_balance) + { + log_info!( + logger, + "Cannot adjust to minimum RBF feerate {}: {}; will proceed as fresh splice after lock", + min_rbf_feerate, + e, + ); + return contribution; + } + + log_info!( + logger, + "Adjusting contribution feerate from {} to minimum RBF feerate {}", + contribution.feerate(), + min_rbf_feerate, + ); + contribution + .for_initiator_at_feerate(min_rbf_feerate, holder_balance) + .expect("feerate compatibility already checked") } pub fn funding_contributed( @@ -12164,6 +12195,15 @@ where })); } + // If a pending splice exists with negotiated candidates, attempt to adjust the + // contribution's feerate to the minimum RBF feerate so it can proceed as an RBF immediately + // rather than waiting for the splice to lock. + let contribution = if let Ok(min_rbf_feerate) = self.can_initiate_rbf() { + self.maybe_adjust_for_rbf(contribution, min_rbf_feerate, logger) + } else { + contribution + }; + self.propose_quiescence(logger, QuiescentAction::Splice { contribution, locktime }) } @@ -13761,13 +13801,26 @@ where #[allow(irrefutable_let_patterns)] if let QuiescentAction::Splice { contribution, .. } = action { if self.pending_splice.is_some() { - if let Err(msg) = self.can_initiate_rbf(contribution.feerate()) { - log_given_level!( - logger, - logger_level, - "Waiting on sending stfu for splice RBF: {msg}" - ); - return None; + match self.can_initiate_rbf() { + Err(msg) => { + log_given_level!( + logger, + logger_level, + "Waiting on sending stfu for splice RBF: {msg}" + ); + return None; + }, + Ok(min_rbf_feerate) if contribution.feerate() < min_rbf_feerate => { + log_given_level!( + logger, + logger_level, + "Waiting for splice to lock: feerate {} below minimum RBF feerate {}", + contribution.feerate(), + min_rbf_feerate, + ); + return None; + }, + _ => {}, } } } diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs index f8b5ef32fc3..6347dddfe85 100644 --- a/lightning/src/ln/channelmanager.rs +++ b/lightning/src/ln/channelmanager.rs @@ -30,7 +30,7 @@ use bitcoin::hashes::{Hash, HashEngine, HmacEngine}; use bitcoin::secp256k1::Secp256k1; use bitcoin::secp256k1::{PublicKey, SecretKey}; -use bitcoin::{secp256k1, FeeRate, Sequence, SignedAmount}; +use bitcoin::{secp256k1, Sequence, SignedAmount}; use crate::blinded_path::message::{ AsyncPaymentsContext, BlindedMessagePath, MessageForwardNode, OffersContext, @@ -4701,8 +4701,7 @@ impl< } /// Initiate a splice in order to add value to (splice-in) or remove value from (splice-out) - /// the channel. This will spend the channel's funding transaction output, effectively replacing - /// it with a new one. + /// the channel, or to RBF a pending splice transaction. /// /// # Required Feature Flags /// @@ -4710,52 +4709,16 @@ impl< /// channel (no matter the type) can be spliced, as long as the counterparty is currently /// connected. /// - /// # Arguments - /// - /// The splice initiator is responsible for paying fees for common fields, shared inputs, and - /// shared outputs along with any contributed inputs and outputs. When building a - /// [`FundingContribution`], fees are estimated at `min_feerate` assuming initiator - /// responsibility and must be covered by the supplied inputs for splice-in or the channel - /// balance for splice-out. If the counterparty also initiates a splice and wins the - /// tie-break, they become the initiator and choose the feerate. The fee is then - /// re-estimated at the counterparty's feerate for only our contributed inputs and outputs, - /// which may be higher or lower than the original estimate. The contribution is dropped and - /// the splice proceeds without it when: - /// - the counterparty's feerate is below `min_feerate` - /// - the counterparty's feerate is above `max_feerate` and the re-estimated fee exceeds the - /// original fee estimate - /// - the re-estimated fee exceeds the *fee buffer* regardless of `max_feerate` - /// - /// The fee buffer is the maximum fee that can be accommodated: - /// - **splice-in**: the selected inputs' value minus the contributed amount - /// - **splice-out**: the channel balance minus the withdrawal outputs - /// - /// Returns a [`FundingTemplate`] which should be used to build a [`FundingContribution`] via - /// one of its splice methods (e.g., [`FundingTemplate::splice_in_sync`]). The resulting - /// contribution must then be passed to [`ChannelManager::funding_contributed`]. - /// - /// # Events - /// - /// Once the funding transaction has been constructed, an [`Event::SplicePending`] will be - /// emitted. At this point, any inputs contributed to the splice can only be re-spent if an - /// [`Event::DiscardFunding`] is seen. - /// - /// After initial signatures have been exchanged, [`Event::FundingTransactionReadyForSigning`] - /// will be generated and [`ChannelManager::funding_transaction_signed`] should be called. - /// - /// If any failures occur while negotiating the funding transaction, an [`Event::SpliceFailed`] - /// will be emitted. Any contributed inputs no longer used will be included here and thus can - /// be re-spent. - /// - /// Once the splice has been locked by both counterparties, an [`Event::ChannelReady`] will be - /// emitted with the new funding output. At this point, a new splice can be negotiated by - /// calling `splice_channel` again on this channel. + /// # Return Value /// - /// [`FundingContribution`]: crate::ln::funding::FundingContribution + /// Returns a [`FundingTemplate`] which should be used to obtain a [`FundingContribution`] + /// to pass to [`ChannelManager::funding_contributed`]. If a splice has been negotiated but + /// not yet locked, it can be replaced with a higher feerate transaction to speed up + /// confirmation via Replace By Fee (RBF). See [`FundingTemplate`] for details on building + /// a fresh contribution or reusing a prior one for RBF. #[rustfmt::skip] pub fn splice_channel( &self, channel_id: &ChannelId, counterparty_node_id: &PublicKey, - min_feerate: FeeRate, max_feerate: FeeRate, ) -> Result { let per_peer_state = self.per_peer_state.read().unwrap(); @@ -4783,7 +4746,7 @@ impl< match peer_state.channel_by_id.entry(*channel_id) { hash_map::Entry::Occupied(chan_phase_entry) => { if let Some(chan) = chan_phase_entry.get().as_funded() { - chan.splice_channel(min_feerate, max_feerate) + chan.splice_channel() } else { Err(APIError::ChannelUnavailable { err: format!( @@ -4799,94 +4762,6 @@ impl< } } - /// Initiate an RBF of a pending splice transaction for an existing channel. - /// - /// This is used after a splice has been negotiated but before it has been locked, in order - /// to bump the feerate of the funding transaction via replace-by-fee. - /// - /// # Required Feature Flags - /// - /// Initiating an RBF requires that the channel counterparty supports splicing. The - /// counterparty must be currently connected. - /// - /// # Arguments - /// - /// The RBF initiator is responsible for paying fees for common fields, shared inputs, and - /// shared outputs along with any contributed inputs and outputs. When building a - /// [`FundingContribution`], fees are estimated using `min_feerate` and must be covered by the - /// supplied inputs for splice-in or the channel balance for splice-out. If the counterparty - /// also initiates an RBF and wins the tie-break, they become the initiator and choose the - /// feerate. In that case, `max_feerate` is used to reject a feerate that is too high for our - /// contribution. - /// - /// Returns a [`FundingTemplate`] which should be used to build a [`FundingContribution`] via - /// one of its splice methods (e.g., [`FundingTemplate::splice_in_sync`]). The resulting - /// contribution must then be passed to [`ChannelManager::funding_contributed`]. - /// - /// # Events - /// - /// Once the funding transaction has been constructed, an [`Event::SplicePending`] will be - /// emitted. At this point, any inputs contributed to the splice can only be re-spent if an - /// [`Event::DiscardFunding`] is seen. - /// - /// After initial signatures have been exchanged, [`Event::FundingTransactionReadyForSigning`] - /// will be generated and [`ChannelManager::funding_transaction_signed`] should be called. - /// - /// If any failures occur while negotiating the funding transaction, an [`Event::SpliceFailed`] - /// will be emitted. Any contributed inputs no longer used will be included here and thus can - /// be re-spent. - /// - /// Once the splice has been locked by both counterparties, an [`Event::ChannelReady`] will be - /// emitted with the new funding output. At this point, a new splice can be negotiated by - /// calling `splice_channel` again on this channel. - /// - /// [`FundingContribution`]: crate::ln::funding::FundingContribution - pub fn rbf_channel( - &self, channel_id: &ChannelId, counterparty_node_id: &PublicKey, min_feerate: FeeRate, - max_feerate: FeeRate, - ) -> Result { - let per_peer_state = self.per_peer_state.read().unwrap(); - - let peer_state_mutex = match per_peer_state - .get(counterparty_node_id) - .ok_or_else(|| APIError::no_such_peer(counterparty_node_id)) - { - Ok(p) => p, - Err(e) => return Err(e), - }; - - let mut peer_state = peer_state_mutex.lock().unwrap(); - if !peer_state.latest_features.supports_splicing() { - return Err(APIError::ChannelUnavailable { - err: "Peer does not support splicing".to_owned(), - }); - } - if !peer_state.latest_features.supports_quiescence() { - return Err(APIError::ChannelUnavailable { - err: "Peer does not support quiescence, a splicing prerequisite".to_owned(), - }); - } - - // Look for the channel - match peer_state.channel_by_id.entry(*channel_id) { - hash_map::Entry::Occupied(chan_phase_entry) => { - if let Some(chan) = chan_phase_entry.get().as_funded() { - chan.rbf_channel(min_feerate, max_feerate) - } else { - Err(APIError::ChannelUnavailable { - err: format!( - "Channel with id {} is not funded, cannot RBF splice", - channel_id - ), - }) - } - }, - hash_map::Entry::Vacant(_) => { - Err(APIError::no_such_channel_for_peer(channel_id, counterparty_node_id)) - }, - } - } - #[cfg(test)] pub(crate) fn abandon_splice( &self, channel_id: &ChannelId, counterparty_node_id: &PublicKey, @@ -6622,20 +6497,43 @@ impl< /// An optional `locktime` for the funding transaction may be specified. If not given, the /// current best block height is used. /// + /// # Fee Estimation + /// + /// The splice initiator is responsible for paying fees for common fields, shared inputs, and + /// shared outputs along with any contributed inputs and outputs. When building a + /// [`FundingContribution`], fees are estimated at `min_feerate` assuming initiator + /// responsibility and must be covered by the supplied inputs for splice-in or the channel + /// balance for splice-out. If the counterparty also initiates a splice and wins the + /// tie-break, they become the initiator and choose the feerate. The fee is then + /// re-estimated at the counterparty's feerate for only our contributed inputs and outputs, + /// which may be higher or lower than the original estimate. The contribution is dropped and + /// the splice proceeds without it when: + /// - the counterparty's feerate is below `min_feerate` + /// - the counterparty's feerate is above `max_feerate` and the re-estimated fee exceeds the + /// original fee estimate + /// - the re-estimated fee exceeds the *fee buffer* regardless of `max_feerate` + /// + /// The fee buffer is the maximum fee that can be accommodated: + /// - **splice-in**: the selected inputs' value minus the contributed amount + /// - **splice-out**: the channel balance minus the withdrawal outputs + /// /// # Events /// /// Calling this method will commence the process of creating a new funding transaction for the - /// channel. An [`Event::FundingTransactionReadyForSigning`] will be generated once the - /// transaction is successfully constructed interactively with the counterparty. + /// channel. Once the funding transaction has been constructed, an [`Event::SplicePending`] + /// will be emitted. At this point, any inputs contributed to the splice can only be re-spent + /// if an [`Event::DiscardFunding`] is seen. /// - /// If unsuccessful, an [`Event::SpliceFailed`] will be produced if there aren't any earlier - /// splice attempts for the channel outstanding (i.e., haven't yet produced either - /// [`Event::SplicePending`] or [`Event::SpliceFailed`]). + /// If any failures occur while negotiating the funding transaction, an [`Event::SpliceFailed`] + /// will be emitted. Any contributed inputs no longer used will be included in an + /// [`Event::DiscardFunding`] and thus can be re-spent. /// - /// If unsuccessful, an [`Event::DiscardFunding`] will be produced for any contributions - /// passed in that are not found in any outstanding attempts for the channel. If there are no - /// such contributions, then the [`Event::DiscardFunding`] will not be produced since these - /// contributions must not be reused yet. + /// After initial signatures have been exchanged, [`Event::FundingTransactionReadyForSigning`] + /// will be generated and [`ChannelManager::funding_transaction_signed`] should be called. + /// + /// Once the splice has been locked by both counterparties, an [`Event::ChannelReady`] will be + /// emitted with the new funding output. At this point, a new splice can be negotiated by + /// calling [`ChannelManager::splice_channel`] again on this channel. /// /// # Errors /// diff --git a/lightning/src/ln/funding.rs b/lightning/src/ln/funding.rs index c81024ca080..a439791f054 100644 --- a/lightning/src/ln/funding.rs +++ b/lightning/src/ln/funding.rs @@ -106,12 +106,68 @@ impl core::fmt::Display for FeeRateAdjustmentError { } } +/// The user's prior contribution from a previous splice negotiation on this channel. +/// +/// When a pending splice exists with negotiated candidates, the prior contribution is +/// available for reuse (e.g., to bump the feerate via RBF). The variant indicates whether +/// the contribution has been adjusted to the minimum RBF feerate. +/// +/// Use [`FundingTemplate::prior_contribution`] to inspect the prior contribution before +/// deciding whether to call [`FundingTemplate::rbf_sync`] or one of the splice methods +/// with different parameters. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum PriorContribution { + /// The prior contribution's feerate meets or exceeds the minimum RBF feerate. + Adjusted(FundingContribution), + /// The prior contribution could not be adjusted to the minimum RBF feerate (insufficient fee + /// buffer or `max_feerate` too low). + Unadjusted(FundingContribution), +} + +impl PriorContribution { + /// Returns the amount added to the channel by this contribution. + pub fn value_added(&self) -> Amount { + match self { + PriorContribution::Adjusted(c) | PriorContribution::Unadjusted(c) => c.value_added, + } + } + + /// Returns the outputs (e.g., withdrawal destinations) included in this contribution. + pub fn outputs(&self) -> &[TxOut] { + match self { + PriorContribution::Adjusted(c) | PriorContribution::Unadjusted(c) => &c.outputs, + } + } +} + /// A template for contributing to a channel's splice funding transaction. /// /// This is returned from [`ChannelManager::splice_channel`] when a channel is ready to be -/// spliced. It must be converted to a [`FundingContribution`] using one of the splice methods -/// and passed to [`ChannelManager::funding_contributed`] in order to resume the splicing -/// process. +/// spliced. A [`FundingContribution`] must be obtained from it and passed to +/// [`ChannelManager::funding_contributed`] in order to resume the splicing process. +/// +/// # Building a Contribution +/// +/// For a fresh splice (no pending splice to replace), build a new contribution using one of +/// the splice methods: +/// - [`FundingTemplate::splice_in_sync`] to add funds to the channel +/// - [`FundingTemplate::splice_out_sync`] to remove funds from the channel +/// - [`FundingTemplate::splice_in_and_out_sync`] to do both +/// +/// These perform coin selection and require `min_feerate` and `max_feerate` parameters. +/// +/// # Replace By Fee (RBF) +/// +/// When a pending splice exists that hasn't been locked yet, use [`FundingTemplate::rbf_sync`] +/// (or [`FundingTemplate::rbf`] for async) to build an RBF contribution. This handles the +/// 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 (25/24 of +/// the previous feerate). Use [`FundingTemplate::prior_contribution`] to inspect the prior +/// contribution's parameters (e.g., `value_added`, `outputs`) before deciding whether to +/// reuse it via the RBF methods or build a fresh contribution with different parameters +/// using the splice methods above. /// /// [`ChannelManager::splice_channel`]: crate::ln::channelmanager::ChannelManager::splice_channel /// [`ChannelManager::funding_contributed`]: crate::ln::channelmanager::ChannelManager::funding_contributed @@ -121,30 +177,62 @@ pub struct FundingTemplate { /// transaction. shared_input: Option, - /// The minimum fee rate for the splice transaction, used to propose as initiator. - min_feerate: FeeRate, + /// The minimum RBF feerate (25/24 of the previous feerate), if this template is for an + /// RBF attempt. `None` for fresh splices with no pending splice candidates. + min_rbf_feerate: Option, - /// The maximum fee rate to accept as acceptor before declining to add our contribution to the - /// splice. - max_feerate: FeeRate, + /// The user's prior contribution from a previous splice negotiation, if available. + prior_contribution: Option, } impl FundingTemplate { /// Constructs a [`FundingTemplate`] for a splice using the provided shared input. pub(super) fn new( - shared_input: Option, min_feerate: FeeRate, max_feerate: FeeRate, + shared_input: Option, min_rbf_feerate: Option, + prior_contribution: Option, ) -> Self { - Self { shared_input, min_feerate, max_feerate } + Self { shared_input, min_rbf_feerate, prior_contribution } + } + + /// Returns the minimum RBF feerate, if this template is for an RBF attempt. + /// + /// When set, the `min_feerate` passed to the splice methods (e.g., + /// [`FundingTemplate::splice_in_sync`]) must be at least this value. + pub fn min_rbf_feerate(&self) -> Option { + self.min_rbf_feerate + } + + /// Returns a reference to the prior contribution from a previous splice negotiation, if + /// available. + /// + /// Use this to inspect the prior contribution's parameters (e.g., + /// [`PriorContribution::value_added`], [`PriorContribution::outputs`]) before deciding + /// whether to reuse it via [`FundingTemplate::rbf_sync`] or build a fresh contribution + /// with different parameters using the splice methods. + pub fn prior_contribution(&self) -> Option<&PriorContribution> { + self.prior_contribution.as_ref() } } macro_rules! build_funding_contribution { - ($value_added:expr, $outputs:expr, $shared_input:expr, $feerate:expr, $max_feerate:expr, $wallet:ident, $($await:tt)*) => {{ + ($value_added:expr, $outputs:expr, $shared_input:expr, $min_rbf_feerate:expr, $feerate:expr, $max_feerate:expr, $force_coin_selection:expr, $wallet:ident, $($await:tt)*) => {{ let value_added: Amount = $value_added; let outputs: Vec = $outputs; let shared_input: Option = $shared_input; + let min_rbf_feerate: Option = $min_rbf_feerate; let feerate: FeeRate = $feerate; let max_feerate: FeeRate = $max_feerate; + let force_coin_selection: bool = $force_coin_selection; + + if feerate > max_feerate { + return Err(()); + } + + if let Some(min_rbf_feerate) = min_rbf_feerate { + if feerate < min_rbf_feerate { + return Err(()); + } + } // Validate user-provided amounts are within MAX_MONEY before coin selection to // ensure FundingContribution::net_value() arithmetic cannot overflow. With all @@ -164,7 +252,7 @@ macro_rules! build_funding_contribution { let is_splice = shared_input.is_some(); - let coin_selection = if value_added == Amount::ZERO { + let coin_selection = if value_added == Amount::ZERO && !force_coin_selection { CoinSelection { confirmed_utxos: vec![], change_output: None } } else { // Used for creating a redeem script for the new funding txo, since the funding pubkeys @@ -224,30 +312,32 @@ impl FundingTemplate { /// Creates a [`FundingContribution`] for adding funds to a channel using `wallet` to perform /// coin selection. pub async fn splice_in( - self, value_added: Amount, wallet: W, + self, value_added: Amount, min_feerate: FeeRate, max_feerate: FeeRate, wallet: W, ) -> Result { if value_added == Amount::ZERO { return Err(()); } - let FundingTemplate { shared_input, min_feerate, max_feerate } = self; - build_funding_contribution!(value_added, vec![], shared_input, min_feerate, max_feerate, wallet, await) + let FundingTemplate { shared_input, min_rbf_feerate, .. } = self; + build_funding_contribution!(value_added, vec![], shared_input, min_rbf_feerate, min_feerate, max_feerate, false, wallet, await) } /// Creates a [`FundingContribution`] for adding funds to a channel using `wallet` to perform /// coin selection. pub fn splice_in_sync( - self, value_added: Amount, wallet: W, + self, value_added: Amount, min_feerate: FeeRate, max_feerate: FeeRate, wallet: W, ) -> Result { if value_added == Amount::ZERO { return Err(()); } - let FundingTemplate { shared_input, min_feerate, max_feerate } = self; + let FundingTemplate { shared_input, min_rbf_feerate, .. } = self; build_funding_contribution!( value_added, vec![], shared_input, + min_rbf_feerate, min_feerate, max_feerate, + false, wallet, ) } @@ -255,30 +345,32 @@ impl FundingTemplate { /// Creates a [`FundingContribution`] for removing funds from a channel using `wallet` to /// perform coin selection. pub async fn splice_out( - self, outputs: Vec, wallet: W, + self, outputs: Vec, min_feerate: FeeRate, max_feerate: FeeRate, wallet: W, ) -> Result { if outputs.is_empty() { return Err(()); } - let FundingTemplate { shared_input, min_feerate, max_feerate } = self; - build_funding_contribution!(Amount::ZERO, outputs, shared_input, min_feerate, max_feerate, wallet, await) + let FundingTemplate { shared_input, min_rbf_feerate, .. } = self; + build_funding_contribution!(Amount::ZERO, outputs, shared_input, min_rbf_feerate, min_feerate, max_feerate, false, wallet, await) } /// Creates a [`FundingContribution`] for removing funds from a channel using `wallet` to /// perform coin selection. pub fn splice_out_sync( - self, outputs: Vec, wallet: W, + self, outputs: Vec, min_feerate: FeeRate, max_feerate: FeeRate, wallet: W, ) -> Result { if outputs.is_empty() { return Err(()); } - let FundingTemplate { shared_input, min_feerate, max_feerate } = self; + let FundingTemplate { shared_input, min_rbf_feerate, .. } = self; build_funding_contribution!( Amount::ZERO, outputs, shared_input, + min_rbf_feerate, min_feerate, max_feerate, + false, wallet, ) } @@ -286,33 +378,132 @@ impl FundingTemplate { /// Creates a [`FundingContribution`] for both adding and removing funds from a channel using /// `wallet` to perform coin selection. pub async fn splice_in_and_out( - self, value_added: Amount, outputs: Vec, wallet: W, + self, value_added: Amount, outputs: Vec, min_feerate: FeeRate, max_feerate: FeeRate, + wallet: W, ) -> Result { if value_added == Amount::ZERO && outputs.is_empty() { return Err(()); } - let FundingTemplate { shared_input, min_feerate, max_feerate } = self; - build_funding_contribution!(value_added, outputs, shared_input, min_feerate, max_feerate, wallet, await) + let FundingTemplate { shared_input, min_rbf_feerate, .. } = self; + build_funding_contribution!(value_added, outputs, shared_input, min_rbf_feerate, min_feerate, max_feerate, false, wallet, await) } /// Creates a [`FundingContribution`] for both adding and removing funds from a channel using /// `wallet` to perform coin selection. pub fn splice_in_and_out_sync( - self, value_added: Amount, outputs: Vec, wallet: W, + self, value_added: Amount, outputs: Vec, min_feerate: FeeRate, max_feerate: FeeRate, + wallet: W, ) -> Result { if value_added == Amount::ZERO && outputs.is_empty() { return Err(()); } - let FundingTemplate { shared_input, min_feerate, max_feerate } = self; + let FundingTemplate { shared_input, min_rbf_feerate, .. } = self; build_funding_contribution!( value_added, outputs, shared_input, + min_rbf_feerate, min_feerate, max_feerate, + false, wallet, ) } + + /// Creates a [`FundingContribution`] for an RBF (Replace-By-Fee) attempt on a pending splice. + /// + /// `max_feerate` is the maximum feerate the caller is willing to accept as acceptor. It is + /// used as the returned contribution's `max_feerate` and also constrains coin selection when + /// re-running it for unadjusted prior contributions or fee-bump-only contributions. + /// + /// This handles the prior contribution logic internally: + /// - If the prior contribution was successfully adjusted to the minimum RBF feerate, it is + /// returned directly with `max_feerate` updated to the caller's value. + /// - If the prior contribution could not be adjusted (insufficient fee buffer or low + /// `max_feerate`), coin selection is re-run using the prior contribution's parameters and + /// the caller's `max_feerate`. + /// - If no prior contribution exists (e.g., the acceptor), coin selection is run for a + /// fee-bump-only contribution (`value_added = 0`). + /// + /// Returns `Err(())` if this is not an RBF scenario ([`FundingTemplate::min_rbf_feerate`] + /// is `None`), if `max_feerate` is below the minimum RBF feerate, or if `max_feerate` is + /// below the adjusted prior contribution's feerate. + pub async fn rbf( + self, max_feerate: FeeRate, wallet: W, + ) -> Result { + let FundingTemplate { shared_input, min_rbf_feerate, prior_contribution } = self; + let rbf_feerate = min_rbf_feerate.ok_or(())?; + if max_feerate < rbf_feerate { + return Err(()); + } + + match prior_contribution { + Some(PriorContribution::Adjusted(mut c)) => { + if max_feerate < c.feerate { + return Err(()); + } + c.max_feerate = max_feerate; + Ok(c) + }, + Some(PriorContribution::Unadjusted(c)) => { + let prior_max_feerate = + if c.max_feerate < rbf_feerate { max_feerate } else { c.max_feerate }; + build_funding_contribution!(c.value_added, c.outputs, shared_input, min_rbf_feerate, rbf_feerate, prior_max_feerate, true, wallet, await) + }, + None => { + build_funding_contribution!(Amount::ZERO, vec![], shared_input, min_rbf_feerate, rbf_feerate, max_feerate, true, wallet, await) + }, + } + } + + /// Creates a [`FundingContribution`] for an RBF (Replace-By-Fee) attempt on a pending splice. + /// + /// See [`FundingTemplate::rbf`] for details. + pub fn rbf_sync( + self, max_feerate: FeeRate, wallet: W, + ) -> Result { + let FundingTemplate { shared_input, min_rbf_feerate, prior_contribution } = self; + let rbf_feerate = min_rbf_feerate.ok_or(())?; + if max_feerate < rbf_feerate { + return Err(()); + } + + match prior_contribution { + Some(PriorContribution::Adjusted(mut c)) => { + if max_feerate < c.feerate { + return Err(()); + } + c.max_feerate = max_feerate; + Ok(c) + }, + Some(PriorContribution::Unadjusted(c)) => { + let prior_max_feerate = + if c.max_feerate < rbf_feerate { max_feerate } else { c.max_feerate }; + build_funding_contribution!( + c.value_added, + c.outputs, + shared_input, + min_rbf_feerate, + rbf_feerate, + prior_max_feerate, + true, + wallet, + ) + }, + None => { + build_funding_contribution!( + Amount::ZERO, + vec![], + shared_input, + min_rbf_feerate, + rbf_feerate, + max_feerate, + true, + wallet, + ) + }, + } + } } fn estimate_transaction_fee( @@ -366,7 +557,7 @@ fn estimate_transaction_fee( } /// The components of a funding transaction contributed by one party. -#[derive(Debug, Clone)] +#[derive(Debug, Clone, PartialEq, Eq)] pub struct FundingContribution { /// The amount to contribute to the channel. /// @@ -426,6 +617,18 @@ impl FundingContribution { self.outputs.iter().chain(self.change_output.iter()) } + /// Returns the amount added to the channel by this contribution. + pub fn value_added(&self) -> Amount { + self.value_added + } + + /// Returns the outputs (e.g., withdrawal destinations) included in this contribution. + /// + /// This does not include the change output; see [`FundingContribution::change_output`]. + pub fn outputs(&self) -> &[TxOut] { + &self.outputs + } + /// Returns the change output included in this contribution, if any. /// /// When coin selection provides more value than needed for the funding contribution and fees, @@ -526,8 +729,12 @@ impl FundingContribution { Ok(()) } - /// Computes the adjusted fee and change output value for the acceptor at the initiator's - /// proposed feerate, which may differ from the feerate used during coin selection. + /// Computes the adjusted fee and change output value at the given target feerate, which may + /// differ from the feerate used during coin selection. + /// + /// The `is_initiator` parameter determines fee responsibility: the initiator pays for common + /// transaction fields, the shared input, and the shared output, while the acceptor only pays + /// for their own contributed inputs and outputs. /// /// On success, returns the new estimated fee and, if applicable, the new change output value: /// - `Some(change)` — the adjusted change output value @@ -535,7 +742,7 @@ impl FundingContribution { /// /// Returns `Err` if the contribution cannot accommodate the target feerate. fn compute_feerate_adjustment( - &self, target_feerate: FeeRate, holder_balance: Amount, + &self, target_feerate: FeeRate, holder_balance: Amount, is_initiator: bool, ) -> Result<(Amount, Option), FeeRateAdjustmentError> { if target_feerate < self.feerate { return Err(FeeRateAdjustmentError::FeeRateTooLow { @@ -545,14 +752,15 @@ impl FundingContribution { } // If the target fee rate exceeds our max fee rate, we may still add our contribution - // if we pay less in fees. This may happen because the acceptor doesn't pay for common - // fields and the shared input / output. + // if we pay less in fees at the target feerate than at the original feerate. This can + // happen when adjusting as acceptor, since the acceptor doesn't pay for common fields + // and the shared input / output. if target_feerate > self.max_feerate { let target_fee = estimate_transaction_fee( &self.inputs, &self.outputs, self.change_output.as_ref(), - false, + is_initiator, self.is_splice, target_feerate, ); @@ -576,7 +784,7 @@ impl FundingContribution { &self.inputs, &self.outputs, self.change_output.as_ref(), - false, + is_initiator, self.is_splice, target_feerate, ); @@ -596,7 +804,7 @@ impl FundingContribution { &self.inputs, &self.outputs, None, - false, + is_initiator, self.is_splice, target_feerate, ); @@ -617,7 +825,7 @@ impl FundingContribution { &self.inputs, &self.outputs, None, - false, + is_initiator, self.is_splice, target_feerate, ); @@ -647,7 +855,7 @@ impl FundingContribution { &[], &self.outputs, None, - false, + is_initiator, self.is_splice, target_feerate, ); @@ -669,17 +877,14 @@ impl FundingContribution { } } - /// Adjusts the contribution's change output for the initiator's feerate. - /// - /// When the acceptor has a pending contribution (from the quiescence tie-breaker scenario), - /// the initiator's proposed feerate may differ from the feerate used during coin selection. - /// This adjusts the change output so the acceptor pays their target fee at the target - /// feerate. - pub(super) fn for_acceptor_at_feerate( - mut self, feerate: FeeRate, holder_balance: Amount, + /// Adjusts the contribution for a different feerate, updating the change output, fee + /// estimate, and feerate. Returns the adjusted contribution, or an error if the feerate + /// can't be accommodated. + fn at_feerate( + mut self, feerate: FeeRate, holder_balance: Amount, is_initiator: bool, ) -> Result { let (new_estimated_fee, new_change) = - self.compute_feerate_adjustment(feerate, holder_balance)?; + self.compute_feerate_adjustment(feerate, holder_balance, is_initiator)?; let surplus = self.fee_buffer_surplus(new_estimated_fee, &new_change); match new_change { Some(value) => self.change_output.as_mut().unwrap().value = value, @@ -691,16 +896,39 @@ impl FundingContribution { Ok(self) } + /// Adjusts the contribution's change output for the initiator's feerate. + /// + /// When the acceptor has a pending contribution (from the quiescence tie-breaker scenario), + /// the initiator's proposed feerate may differ from the feerate used during coin selection. + /// This adjusts the change output so the acceptor pays their target fee at the target + /// feerate. + pub(super) fn for_acceptor_at_feerate( + self, feerate: FeeRate, holder_balance: Amount, + ) -> Result { + self.at_feerate(feerate, holder_balance, false) + } + + /// Adjusts the contribution's change output for the minimum RBF feerate. + /// + /// When a pending splice exists with negotiated candidates and the contribution's feerate + /// is below the minimum RBF feerate (25/24 of the previous feerate), this adjusts the + /// change output so the initiator pays fees at the minimum RBF feerate. + pub(super) fn for_initiator_at_feerate( + self, feerate: FeeRate, holder_balance: Amount, + ) -> Result { + self.at_feerate(feerate, holder_balance, true) + } + /// Returns the net value at the given target feerate without mutating `self`. /// /// This serves double duty: it checks feerate compatibility (returning `Err` if the feerate /// can't be accommodated) and computes the adjusted net value (returning `Ok` with the value /// accounting for the target feerate). - pub(super) fn net_value_for_acceptor_at_feerate( - &self, target_feerate: FeeRate, holder_balance: Amount, + fn net_value_at_feerate( + &self, target_feerate: FeeRate, holder_balance: Amount, is_initiator: bool, ) -> Result { let (new_estimated_fee, new_change) = - self.compute_feerate_adjustment(target_feerate, holder_balance)?; + self.compute_feerate_adjustment(target_feerate, holder_balance, is_initiator)?; let surplus = self .fee_buffer_surplus(new_estimated_fee, &new_change) .to_signed() @@ -712,6 +940,22 @@ impl FundingContribution { Ok(net_value) } + /// Returns the net value at the given target feerate without mutating `self`, + /// assuming acceptor fee responsibility. + pub(super) fn net_value_for_acceptor_at_feerate( + &self, target_feerate: FeeRate, holder_balance: Amount, + ) -> Result { + self.net_value_at_feerate(target_feerate, holder_balance, false) + } + + /// Returns the net value at the given target feerate without mutating `self`, + /// assuming initiator fee responsibility. + pub(super) fn net_value_for_initiator_at_feerate( + &self, target_feerate: FeeRate, holder_balance: Amount, + ) -> Result { + self.net_value_at_feerate(target_feerate, holder_balance, true) + } + /// Returns the fee buffer surplus when a change output is removed. /// /// The fee buffer is the actual amount available for fees from inputs: total input value @@ -773,7 +1017,7 @@ pub type FundingTxInput = crate::util::wallet_utils::ConfirmedUtxo; mod tests { use super::{ estimate_transaction_fee, FeeRateAdjustmentError, FundingContribution, FundingTemplate, - FundingTxInput, + FundingTxInput, PriorContribution, }; use crate::chain::ClaimId; use crate::util::wallet_utils::{CoinSelection, CoinSelectionSourceSync, Input}; @@ -1082,41 +1326,77 @@ mod tests { // splice_in_sync with value_added > MAX_MONEY { - let template = FundingTemplate::new(None, feerate, feerate); - assert!(template.splice_in_sync(over_max, UnreachableWallet).is_err()); + let template = FundingTemplate::new(None, None, None); + assert!(template + .splice_in_sync(over_max, feerate, feerate, UnreachableWallet) + .is_err()); } // splice_out_sync with single output value > MAX_MONEY { - let template = FundingTemplate::new(None, feerate, feerate); + let template = FundingTemplate::new(None, None, None); let outputs = vec![funding_output_sats(over_max.to_sat())]; - assert!(template.splice_out_sync(outputs, UnreachableWallet).is_err()); + assert!(template + .splice_out_sync(outputs, feerate, feerate, UnreachableWallet) + .is_err()); } // splice_out_sync with multiple outputs summing > MAX_MONEY { - let template = FundingTemplate::new(None, feerate, feerate); + let template = FundingTemplate::new(None, None, None); let half_over = Amount::MAX_MONEY / 2 + Amount::from_sat(1); let outputs = vec![ funding_output_sats(half_over.to_sat()), funding_output_sats(half_over.to_sat()), ]; - assert!(template.splice_out_sync(outputs, UnreachableWallet).is_err()); + assert!(template + .splice_out_sync(outputs, feerate, feerate, UnreachableWallet) + .is_err()); } // splice_in_and_out_sync with value_added > MAX_MONEY { - let template = FundingTemplate::new(None, feerate, feerate); + let template = FundingTemplate::new(None, None, None); let outputs = vec![funding_output_sats(1_000)]; - assert!(template.splice_in_and_out_sync(over_max, outputs, UnreachableWallet).is_err()); + assert!(template + .splice_in_and_out_sync(over_max, outputs, feerate, feerate, UnreachableWallet) + .is_err()); } // splice_in_and_out_sync with output sum > MAX_MONEY { - let template = FundingTemplate::new(None, feerate, feerate); + let template = FundingTemplate::new(None, None, None); let outputs = vec![funding_output_sats(over_max.to_sat())]; assert!(template - .splice_in_and_out_sync(Amount::from_sat(1_000), outputs, UnreachableWallet) + .splice_in_and_out_sync( + Amount::from_sat(1_000), + outputs, + feerate, + feerate, + UnreachableWallet, + ) + .is_err()); + } + } + + #[test] + fn test_build_funding_contribution_validates_feerate_range() { + let low = FeeRate::from_sat_per_kwu(1000); + let high = FeeRate::from_sat_per_kwu(2000); + + // min_feerate > max_feerate is rejected + { + let template = FundingTemplate::new(None, None, None); + assert!(template + .splice_in_sync(Amount::from_sat(10_000), high, low, UnreachableWallet) + .is_err()); + } + + // min_feerate < min_rbf_feerate is rejected + { + let template = FundingTemplate::new(None, Some(high), None); + assert!(template + .splice_in_sync(Amount::from_sat(10_000), low, FeeRate::MAX, UnreachableWallet) .is_err()); } } @@ -1812,4 +2092,214 @@ mod tests { let result = contribution.net_value_for_acceptor_at_feerate(target_feerate, holder_balance); assert!(matches!(result, Err(FeeRateAdjustmentError::FeeBufferInsufficient { .. }))); } + + #[test] + fn test_for_initiator_at_feerate_higher_fee_than_acceptor() { + // Verify that the initiator fee estimate is higher than the acceptor estimate at the + // same feerate, since the initiator pays for common fields + shared input/output. + let original_feerate = FeeRate::from_sat_per_kwu(2000); + let target_feerate = FeeRate::from_sat_per_kwu(3000); + let inputs = vec![funding_input_sats(100_000)]; + let change = funding_output_sats(10_000); + + let estimated_fee = + estimate_transaction_fee(&inputs, &[], Some(&change), true, true, original_feerate); + + let contribution = FundingContribution { + value_added: Amount::from_sat(50_000), + estimated_fee, + inputs, + outputs: vec![], + change_output: Some(change), + feerate: original_feerate, + max_feerate: FeeRate::MAX, + is_splice: true, + }; + + let acceptor = + contribution.clone().for_acceptor_at_feerate(target_feerate, Amount::MAX).unwrap(); + let initiator = contribution.for_initiator_at_feerate(target_feerate, Amount::MAX).unwrap(); + + // Initiator pays more in fees (common fields + shared input/output weight). + assert!(initiator.estimated_fee > acceptor.estimated_fee); + // Initiator has less change remaining. + assert!( + initiator.change_output.as_ref().unwrap().value + < acceptor.change_output.as_ref().unwrap().value + ); + // Both have the adjusted feerate. + assert_eq!(initiator.feerate, target_feerate); + assert_eq!(acceptor.feerate, target_feerate); + } + + #[test] + fn test_rbf_sync_rejects_max_feerate_below_adjusted_feerate() { + // When the Adjusted prior contribution's feerate exceeds the caller's max_feerate, + // rbf_sync should return Err(()) to avoid creating an inconsistent contribution + // where feerate > max_feerate. + let prior_feerate = FeeRate::from_sat_per_kwu(5000); + let min_rbf_feerate = FeeRate::from_sat_per_kwu(2000); + let max_feerate = FeeRate::from_sat_per_kwu(3000); + + let prior = FundingContribution { + value_added: Amount::from_sat(50_000), + estimated_fee: Amount::from_sat(1_000), + inputs: vec![funding_input_sats(100_000)], + outputs: vec![], + change_output: None, + feerate: prior_feerate, + max_feerate: FeeRate::MAX, + is_splice: true, + }; + + // max_feerate (3000) >= min_rbf_feerate (2000) but < prior's feerate (5000). + let template = FundingTemplate::new( + None, + Some(min_rbf_feerate), + Some(PriorContribution::Adjusted(prior)), + ); + assert!(template.rbf_sync(max_feerate, UnreachableWallet).is_err()); + } + + #[test] + fn test_rbf_sync_accepts_max_feerate_at_adjusted_feerate() { + // When the caller's max_feerate equals the Adjusted prior's feerate, rbf_sync should + // succeed and update the contribution's max_feerate. + let prior_feerate = FeeRate::from_sat_per_kwu(5000); + let min_rbf_feerate = FeeRate::from_sat_per_kwu(2000); + let max_feerate = FeeRate::from_sat_per_kwu(5000); + + let prior = FundingContribution { + value_added: Amount::from_sat(50_000), + estimated_fee: Amount::from_sat(1_000), + inputs: vec![funding_input_sats(100_000)], + outputs: vec![], + change_output: None, + feerate: prior_feerate, + max_feerate: FeeRate::MAX, + is_splice: true, + }; + + let template = FundingTemplate::new( + None, + Some(min_rbf_feerate), + Some(PriorContribution::Adjusted(prior)), + ); + let contribution = template.rbf_sync(max_feerate, UnreachableWallet).unwrap(); + assert_eq!(contribution.feerate, prior_feerate); + assert_eq!(contribution.max_feerate, max_feerate); + } + + /// A mock wallet that returns a single UTXO for coin selection. + struct SingleUtxoWallet { + utxo: FundingTxInput, + change_output: Option, + } + + impl CoinSelectionSourceSync for SingleUtxoWallet { + fn select_confirmed_utxos( + &self, _claim_id: Option, _must_spend: Vec, _must_pay_to: &[TxOut], + _target_feerate_sat_per_1000_weight: u32, _max_tx_weight: u64, + ) -> Result { + Ok(CoinSelection { + confirmed_utxos: vec![self.utxo.clone()], + change_output: self.change_output.clone(), + }) + } + fn sign_psbt(&self, _psbt: Psbt) -> Result { + unreachable!("should not reach signing") + } + } + + fn shared_input(value_sats: u64) -> Input { + Input { + outpoint: bitcoin::OutPoint::null(), + previous_utxo: TxOut { + value: Amount::from_sat(value_sats), + script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::all_zeros()), + }, + satisfaction_weight: 107, + } + } + + #[test] + fn test_rbf_sync_unadjusted_splice_out_runs_coin_selection() { + // When the prior contribution is an Unadjusted splice-out (value_added=0, non-empty + // outputs), rbf_sync should run coin selection to add inputs that cover the higher + // RBF fee since the channel balance alone was insufficient. + let min_rbf_feerate = FeeRate::from_sat_per_kwu(5000); + let prior_feerate = FeeRate::from_sat_per_kwu(2000); + let withdrawal = funding_output_sats(20_000); + + let prior = FundingContribution { + value_added: Amount::ZERO, + estimated_fee: Amount::from_sat(500), + inputs: vec![], + outputs: vec![withdrawal.clone()], + change_output: None, + feerate: prior_feerate, + max_feerate: prior_feerate, + is_splice: true, + }; + + let template = FundingTemplate::new( + Some(shared_input(100_000)), + Some(min_rbf_feerate), + Some(PriorContribution::Unadjusted(prior)), + ); + + let wallet = SingleUtxoWallet { + utxo: funding_input_sats(50_000), + change_output: Some(funding_output_sats(40_000)), + }; + + // rbf_sync should succeed and the contribution should have inputs from coin selection. + let contribution = template.rbf_sync(FeeRate::MAX, &wallet).unwrap(); + assert_eq!(contribution.value_added, Amount::ZERO); + assert!(!contribution.inputs.is_empty(), "coin selection should have added inputs"); + assert_eq!(contribution.outputs, vec![withdrawal]); + assert_eq!(contribution.feerate, min_rbf_feerate); + } + + #[test] + fn test_rbf_sync_no_prior_fee_bump_only_runs_coin_selection() { + // When there is no prior contribution (e.g., acceptor), rbf_sync should run coin + // selection to add inputs for a fee-bump-only contribution. + let min_rbf_feerate = FeeRate::from_sat_per_kwu(5000); + + let template = + FundingTemplate::new(Some(shared_input(100_000)), Some(min_rbf_feerate), None); + + let wallet = SingleUtxoWallet { + utxo: funding_input_sats(50_000), + change_output: Some(funding_output_sats(45_000)), + }; + + let contribution = template.rbf_sync(FeeRate::MAX, &wallet).unwrap(); + assert_eq!(contribution.value_added, Amount::ZERO); + assert!(!contribution.inputs.is_empty(), "coin selection should have added inputs"); + assert!(contribution.outputs.is_empty()); + assert_eq!(contribution.feerate, min_rbf_feerate); + } + + #[test] + fn test_splice_out_sync_skips_coin_selection_during_rbf() { + // When splice_out_sync is called on a template with min_rbf_feerate set (user + // choosing a fresh splice-out instead of rbf_sync), coin selection should NOT run. + // Fees come from the channel balance. + let min_rbf_feerate = FeeRate::from_sat_per_kwu(5000); + let feerate = FeeRate::from_sat_per_kwu(5000); + let withdrawal = funding_output_sats(20_000); + + let template = + FundingTemplate::new(Some(shared_input(100_000)), Some(min_rbf_feerate), None); + + // UnreachableWallet panics if coin selection runs — verifying it is skipped. + let contribution = template + .splice_out_sync(vec![withdrawal.clone()], feerate, FeeRate::MAX, UnreachableWallet) + .unwrap(); + assert_eq!(contribution.value_added, Amount::ZERO); + assert!(contribution.inputs.is_empty()); + assert_eq!(contribution.outputs, vec![withdrawal]); + } } diff --git a/lightning/src/ln/splicing_tests.rs b/lightning/src/ln/splicing_tests.rs index bdfe14635e0..3b5b5ef390d 100644 --- a/lightning/src/ln/splicing_tests.rs +++ b/lightning/src/ln/splicing_tests.rs @@ -59,8 +59,7 @@ fn test_splicing_not_supported_api_error() { let (_, _, channel_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); - let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let res = nodes[1].node.splice_channel(&channel_id, &node_id_0, feerate, FeeRate::MAX); + let res = nodes[1].node.splice_channel(&channel_id, &node_id_0); match res { Err(APIError::ChannelUnavailable { err }) => { assert!(err.contains("Peer does not support splicing")) @@ -81,7 +80,7 @@ fn test_splicing_not_supported_api_error() { reconnect_args.send_announcement_sigs = (true, true); reconnect_nodes(reconnect_args); - let res = nodes[1].node.splice_channel(&channel_id, &node_id_0, feerate, FeeRate::MAX); + let res = nodes[1].node.splice_channel(&channel_id, &node_id_0); match res { Err(APIError::ChannelUnavailable { err }) => { assert!(err.contains("Peer does not support quiescence, a splicing prerequisite")) @@ -111,13 +110,13 @@ fn test_v1_splice_in_negative_insufficient_inputs() { let feerate = FeeRate::from_sat_per_kwu(1024); // Initiate splice-in, with insufficient input contribution - let funding_template = nodes[0] - .node - .splice_channel(&channel_id, &nodes[1].node.get_our_node_id(), feerate, FeeRate::MAX) - .unwrap(); + let funding_template = + nodes[0].node.splice_channel(&channel_id, &nodes[1].node.get_our_node_id()).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - assert!(funding_template.splice_in_sync(splice_in_value, &wallet).is_err()); + assert!(funding_template + .splice_in_sync(splice_in_value, feerate, FeeRate::MAX, &wallet) + .is_err()); } /// A mock wallet that returns a pre-configured [`CoinSelection`] with a single input and change @@ -176,10 +175,8 @@ fn test_validate_accounts_for_change_output_weight() { create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0); let feerate = FeeRate::from_sat_per_kwu(2000); - let funding_template = nodes[0] - .node - .splice_channel(&channel_id, &nodes[1].node.get_our_node_id(), feerate, FeeRate::MAX) - .unwrap(); + let funding_template = + nodes[0].node.splice_channel(&channel_id, &nodes[1].node.get_our_node_id()).unwrap(); // Input value = value_added + 1800: above 1736/1740 (fee without change), below 1984/1988 // (fee with change). @@ -188,7 +185,8 @@ fn test_validate_accounts_for_change_output_weight() { utxo_value: value_added + Amount::from_sat(1800), change_value: Amount::from_sat(1000), }; - let contribution = funding_template.splice_in_sync(value_added, &wallet).unwrap(); + let contribution = + funding_template.splice_in_sync(value_added, feerate, FeeRate::MAX, &wallet).unwrap(); assert!(contribution.change_output().is_some()); assert!(contribution.validate().is_err()); @@ -221,13 +219,12 @@ pub fn do_initiate_splice_in<'a, 'b, 'c, 'd>( value_added: Amount, ) -> FundingContribution { let node_id_acceptor = acceptor.node.get_our_node_id(); - let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = initiator - .node - .splice_channel(&channel_id, &node_id_acceptor, feerate, FeeRate::MAX) - .unwrap(); + let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); + let funding_template = initiator.node.splice_channel(&channel_id, &node_id_acceptor).unwrap(); + let feerate = funding_template.min_rbf_feerate().unwrap_or(floor_feerate); let wallet = WalletSync::new(Arc::clone(&initiator.wallet_source), initiator.logger); - let funding_contribution = funding_template.splice_in_sync(value_added, &wallet).unwrap(); + let funding_contribution = + funding_template.splice_in_sync(value_added, feerate, FeeRate::MAX, &wallet).unwrap(); initiator .node .funding_contributed(&channel_id, &node_id_acceptor, funding_contribution.clone(), None) @@ -240,10 +237,10 @@ pub fn do_initiate_rbf_splice_in<'a, 'b, 'c, 'd>( value_added: Amount, feerate: FeeRate, ) -> FundingContribution { let node_id_counterparty = counterparty.node.get_our_node_id(); - let funding_template = - node.node.rbf_channel(&channel_id, &node_id_counterparty, feerate, FeeRate::MAX).unwrap(); + let funding_template = node.node.splice_channel(&channel_id, &node_id_counterparty).unwrap(); let wallet = WalletSync::new(Arc::clone(&node.wallet_source), node.logger); - let funding_contribution = funding_template.splice_in_sync(value_added, &wallet).unwrap(); + let funding_contribution = + funding_template.splice_in_sync(value_added, feerate, FeeRate::MAX, &wallet).unwrap(); node.node .funding_contributed(&channel_id, &node_id_counterparty, funding_contribution.clone(), None) .unwrap(); @@ -255,11 +252,11 @@ pub fn do_initiate_rbf_splice_in_and_out<'a, 'b, 'c, 'd>( value_added: Amount, outputs: Vec, feerate: FeeRate, ) -> FundingContribution { let node_id_counterparty = counterparty.node.get_our_node_id(); - let funding_template = - node.node.rbf_channel(&channel_id, &node_id_counterparty, feerate, FeeRate::MAX).unwrap(); + let funding_template = node.node.splice_channel(&channel_id, &node_id_counterparty).unwrap(); let wallet = WalletSync::new(Arc::clone(&node.wallet_source), node.logger); - let funding_contribution = - funding_template.splice_in_and_out_sync(value_added, outputs, &wallet).unwrap(); + let funding_contribution = funding_template + .splice_in_and_out_sync(value_added, outputs, feerate, FeeRate::MAX, &wallet) + .unwrap(); node.node .funding_contributed(&channel_id, &node_id_counterparty, funding_contribution.clone(), None) .unwrap(); @@ -271,13 +268,12 @@ pub fn initiate_splice_out<'a, 'b, 'c, 'd>( outputs: Vec, ) -> Result { let node_id_acceptor = acceptor.node.get_our_node_id(); - let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = initiator - .node - .splice_channel(&channel_id, &node_id_acceptor, feerate, FeeRate::MAX) - .unwrap(); + let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); + let funding_template = initiator.node.splice_channel(&channel_id, &node_id_acceptor).unwrap(); + let feerate = funding_template.min_rbf_feerate().unwrap_or(floor_feerate); let wallet = WalletSync::new(Arc::clone(&initiator.wallet_source), initiator.logger); - let funding_contribution = funding_template.splice_out_sync(outputs, &wallet).unwrap(); + let funding_contribution = + funding_template.splice_out_sync(outputs, feerate, FeeRate::MAX, &wallet).unwrap(); match initiator.node.funding_contributed( &channel_id, &node_id_acceptor, @@ -304,14 +300,13 @@ pub fn do_initiate_splice_in_and_out<'a, 'b, 'c, 'd>( value_added: Amount, outputs: Vec, ) -> FundingContribution { let node_id_acceptor = acceptor.node.get_our_node_id(); - let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = initiator - .node - .splice_channel(&channel_id, &node_id_acceptor, feerate, FeeRate::MAX) - .unwrap(); + let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); + let funding_template = initiator.node.splice_channel(&channel_id, &node_id_acceptor).unwrap(); + let feerate = funding_template.min_rbf_feerate().unwrap_or(floor_feerate); let wallet = WalletSync::new(Arc::clone(&initiator.wallet_source), initiator.logger); - let funding_contribution = - funding_template.splice_in_and_out_sync(value_added, outputs, &wallet).unwrap(); + let funding_contribution = funding_template + .splice_in_and_out_sync(value_added, outputs, feerate, FeeRate::MAX, &wallet) + .unwrap(); initiator .node .funding_contributed(&channel_id, &node_id_acceptor, funding_contribution.clone(), None) @@ -751,8 +746,17 @@ pub fn lock_splice<'a, 'b, 'c, 'd>( check_added_monitors(node, 1); } + let mut node_a_stfu = None; if !is_0conf { let mut msg_events = node_a.node.get_and_clear_pending_msg_events(); + + // If node_a had a pending QuiescentAction, filter out the stfu message. + node_a_stfu = msg_events + .last() + .filter(|event| matches!(event, MessageSendEvent::SendStfu { .. })) + .is_some() + .then(|| msg_events.pop().unwrap()); + assert_eq!(msg_events.len(), 2, "{msg_events:?}"); if let MessageSendEvent::SendAnnouncementSignatures { msg, .. } = msg_events.remove(0) { node_b.node.handle_announcement_signatures(node_id_a, &msg); @@ -781,7 +785,7 @@ pub fn lock_splice<'a, 'b, 'c, 'd>( } } - node_b_stfu + node_a_stfu.or(node_b_stfu) } pub fn lock_rbf_splice_after_blocks<'a, 'b, 'c, 'd>( @@ -1363,17 +1367,17 @@ fn fails_initiating_concurrent_splices(reconnect: bool) { }]; let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_1_id, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_1_id).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let funding_contribution = funding_template.splice_out_sync(outputs.clone(), &wallet).unwrap(); + let funding_contribution = + funding_template.splice_out_sync(outputs.clone(), feerate, FeeRate::MAX, &wallet).unwrap(); nodes[0] .node .funding_contributed(&channel_id, &node_1_id, funding_contribution.clone(), None) .unwrap(); assert_eq!( - nodes[0].node.splice_channel(&channel_id, &node_1_id, feerate, FeeRate::MAX), + nodes[0].node.splice_channel(&channel_id, &node_1_id), Err(APIError::APIMisuseError { err: format!( "Channel {} cannot be spliced as one is waiting to be negotiated", @@ -1385,7 +1389,7 @@ fn fails_initiating_concurrent_splices(reconnect: bool) { let new_funding_script = complete_splice_handshake(&nodes[0], &nodes[1]); assert_eq!( - nodes[0].node.splice_channel(&channel_id, &node_1_id, feerate, FeeRate::MAX), + nodes[0].node.splice_channel(&channel_id, &node_1_id), Err(APIError::APIMisuseError { err: format!( "Channel {} cannot be spliced as one is currently being negotiated", @@ -1394,18 +1398,6 @@ fn fails_initiating_concurrent_splices(reconnect: bool) { }), ); - // The acceptor can enqueue a quiescent action while the current splice is pending. - let added_value = Amount::from_sat(initial_channel_value_sat); - let acceptor_template = - nodes[1].node.splice_channel(&channel_id, &node_0_id, feerate, FeeRate::MAX).unwrap(); - let acceptor_wallet = WalletSync::new(Arc::clone(&nodes[1].wallet_source), nodes[1].logger); - let acceptor_contribution = - acceptor_template.splice_in_sync(added_value, &acceptor_wallet).unwrap(); - nodes[1] - .node - .funding_contributed(&channel_id, &node_0_id, acceptor_contribution, None) - .unwrap(); - complete_interactive_funding_negotiation( &nodes[0], &nodes[1], @@ -1415,7 +1407,7 @@ fn fails_initiating_concurrent_splices(reconnect: bool) { ); assert_eq!( - nodes[0].node.splice_channel(&channel_id, &node_1_id, feerate, FeeRate::MAX), + nodes[0].node.splice_channel(&channel_id, &node_1_id), Err(APIError::APIMisuseError { err: format!( "Channel {} cannot be spliced as one is currently being negotiated", @@ -1430,9 +1422,8 @@ fn fails_initiating_concurrent_splices(reconnect: bool) { expect_splice_pending_event(&nodes[0], &node_1_id); expect_splice_pending_event(&nodes[1], &node_0_id); - // Now that the splice is pending, another splice may be initiated, but we must wait until - // the `splice_locked` exchange to send the initiator `stfu`. - assert!(nodes[0].node.splice_channel(&channel_id, &node_1_id, feerate, FeeRate::MAX).is_ok()); + // Now that the splice is pending, another splice may be initiated. + assert!(nodes[0].node.splice_channel(&channel_id, &node_1_id).is_ok()); if reconnect { nodes[0].node.peer_disconnected(node_1_id); @@ -1446,54 +1437,35 @@ fn fails_initiating_concurrent_splices(reconnect: bool) { mine_transaction(&nodes[0], &splice_tx); mine_transaction(&nodes[1], &splice_tx); let stfu = lock_splice_after_blocks(&nodes[0], &nodes[1], ANTI_REORG_DELAY - 1); - - assert!( - matches!(stfu, Some(MessageSendEvent::SendStfu { node_id, .. }) if node_id == node_0_id) - ); + // Node 0 had called splice_channel (line above) but never funding_contributed, so no stfu + // is expected from node 0 at this point. + assert!(stfu.is_none()); } #[test] fn test_initiating_splice_holds_stfu_with_pending_splice() { - // Test that we don't send stfu too early for a new splice while we're already pending one. + // Test that a splice can be completed and locked successfully. let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let config = test_default_channel_config(); - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(config)]); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let node_0_id = nodes[0].node.get_our_node_id(); provide_utxo_reserves(&nodes, 2, Amount::ONE_BTC); 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); - // Have both nodes attempt a splice, but only node 0 will call back and negotiate the splice. + // Node 0 initiates a splice, completing the full flow. let value_added = Amount::from_sat(10_000); let funding_contribution_0 = initiate_splice_in(&nodes[0], &nodes[1], channel_id, value_added); - - let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = - nodes[1].node.splice_channel(&channel_id, &node_0_id, feerate, FeeRate::MAX).unwrap(); - let (splice_tx, _) = splice_channel(&nodes[0], &nodes[1], channel_id, funding_contribution_0); - // With the splice negotiated, have node 1 call back. This will queue the quiescent action, but - // it shouldn't send stfu yet as there's a pending splice. - let wallet = WalletSync::new(Arc::clone(&nodes[1].wallet_source), &nodes[1].logger); - let funding_contribution = funding_template.splice_in_sync(value_added, &wallet).unwrap(); - nodes[1] - .node - .funding_contributed(&channel_id, &node_0_id, funding_contribution.clone(), None) - .unwrap(); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - + // Mine and lock the splice. mine_transaction(&nodes[0], &splice_tx); mine_transaction(&nodes[1], &splice_tx); let stfu = lock_splice_after_blocks(&nodes[0], &nodes[1], 5); - assert!( - matches!(stfu, Some(MessageSendEvent::SendStfu { node_id, .. }) if node_id == node_0_id) - ); + assert!(stfu.is_none()); } #[test] @@ -1569,26 +1541,22 @@ fn do_test_splice_tiebreak( provide_utxo_reserves(&nodes, 2, Amount::from_sat(100_000)); // Node 0 calls splice_channel + splice_in_sync + funding_contributed. - let funding_template_0 = nodes[0] - .node - .splice_channel(&channel_id, &node_id_1, node_0_feerate, FeeRate::MAX) - .unwrap(); + let funding_template_0 = nodes[0].node.splice_channel(&channel_id, &node_id_1).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(added_value, &wallet_0).unwrap(); + let node_0_funding_contribution = funding_template_0 + .splice_in_sync(added_value, node_0_feerate, FeeRate::MAX, &wallet_0) + .unwrap(); nodes[0] .node .funding_contributed(&channel_id, &node_id_1, node_0_funding_contribution.clone(), None) .unwrap(); // Node 1 calls splice_channel + splice_in_sync + funding_contributed. - let funding_template_1 = nodes[1] - .node - .splice_channel(&channel_id, &node_id_0, node_1_feerate, FeeRate::MAX) - .unwrap(); + let funding_template_1 = nodes[1].node.splice_channel(&channel_id, &node_id_0).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_splice_value, &wallet_1).unwrap(); + let node_1_funding_contribution = funding_template_1 + .splice_in_sync(node_1_splice_value, node_1_feerate, FeeRate::MAX, &wallet_1) + .unwrap(); nodes[1] .node .funding_contributed(&channel_id, &node_id_0, node_1_funding_contribution.clone(), None) @@ -1812,24 +1780,22 @@ fn test_splice_tiebreak_feerate_too_high_rejected() { 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 funding_template_0 = nodes[0].node.splice_channel(&channel_id, &node_id_1).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(); + let node_0_funding_contribution = funding_template_0 + .splice_in_sync(node_0_added_value, high_feerate, FeeRate::MAX, &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 funding_template_1 = nodes[1].node.splice_channel(&channel_id, &node_id_0).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(); + let node_1_funding_contribution = funding_template_1 + .splice_in_sync(node_1_added_value, floor_feerate, node_1_max_feerate, &wallet_1) + .unwrap(); nodes[1] .node .funding_contributed(&channel_id, &node_id_0, node_1_funding_contribution.clone(), None) @@ -3530,10 +3496,10 @@ fn test_funding_contributed_counterparty_not_found() { provide_utxo_reserves(&nodes, 1, splice_in_amount * 2); let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let funding_contribution = funding_template.splice_in_sync(splice_in_amount, &wallet).unwrap(); + let funding_contribution = + funding_template.splice_in_sync(splice_in_amount, feerate, FeeRate::MAX, &wallet).unwrap(); // Use a fake/unknown public key as counterparty let fake_node_id = @@ -3570,10 +3536,10 @@ fn test_funding_contributed_channel_not_found() { provide_utxo_reserves(&nodes, 1, splice_in_amount * 2); let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let funding_contribution = funding_template.splice_in_sync(splice_in_amount, &wallet).unwrap(); + let funding_contribution = + funding_template.splice_in_sync(splice_in_amount, feerate, FeeRate::MAX, &wallet).unwrap(); // Use a random/unknown channel_id let fake_channel_id = ChannelId::from_bytes([42; 32]); @@ -3615,11 +3581,16 @@ fn test_funding_contributed_splice_already_pending() { script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::from_raw_hash(Hash::all_zeros())), }; let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); let first_contribution = funding_template - .splice_in_and_out_sync(splice_in_amount, vec![first_splice_out.clone()], &wallet) + .splice_in_and_out_sync( + splice_in_amount, + vec![first_splice_out.clone()], + feerate, + FeeRate::MAX, + &wallet, + ) .unwrap(); // Initiate a second splice with a DIFFERENT output to test that different outputs @@ -3638,11 +3609,16 @@ fn test_funding_contributed_splice_already_pending() { nodes[0].wallet_source.clear_utxos(); provide_utxo_reserves(&nodes, 1, splice_in_amount * 3); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); let second_contribution = funding_template - .splice_in_and_out_sync(splice_in_amount, vec![second_splice_out.clone()], &wallet) + .splice_in_and_out_sync( + splice_in_amount, + vec![second_splice_out.clone()], + feerate, + FeeRate::MAX, + &wallet, + ) .unwrap(); // First funding_contributed - this sets up the quiescent action @@ -3708,10 +3684,10 @@ fn test_funding_contributed_duplicate_contribution_no_event() { provide_utxo_reserves(&nodes, 1, splice_in_amount * 2); let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let contribution = funding_template.splice_in_sync(splice_in_amount, &wallet).unwrap(); + let contribution = + funding_template.splice_in_sync(splice_in_amount, feerate, FeeRate::MAX, &wallet).unwrap(); // First funding_contributed - this sets up the quiescent action nodes[0].node.funding_contributed(&channel_id, &node_id_1, contribution.clone(), None).unwrap(); @@ -3767,19 +3743,19 @@ fn do_test_funding_contributed_active_funding_negotiation(state: u8) { // Build first contribution let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let first_contribution = funding_template.splice_in_sync(splice_in_amount, &wallet).unwrap(); + let first_contribution = + funding_template.splice_in_sync(splice_in_amount, feerate, FeeRate::MAX, &wallet).unwrap(); // Build second contribution with different UTXOs so inputs/outputs don't overlap nodes[0].wallet_source.clear_utxos(); provide_utxo_reserves(&nodes, 1, splice_in_amount * 3); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let second_contribution = funding_template.splice_in_sync(splice_in_amount, &wallet).unwrap(); + let second_contribution = + funding_template.splice_in_sync(splice_in_amount, feerate, FeeRate::MAX, &wallet).unwrap(); // First funding_contributed - sets up the quiescent action and queues STFU nodes[0] @@ -3897,10 +3873,10 @@ fn test_funding_contributed_channel_shutdown() { provide_utxo_reserves(&nodes, 1, splice_in_amount * 2); let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let funding_contribution = funding_template.splice_in_sync(splice_in_amount, &wallet).unwrap(); + let funding_contribution = + funding_template.splice_in_sync(splice_in_amount, feerate, FeeRate::MAX, &wallet).unwrap(); // Initiate channel shutdown - this makes is_usable() return false nodes[0].node.close_channel(&channel_id, &node_id_1).unwrap(); @@ -3951,12 +3927,10 @@ fn test_funding_contributed_unfunded_channel() { provide_utxo_reserves(&nodes, 1, splice_in_amount * 2); let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template = nodes[0] - .node - .splice_channel(&funded_channel_id, &node_id_1, feerate, FeeRate::MAX) - .unwrap(); + let funding_template = nodes[0].node.splice_channel(&funded_channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let funding_contribution = funding_template.splice_in_sync(splice_in_amount, &wallet).unwrap(); + let funding_contribution = + funding_template.splice_in_sync(splice_in_amount, feerate, FeeRate::MAX, &wallet).unwrap(); // Call funding_contributed with the unfunded channel's ID instead of the funded one. // Returns APIMisuseError because the channel is not funded. @@ -4321,7 +4295,7 @@ fn test_splice_acceptor_disconnect_emits_events() { #[test] fn test_splice_rbf_acceptor_basic() { // Test the full end-to-end flow for RBF of a pending splice transaction. - // Complete a splice-in, then use rbf_channel API to initiate an RBF attempt + // Complete a splice-in, then use splice_channel API to initiate an RBF attempt // with a higher feerate, going through the full tx_init_rbf → tx_ack_rbf → // interactive TX → signing → mining → splice_locked flow. let chanmon_cfgs = create_chanmon_cfgs(2); @@ -4348,7 +4322,7 @@ fn test_splice_rbf_acceptor_basic() { // Step 2: Provide more UTXO reserves for the RBF attempt. provide_utxo_reserves(&nodes, 2, added_value * 2); - // Step 3: Use rbf_channel API to initiate the RBF. + // Step 3: Use splice_channel API to initiate the RBF. // Original feerate was FEERATE_FLOOR_SATS_PER_KW (253). 253 * 25 / 24 = 263.54, so 264 works. let rbf_feerate_sat_per_kwu = (FEERATE_FLOOR_SATS_PER_KW as u64 * 25).div_ceil(24); let rbf_feerate = FeeRate::from_sat_per_kwu(rbf_feerate_sat_per_kwu); @@ -4386,7 +4360,7 @@ fn test_splice_rbf_acceptor_basic() { #[test] fn test_splice_rbf_insufficient_feerate() { - // Test that rbf_channel rejects a feerate that doesn't satisfy the 25/24 rule, and that the + // Test that splice_in_sync rejects a feerate that doesn't satisfy the 25/24 rule, and that the // acceptor also rejects tx_init_rbf with an insufficient feerate from a misbehaving peer. let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); @@ -4408,20 +4382,27 @@ fn test_splice_rbf_insufficient_feerate() { let (_splice_tx, _new_funding_script) = splice_channel(&nodes[0], &nodes[1], channel_id, funding_contribution); - // Initiator-side: rbf_channel rejects an insufficient feerate. + // Initiator-side: splice_in_sync rejects an insufficient feerate. // Original feerate was 253. Using exactly 253 should fail since 253 * 24 < 253 * 25. let same_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let err = - nodes[0].node.rbf_channel(&channel_id, &node_id_1, same_feerate, FeeRate::MAX).unwrap_err(); - assert_eq!( - err, - APIError::APIMisuseError { - err: format!( - "Channel {} RBF feerate {} is less than 25/24 of the previous feerate {}", - channel_id, FEERATE_FLOOR_SATS_PER_KW, FEERATE_FLOOR_SATS_PER_KW, - ), - } - ); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + + // Verify that the template exposes the RBF floor. + let min_rbf_feerate = funding_template.min_rbf_feerate().unwrap(); + let expected_floor = + FeeRate::from_sat_per_kwu(((FEERATE_FLOOR_SATS_PER_KW as u64) * 25).div_ceil(24)); + assert_eq!(min_rbf_feerate, expected_floor); + + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + assert!(funding_template + .splice_in_sync(added_value, same_feerate, FeeRate::MAX, &wallet) + .is_err()); + + // Verify that the floor feerate succeeds. + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + assert!(funding_template + .splice_in_sync(added_value, min_rbf_feerate, FeeRate::MAX, &wallet) + .is_ok()); // Acceptor-side: tx_init_rbf with an insufficient feerate is also rejected. reenter_quiescence(&nodes[0], &nodes[1], &channel_id); @@ -4760,7 +4741,7 @@ fn test_splice_rbf_tiebreak_feerate_too_high() { /// Runs the tie-breaker test with the given per-node feerates and node 1's splice value. /// -/// Both nodes call `rbf_channel` + `funding_contributed`, both send STFU, and node 0 (the outbound +/// Both nodes call `splice_channel` + `funding_contributed`, both send STFU, and node 0 (the outbound /// channel funder) wins the quiescence tie-break. The loser (node 1) becomes the acceptor. Whether /// node 1 contributes to the RBF transaction depends on the feerate and budget constraints. /// @@ -4792,11 +4773,11 @@ pub fn do_test_splice_rbf_tiebreak( // Provide more UTXOs for both nodes' RBF attempts. provide_utxo_reserves(&nodes, 2, added_value * 2); - // Node 0 calls rbf_channel + funding_contributed. + // Node 0 calls splice_channel + funding_contributed. let node_0_funding_contribution = do_initiate_rbf_splice_in(&nodes[0], &nodes[1], channel_id, added_value, rbf_feerate_0); - // Node 1 calls rbf_channel + funding_contributed. + // Node 1 calls splice_channel + funding_contributed. let node_1_funding_contribution = do_initiate_rbf_splice_in( &nodes[1], &nodes[0], @@ -5054,23 +5035,21 @@ fn test_splice_rbf_tiebreak_feerate_too_high_rejected() { let min_rbf_feerate = FeeRate::from_sat_per_kwu(min_rbf_feerate_sat_per_kwu); let node_1_max_feerate = FeeRate::from_sat_per_kwu(3_000); - let funding_template_0 = - nodes[0].node.rbf_channel(&channel_id, &node_id_1, high_feerate, FeeRate::MAX).unwrap(); + let funding_template_0 = nodes[0].node.splice_channel(&channel_id, &node_id_1).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(added_value, &wallet_0).unwrap(); + let node_0_funding_contribution = funding_template_0 + .splice_in_sync(added_value, high_feerate, FeeRate::MAX, &wallet_0) + .unwrap(); nodes[0] .node .funding_contributed(&channel_id, &node_id_1, node_0_funding_contribution.clone(), None) .unwrap(); - let funding_template_1 = nodes[1] - .node - .rbf_channel(&channel_id, &node_id_0, min_rbf_feerate, node_1_max_feerate) - .unwrap(); + let funding_template_1 = nodes[1].node.splice_channel(&channel_id, &node_id_0).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(added_value, &wallet_1).unwrap(); + let node_1_funding_contribution = funding_template_1 + .splice_in_sync(added_value, min_rbf_feerate, node_1_max_feerate, &wallet_1) + .unwrap(); nodes[1] .node .funding_contributed(&channel_id, &node_id_0, node_1_funding_contribution.clone(), None) @@ -5121,21 +5100,19 @@ fn test_splice_rbf_acceptor_recontributes() { // Step 1: Both nodes initiate a splice at floor feerate. let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template_0 = - nodes[0].node.splice_channel(&channel_id, &node_id_1, feerate, FeeRate::MAX).unwrap(); + let funding_template_0 = nodes[0].node.splice_channel(&channel_id, &node_id_1).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(added_value, &wallet_0).unwrap(); + funding_template_0.splice_in_sync(added_value, feerate, FeeRate::MAX, &wallet_0).unwrap(); nodes[0] .node .funding_contributed(&channel_id, &node_id_1, node_0_funding_contribution.clone(), None) .unwrap(); - let funding_template_1 = - nodes[1].node.splice_channel(&channel_id, &node_id_0, feerate, FeeRate::MAX).unwrap(); + let funding_template_1 = nodes[1].node.splice_channel(&channel_id, &node_id_0).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(added_value, &wallet_1).unwrap(); + funding_template_1.splice_in_sync(added_value, feerate, FeeRate::MAX, &wallet_1).unwrap(); nodes[1] .node .funding_contributed(&channel_id, &node_id_0, node_1_funding_contribution.clone(), None) @@ -5183,7 +5160,7 @@ fn test_splice_rbf_acceptor_recontributes() { // Step 4: Provide new UTXOs for node 0's RBF (node 1 does NOT initiate RBF). provide_utxo_reserves(&nodes, 2, added_value * 2); - // Step 5: Only node 0 calls rbf_channel + funding_contributed. + // Step 5: Only node 0 calls splice_channel + funding_contributed. let rbf_feerate_sat_per_kwu = (FEERATE_FLOOR_SATS_PER_KW as u64 * 25).div_ceil(24); let rbf_feerate = FeeRate::from_sat_per_kwu(rbf_feerate_sat_per_kwu); let rbf_funding_contribution = @@ -5249,22 +5226,22 @@ fn test_splice_rbf_recontributes_feerate_too_high() { // from a 100k UTXO (tight budget: ~5k for change/fees). let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); - let funding_template_0 = - nodes[0].node.splice_channel(&channel_id, &node_id_1, floor_feerate, FeeRate::MAX).unwrap(); + let funding_template_0 = nodes[0].node.splice_channel(&channel_id, &node_id_1).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(Amount::from_sat(50_000), &wallet_0).unwrap(); + let node_0_funding_contribution = funding_template_0 + .splice_in_sync(Amount::from_sat(50_000), floor_feerate, FeeRate::MAX, &wallet_0) + .unwrap(); nodes[0] .node .funding_contributed(&channel_id, &node_id_1, node_0_funding_contribution.clone(), None) .unwrap(); let node_1_added_value = Amount::from_sat(95_000); - let funding_template_1 = - nodes[1].node.splice_channel(&channel_id, &node_id_0, floor_feerate, FeeRate::MAX).unwrap(); + let funding_template_1 = nodes[1].node.splice_channel(&channel_id, &node_id_0).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(); + let node_1_funding_contribution = funding_template_1 + .splice_in_sync(node_1_added_value, floor_feerate, FeeRate::MAX, &wallet_1) + .unwrap(); nodes[1] .node .funding_contributed(&channel_id, &node_id_0, node_1_funding_contribution.clone(), None) @@ -5312,11 +5289,11 @@ fn test_splice_rbf_recontributes_feerate_too_high() { provide_utxo_reserves(&nodes, 2, Amount::from_sat(100_000)); let high_feerate = FeeRate::from_sat_per_kwu(20_000); - let funding_template = - nodes[0].node.rbf_channel(&channel_id, &node_id_1, high_feerate, FeeRate::MAX).unwrap(); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); - let rbf_funding_contribution = - funding_template.splice_in_sync(Amount::from_sat(50_000), &wallet).unwrap(); + let rbf_funding_contribution = funding_template + .splice_in_sync(Amount::from_sat(50_000), high_feerate, FeeRate::MAX, &wallet) + .unwrap(); nodes[0] .node .funding_contributed(&channel_id, &node_id_1, rbf_funding_contribution.clone(), None) @@ -5651,3 +5628,388 @@ fn test_splice_rbf_disconnect_filters_prior_contributions() { reconnect_args.send_announcement_sigs = (true, true); reconnect_nodes(reconnect_args); } + +#[test] +fn test_splice_channel_with_pending_splice_includes_rbf_floor() { + // Test that splice_channel includes the RBF floor when a pending splice exists with + // negotiated candidates. + 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_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); + + // Fresh splice — no pending splice, so no prior contribution or minimum RBF feerate. + { + let template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + assert!(template.min_rbf_feerate().is_none()); + assert!(template.prior_contribution().is_none()); + } + + // Complete a splice-in at floor feerate. + let funding_contribution = do_initiate_splice_in(&nodes[0], &nodes[1], channel_id, added_value); + let (_splice_tx, _) = splice_channel(&nodes[0], &nodes[1], channel_id, funding_contribution); + + // Call splice_channel again — the pending splice should cause min_rbf_feerate to be set + // and the prior contribution to be available. + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + let expected_floor = + FeeRate::from_sat_per_kwu(((FEERATE_FLOOR_SATS_PER_KW as u64) * 25).div_ceil(24)); + assert_eq!(funding_template.min_rbf_feerate(), Some(expected_floor)); + assert!(funding_template.prior_contribution().is_some()); + + // rbf_sync returns the Adjusted prior contribution directly. + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + assert!(funding_template.rbf_sync(FeeRate::MAX, &wallet).is_ok()); +} + +#[test] +fn test_funding_contributed_adjusts_feerate_for_rbf() { + // Test that funding_contributed adjusts the contribution's feerate to the minimum RBF feerate + // when a pending splice appears between splice_channel and funding_contributed. + // + // Node 0 calls splice_channel (no pending splice → min_rbf_feerate = None) and builds a + // contribution at floor feerate. Node 1 then initiates and completes a splice. When node 0 + // calls funding_contributed, the contribution is adjusted to the minimum RBF feerate and STFU + // is sent immediately. + 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, 4, added_value * 2); + + // Node 0 calls splice_channel before any pending splice exists. + let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + assert!(funding_template.min_rbf_feerate().is_none()); + + // Build contribution at floor feerate with high max_feerate to allow adjustment. + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + let contribution = + funding_template.splice_in_sync(added_value, floor_feerate, FeeRate::MAX, &wallet).unwrap(); + + // Node 1 initiates and completes a splice, creating pending_splice with negotiated candidates. + let node_1_contribution = do_initiate_splice_in(&nodes[1], &nodes[0], channel_id, added_value); + let (first_splice_tx, new_funding_script) = + splice_channel(&nodes[1], &nodes[0], channel_id, node_1_contribution); + + // Node 0 calls funding_contributed. The contribution's feerate (floor) is below the RBF + // floor (25/24 of floor), but funding_contributed adjusts it upward. + nodes[0].node.funding_contributed(&channel_id, &node_id_1, contribution.clone(), None).unwrap(); + + // STFU should be sent immediately (the adjusted feerate satisfies the RBF check). + let stfu = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, node_id_1); + nodes[1].node.handle_stfu(node_id_0, &stfu); + let stfu_resp = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0); + nodes[0].node.handle_stfu(node_id_1, &stfu_resp); + + // Verify the RBF handshake proceeds. + let tx_init_rbf = get_event_msg!(nodes[0], MessageSendEvent::SendTxInitRbf, node_id_1); + let rbf_feerate = FeeRate::from_sat_per_kwu(tx_init_rbf.feerate_sat_per_1000_weight as u64); + let expected_floor = + FeeRate::from_sat_per_kwu((FEERATE_FLOOR_SATS_PER_KW as u64 * 25).div_ceil(24)); + assert!(rbf_feerate >= expected_floor); +} + +#[test] +fn test_funding_contributed_rbf_adjustment_exceeds_max_feerate() { + // Test that when the minimum RBF feerate exceeds max_feerate, the adjustment in + // funding_contributed fails gracefully and the contribution keeps its original feerate. The + // splice still proceeds (STFU is sent) and the RBF negotiation handles the feerate mismatch. + 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, 4, added_value * 2); + + // Node 0 calls splice_channel and builds contribution with max_feerate = floor_feerate. + // This means the minimum RBF feerate (25/24 of floor) will exceed max_feerate, preventing adjustment. + let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + let contribution = funding_template + .splice_in_sync(added_value, floor_feerate, floor_feerate, &wallet) + .unwrap(); + + // Node 1 initiates and completes a splice. + let node_1_contribution = do_initiate_splice_in(&nodes[1], &nodes[0], channel_id, added_value); + let (_splice_tx, _) = splice_channel(&nodes[1], &nodes[0], channel_id, node_1_contribution); + + // Node 0 calls funding_contributed. The adjustment fails (minimum RBF feerate > max_feerate), + // but funding_contributed still succeeds — the contribution keeps its original feerate. + nodes[0].node.funding_contributed(&channel_id, &node_id_1, contribution, None).unwrap(); + + // STFU is NOT sent — the feerate is below the minimum RBF feerate so try_send_stfu delays. + assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + + // Mine and lock the pending splice → pending_splice is cleared. + mine_transaction(&nodes[0], &_splice_tx); + mine_transaction(&nodes[1], &_splice_tx); + let stfu = lock_splice_after_blocks(&nodes[0], &nodes[1], ANTI_REORG_DELAY - 1); + + // STFU is sent during lock — the splice proceeds as a fresh splice (not RBF). + let stfu = match stfu { + Some(MessageSendEvent::SendStfu { msg, .. }) => { + assert!(msg.initiator); + msg + }, + other => panic!("Expected SendStfu, got {:?}", other), + }; + + // Complete the fresh splice and verify it uses the original floor feerate. + nodes[1].node.handle_stfu(node_id_0, &stfu); + let stfu_resp = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0); + nodes[0].node.handle_stfu(node_id_1, &stfu_resp); + + let splice_init = get_event_msg!(nodes[0], MessageSendEvent::SendSpliceInit, node_id_1); + assert_eq!(splice_init.funding_feerate_per_kw, FEERATE_FLOOR_SATS_PER_KW); +} + +#[test] +fn test_funding_contributed_rbf_adjustment_insufficient_budget() { + // Test that when the change output can't absorb the fee increase needed for the minimum RBF feerate + // (even though max_feerate allows it), the adjustment fails gracefully and the splice + // proceeds with the original feerate. + 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, 4, added_value * 2); + + // Node 0 calls splice_channel before any pending splice exists. + let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + + // Build node 0's contribution at floor feerate with a tight budget. + let wallet = TightBudgetWallet { + utxo_value: added_value + Amount::from_sat(3000), + change_value: Amount::from_sat(300), + }; + let contribution = + 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 + // 25/24 of 10,000 = 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); + let node_1_contribution = node_1_template + .splice_in_sync(added_value, high_feerate, FeeRate::MAX, &node_1_wallet) + .unwrap(); + nodes[1] + .node + .funding_contributed(&channel_id, &node_id_0, node_1_contribution.clone(), None) + .unwrap(); + let (_splice_tx, _) = splice_channel(&nodes[1], &nodes[0], channel_id, node_1_contribution); + + // Node 0 calls funding_contributed. Adjustment fails (insufficient fee buffer), so the + // contribution keeps its original feerate. + nodes[0].node.funding_contributed(&channel_id, &node_id_1, contribution, None).unwrap(); + + // STFU is NOT sent — the feerate is below the minimum RBF feerate so try_send_stfu delays. + assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + + // Mine and lock the pending splice → pending_splice is cleared. + mine_transaction(&nodes[0], &_splice_tx); + mine_transaction(&nodes[1], &_splice_tx); + let stfu = lock_splice_after_blocks(&nodes[0], &nodes[1], ANTI_REORG_DELAY - 1); + + // STFU is sent during lock — the splice proceeds as a fresh splice (not RBF). + let stfu = match stfu { + Some(MessageSendEvent::SendStfu { msg, .. }) => { + assert!(msg.initiator); + msg + }, + other => panic!("Expected SendStfu, got {:?}", other), + }; + + // Complete the fresh splice and verify it uses the original floor feerate. + nodes[1].node.handle_stfu(node_id_0, &stfu); + let stfu_resp = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0); + nodes[0].node.handle_stfu(node_id_1, &stfu_resp); + + let splice_init = get_event_msg!(nodes[0], MessageSendEvent::SendSpliceInit, node_id_1); + assert_eq!(splice_init.funding_feerate_per_kw, FEERATE_FLOOR_SATS_PER_KW); +} + +#[test] +fn test_prior_contribution_unadjusted_when_max_feerate_too_low() { + // Test that rbf_sync re-runs coin selection when the prior contribution's max_feerate is + // too low to accommodate the minimum RBF feerate. + 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_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); + + // Complete a splice with max_feerate = floor_feerate. This means the prior contribution + // stored in pending_splice.contributions will have a tight max_feerate. + let floor_feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64); + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + let funding_contribution = funding_template + .splice_in_sync(added_value, floor_feerate, floor_feerate, &wallet) + .unwrap(); + nodes[0] + .node + .funding_contributed(&channel_id, &node_id_1, funding_contribution.clone(), None) + .unwrap(); + let (_splice_tx, _) = splice_channel(&nodes[0], &nodes[1], channel_id, funding_contribution); + + // Call splice_channel again — the minimum RBF feerate (25/24 of floor) exceeds the prior + // contribution's max_feerate (floor), so adjustment fails. rbf_sync re-runs coin selection + // with the caller's max_feerate. + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + assert!(funding_template.min_rbf_feerate().is_some()); + assert!(funding_template.prior_contribution().is_some()); + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + assert!(funding_template.rbf_sync(FeeRate::MAX, &wallet).is_ok()); +} + +#[test] +fn test_splice_channel_during_negotiation_includes_rbf_feerate() { + // Test that splice_channel returns min_rbf_feerate derived from the in-progress + // negotiation's feerate when the acceptor calls it during active negotiation. + 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); + + // Node 1 initiates a splice. Perform stfu exchange and splice_init handling, which creates + // a pending_splice with funding_negotiation on node 0 (the acceptor). + let funding_contribution = do_initiate_splice_in(&nodes[1], &nodes[0], channel_id, added_value); + let stfu_init = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0); + nodes[0].node.handle_stfu(node_id_1, &stfu_init); + let stfu_ack = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, node_id_1); + nodes[1].node.handle_stfu(node_id_0, &stfu_ack); + + let splice_init = get_event_msg!(nodes[1], MessageSendEvent::SendSpliceInit, node_id_0); + nodes[0].node.handle_splice_init(node_id_1, &splice_init); + let _splice_ack = get_event_msg!(nodes[0], MessageSendEvent::SendSpliceAck, node_id_1); + + // Node 0 (acceptor) calls splice_channel while the negotiation is in progress. + // min_rbf_feerate should be derived from the in-progress negotiation's feerate. + let template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + let expected_floor = + FeeRate::from_sat_per_kwu(((FEERATE_FLOOR_SATS_PER_KW as u64) * 25).div_ceil(24)); + assert_eq!(template.min_rbf_feerate(), Some(expected_floor)); + + // No prior contribution since there are no negotiated candidates yet. rbf_sync runs + // fee-bump-only coin selection. + assert!(template.prior_contribution().is_none()); + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + assert!(template.rbf_sync(FeeRate::MAX, &wallet).is_ok()); +} + +#[test] +fn test_rbf_sync_returns_err_when_no_min_rbf_feerate() { + // Test that rbf_sync returns Err(()) when there is no pending splice (min_rbf_feerate is + // None), indicating this is not an RBF scenario. + 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_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); + + // Fresh splice — no pending splice, so min_rbf_feerate is None. + let template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + assert!(template.min_rbf_feerate().is_none()); + assert!(template.prior_contribution().is_none()); + + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + assert!(template.rbf_sync(FeeRate::MAX, &wallet).is_err()); +} + +#[test] +fn test_rbf_sync_returns_err_when_max_feerate_below_min_rbf() { + // Test that rbf_sync returns Err(()) when the caller's max_feerate is below the minimum + // RBF feerate. + 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_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); + + // Complete a splice to create a pending splice. + let funding_contribution = do_initiate_splice_in(&nodes[0], &nodes[1], channel_id, added_value); + let (_splice_tx, _) = splice_channel(&nodes[0], &nodes[1], channel_id, funding_contribution); + + // Call splice_channel again to get the RBF template. + let funding_template = nodes[0].node.splice_channel(&channel_id, &node_id_1).unwrap(); + let min_rbf_feerate = funding_template.min_rbf_feerate().unwrap(); + + // Use a max_feerate that is 1 sat/kwu below the minimum RBF feerate. + let too_low_feerate = + FeeRate::from_sat_per_kwu(min_rbf_feerate.to_sat_per_kwu().saturating_sub(1)); + let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger); + assert!(funding_template.rbf_sync(too_low_feerate, &wallet).is_err()); +} diff --git a/lightning/src/util/wallet_utils.rs b/lightning/src/util/wallet_utils.rs index b82437c03e8..61228402959 100644 --- a/lightning/src/util/wallet_utils.rs +++ b/lightning/src/util/wallet_utils.rs @@ -148,7 +148,7 @@ impl Utxo { /// /// Can be used as an input to contribute to a channel's funding transaction either when using the /// v2 channel establishment protocol or when splicing. -#[derive(Debug, Clone)] +#[derive(Debug, Clone, PartialEq, Eq)] pub struct ConfirmedUtxo { /// The unspent [`TxOut`] found in [`prevtx`]. ///