Add Node::splice_in method

Instead of closing and re-opening a channel when outbound liquidity is
exhausted, splicing allows to adding more funds (splice-in) while
keeping the channel operational. This commit implements splice-in using
funds from the BDK on-chain wallet.

Author: jkczyz

bindings/ldk_node.udl

@@ -150,6 +150,8 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +292,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
 		wallet,
 		chain_source,
 		tx_broadcaster,
+		fee_estimator,
 		event_queue,
 		channel_manager,
 		chain_monitor,

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
 			Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
 			Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
 			Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+			Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
 			Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
 			Self::PersistenceFailed => write!(f, "Failed to persist data."),
 			Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -1741,6 +1741,7 @@ where
 				user_channel_id,
 				counterparty_node_id,
 				abandoned_funding_txo,
+				contributed_outputs,
 				..
 			} => {
 				if let Some(funding_txo) = abandoned_funding_txo {
@@ -1760,6 +1761,17 @@ where
 					);
 				}
 
+				let tx = bitcoin::Transaction {
+					version: bitcoin::transaction::Version::TWO,
+					lock_time: bitcoin::absolute::LockTime::ZERO,
+					input: vec![],
+					output: contributed_outputs,
+				};
+				if let Err(e) = self.wallet.cancel_tx(&tx) {
+					log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+					return Err(ReplayEvent());
+				}
+
 				let event = Event::SpliceFailed {
 					channel_id,
 					user_channel_id: UserChannelId(user_channel_id),

src/lib.rs

@@ -109,6 +109,7 @@ use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 pub use balance::{BalanceDetails, LightningBalance, PendingSweepBalance};
 use bitcoin::secp256k1::PublicKey;
+use bitcoin::Amount;
 #[cfg(feature = "uniffi")]
 pub use builder::ArcedNodeBuilder as Builder;
 pub use builder::BuildError;
@@ -124,17 +125,20 @@ pub use error::Error as NodeError;
 use error::Error;
 pub use event::Event;
 use event::{EventHandler, EventQueue};
+use fee_estimator::{ConfirmationTarget, FeeEstimator, OnchainFeeEstimator};
 #[cfg(feature = "uniffi")]
 use ffi::*;
 use gossip::GossipSource;
 use graph::NetworkGraph;
 pub use io::utils::generate_entropy_mnemonic;
 use io::utils::write_node_metrics;
 use lightning::chain::BestBlock;
-use lightning::events::bump_transaction::Wallet as LdkWallet;
+use lightning::events::bump_transaction::{Input, Wallet as LdkWallet};
 use lightning::impl_writeable_tlv_based;
+use lightning::ln::chan_utils::{make_funding_redeemscript, 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;
@@ -179,6 +183,7 @@ pub struct Node {
 	wallet: Arc<Wallet>,
 	chain_source: Arc<ChainSource>,
 	tx_broadcaster: Arc<Broadcaster>,
+	fee_estimator: Arc<OnchainFeeEstimator>,
 	event_queue: Arc<EventQueue<Arc<Logger>>>,
 	channel_manager: Arc<ChannelManager>,
 	chain_monitor: Arc<ChainMonitor>,
@@ -1236,6 +1241,117 @@ 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(
+		&self, user_channel_id: &UserChannelId, counterparty_node_id: PublicKey,
+		splice_amount_sats: 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;
+
+			// Used for creating a redeem script for the previous funding txo and the new funding
+			// txo. Only needed when selecting which UTXOs to include in the funding tx that would
+			// be sufficient to pay for fees. Hence, the value does not matter.
+			let dummy_pubkey = PublicKey::from_slice(&[2; 33]).unwrap();
+
+			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 shared_input = Input {
+				outpoint: funding_txo.into_bitcoin_outpoint(),
+				previous_utxo: bitcoin::TxOut {
+					value: Amount::from_sat(channel_details.channel_value_satoshis),
+					script_pubkey: make_funding_redeemscript(&dummy_pubkey, &dummy_pubkey)
+						.to_p2wsh(),
+				},
+				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),
+				script_pubkey: make_funding_redeemscript(&dummy_pubkey, &dummy_pubkey).to_p2wsh(),
+			};
+
+			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",
+					);
+					Error::ChannelSplicingFailed
+				})?;
+
+			let change_address = self.wallet.get_new_internal_address()?;
+
+			let contribution = SpliceContribution::SpliceIn {
+				value: Amount::from_sat(splice_amount_sats),
+				inputs,
+				change_script: Some(change_address.script_pubkey()),
+			};
+
+			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)
+				},
+			};
+
+			self.channel_manager
+				.splice_channel(
+					&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,
+					}
+				})
+		} else {
+			log_error!(
+				self.logger,
+				"Channel not found for user_channel_id {} and counterparty {}",
+				user_channel_id,
+				counterparty_node_id
+			);
+
+			Err(Error::ChannelSplicingFailed)
+		}
+	}
+
 	/// Manually sync the LDK and BDK wallets with the current chain state and update the fee rate
 	/// cache.
 	///

src/wallet/mod.rs

@@ -6,11 +6,13 @@
 // accordance with one or both of these licenses.
 
 use std::future::Future;
+use std::ops::Deref;
 use std::pin::Pin;
 use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 
 use bdk_chain::spk_client::{FullScanRequest, SyncRequest};
+use bdk_wallet::descriptor::ExtendedDescriptor;
 #[allow(deprecated)]
 use bdk_wallet::SignOptions;
 use bdk_wallet::{Balance, KeychainKind, PersistedWallet, Update};
@@ -19,19 +21,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::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::{
-	Address, Amount, FeeRate, Network, ScriptBuf, Transaction, TxOut, Txid, WPubkeyHash,
+	Address, Amount, FeeRate, Network, 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::events::bump_transaction::{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;
@@ -285,7 +288,7 @@ impl Wallet {
 		Ok(address_info.address)
 	}
 
-	fn get_new_internal_address(&self) -> Result<bitcoin::Address, Error> {
+	pub(crate) fn get_new_internal_address(&self) -> Result<bitcoin::Address, Error> {
 		let mut locked_wallet = self.inner.lock().unwrap();
 		let mut locked_persister = self.persister.lock().unwrap();
 
@@ -297,6 +300,19 @@ impl Wallet {
 		Ok(address_info.address)
 	}
 
+	pub(crate) fn cancel_tx(&self, tx: &Transaction) -> Result<(), Error> {
+		let mut locked_wallet = self.inner.lock().unwrap();
+		let mut locked_persister = self.persister.lock().unwrap();
+
+		locked_wallet.cancel_tx(tx);
+		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> {
@@ -559,6 +575,56 @@ 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();