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

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/lib.rs

@@ -106,6 +106,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;
@@ -128,10 +129,11 @@ 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::channel_state::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;
@@ -1200,6 +1202,96 @@ 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.
+	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;
+			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: lightning::ln::chan_utils::make_funding_redeemscript(
+						&PublicKey::from_slice(&[2; 33]).unwrap(),
+						&PublicKey::from_slice(&[2; 33]).unwrap(),
+					)
+					.to_p2wsh(),
+				},
+				satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT
+					+ lightning::ln::chan_utils::FUNDING_TRANSACTION_WITNESS_WEIGHT,
+			};
+
+			let shared_output = bitcoin::TxOut {
+				value: shared_input.previous_utxo.value + Amount::from_sat(splice_amount_sats),
+				script_pubkey: lightning::ln::chan_utils::make_funding_redeemscript(
+					&PublicKey::from_slice(&[2; 33]).unwrap(),
+					&PublicKey::from_slice(&[2; 33]).unwrap(),
+				)
+				.to_p2wsh(),
+			};
+
+			let fee_rate = self.wallet.estimate_channel_funding_fee_rate();
+
+			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 contribution = SpliceContribution::SpliceIn {
+				value: Amount::from_sat(splice_amount_sats),
+				inputs,
+				change_script: None,
+			};
+
+			let funding_feerate_per_kw = fee_rate.to_sat_per_kwu().try_into().unwrap_or(u32::MAX);
+
+			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);
+					Error::ChannelSplicingFailed
+				})
+		} 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,6 +6,7 @@
 // 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};
@@ -19,19 +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::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;
@@ -273,6 +275,10 @@ impl Wallet {
 		Ok(tx)
 	}
 
+	pub(crate) fn estimate_channel_funding_fee_rate(&self) -> FeeRate {
+		self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding)
+	}
+
 	pub(crate) fn get_new_address(&self) -> Result<bitcoin::Address, Error> {
 		let mut locked_wallet = self.inner.lock().unwrap();
 		let mut locked_persister = self.persister.lock().unwrap();
@@ -559,6 +565,47 @@ 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();
+		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();