f - use select_confirmed_utxos

Author: jkczyz

src/lib.rs

@@ -1290,7 +1290,6 @@ impl Node {
 
 			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)
@@ -1299,22 +1298,17 @@ impl Node {
 					Error::ChannelSplicingFailed
 				})?;
 
-			// 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),
+					funding_template
+						.splice_in(Amount::from_sat(splice_amount_sats), Arc::clone(&self.wallet)),
 				)
 				.map_err(|()| {
 					log_error!(self.logger, "Failed to splice channel: coin selection failed");
 					Error::ChannelSplicingFailed
 				})?;
 
-			// Persist wallet state after coin selection
-			self.wallet.persist()?;
-
-			// Phase 3: Submit contribution
 			self.channel_manager
 				.funding_contributed(
 					&channel_details.channel_id,
@@ -1365,7 +1359,6 @@ impl Node {
 
 			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)
@@ -1374,24 +1367,18 @@ impl Node {
 					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))
+				.block_on(funding_template.splice_out(outputs, Arc::clone(&self.wallet)))
 				.map_err(|()| {
 					log_error!(self.logger, "Failed to splice channel: coin selection failed");
 					Error::ChannelSplicingFailed
 				})?;
 
-			// Persist wallet state after coin selection
-			self.wallet.persist()?;
-
-			// Phase 3: Submit contribution
 			self.channel_manager
 				.funding_contributed(
 					&channel_details.channel_id,

src/wallet/mod.rs

@@ -11,6 +11,7 @@ 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;
@@ -20,20 +21,23 @@ use bitcoin::blockdata::constants::WITNESS_SCALE_FACTOR;
 use bitcoin::blockdata::locktime::absolute::LockTime;
 use bitcoin::hashes::Hash;
 use bitcoin::key::XOnlyPublicKey;
-use bitcoin::psbt::Psbt;
+use bitcoin::psbt::{self, 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,
+	Address, Amount, FeeRate, OutPoint, ScriptBuf, Transaction, TxOut, Txid, WPubkeyHash, Weight,
 	WitnessProgram, WitnessVersion,
 };
 use lightning::chain::chaininterface::BroadcasterInterface;
 use lightning::chain::channelmonitor::ANTI_REORG_DELAY;
-use lightning::chain::{BestBlock, Listen};
-use lightning::events::bump_transaction::{Utxo, WalletSource};
+use lightning::chain::{BestBlock, ClaimId, Listen};
+use lightning::events::bump_transaction::{
+	CoinSelection, CoinSelectionSource, Input, 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;
@@ -444,16 +448,6 @@ 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> {
@@ -717,6 +711,82 @@ impl Wallet {
 		Ok(txid)
 	}
 
+	pub(crate) fn select_confirmed_utxos(
+		&self, must_spend: Vec<Input>, must_pay_to: &[TxOut], fee_rate: FeeRate,
+	) -> Result<CoinSelection, ()> {
+		let mut locked_wallet = self.inner.lock().unwrap();
+		let mut locked_persister = self.persister.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();
+
+		let unsigned_tx = tx_builder
+			.finish()
+			.map_err(|e| {
+				log_error!(self.logger, "Failed to select confirmed UTXOs: {}", e);
+			})?
+			.unsigned_tx;
+
+		let confirmed_utxos = 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<_>, ()>>()?;
+
+		if unsigned_tx.output.len() > must_pay_to.len() + 1 {
+			log_error!(
+				self.logger,
+				"Unexpected number of change outputs during coin selection: {}",
+				unsigned_tx.output.len() - must_pay_to.len(),
+			);
+			return Err(());
+		}
+
+		let change_output = unsigned_tx
+			.output
+			.into_iter()
+			.filter(|txout| must_pay_to.iter().all(|output| output != txout))
+			.next();
+
+		locked_wallet.persist(&mut locked_persister).map_err(|e| {
+			log_error!(self.logger, "Failed to persist wallet: {}", e);
+			()
+		})?;
+
+		Ok(CoinSelection { confirmed_utxos, change_output })
+	}
+
 	fn list_confirmed_utxos_inner(&self) -> Result<Vec<Utxo>, ()> {
 		let locked_wallet = self.inner.lock().unwrap();
 		let mut utxos = Vec::new();
@@ -1079,6 +1149,26 @@ impl WalletSource for Wallet {
 	}
 }
 
+// Anchor bumping uses LdkWallet for coin selection, which wraps a WalletSource to implement
+// CoinSelectionSource. Splicing uses this implementation of coin selection instead.
+impl CoinSelectionSource for Wallet {
+	fn select_confirmed_utxos<'a>(
+		&'a self, claim_id: Option<ClaimId>, must_spend: Vec<Input>, must_pay_to: &'a [TxOut],
+		target_feerate_sat_per_1000_weight: u32, _max_tx_weight: u64,
+	) -> impl Future<Output = Result<CoinSelection, ()>> + Send + 'a {
+		debug_assert!(claim_id.is_none());
+		let fee_rate = FeeRate::from_sat_per_kwu(target_feerate_sat_per_1000_weight as u64);
+		async move { self.select_confirmed_utxos(must_spend, must_pay_to, fee_rate) }
+	}
+
+	fn sign_psbt<'a>(
+		&'a self, psbt: Psbt,
+	) -> impl Future<Output = Result<Transaction, ()>> + Send + 'a {
+		debug_assert!(false);
+		async move { self.sign_psbt_inner(psbt) }
+	}
+}
+
 /// Similar to [`KeysManager`], but overrides the destination and shutdown scripts so they are
 /// directly spendable by the BDK wallet.
 pub(crate) struct WalletKeysManager {

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 = 253;
+	let expected_splice_in_fee_sat = 255;
 
 	let payments = node_b.list_payments();
 	let payment =