Expose with-all channel funding variants

Accept "all" in the CLI and MCP funding amount fields for channel
opening and splice-in. Represent each choice in a typed protobuf
oneof.

Dispatch announced, unannounced, and zero-reserve channel opens and
splice-in to the corresponding ldk-node with-all methods.

AI-assisted-by: OpenAI Codex

Author: tankyleo

e2e-tests/src/lib.rs

@@ -18,7 +18,8 @@ use hex_conservative::DisplayHex;
 use ldk_server_client::client::LdkServerClient;
 use ldk_server_client::ldk_server_grpc::api::{GetNodeInfoRequest, GetNodeInfoResponse};
 use ldk_server_grpc::api::{
-	GetBalancesRequest, ListChannelsRequest, OnchainReceiveRequest, OpenChannelRequest,
+	open_channel_request, GetBalancesRequest, ListChannelsRequest, OnchainReceiveRequest,
+	OpenChannelRequest,
 };
 use serde_json::Value;
 
@@ -737,7 +738,9 @@ pub async fn setup_funded_channel(
 		.open_channel(OpenChannelRequest {
 			node_pubkey: server_b.node_id().to_string(),
 			address: format!("127.0.0.1:{}", server_b.p2p_port),
-			channel_amount_sats,
+			amount: Some(open_channel_request::Amount::ChannelAmountSats(
+				channel_amount_sats,
+			)),
 			push_to_counterparty_msat: None,
 			channel_config: None,
 			announce_channel: true,

e2e-tests/tests/e2e.rs

@@ -23,8 +23,8 @@ use ldk_node::lightning::offers::offer::Offer;
 use ldk_node::lightning_invoice::Bolt11Invoice;
 use ldk_server_client::client::EventStream;
 use ldk_server_client::ldk_server_grpc::api::{
-	Bolt11ReceiveRequest, Bolt12ReceiveRequest, GetBalancesRequest, OnchainReceiveRequest,
-	OpenChannelRequest,
+	open_channel_request, Bolt11ReceiveRequest, Bolt12ReceiveRequest, GetBalancesRequest,
+	OnchainReceiveRequest, OpenChannelRequest,
 };
 use ldk_server_client::ldk_server_grpc::events::event_envelope::Event;
 use ldk_server_client::ldk_server_grpc::events::{
@@ -435,8 +435,7 @@ async fn test_cli_list_peers() {
 
 // === CLI tests: Group 4 — Two-node with channel ===
 
-#[tokio::test]
-async fn test_cli_open_channel() {
+async fn open_channel_via_cli(channel_amount: &str) {
 	let bitcoind = TestBitcoind::new();
 	let server_a = LdkServerHandle::start(&bitcoind).await;
 	let server_b = LdkServerHandle::start(&bitcoind).await;
@@ -454,11 +453,27 @@ async fn test_cli_open_channel() {
 	let addr = format!("127.0.0.1:{}", server_b.p2p_port);
 	let output = run_cli(
 		&server_a,
-		&["open-channel", server_b.node_id(), &addr, "100000sat", "--announce-channel"],
+		&[
+			"open-channel",
+			server_b.node_id(),
+			&addr,
+			channel_amount,
+			"--announce-channel",
+		],
 	);
 	assert!(!output["user_channel_id"].as_str().unwrap().is_empty());
 }
 
+#[tokio::test]
+async fn test_cli_open_channel() {
+	open_channel_via_cli("100000sat").await;
+}
+
+#[tokio::test]
+async fn test_cli_open_channel_with_all() {
+	open_channel_via_cli("all").await;
+}
+
 #[tokio::test]
 async fn test_subscribe_events_channel_state_lifecycle_pending_ready_closed() {
 	let bitcoind = TestBitcoind::new();
@@ -481,7 +496,9 @@ async fn test_subscribe_events_channel_state_lifecycle_pending_ready_closed() {
 		.open_channel(OpenChannelRequest {
 			node_pubkey: server_b.node_id().to_string(),
 			address: format!("127.0.0.1:{}", server_b.p2p_port),
-			channel_amount_sats: 100_000,
+			amount: Some(open_channel_request::Amount::ChannelAmountSats(
+				100_000,
+			)),
 			push_to_counterparty_msat: None,
 			channel_config: None,
 			announce_channel: true,
@@ -645,7 +662,9 @@ async fn test_subscribe_events_channel_state_lifecycle_pending_ready_force_close
 		.open_channel(OpenChannelRequest {
 			node_pubkey: server_b.node_id().to_string(),
 			address: format!("127.0.0.1:{}", server_b.p2p_port),
-			channel_amount_sats: 100_000,
+			amount: Some(open_channel_request::Amount::ChannelAmountSats(
+				100_000,
+			)),
 			push_to_counterparty_msat: None,
 			channel_config: None,
 			announce_channel: true,
@@ -1119,18 +1138,29 @@ async fn test_cli_force_close_channel() {
 	assert!(channels_output["channels"].as_array().unwrap().is_empty());
 }
 
-#[tokio::test]
-async fn test_cli_splice_in() {
+async fn splice_in_via_cli(splice_amount: &str) {
 	let bitcoind = TestBitcoind::new();
 	let server_a = LdkServerHandle::start(&bitcoind).await;
 	let server_b = LdkServerHandle::start(&bitcoind).await;
 	let user_channel_id = setup_funded_channel(&bitcoind, &server_a, &server_b, 100_000).await;
 
-	let output =
-		run_cli(&server_a, &["splice-in", &user_channel_id, server_b.node_id(), "50000sat"]);
+	let output = run_cli(
+		&server_a,
+		&["splice-in", &user_channel_id, server_b.node_id(), splice_amount],
+	);
 	assert!(output.is_object());
 }
 
+#[tokio::test]
+async fn test_cli_splice_in() {
+	splice_in_via_cli("50000sat").await;
+}
+
+#[tokio::test]
+async fn test_cli_splice_in_with_all() {
+	splice_in_via_cli("all").await;
+}
+
 #[tokio::test]
 async fn test_cli_splice_out() {
 	let bitcoind = TestBitcoind::new();

ldk-server-cli/src/main.rs

@@ -23,9 +23,10 @@ use ldk_server_client::error::LdkServerErrorCode::{
 	AuthError, InternalError, InternalServerError, InvalidRequestError, LightningError,
 };
 use ldk_server_client::ldk_server_grpc::api::{
-	Bolt11ClaimForHashRequest, Bolt11ClaimForHashResponse, Bolt11FailForHashRequest,
-	Bolt11FailForHashResponse, Bolt11ReceiveForHashRequest, Bolt11ReceiveForHashResponse,
-	Bolt11ReceiveRequest, Bolt11ReceiveResponse, Bolt11ReceiveVariableAmountViaJitChannelRequest,
+	open_channel_request, splice_in_request, AllFunds, Bolt11ClaimForHashRequest,
+	Bolt11ClaimForHashResponse, Bolt11FailForHashRequest, Bolt11FailForHashResponse,
+	Bolt11ReceiveForHashRequest, Bolt11ReceiveForHashResponse, Bolt11ReceiveRequest,
+	Bolt11ReceiveResponse, Bolt11ReceiveVariableAmountViaJitChannelRequest,
 	Bolt11ReceiveVariableAmountViaJitChannelResponse, Bolt11ReceiveViaJitChannelRequest,
 	Bolt11ReceiveViaJitChannelResponse, Bolt11SendRequest, Bolt11SendResponse,
 	Bolt11SendUnderpayingRequest, Bolt11SendUnderpayingResponse, Bolt12ReceiveRequest,
@@ -56,8 +57,8 @@ use ldk_server_client::{
 use serde::Serialize;
 use serde_json::{json, Value};
 use types::{
-	Amount, CliListForwardedPaymentsResponse, CliListPaymentsResponse, CliPaginatedResponse,
-	Preimage,
+	Amount, AmountOrAll, CliListForwardedPaymentsResponse, CliListPaymentsResponse,
+	CliPaginatedResponse, Preimage,
 };
 
 mod types;
@@ -419,9 +420,9 @@ enum Commands {
 		)]
 		address: String,
 		#[arg(
-			help = "The amount to commit to the channel, e.g. 100sat or 100000msat, must be a whole sat amount, cannot send msats on-chain."
+			help = "The amount to commit to the channel, e.g. 100sat or 100000msat, or 'all' to use all available on-chain funds. Exact amounts must be a whole sat amount."
 		)]
-		channel_amount: Amount,
+		channel_amount: AmountOrAll,
 		#[arg(long, help = "Amount to push to the remote side, e.g. 50sat or 50000msat")]
 		push_to_counterparty: Option<Amount>,
 		#[arg(long, help = "Whether the channel should be public")]
@@ -457,9 +458,9 @@ enum Commands {
 		#[arg(help = "The hex-encoded public key of the channel's counterparty node")]
 		counterparty_node_id: String,
 		#[arg(
-			help = "The amount to splice into the channel, e.g. 50sat or 50000msat, must be a whole sat amount, cannot send msats on-chain."
+			help = "The amount to splice into the channel, e.g. 50sat or 50000msat, or 'all' to use all available on-chain funds. Exact amounts must be a whole sat amount."
 		)]
-		splice_amount: Amount,
+		splice_amount: AmountOrAll,
 	},
 	#[command(about = "Decrease the channel balance by the given amount")]
 	SpliceOut {
@@ -983,8 +984,10 @@ async fn main() {
 			forwarding_fee_base_msat,
 			cltv_expiry_delta,
 		} => {
-			let channel_amount_sats =
-				channel_amount.to_sat().unwrap_or_else(|e| handle_error_msg(e));
+			let amount = match channel_amount.to_sat().unwrap_or_else(|e| handle_error_msg(e)) {
+				Some(amount_sats) => open_channel_request::Amount::ChannelAmountSats(amount_sats),
+				None => open_channel_request::Amount::AllFunds(AllFunds {}),
+			};
 			let push_to_counterparty_msat = push_to_counterparty.map(|a| a.to_msat());
 			let channel_config = build_open_channel_config(
 				forwarding_fee_proportional_millionths,
@@ -1003,7 +1006,7 @@ async fn main() {
 					.open_channel(OpenChannelRequest {
 						node_pubkey,
 						address,
-						channel_amount_sats,
+						amount: Some(amount),
 						push_to_counterparty_msat,
 						channel_config,
 						announce_channel,
@@ -1013,13 +1016,16 @@ async fn main() {
 			);
 		},
 		Commands::SpliceIn { user_channel_id, counterparty_node_id, splice_amount } => {
-			let splice_amount_sats = splice_amount.to_sat().unwrap_or_else(|e| handle_error_msg(e));
+			let amount = match splice_amount.to_sat().unwrap_or_else(|e| handle_error_msg(e)) {
+				Some(amount_sats) => splice_in_request::Amount::SpliceAmountSats(amount_sats),
+				None => splice_in_request::Amount::AllFunds(AllFunds {}),
+			};
 			handle_response_result::<_, SpliceInResponse>(
 				client
 					.splice_in(SpliceInRequest {
 						user_channel_id,
 						counterparty_node_id,
-						splice_amount_sats,
+						amount: Some(amount),
 					})
 					.await,
 			);

ldk-server-cli/src/types.rs

@@ -120,6 +120,35 @@ impl FromStr for Amount {
 	}
 }
 
+/// An exact on-chain amount or all available on-chain funds.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AmountOrAll {
+	Exact(Amount),
+	All,
+}
+
+impl AmountOrAll {
+	/// Returns the exact amount in satoshis, or `None` when all funds should be used.
+	pub fn to_sat(self) -> Result<Option<u64>, String> {
+		match self {
+			Self::Exact(amount) => amount.to_sat().map(Some),
+			Self::All => Ok(None),
+		}
+	}
+}
+
+impl FromStr for AmountOrAll {
+	type Err = String;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		if s.trim() == "all" {
+			Ok(Self::All)
+		} else {
+			Amount::from_str(s).map(Self::Exact)
+		}
+	}
+}
+
 /// A validated 32-byte payment preimage, parsed from a 64-character hex string.
 #[derive(Debug, Clone)]
 pub struct Preimage(pub [u8; 32]);
@@ -207,6 +236,14 @@ mod tests {
 		assert!(Amount::from_str(&big).is_err());
 	}
 
+	#[test]
+	fn amount_or_all_parses_exact_amount_or_all() {
+		assert_eq!(AmountOrAll::from_str("all").unwrap(), AmountOrAll::All);
+		assert_eq!(AmountOrAll::from_str(" all ").unwrap(), AmountOrAll::All);
+		assert_eq!(AmountOrAll::from_str("100sat").unwrap().to_sat().unwrap(), Some(100));
+		assert_eq!(AmountOrAll::All.to_sat().unwrap(), None);
+	}
+
 	#[test]
 	fn preimage_parsing_and_roundtrip() {
 		// valid 64-char hex string

ldk-server-grpc/src/api.rs

@@ -521,6 +521,13 @@ pub struct SpontaneousSendResponse {
 	#[prost(string, tag = "1")]
 	pub payment_id: ::prost::alloc::string::String,
 }
+/// Selects all available on-chain funds.
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[cfg_attr(feature = "serde", serde(default))]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AllFunds {}
 /// Creates a new outbound channel to the given remote node.
 /// See more: <https://docs.rs/ldk-node/latest/ldk_node/struct.Node.html#method.connect_open_channel>
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -536,9 +543,6 @@ pub struct OpenChannelRequest {
 	/// It can be of type IPv4:port, IPv6:port, OnionV3:port or hostname:port
 	#[prost(string, tag = "2")]
 	pub address: ::prost::alloc::string::String,
-	/// The amount of satoshis the caller is willing to commit to the channel.
-	#[prost(uint64, tag = "3")]
-	pub channel_amount_sats: u64,
 	/// The amount of satoshis to push to the remote side as part of the initial commitment state.
 	#[prost(uint64, optional, tag = "4")]
 	pub push_to_counterparty_msat: ::core::option::Option<u64>,
@@ -551,6 +555,25 @@ pub struct OpenChannelRequest {
 	/// Allow the counterparty to spend all its channel balance. This cannot be set together with `announce_channel`.
 	#[prost(bool, tag = "7")]
 	pub disable_counterparty_reserve: bool,
+	/// Required. The funds to commit to the channel.
+	#[prost(oneof = "open_channel_request::Amount", tags = "3, 8")]
+	pub amount: ::core::option::Option<open_channel_request::Amount>,
+}
+/// Nested message and enum types in `OpenChannelRequest`.
+pub mod open_channel_request {
+	/// Required. The funds to commit to the channel.
+	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+	#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+	#[allow(clippy::derive_partial_eq_without_eq)]
+	#[derive(Clone, PartialEq, ::prost::Oneof)]
+	pub enum Amount {
+		/// Commit the given amount of satoshis.
+		#[prost(uint64, tag = "3")]
+		ChannelAmountSats(u64),
+		/// Commit all available on-chain funds, minus fees and anchor reserves.
+		#[prost(message, tag = "8")]
+		AllFunds(super::AllFunds),
+	}
 }
 /// The response for the `OpenChannel` RPC. On failure, a gRPC error status is returned.
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -577,9 +600,25 @@ pub struct SpliceInRequest {
 	/// The hex-encoded public key of the channel's counterparty node.
 	#[prost(string, tag = "2")]
 	pub counterparty_node_id: ::prost::alloc::string::String,
-	/// The amount of sats to splice into the channel.
-	#[prost(uint64, tag = "3")]
-	pub splice_amount_sats: u64,
+	/// Required. The funds to splice into the channel.
+	#[prost(oneof = "splice_in_request::Amount", tags = "3, 4")]
+	pub amount: ::core::option::Option<splice_in_request::Amount>,
+}
+/// Nested message and enum types in `SpliceInRequest`.
+pub mod splice_in_request {
+	/// Required. The funds to splice into the channel.
+	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+	#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+	#[allow(clippy::derive_partial_eq_without_eq)]
+	#[derive(Clone, PartialEq, ::prost::Oneof)]
+	pub enum Amount {
+		/// Splice in the given amount of satoshis.
+		#[prost(uint64, tag = "3")]
+		SpliceAmountSats(u64),
+		/// Splice in all available confirmed on-chain funds.
+		#[prost(message, tag = "4")]
+		AllFunds(super::AllFunds),
+	}
 }
 /// The response for the `SpliceIn` RPC. On failure, a gRPC error status is returned.
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

ldk-server-grpc/src/proto/api.proto

@@ -408,6 +408,9 @@ message SpontaneousSendResponse {
   string payment_id = 1;
 }
 
+// Selects all available on-chain funds.
+message AllFunds {}
+
 // Creates a new outbound channel to the given remote node.
 // See more: https://docs.rs/ldk-node/latest/ldk_node/struct.Node.html#method.connect_open_channel
 message OpenChannelRequest {
@@ -419,8 +422,14 @@ message OpenChannelRequest {
   // It can be of type IPv4:port, IPv6:port, OnionV3:port or hostname:port
   string address = 2;
 
-  // The amount of satoshis the caller is willing to commit to the channel.
-  uint64 channel_amount_sats = 3;
+  // Required. The funds to commit to the channel.
+  oneof amount {
+    // Commit the given amount of satoshis.
+    uint64 channel_amount_sats = 3;
+
+    // Commit all available on-chain funds, minus fees and anchor reserves.
+    AllFunds all_funds = 8;
+  }
 
   // The amount of satoshis to push to the remote side as part of the initial commitment state.
   optional uint64 push_to_counterparty_msat = 4;
@@ -452,8 +461,14 @@ message SpliceInRequest {
   // The hex-encoded public key of the channel's counterparty node.
   string counterparty_node_id = 2;
 
-  // The amount of sats to splice into the channel.
-  uint64 splice_amount_sats = 3;
+  // Required. The funds to splice into the channel.
+  oneof amount {
+    // Splice in the given amount of satoshis.
+    uint64 splice_amount_sats = 3;
+
+    // Splice in all available confirmed on-chain funds.
+    AllFunds all_funds = 4;
+  }
 }
 
 // The response for the `SpliceIn` RPC. On failure, a gRPC error status is returned.