Split splice initiation into two phases

Previously, splice_channel required callers to manually construct
funding inputs and pass them directly, making coin selection the
caller's responsibility. This made the API difficult to use and
prevented reuse of the existing CoinSelectionSource trait.

Introduce a two-phase API: splice_channel now returns a FundingTemplate
that callers use to build a FundingContribution via wallet-backed
splice methods (e.g., splice_in_sync, splice_out_sync), which handle
coin selection automatically. The completed contribution is then passed
to a new funding_contributed method to begin quiescence and negotiation.

This also renames SpliceContribution to FundingContribution and moves
fee estimation and input validation into the funding module, co-located
with the types they operate on.

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

Author: jkczyz

.claude/settings.local.json

@@ -22,6 +22,7 @@ use bitcoin::opcodes;
 use bitcoin::script::{Builder, ScriptBuf};
 use bitcoin::transaction::Version;
 use bitcoin::transaction::{Transaction, TxIn, TxOut};
+use bitcoin::FeeRate;
 
 use bitcoin::hash_types::{BlockHash, Txid};
 use bitcoin::hashes::sha256::Hash as Sha256;
@@ -30,8 +31,6 @@ use bitcoin::hashes::Hash as _;
 use bitcoin::hex::FromHex;
 use bitcoin::WPubkeyHash;
 
-use lightning::ln::funding::{FundingTxInput, SpliceContribution};
-
 use lightning::blinded_path::message::{BlindedMessagePath, MessageContext, MessageForwardNode};
 use lightning::blinded_path::payment::{BlindedPaymentPath, ReceiveTlvs};
 use lightning::chain;
@@ -41,7 +40,7 @@ use lightning::chain::chaininterface::{
 use lightning::chain::chainmonitor;
 use lightning::chain::transaction::OutPoint;
 use lightning::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen};
-use lightning::events::bump_transaction::sync::WalletSourceSync;
+use lightning::events::bump_transaction::sync::{WalletSourceSync, WalletSync};
 use lightning::events::Event;
 use lightning::ln::channel_state::ChannelDetails;
 use lightning::ln::channelmanager::{ChainParameters, ChannelManager, InterceptId, PaymentId};
@@ -65,6 +64,7 @@ use lightning::sign::{
 	SignerProvider,
 };
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
+use lightning::util::async_poll::{MaybeSend, MaybeSync};
 use lightning::util::config::{ChannelConfig, UserConfig};
 use lightning::util::hash_tables::*;
 use lightning::util::logger::Logger;
@@ -227,7 +227,7 @@ type ChannelMan<'a> = ChannelManager<
 			Arc<dyn chain::Filter>,
 			Arc<TestBroadcaster>,
 			Arc<FuzzEstimator>,
-			Arc<dyn Logger>,
+			Arc<dyn Logger + MaybeSend + MaybeSync>,
 			Arc<TestPersister>,
 			Arc<KeyProvider>,
 		>,
@@ -239,14 +239,20 @@ type ChannelMan<'a> = ChannelManager<
 	Arc<FuzzEstimator>,
 	&'a FuzzRouter,
 	&'a FuzzRouter,
-	Arc<dyn Logger>,
+	Arc<dyn Logger + MaybeSend + MaybeSync>,
 >;
 type PeerMan<'a> = PeerManager<
 	Peer<'a>,
 	Arc<ChannelMan<'a>>,
-	Arc<P2PGossipSync<Arc<NetworkGraph<Arc<dyn Logger>>>, Arc<dyn UtxoLookup>, Arc<dyn Logger>>>,
+	Arc<
+		P2PGossipSync<
+			Arc<NetworkGraph<Arc<dyn Logger + MaybeSend + MaybeSync>>>,
+			Arc<dyn UtxoLookup>,
+			Arc<dyn Logger + MaybeSend + MaybeSync>,
+		>,
+	>,
 	IgnoringMessageHandler,
-	Arc<dyn Logger>,
+	Arc<dyn Logger + MaybeSend + MaybeSync>,
 	IgnoringMessageHandler,
 	Arc<KeyProvider>,
 	IgnoringMessageHandler,
@@ -260,7 +266,7 @@ struct MoneyLossDetector<'a> {
 			Arc<dyn chain::Filter>,
 			Arc<TestBroadcaster>,
 			Arc<FuzzEstimator>,
-			Arc<dyn Logger>,
+			Arc<dyn Logger + MaybeSend + MaybeSync>,
 			Arc<TestPersister>,
 			Arc<KeyProvider>,
 		>,
@@ -285,7 +291,7 @@ impl<'a> MoneyLossDetector<'a> {
 				Arc<dyn chain::Filter>,
 				Arc<TestBroadcaster>,
 				Arc<FuzzEstimator>,
-				Arc<dyn Logger>,
+				Arc<dyn Logger + MaybeSend + MaybeSync>,
 				Arc<TestPersister>,
 				Arc<KeyProvider>,
 			>,
@@ -520,7 +526,7 @@ impl SignerProvider for KeyProvider {
 }
 
 #[inline]
-pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
+pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger + MaybeSend + MaybeSync>) {
 	if data.len() < 32 {
 		return;
 	}
@@ -1024,20 +1030,27 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 				if splice_in_sats == 0 {
 					continue;
 				}
-				// Create a funding input from the coinbase transaction
-				if let Ok(input) = FundingTxInput::new_p2wpkh(coinbase_tx.clone(), 0) {
-					let contribution = SpliceContribution::splice_in(
-						Amount::from_sat(splice_in_sats.min(900_000)), // Cap at available funds minus fees
-						vec![input],
-						Some(wallet.get_change_script().unwrap()),
-					);
-					let _ = channelmanager.splice_channel(
-						&chan.channel_id,
-						&chan.counterparty.node_id,
-						contribution,
-						253, // funding_feerate_per_kw
+				let chan_id = chan.channel_id;
+				let counterparty = chan.counterparty.node_id;
+				if let Ok(funding_template) = channelmanager.splice_channel(
+					&chan_id,
+					&counterparty,
+					None,
+					FeeRate::from_sat_per_kwu(253),
+				) {
+					let wallet_sync = WalletSync::new(&wallet, Arc::clone(&logger));
+					if let Ok(contribution) = funding_template.splice_in_sync(
 						None,
-					);
+						Amount::from_sat(splice_in_sats.min(900_000)),
+						&wallet_sync,
+					) {
+						let _ = channelmanager.funding_contributed(
+							&chan_id,
+							&counterparty,
+							contribution,
+							None,
+						);
+					}
 				}
 			},
 			// Splice-out: remove funds from a channel
@@ -1060,17 +1073,28 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 				// Cap splice-out at a reasonable portion of channel capacity
 				let max_splice_out = chan.channel_value_satoshis / 4;
 				let splice_out_sats = splice_out_sats.min(max_splice_out).max(546); // At least dust limit
-				let contribution = SpliceContribution::splice_out(vec![TxOut {
-					value: Amount::from_sat(splice_out_sats),
-					script_pubkey: wallet.get_change_script().unwrap(),
-				}]);
-				let _ = channelmanager.splice_channel(
-					&chan.channel_id,
-					&chan.counterparty.node_id,
-					contribution,
-					253, // funding_feerate_per_kw
+				let chan_id = chan.channel_id;
+				let counterparty = chan.counterparty.node_id;
+				if let Ok(funding_template) = channelmanager.splice_channel(
+					&chan_id,
+					&counterparty,
 					None,
-				);
+					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) {
+						let _ = channelmanager.funding_contributed(
+							&chan_id,
+							&counterparty,
+							contribution,
+							None,
+						);
+					}
+				}
 			},
 			_ => return,
 		}
@@ -1137,14 +1161,15 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 	}
 }
 
-pub fn full_stack_test<Out: test_logger::Output>(data: &[u8], out: Out) {
-	let logger: Arc<dyn Logger> = Arc::new(test_logger::TestLogger::new("".to_owned(), out));
+pub fn full_stack_test<Out: test_logger::Output + MaybeSend + MaybeSync>(data: &[u8], out: Out) {
+	let logger: Arc<dyn Logger + MaybeSend + MaybeSync> =
+		Arc::new(test_logger::TestLogger::new("".to_owned(), out));
 	do_test(data, &logger);
 }
 
 #[no_mangle]
 pub extern "C" fn full_stack_run(data: *const u8, datalen: usize) {
-	let logger: Arc<dyn Logger> =
+	let logger: Arc<dyn Logger + MaybeSend + MaybeSync> =
 		Arc::new(test_logger::TestLogger::new("".to_owned(), test_logger::DevNull {}));
 	do_test(unsafe { std::slice::from_raw_parts(data, datalen) }, &logger);
 }
@@ -1930,6 +1955,7 @@ pub fn write_fst_seeds(path: &str) {
 
 #[cfg(test)]
 mod tests {
+	use lightning::util::async_poll::{MaybeSend, MaybeSync};
 	use lightning::util::logger::{Logger, Record};
 	use std::collections::HashMap;
 	use std::sync::{Arc, Mutex};
@@ -1961,7 +1987,7 @@ mod tests {
 		let test = super::two_peer_forwarding_seed();
 
 		let logger = Arc::new(TrackingLogger { lines: Mutex::new(HashMap::new()) });
-		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger>));
+		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger + MaybeSend + MaybeSync>));
 
 		let log_entries = logger.lines.lock().unwrap();
 		// 1
@@ -1996,7 +2022,7 @@ mod tests {
 		let test = super::gossip_exchange_seed();
 
 		let logger = Arc::new(TrackingLogger { lines: Mutex::new(HashMap::new()) });
-		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger>));
+		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger + MaybeSend + MaybeSync>));
 
 		let log_entries = logger.lines.lock().unwrap();
 		assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Sending message to all peers except Some(PublicKey(0000000000000000000000000000000000000000000000000000000000000002ff00000000000000000000000000000000000000000000000000000000000002)) or the announced channel's counterparties: ChannelAnnouncement { node_signature_1: 3026020200b202200303030303030303030303030303030303030303030303030303030303030303, node_signature_2: 3026020200b202200202020202020202020202020202020202020202020202020202020202020202, bitcoin_signature_1: 3026020200b202200303030303030303030303030303030303030303030303030303030303030303, bitcoin_signature_2: 3026020200b202200202020202020202020202020202020202020202020202020202020202020202, contents: UnsignedChannelAnnouncement { features: [], chain_hash: 6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000, short_channel_id: 42, node_id_1: NodeId(030303030303030303030303030303030303030303030303030303030303030303), node_id_2: NodeId(020202020202020202020202020202020202020202020202020202020202020202), bitcoin_key_1: NodeId(030303030303030303030303030303030303030303030303030303030303030303), bitcoin_key_2: NodeId(020202020202020202020202020202020202020202020202020202020202020202), excess_data: [] } }".to_string())), Some(&1));
@@ -2009,7 +2035,7 @@ mod tests {
 		let test = super::splice_seed();
 
 		let logger = Arc::new(TrackingLogger { lines: Mutex::new(HashMap::new()) });
-		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger>));
+		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger + MaybeSend + MaybeSync>));
 
 		let log_entries = logger.lines.lock().unwrap();
 

fuzz/src/chanmon_consistency.rs

@@ -49,7 +49,6 @@ use lightning::chain::channelmonitor::{ANTI_REORG_DELAY, HTLC_FAIL_BACK_BUFFER};
 use lightning::events::bump_transaction::sync::WalletSourceSync;
 use lightning::events::{ClosureReason, Event, HTLCHandlingFailureType};
 use lightning::ln::functional_test_utils::*;
-use lightning::ln::funding::SpliceContribution;
 use lightning::ln::msgs::BaseMessageHandler as _;
 use lightning::ln::msgs::ChannelMessageHandler as _;
 use lightning::ln::msgs::MessageSendEvent;
@@ -453,11 +452,13 @@ fn do_test_0_1_htlc_forward_after_splice(fail_htlc: bool) {
 	reconnect_b_c_args.send_announcement_sigs = (true, true);
 	reconnect_nodes(reconnect_b_c_args);
 
-	let contribution = SpliceContribution::splice_out(vec![TxOut {
+	let outputs = vec![TxOut {
 		value: Amount::from_sat(1_000),
 		script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
-	}]);
-	let splice_tx = splice_channel(&nodes[0], &nodes[1], ChannelId(chan_id_bytes_a), contribution);
+	}];
+	let channel_id = ChannelId(chan_id_bytes_a);
+	let funding_contribution = initiate_splice_out(&nodes[0], &nodes[1], channel_id, outputs);
+	let splice_tx = splice_channel(&nodes[0], &nodes[1], channel_id, funding_contribution);
 	for node in nodes.iter() {
 		mine_transaction(node, &splice_tx);
 		connect_blocks(node, ANTI_REORG_DELAY - 1);

fuzz/src/full_stack.rs

@@ -11,8 +11,7 @@
 //! properly with a signer implementation that asynchronously derives signatures.
 
 use crate::events::bump_transaction::sync::WalletSourceSync;
-use crate::ln::funding::SpliceContribution;
-use crate::ln::splicing_tests::negotiate_splice_tx;
+use crate::ln::splicing_tests::{initiate_splice_out, negotiate_splice_tx};
 use crate::prelude::*;
 use crate::util::ser::Writeable;
 use bitcoin::secp256k1::Secp256k1;
@@ -1573,10 +1572,11 @@ fn test_async_splice_initial_commit_sig() {
 	);
 
 	// Negotiate a splice up until the signature exchange.
-	let contribution = SpliceContribution::splice_out(vec![TxOut {
+	let outputs = vec![TxOut {
 		value: Amount::from_sat(1_000),
 		script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
-	}]);
+	}];
+	let contribution = initiate_splice_out(initiator, acceptor, channel_id, outputs);
 	negotiate_splice_tx(initiator, acceptor, channel_id, contribution);
 
 	assert!(initiator.node.get_and_clear_pending_msg_events().is_empty());