Add Node::splice_out method

Instead of closing and re-opening a channel when on-chain funds are
needed, splicing allows removing funds (splice-out) while keeping the
channel operational. This commit implements splice-out sending funds to
a user-provided on-chain address.

Author: jkczyz

src/lib.rs

@@ -106,7 +106,7 @@ use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 pub use balance::{BalanceDetails, LightningBalance, PendingSweepBalance};
 use bitcoin::secp256k1::PublicKey;
-use bitcoin::Amount;
+use bitcoin::{Address, Amount};
 #[cfg(feature = "uniffi")]
 pub use builder::ArcedNodeBuilder as Builder;
 pub use builder::BuildError;
@@ -1292,6 +1292,59 @@ impl Node {
 		}
 	}
 
+	/// 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
+	/// it. Once negotiation with the counterparty is complete, the channel remains operational
+	/// while waiting for a new funding transaction to confirm.
+	pub fn splice_out(
+		&self, user_channel_id: &UserChannelId, counterparty_node_id: PublicKey, address: Address,
+		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)
+		{
+			if splice_amount_sats > channel_details.outbound_capacity_msat {
+				return Err(Error::ChannelSplicingFailed);
+			}
+
+			self.wallet.parse_and_validate_address(&address)?;
+
+			let contribution = SpliceContribution::SpliceOut {
+				outputs: vec![bitcoin::TxOut {
+					value: Amount::from_sat(splice_amount_sats),
+					script_pubkey: address.script_pubkey(),
+				}],
+			};
+
+			let fee_rate = self.wallet.estimate_channel_funding_fee_rate();
+			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

@@ -25,7 +25,7 @@ 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, Weight,
+	Address, Amount, FeeRate, ScriptBuf, Transaction, TxOut, Txid, WPubkeyHash, Weight,
 	WitnessProgram, WitnessVersion,
 };
 use lightning::chain::chaininterface::BroadcasterInterface;
@@ -338,12 +338,10 @@ impl Wallet {
 		self.get_balances(total_anchor_channels_reserve_sats).map(|(_, s)| s)
 	}
 
-	fn parse_and_validate_address(
-		&self, network: Network, address: &Address,
-	) -> Result<Address, Error> {
+	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)?
-			.require_network(network)
+			.require_network(self.config.network)
 			.map_err(|_| Error::InvalidAddress)
 	}
 
@@ -352,7 +350,7 @@ impl Wallet {
 		&self, address: &bitcoin::Address, send_amount: OnchainSendAmount,
 		fee_rate: Option<FeeRate>,
 	) -> Result<Txid, Error> {
-		self.parse_and_validate_address(self.config.network, &address)?;
+		self.parse_and_validate_address(&address)?;
 
 		// Use the set fee_rate or default to fee estimation.
 		let confirmation_target = ConfirmationTarget::OnchainPayment;