Update splice_in/splice_out to use new LDK two-phase funding API

The LDK dependency bump introduced a new splicing API that separates
negotiation from coin selection, letting LDK handle transaction
construction internally rather than requiring manual UTXO selection
and change address management.

Generated with the assistance of AI (Claude Code).

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

Author: jkczyz

src/lib.rs

@@ -138,12 +138,10 @@ use gossip::GossipSource;
 use graph::NetworkGraph;
 use io::utils::write_node_metrics;
 use lightning::chain::BestBlock;
-use lightning::events::bump_transaction::{Input, Wallet as LdkWallet};
+use lightning::events::bump_transaction::Wallet as LdkWallet;
 use lightning::impl_writeable_tlv_based;
-use lightning::ln::chan_utils::FUNDING_TRANSACTION_WITNESS_WEIGHT;
 use lightning::ln::channel_state::{ChannelDetails as LdkChannelDetails, ChannelShutdownState};
 use lightning::ln::channelmanager::PaymentId;
-use lightning::ln::funding::SpliceContribution;
 use lightning::ln::msgs::SocketAddress;
 use lightning::routing::gossip::NodeAlias;
 use lightning::util::persist::KVStoreSync;
@@ -1290,84 +1288,43 @@ impl Node {
 		{
 			self.check_sufficient_funds_for_channel(splice_amount_sats, &counterparty_node_id)?;
 
-			const EMPTY_SCRIPT_SIG_WEIGHT: u64 =
-				1 /* empty script_sig */ * bitcoin::constants::WITNESS_SCALE_FACTOR as u64;
-
-			let funding_txo = channel_details.funding_txo.ok_or_else(|| {
-				log_error!(self.logger, "Failed to splice channel: channel not yet ready",);
-				Error::ChannelSplicingFailed
-			})?;
-
-			let funding_output = channel_details.get_funding_output().ok_or_else(|| {
-				log_error!(self.logger, "Failed to splice channel: channel not yet ready");
-				Error::ChannelSplicingFailed
-			})?;
-
-			let shared_input = Input {
-				outpoint: funding_txo.into_bitcoin_outpoint(),
-				previous_utxo: funding_output.clone(),
-				satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT + FUNDING_TRANSACTION_WITNESS_WEIGHT,
-			};
-
-			let shared_output = bitcoin::TxOut {
-				value: shared_input.previous_utxo.value + Amount::from_sat(splice_amount_sats),
-				// will not actually be the exact same script pubkey after splice
-				// but it is the same size and good enough for coin selection purposes
-				script_pubkey: funding_output.script_pubkey.clone(),
-			};
-
 			let fee_rate = self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
 
-			let inputs = self
-				.wallet
-				.select_confirmed_utxos(vec![shared_input], &[shared_output], fee_rate)
-				.map_err(|()| {
-					log_error!(
-						self.logger,
-						"Failed to splice channel: insufficient confirmed UTXOs",
-					);
+			// Phase 1: Initiate splice negotiation
+			let funding_template = self
+				.channel_manager
+				.splice_channel(&channel_details.channel_id, &counterparty_node_id, fee_rate)
+				.map_err(|e| {
+					log_error!(self.logger, "Failed to splice channel: {:?}", e);
 					Error::ChannelSplicingFailed
 				})?;
 
-			let change_address = self.wallet.get_new_internal_address()?;
-
-			let contribution = SpliceContribution::splice_in(
-				Amount::from_sat(splice_amount_sats),
-				inputs,
-				Some(change_address.script_pubkey()),
-			);
+			// Phase 2: Coin selection via LdkWallet (wraps our WalletSource)
+			let ldk_wallet = LdkWallet::new(Arc::clone(&self.wallet), Arc::clone(&self.logger));
+			let contribution = self
+				.runtime
+				.block_on(
+					funding_template.splice_in(Amount::from_sat(splice_amount_sats), &ldk_wallet),
+				)
+				.map_err(|()| {
+					log_error!(self.logger, "Failed to splice channel: coin selection failed");
+					Error::ChannelSplicingFailed
+				})?;
 
-			let funding_feerate_per_kw: u32 = match fee_rate.to_sat_per_kwu().try_into() {
-				Ok(fee_rate) => fee_rate,
-				Err(_) => {
-					debug_assert!(false);
-					fee_estimator::get_fallback_rate_for_target(ConfirmationTarget::ChannelFunding)
-				},
-			};
+			// Persist wallet state after coin selection
+			self.wallet.persist()?;
 
+			// Phase 3: Submit contribution
 			self.channel_manager
-				.splice_channel(
+				.funding_contributed(
 					&channel_details.channel_id,
 					&counterparty_node_id,
 					contribution,
-					funding_feerate_per_kw,
 					None,
 				)
 				.map_err(|e| {
 					log_error!(self.logger, "Failed to splice channel: {:?}", e);
-					let tx = bitcoin::Transaction {
-						version: bitcoin::transaction::Version::TWO,
-						lock_time: bitcoin::absolute::LockTime::ZERO,
-						input: vec![],
-						output: vec![bitcoin::TxOut {
-							value: Amount::ZERO,
-							script_pubkey: change_address.script_pubkey(),
-						}],
-					};
-					match self.wallet.cancel_tx(&tx) {
-						Ok(()) => Error::ChannelSplicingFailed,
-						Err(e) => e,
-					}
+					Error::ChannelSplicingFailed
 				})
 		} else {
 			log_error!(
@@ -1376,7 +1333,6 @@ impl Node {
 				user_channel_id,
 				counterparty_node_id
 			);
-
 			Err(Error::ChannelSplicingFailed)
 		}
 	}
@@ -1407,27 +1363,40 @@ impl Node {
 
 			self.wallet.parse_and_validate_address(address)?;
 
-			let contribution = SpliceContribution::splice_out(vec![bitcoin::TxOut {
+			let fee_rate = self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
+
+			// Phase 1: Initiate splice negotiation
+			let funding_template = self
+				.channel_manager
+				.splice_channel(&channel_details.channel_id, &counterparty_node_id, fee_rate)
+				.map_err(|e| {
+					log_error!(self.logger, "Failed to splice channel: {:?}", e);
+					Error::ChannelSplicingFailed
+				})?;
+
+			// Phase 2: Build contribution with splice-out outputs
+			let outputs = vec![bitcoin::TxOut {
 				value: Amount::from_sat(splice_amount_sats),
 				script_pubkey: address.script_pubkey(),
-			}]);
+			}];
+			let ldk_wallet = LdkWallet::new(Arc::clone(&self.wallet), Arc::clone(&self.logger));
+			let contribution = self
+				.runtime
+				.block_on(funding_template.splice_out(outputs, &ldk_wallet))
+				.map_err(|()| {
+					log_error!(self.logger, "Failed to splice channel: coin selection failed");
+					Error::ChannelSplicingFailed
+				})?;
 
-			let fee_rate = self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
-			let funding_feerate_per_kw: u32 = match fee_rate.to_sat_per_kwu().try_into() {
-				Ok(fee_rate) => fee_rate,
-				Err(_) => {
-					debug_assert!(false, "FeeRate should always fit within u32");
-					log_error!(self.logger, "FeeRate should always fit within u32");
-					fee_estimator::get_fallback_rate_for_target(ConfirmationTarget::ChannelFunding)
-				},
-			};
+			// Persist wallet state after coin selection
+			self.wallet.persist()?;
 
+			// Phase 3: Submit contribution
 			self.channel_manager
-				.splice_channel(
+				.funding_contributed(
 					&channel_details.channel_id,
 					&counterparty_node_id,
 					contribution,
-					funding_feerate_per_kw,
 					None,
 				)
 				.map_err(|e| {

src/wallet/mod.rs

@@ -11,7 +11,6 @@ use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 
 use bdk_chain::spk_client::{FullScanRequest, SyncRequest};
-use bdk_wallet::descriptor::ExtendedDescriptor;
 use bdk_wallet::event::WalletEvent;
 #[allow(deprecated)]
 use bdk_wallet::SignOptions;
@@ -21,20 +20,20 @@ use bitcoin::blockdata::constants::WITNESS_SCALE_FACTOR;
 use bitcoin::blockdata::locktime::absolute::LockTime;
 use bitcoin::hashes::Hash;
 use bitcoin::key::XOnlyPublicKey;
-use bitcoin::psbt::{self, Psbt};
+use bitcoin::psbt::Psbt;
 use bitcoin::secp256k1::ecdh::SharedSecret;
 use bitcoin::secp256k1::ecdsa::{RecoverableSignature, Signature};
 use bitcoin::secp256k1::{All, PublicKey, Scalar, Secp256k1, SecretKey};
+use bitcoin::transaction::Sequence;
 use bitcoin::{
-	Address, Amount, FeeRate, OutPoint, ScriptBuf, Transaction, TxOut, Txid, WPubkeyHash, Weight,
+	Address, Amount, FeeRate, OutPoint, ScriptBuf, Transaction, TxOut, Txid, WPubkeyHash,
 	WitnessProgram, WitnessVersion,
 };
 use lightning::chain::chaininterface::BroadcasterInterface;
 use lightning::chain::channelmonitor::ANTI_REORG_DELAY;
 use lightning::chain::{BestBlock, Listen};
-use lightning::events::bump_transaction::{Input, Utxo, WalletSource};
+use lightning::events::bump_transaction::{Utxo, WalletSource};
 use lightning::ln::channelmanager::PaymentId;
-use lightning::ln::funding::FundingTxInput;
 use lightning::ln::inbound_payment::ExpandedKey;
 use lightning::ln::msgs::UnsignedGossipMessage;
 use lightning::ln::script::ShutdownScript;
@@ -445,6 +444,16 @@ impl Wallet {
 		Ok(())
 	}
 
+	pub(crate) fn persist(&self) -> Result<(), Error> {
+		let mut locked_wallet = self.inner.lock().unwrap();
+		let mut locked_persister = self.persister.lock().unwrap();
+		locked_wallet.persist(&mut locked_persister).map_err(|e| {
+			log_error!(self.logger, "Failed to persist wallet: {}", e);
+			Error::PersistenceFailed
+		})?;
+		Ok(())
+	}
+
 	pub(crate) fn get_balances(
 		&self, total_anchor_channels_reserve_sats: u64,
 	) -> Result<(u64, u64), Error> {
@@ -708,56 +717,6 @@ impl Wallet {
 		Ok(txid)
 	}
 
-	pub(crate) fn select_confirmed_utxos(
-		&self, must_spend: Vec<Input>, must_pay_to: &[TxOut], fee_rate: FeeRate,
-	) -> Result<Vec<FundingTxInput>, ()> {
-		let mut locked_wallet = self.inner.lock().unwrap();
-		debug_assert!(matches!(
-			locked_wallet.public_descriptor(KeychainKind::External),
-			ExtendedDescriptor::Wpkh(_)
-		));
-		debug_assert!(matches!(
-			locked_wallet.public_descriptor(KeychainKind::Internal),
-			ExtendedDescriptor::Wpkh(_)
-		));
-
-		let mut tx_builder = locked_wallet.build_tx();
-		tx_builder.only_witness_utxo();
-
-		for input in &must_spend {
-			let psbt_input = psbt::Input {
-				witness_utxo: Some(input.previous_utxo.clone()),
-				..Default::default()
-			};
-			let weight = Weight::from_wu(input.satisfaction_weight);
-			tx_builder.add_foreign_utxo(input.outpoint, psbt_input, weight).map_err(|_| ())?;
-		}
-
-		for output in must_pay_to {
-			tx_builder.add_recipient(output.script_pubkey.clone(), output.value);
-		}
-
-		tx_builder.fee_rate(fee_rate);
-		tx_builder.exclude_unconfirmed();
-
-		tx_builder
-			.finish()
-			.map_err(|e| {
-				log_error!(self.logger, "Failed to select confirmed UTXOs: {}", e);
-			})?
-			.unsigned_tx
-			.input
-			.iter()
-			.filter(|txin| must_spend.iter().all(|input| input.outpoint != txin.previous_output))
-			.filter_map(|txin| {
-				locked_wallet
-					.tx_details(txin.previous_output.txid)
-					.map(|tx_details| tx_details.tx.deref().clone())
-					.map(|prevtx| FundingTxInput::new_p2wpkh(prevtx, txin.previous_output.vout))
-			})
-			.collect::<Result<Vec<_>, ()>>()
-	}
-
 	fn list_confirmed_utxos_inner(&self) -> Result<Vec<Utxo>, ()> {
 		let locked_wallet = self.inner.lock().unwrap();
 		let mut utxos = Vec::new();
@@ -831,6 +790,7 @@ impl Wallet {
 						},
 						satisfaction_weight: 1 /* empty script_sig */ * WITNESS_SCALE_FACTOR as u64 +
 							1 /* witness items */ + 1 /* schnorr sig len */ + 64, // schnorr sig
+						sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
 					};
 					utxos.push(utxo);
 				},
@@ -1094,6 +1054,24 @@ impl WalletSource for Wallet {
 		async move { self.get_change_script_inner() }
 	}
 
+	fn get_prevtx<'a>(
+		&'a self, outpoint: OutPoint,
+	) -> impl Future<Output = Result<Transaction, ()>> + Send + 'a {
+		async move {
+			let locked_wallet = self.inner.lock().unwrap();
+			locked_wallet
+				.tx_details(outpoint.txid)
+				.map(|tx_details| tx_details.tx.deref().clone())
+				.ok_or_else(|| {
+					log_error!(
+						self.logger,
+						"Failed to get previous transaction for {}",
+						outpoint.txid
+					);
+				})
+		}
+	}
+
 	fn sign_psbt<'a>(
 		&'a self, psbt: Psbt,
 	) -> impl Future<Output = Result<Transaction, ()>> + Send + 'a {

tests/integration_tests_rust.rs

@@ -983,7 +983,7 @@ async fn splice_channel() {
 	expect_channel_ready_event!(node_a, node_b.node_id());
 	expect_channel_ready_event!(node_b, node_a.node_id());
 
-	let expected_splice_in_fee_sat = 252;
+	let expected_splice_in_fee_sat = 253;
 
 	let payments = node_b.list_payments();
 	let payment =