Add ability to open channel with all on-chain funds

Adds open_channel_with_all which uses get_max_drain_amount to
determine the largest funding amount after accounting for on-chain fees
and anchor reserves

Author: benthecarman

bindings/ldk_node.udl

@@ -174,6 +174,10 @@ 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]
+	UserChannelId open_channel_with_all(PublicKey node_id, SocketAddress address, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
+	[Throws=NodeError]
+	UserChannelId open_announced_channel_with_all(PublicKey node_id, SocketAddress address, 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 splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);

src/lib.rs

@@ -169,6 +169,7 @@ pub use {
 };
 
 use crate::scoring::setup_background_pathfinding_scores_sync;
+use crate::wallet::FundingAmount;
 
 #[cfg(feature = "uniffi")]
 uniffi::include_scaffolding!("ldk_node");
@@ -1092,7 +1093,7 @@ impl Node {
 	}
 
 	fn open_channel_inner(
-		&self, node_id: PublicKey, address: SocketAddress, channel_amount_sats: u64,
+		&self, node_id: PublicKey, address: SocketAddress, channel_amount_sats: FundingAmount,
 		push_to_counterparty_msat: Option<u64>, channel_config: Option<ChannelConfig>,
 		announce_for_forwarding: bool,
 	) -> Result<UserChannelId, Error> {
@@ -1112,8 +1113,38 @@ impl Node {
 			con_cm.connect_peer_if_necessary(con_node_id, con_addr).await
 		})?;
 
-		// Check funds availability after connection (includes anchor reserve calculation)
-		self.check_sufficient_funds_for_channel(channel_amount_sats, &node_id)?;
+		let channel_amount_sats = match channel_amount_sats {
+			FundingAmount::Exact { amount_sats } => {
+				// Check funds availability after connection (includes anchor reserve
+				// calculation).
+				self.check_sufficient_funds_for_channel(amount_sats, &peer_info.node_id)?;
+				amount_sats
+			},
+			FundingAmount::Max => {
+				// Determine max funding amount from all available on-chain funds.
+				let cur_anchor_reserve_sats =
+					total_anchor_channels_reserve_sats(&self.channel_manager, &self.config);
+				let new_channel_reserve =
+					self.new_channel_anchor_reserve_sats(&peer_info.node_id)?;
+				let total_anchor_reserve_sats = cur_anchor_reserve_sats + new_channel_reserve;
+
+				let fee_rate =
+					self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
+
+				let amount =
+					self.wallet.get_max_funding_amount(total_anchor_reserve_sats, fee_rate)?;
+
+				log_info!(
+					self.logger,
+					"Opening channel with all balance: {}sats (fee rate: {} sat/kw, anchor reserve: {}sats)",
+					amount,
+					fee_rate.to_sat_per_kwu(),
+					total_anchor_reserve_sats,
+				);
+
+				amount
+			},
+		};
 
 		let mut user_config = default_user_config(&self.config);
 		user_config.channel_handshake_config.announce_for_forwarding = announce_for_forwarding;
@@ -1156,6 +1187,25 @@ impl Node {
 		}
 	}
 
+	fn new_channel_anchor_reserve_sats(&self, peer_node_id: &PublicKey) -> Result<u64, Error> {
+		let init_features = self
+			.peer_manager
+			.peer_by_node_id(peer_node_id)
+			.ok_or(Error::ConnectionFailed)?
+			.init_features;
+		let sats = self.config.anchor_channels_config.as_ref().map_or(0, |c| {
+			if init_features.requires_anchors_zero_fee_htlc_tx()
+				&& !c.trusted_peers_no_reserve.contains(peer_node_id)
+			{
+				c.per_channel_reserve_sats
+			} else {
+				0
+			}
+		});
+
+		Ok(sats)
+	}
+
 	fn check_sufficient_funds_for_channel(
 		&self, amount_sats: u64, peer_node_id: &PublicKey,
 	) -> Result<(), Error> {
@@ -1174,21 +1224,8 @@ impl Node {
 		}
 
 		// Fail if we have less than the channel value + anchor reserve available (if applicable).
-		let init_features = self
-			.peer_manager
-			.peer_by_node_id(peer_node_id)
-			.ok_or(Error::ConnectionFailed)?
-			.init_features;
-		let required_funds_sats = amount_sats
-			+ self.config.anchor_channels_config.as_ref().map_or(0, |c| {
-				if init_features.requires_anchors_zero_fee_htlc_tx()
-					&& !c.trusted_peers_no_reserve.contains(peer_node_id)
-				{
-					c.per_channel_reserve_sats
-				} else {
-					0
-				}
-			});
+		let required_funds_sats =
+			amount_sats + self.new_channel_anchor_reserve_sats(peer_node_id)?;
 
 		if spendable_amount_sats < required_funds_sats {
 			log_error!(self.logger,
@@ -1225,7 +1262,7 @@ impl Node {
 		self.open_channel_inner(
 			node_id,
 			address,
-			channel_amount_sats,
+			FundingAmount::Exact { amount_sats: channel_amount_sats },
 			push_to_counterparty_msat,
 			channel_config,
 			false,
@@ -1265,7 +1302,72 @@ impl Node {
 		self.open_channel_inner(
 			node_id,
 			address,
-			channel_amount_sats,
+			FundingAmount::Exact { amount_sats: channel_amount_sats },
+			push_to_counterparty_msat,
+			channel_config,
+			true,
+		)
+	}
+
+	/// Connect to a node and open a new unannounced channel, using all available on-chain funds
+	/// minus fees and anchor reserves.
+	///
+	/// To open an announced channel, see [`Node::open_announced_channel_with_all`].
+	///
+	/// Disconnects and reconnects are handled automatically.
+	///
+	/// If `push_to_counterparty_msat` is set, the given value will be pushed (read: sent) to the
+	/// channel counterparty on channel open. This can be useful to start out with the balance not
+	/// entirely shifted to one side, therefore allowing to receive payments from the getgo.
+	///
+	/// Returns a [`UserChannelId`] allowing to locally keep track of the channel.
+	///
+	/// [`AnchorChannelsConfig::per_channel_reserve_sats`]: crate::config::AnchorChannelsConfig::per_channel_reserve_sats
+	pub fn open_channel_with_all(
+		&self, node_id: PublicKey, address: SocketAddress, push_to_counterparty_msat: Option<u64>,
+		channel_config: Option<ChannelConfig>,
+	) -> Result<UserChannelId, Error> {
+		self.open_channel_inner(
+			node_id,
+			address,
+			FundingAmount::Max,
+			push_to_counterparty_msat,
+			channel_config,
+			false,
+		)
+	}
+
+	/// Connect to a node and open a new announced channel, using all available on-chain funds
+	/// minus fees and anchor reserves.
+	///
+	/// This will return an error if the node has not been sufficiently configured to operate as a
+	/// forwarding node that can properly announce its existence to the public network graph, i.e.,
+	/// [`Config::listening_addresses`] and [`Config::node_alias`] are unset.
+	///
+	/// To open an unannounced channel, see [`Node::open_channel_with_all`].
+	///
+	/// Disconnects and reconnects are handled automatically.
+	///
+	/// If `push_to_counterparty_msat` is set, the given value will be pushed (read: sent) to the
+	/// channel counterparty on channel open. This can be useful to start out with the balance not
+	/// entirely shifted to one side, therefore allowing to receive payments from the getgo.
+	///
+	/// Returns a [`UserChannelId`] allowing to locally keep track of the channel.
+	///
+	/// [`AnchorChannelsConfig::per_channel_reserve_sats`]: crate::config::AnchorChannelsConfig::per_channel_reserve_sats
+	pub fn open_announced_channel_with_all(
+		&self, node_id: PublicKey, address: SocketAddress, push_to_counterparty_msat: Option<u64>,
+		channel_config: Option<ChannelConfig>,
+	) -> Result<UserChannelId, Error> {
+		if let Err(err) = may_announce_channel(&self.config) {
+			log_error!(self.logger, "Failed to open announced channel as the node hasn't been sufficiently configured to act as a forwarding node: {err}");
+			return Err(Error::ChannelCreationFailed);
+		}
+
+		self.open_channel_inner(
+			node_id,
+			address,
+			FundingAmount::Max,
 			push_to_counterparty_msat,
 			channel_config,
 			true,

src/wallet/mod.rs

@@ -68,6 +68,11 @@ pub(crate) enum OnchainSendAmount {
 	AllDrainingReserve,
 }
 
+pub(crate) enum FundingAmount {
+	Exact { amount_sats: u64 },
+	Max,
+}
+
 pub(crate) mod persist;
 pub(crate) mod ser;
 
@@ -634,6 +639,29 @@ impl Wallet {
 		Ok((max_amount, tmp_psbt))
 	}
 
+	/// Returns the maximum amount available for funding a channel, accounting for on-chain fees
+	/// and anchor reserves.
+	pub(crate) fn get_max_funding_amount(
+		&self, cur_anchor_reserve_sats: u64, fee_rate: FeeRate,
+	) -> Result<u64, Error> {
+		let mut locked_wallet = self.inner.lock().unwrap();
+
+		// Use a dummy P2WSH script (34 bytes) to match the size of a real funding output.
+		let dummy_p2wsh_script = ScriptBuf::new().to_p2wsh();
+
+		let (max_amount, tmp_psbt) = self.get_max_drain_amount(
+			&mut locked_wallet,
+			dummy_p2wsh_script,
+			cur_anchor_reserve_sats,
+			fee_rate,
+			None,
+		)?;
+
+		locked_wallet.cancel_tx(&tmp_psbt.unsigned_tx);
+
+		Ok(max_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

@@ -747,6 +747,38 @@ pub async fn open_channel_push_amt(
 	funding_txo_a
 }
 
+pub async fn open_channel_with_all(
+	node_a: &TestNode, node_b: &TestNode, should_announce: bool, electrsd: &ElectrsD,
+) -> OutPoint {
+	if should_announce {
+		node_a
+			.open_announced_channel_with_all(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				None,
+				None,
+			)
+			.unwrap();
+	} else {
+		node_a
+			.open_channel_with_all(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				None,
+				None,
+			)
+			.unwrap();
+	}
+	assert!(node_a.list_peers().iter().find(|c| { c.node_id == node_b.node_id() }).is_some());
+
+	let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id());
+	let funding_txo_b = expect_channel_pending_event!(node_b, node_a.node_id());
+	assert_eq!(funding_txo_a, funding_txo_b);
+	wait_for_tx(&electrsd.client, funding_txo_a.txid).await;
+
+	funding_txo_a
+}
+
 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,