Add ability to splice in with all on-chain funds

Adds splice_in_with_all which uses get_max_drain_amount with a
shared input to determine the largest splice-in amount after accounting
for on-chain fees and anchor reserves.

Author: benthecarman

bindings/ldk_node.udl

@@ -180,6 +180,8 @@ interface Node {
 	[Throws=NodeError]
 	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
 	[Throws=NodeError]
+	void splice_in_with_all([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
+	[Throws=NodeError]
 	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
 	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);

src/lib.rs

@@ -1380,17 +1380,15 @@ impl Node {
 	///
 	/// This API is experimental. Currently, a splice-in will be marked as an outbound payment, but
 	/// this classification may change in the future.
-	pub fn splice_in(
+	fn splice_in_inner(
 		&self, user_channel_id: &UserChannelId, counterparty_node_id: PublicKey,
-		splice_amount_sats: u64,
+		splice_amount_sats: Option<u64>,
 	) -> Result<(), Error> {
 		let open_channels =
 			self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
 		if let Some(channel_details) =
 			open_channels.iter().find(|c| c.user_channel_id == user_channel_id.0)
 		{
-			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;
 
@@ -1410,25 +1408,63 @@ impl Node {
 				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!(
+			let (splice_amount_sats, inputs) = match splice_amount_sats {
+				Some(amount) => {
+					self.check_sufficient_funds_for_channel(amount, &counterparty_node_id)?;
+
+					let shared_output = bitcoin::TxOut {
+						value: shared_input.previous_utxo.value + Amount::from_sat(amount),
+						// 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 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",
+							);
+							Error::ChannelSplicingFailed
+						})?;
+
+					(amount, inputs)
+				},
+				None => {
+					let cur_anchor_reserve_sats =
+						total_anchor_channels_reserve_sats(&self.channel_manager, &self.config);
+
+					let (amount, inputs) = self
+						.wallet
+						.get_max_splice_in_amount(
+							shared_input,
+							funding_output.script_pubkey.clone(),
+							cur_anchor_reserve_sats,
+							fee_rate,
+						)
+						.map_err(|e| {
+							log_error!(
+								self.logger,
+								"Failed to determine max splice-in amount: {e:?}"
+							);
+							e
+						})?;
+
+					log_info!(
 						self.logger,
-						"Failed to splice channel: insufficient confirmed UTXOs",
+						"Splicing in with all balance: {}sats (fee rate: {} sat/kw, anchor reserve: {}sats)",
+						amount,
+						fee_rate.to_sat_per_kwu(),
+						cur_anchor_reserve_sats,
 					);
-					Error::ChannelSplicingFailed
-				})?;
+
+					(amount, inputs)
+				},
+			};
 
 			let change_address = self.wallet.get_new_internal_address()?;
 
@@ -1482,6 +1518,42 @@ impl Node {
 		}
 	}
 
+	/// Add funds to an existing channel from a transaction output you control.
+	///
+	/// This provides for increasing a channel's outbound liquidity without re-balancing or closing
+	/// it. Once negotiation with the counterparty is complete, the channel remains operational
+	/// while waiting for a new funding transaction to confirm.
+	///
+	/// # Experimental API
+	///
+	/// This API is experimental. Currently, a splice-in will be marked as an outbound payment, but
+	/// this classification may change in the future.
+	pub fn splice_in(
+		&self, user_channel_id: &UserChannelId, counterparty_node_id: PublicKey,
+		splice_amount_sats: u64,
+	) -> Result<(), Error> {
+		self.splice_in_inner(user_channel_id, counterparty_node_id, Some(splice_amount_sats))
+	}
+
+	/// Add all available on-chain funds into an existing channel.
+	///
+	/// This is similar to [`Node::splice_in`] but uses all available confirmed on-chain funds
+	/// instead of requiring a specific amount.
+	///
+	/// This provides for increasing a channel's outbound liquidity without re-balancing or closing
+	/// it. Once negotiation with the counterparty is complete, the channel remains operational
+	/// while waiting for a new funding transaction to confirm.
+	///
+	/// # Experimental API
+	///
+	/// This API is experimental. Currently, a splice-in will be marked as an outbound payment, but
+	/// this classification may change in the future.
+	pub fn splice_in_with_all(
+		&self, user_channel_id: &UserChannelId, counterparty_node_id: PublicKey,
+	) -> Result<(), Error> {
+		self.splice_in_inner(user_channel_id, counterparty_node_id, None)
+	}
+
 	/// Remove funds from an existing channel, sending them to an on-chain address.
 	///
 	/// This provides for decreasing a channel's outbound liquidity without re-balancing or closing

src/wallet/mod.rs

@@ -604,6 +604,53 @@ impl Wallet {
 		Ok(max_amount)
 	}
 
+	/// Returns the maximum amount available for splicing into an existing channel, accounting for
+	/// on-chain fees and anchor reserves, along with the wallet UTXOs to use as inputs.
+	pub(crate) fn get_max_splice_in_amount(
+		&self, shared_input: Input, shared_output_script: ScriptBuf, cur_anchor_reserve_sats: u64,
+		fee_rate: FeeRate,
+	) -> Result<(u64, Vec<FundingTxInput>), Error> {
+		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 (splice_amount, tmp_psbt) = self.get_max_drain_amount(
+			&mut locked_wallet,
+			shared_output_script,
+			cur_anchor_reserve_sats,
+			fee_rate,
+			Some(&shared_input),
+		)?;
+
+		let inputs = tmp_psbt
+			.unsigned_tx
+			.input
+			.iter()
+			.filter(|txin| txin.previous_output != shared_input.outpoint)
+			.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<_>, ()>>()
+			.map_err(|_| {
+				log_error!(self.logger, "Failed to collect wallet UTXOs for splice");
+				Error::ChannelSplicingFailed
+			})?;
+
+		locked_wallet.cancel_tx(&tmp_psbt.unsigned_tx);
+
+		Ok((splice_amount, inputs))
+	}
+
 	pub(crate) fn parse_and_validate_address(&self, address: &Address) -> Result<Address, Error> {
 		Address::<NetworkUnchecked>::from_str(address.to_string().as_str())
 			.map_err(|_| Error::InvalidAddress)?

tests/common/mod.rs

@@ -32,6 +32,7 @@ use ldk_node::io::sqlite_store::SqliteStore;
 use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus};
 use ldk_node::{
 	Builder, CustomTlvRecord, Event, LightningBalance, Node, NodeError, PendingSweepBalance,
+	UserChannelId,
 };
 use lightning::io;
 use lightning::ln::msgs::SocketAddress;
@@ -751,6 +752,16 @@ pub async fn open_channel_with_all(
 	funding_txo_a
 }
 
+pub async fn splice_in_with_all(
+	node_a: &TestNode, node_b: &TestNode, user_channel_id: &UserChannelId, electrsd: &ElectrsD,
+) {
+	node_a.splice_in_with_all(user_channel_id, node_b.node_id()).unwrap();
+
+	let splice_txo = expect_splice_pending_event!(node_a, node_b.node_id());
+	expect_splice_pending_event!(node_b, node_a.node_id());
+	wait_for_tx(&electrsd.client, splice_txo.txid).await;
+}
+
 pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 	node_a: TestNode, node_b: TestNode, bitcoind: &BitcoindClient, electrsd: &E, allow_0conf: bool,
 	expect_anchor_channel: bool, force_close: bool,

tests/integration_tests_rust.rs

@@ -23,8 +23,8 @@ use common::{
 	expect_splice_pending_event, generate_blocks_and_wait, open_channel, open_channel_push_amt,
 	open_channel_with_all, premine_and_distribute_funds, premine_blocks, prepare_rbf,
 	random_chain_source, random_config, random_listening_addresses, setup_bitcoind_and_electrsd,
-	setup_builder, setup_node, setup_two_nodes, wait_for_tx, TestChainSource, TestStoreType,
-	TestSyncStore,
+	setup_builder, setup_node, setup_two_nodes, splice_in_with_all, wait_for_tx, TestChainSource,
+	TestStoreType, TestSyncStore,
 };
 use ldk_node::config::{AsyncPaymentsRole, EsploraSyncConfig};
 use ldk_node::entropy::NodeEntropy;
@@ -2567,3 +2567,81 @@ async fn open_channel_with_all_without_anchors() {
 	node_a.stop().unwrap();
 	node_b.stop().unwrap();
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn splice_in_with_all_balance() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = random_chain_source(&bitcoind, &electrsd);
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+
+	let addr_a = node_a.onchain_payment().new_address().unwrap();
+	let addr_b = node_b.onchain_payment().new_address().unwrap();
+
+	let premine_amount_sat = 5_000_000;
+	let channel_amount_sat = 1_000_000;
+
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![addr_a, addr_b],
+		Amount::from_sat(premine_amount_sat),
+	)
+	.await;
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+	assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
+
+	// Open a channel with a fixed amount first
+	let funding_txo = open_channel(&node_a, &node_b, channel_amount_sat, false, &electrsd).await;
+
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	let user_channel_id_a = expect_channel_ready_event!(node_a, node_b.node_id());
+	let _user_channel_id_b = expect_channel_ready_event!(node_b, node_a.node_id());
+
+	let channels = node_a.list_channels();
+	assert_eq!(channels.len(), 1);
+	assert_eq!(channels[0].channel_value_sats, channel_amount_sat);
+	assert_eq!(channels[0].funding_txo.unwrap(), funding_txo);
+
+	let balance_before_splice = node_a.list_balances().spendable_onchain_balance_sats;
+	assert!(balance_before_splice > 0);
+
+	// Splice in with all remaining on-chain funds
+	splice_in_with_all(&node_a, &node_b, &user_channel_id_a, &electrsd).await;
+
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	let _user_channel_id_a2 = expect_channel_ready_event!(node_a, node_b.node_id());
+	let _user_channel_id_b2 = expect_channel_ready_event!(node_b, node_a.node_id());
+
+	// After splicing with all balance, channel value should be close to the premined amount
+	// minus fees and anchor reserve
+	let anchor_reserve_sat = 25_000;
+	let channels = node_a.list_channels();
+	assert_eq!(channels.len(), 1);
+	let channel = &channels[0];
+	assert!(
+		channel.channel_value_sats > premine_amount_sat - anchor_reserve_sat - 1000,
+		"Channel value {} should be close to premined amount {} minus anchor reserve {} and fees",
+		channel.channel_value_sats,
+		premine_amount_sat,
+		anchor_reserve_sat,
+	);
+
+	// Remaining on-chain balance should be close to just the anchor reserve
+	let remaining_balance = node_a.list_balances().spendable_onchain_balance_sats;
+	assert!(
+		remaining_balance < anchor_reserve_sat + 500,
+		"Remaining balance {remaining_balance} should be close to the anchor reserve {anchor_reserve_sat}"
+	);
+
+	node_a.stop().unwrap();
+	node_b.stop().unwrap();
+}