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

@@ -139,13 +139,14 @@ use graph::NetworkGraph;
 use io::utils::write_node_metrics;
 use lightning::chain::BestBlock;
 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::msgs::SocketAddress;
 use lightning::routing::gossip::NodeAlias;
 use lightning::sign::EntropySource;
 use lightning::util::persist::KVStoreSync;
-use lightning::util::wallet_utils::Wallet as LdkWallet;
+use lightning::util::wallet_utils::{Input, Wallet as LdkWallet};
 use lightning_background_processor::process_events_async;
 use liquidity::{LSPS1Liquidity, LiquiditySource};
 use logger::{log_debug, log_error, log_info, log_trace, LdkLogger, Logger};
@@ -1374,29 +1375,73 @@ impl Node {
 		)
 	}
 
-	/// Add funds from the on-chain wallet into an existing channel.
-	///
-	/// 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(
+	fn splice_in_inner(
 		&self, user_channel_id: &UserChannelId, counterparty_node_id: PublicKey,
-		splice_amount_sats: u64,
+		splice_amount_sats: FundingAmount,
 	) -> 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)?;
-
 			let fee_rate = self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
 
+			let splice_amount_sats = match splice_amount_sats {
+				FundingAmount::Exact { amount_sats } => amount_sats,
+				FundingAmount::Max => {
+					let cur_anchor_reserve_sats =
+						total_anchor_channels_reserve_sats(&self.channel_manager, &self.config);
+
+					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 amount = 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,
+						"Splicing in with all balance: {}sats (fee rate: {} sat/kw, anchor reserve: {}sats)",
+						amount,
+						fee_rate.to_sat_per_kwu(),
+						cur_anchor_reserve_sats,
+					);
+
+					amount
+				},
+			};
+
+			self.check_sufficient_funds_for_channel(splice_amount_sats, &counterparty_node_id)?;
+
 			let funding_template = self
 				.channel_manager
 				.splice_channel(&channel_details.channel_id, &counterparty_node_id, fee_rate)
@@ -1438,6 +1483,46 @@ 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,
+			FundingAmount::Exact { amount_sats: 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, FundingAmount::Max)
+	}
+
 	/// 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

@@ -662,6 +662,36 @@ 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, 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),
+		)?;
+
+		locked_wallet.cancel_tx(&tmp_psbt.unsigned_tx);
+
+		Ok(splice_amount)
+	}
+
 	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;
@@ -779,6 +780,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_payment_successful_event, 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_bitcoind_and_electrsd, 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;
@@ -2731,3 +2731,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();
+}