Rework on-chain send amounts

Replace the send-all boolean with the typed exact-or-all protobuf
oneof used by channel funding. Accept "all" as the positional CLI and
MCP amount while preserving exact sends.

AI-assisted-by: OpenAI Codex

Author: tankyleo

e2e-tests/tests/e2e.rs

@@ -376,7 +376,7 @@ async fn test_cli_onchain_send_all() {
 	let balances_before = server.client().get_balances(GetBalancesRequest {}).await.unwrap();
 
 	let address = bitcoind.bitcoind.client.new_address().unwrap().to_string();
-	let output = run_cli(&server, &["onchain-send", &address, "--send-all", "true"]);
+	let output = run_cli(&server, &["onchain-send", &address, "all"]);
 	assert!(!output["txid"].as_str().unwrap().is_empty());
 
 	mine_and_sync(&bitcoind, &[&server], 6).await;

ldk-server-cli/src/main.rs

@@ -23,10 +23,10 @@ use ldk_server_client::error::LdkServerErrorCode::{
 	AuthError, InternalError, InternalServerError, InvalidRequestError, LightningError,
 };
 use ldk_server_client::ldk_server_grpc::api::{
-	open_channel_request, splice_in_request, AllFunds, Bolt11ClaimForHashRequest,
-	Bolt11ClaimForHashResponse, Bolt11FailForHashRequest, Bolt11FailForHashResponse,
-	Bolt11ReceiveForHashRequest, Bolt11ReceiveForHashResponse, Bolt11ReceiveRequest,
-	Bolt11ReceiveResponse, Bolt11ReceiveVariableAmountViaJitChannelRequest,
+	onchain_send_request, open_channel_request, splice_in_request, AllFunds,
+	Bolt11ClaimForHashRequest, Bolt11ClaimForHashResponse, Bolt11FailForHashRequest,
+	Bolt11FailForHashResponse, Bolt11ReceiveForHashRequest, Bolt11ReceiveForHashResponse,
+	Bolt11ReceiveRequest, Bolt11ReceiveResponse, Bolt11ReceiveVariableAmountViaJitChannelRequest,
 	Bolt11ReceiveVariableAmountViaJitChannelResponse, Bolt11ReceiveViaJitChannelRequest,
 	Bolt11ReceiveViaJitChannelResponse, Bolt11SendRequest, Bolt11SendResponse,
 	Bolt11SendUnderpayingRequest, Bolt11SendUnderpayingResponse, Bolt12ReceiveRequest,
@@ -116,14 +116,9 @@ enum Commands {
 		#[arg(help = "The address to send coins to")]
 		address: String,
 		#[arg(
-			help = "The amount to send, e.g. 50sat or 50000msat, must be a whole sat amount, cannot send msats on-chain. Will respect any on-chain reserve needed for anchor channels"
+			help = "The amount to send, e.g. 50sat or 50000msat, or 'all' to use all available on-chain funds. Exact amounts must be a whole sat amount. Will respect any on-chain reserve needed for anchor channels"
 		)]
-		amount: Option<Amount>,
-		#[arg(
-			long,
-			help = "Send all available balance to the address while retaining on-chain reserves for anchor channels"
-		)]
-		send_all: Option<bool>,
+		amount: AmountOrAll,
 		#[arg(
 			long,
 			help = "Fee rate in satoshis per virtual byte. If not set, a reasonable estimate will be used"
@@ -661,15 +656,17 @@ async fn main() {
 				client.onchain_receive(OnchainReceiveRequest {}).await,
 			);
 		},
-		Commands::OnchainSend { address, amount, send_all, fee_rate_sat_per_vb } => {
-			let amount_sats = amount.map(|a| a.to_sat().unwrap_or_else(|e| handle_error_msg(e)));
+		Commands::OnchainSend { address, amount, fee_rate_sat_per_vb } => {
+			let amount = match amount.to_sat().unwrap_or_else(|e| handle_error_msg(e)) {
+				Some(amount_sats) => onchain_send_request::Amount::AmountSats(amount_sats),
+				None => onchain_send_request::Amount::AllFunds(AllFunds {}),
+			};
 			handle_response_result::<_, OnchainSendResponse>(
 				client
 					.onchain_send(OnchainSendRequest {
 						address,
-						amount_sats,
-						send_all,
 						fee_rate_sat_per_vb,
+						amount: Some(amount),
 					})
 					.await,
 			);

ldk-server-grpc/src/api.rs

@@ -109,6 +109,7 @@ pub struct OnchainReceiveResponse {
 	pub address: ::prost::alloc::string::String,
 }
 /// Send an on-chain payment to the given address.
+/// See more: <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.OnchainPayment.html#method.send_to_address>
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 #[cfg_attr(feature = "serde", serde(default))]
@@ -118,23 +119,29 @@ pub struct OnchainSendRequest {
 	/// The address to send coins to.
 	#[prost(string, tag = "1")]
 	pub address: ::prost::alloc::string::String,
-	/// The amount in satoshis to send.
-	/// While sending the specified amount, we will respect any on-chain reserve we need to keep,
-	/// i.e., won't allow to cut into `total_anchor_channels_reserve_sats`.
-	/// See more: <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.OnchainPayment.html#method.send_to_address>
-	#[prost(uint64, optional, tag = "2")]
-	pub amount_sats: ::core::option::Option<u64>,
-	/// If set, the amount_sats field should be unset.
-	/// It indicates that the node will send all available balance to the specified address.
-	///
-	/// Any on-chain reserves needed for Anchor channels will be retained.
-	/// See more: <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.OnchainPayment.html#method.send_all_to_address>
-	#[prost(bool, optional, tag = "3")]
-	pub send_all: ::core::option::Option<bool>,
 	/// If `fee_rate_sat_per_vb` is set it will be used on the resulting transaction. Otherwise we'll retrieve
 	/// a reasonable estimate from BitcoinD.
 	#[prost(uint64, optional, tag = "4")]
 	pub fee_rate_sat_per_vb: ::core::option::Option<u64>,
+	/// Required. The amount to send.
+	#[prost(oneof = "onchain_send_request::Amount", tags = "2, 3")]
+	pub amount: ::core::option::Option<onchain_send_request::Amount>,
+}
+/// Nested message and enum types in `OnchainSendRequest`.
+pub mod onchain_send_request {
+	/// Required. The amount to send.
+	#[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 {
+		/// Send the given amount of satoshis while retaining any required Anchor channel reserves.
+		#[prost(uint64, tag = "2")]
+		AmountSats(u64),
+		/// Send all available on-chain funds, minus fees and any required Anchor channel reserves.
+		#[prost(message, tag = "3")]
+		AllFunds(super::AllFunds),
+	}
 }
 /// The response for the `OnchainSend` 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

@@ -91,23 +91,20 @@ message OnchainReceiveResponse {
 }
 
 // Send an on-chain payment to the given address.
+// See more: https://docs.rs/ldk-node/latest/ldk_node/payment/struct.OnchainPayment.html#method.send_to_address
 message OnchainSendRequest {
 
   // The address to send coins to.
   string address = 1;
 
-  // The amount in satoshis to send.
-  // While sending the specified amount, we will respect any on-chain reserve we need to keep,
-  // i.e., won't allow to cut into `total_anchor_channels_reserve_sats`.
-  // See more: https://docs.rs/ldk-node/latest/ldk_node/payment/struct.OnchainPayment.html#method.send_to_address
-  optional uint64 amount_sats = 2;
+  // Required. The amount to send.
+  oneof amount {
+    // Send the given amount of satoshis while retaining any required Anchor channel reserves.
+    uint64 amount_sats = 2;
 
-  // If set, the amount_sats field should be unset.
-  // It indicates that the node will send all available balance to the specified address.
-  //
-  // Any on-chain reserves needed for Anchor channels will be retained.
-  // See more: https://docs.rs/ldk-node/latest/ldk_node/payment/struct.OnchainPayment.html#method.send_all_to_address
-  optional bool send_all = 3;
+    // Send all available on-chain funds, minus fees and any required Anchor channel reserves.
+    AllFunds all_funds = 3;
+  }
 
   // If `fee_rate_sat_per_vb` is set it will be used on the resulting transaction. Otherwise we'll retrieve
   // a reasonable estimate from BitcoinD.

ldk-server-mcp/src/tools/handlers.rs

@@ -142,7 +142,7 @@ pub async fn handle_onchain_receive(
 }
 
 pub async fn handle_onchain_send(client: &LdkServerClient, args: Value) -> Result<Value, McpError> {
-	let request: OnchainSendRequest = parse_request(args)?;
+	let request: OnchainSendRequest = parse_request_with_amount(args, "amount_sats")?;
 	let response = client.onchain_send(request).await.map_err(McpError::from)?;
 	serialize_response(response)
 }
@@ -449,7 +449,9 @@ pub async fn handle_graph_get_node(
 
 #[cfg(test)]
 mod tests {
-	use ldk_server_client::ldk_server_grpc::api::{open_channel_request, splice_in_request};
+	use ldk_server_client::ldk_server_grpc::api::{
+		onchain_send_request, open_channel_request, splice_in_request,
+	};
 
 	use super::*;
 
@@ -488,6 +490,20 @@ mod tests {
 		));
 	}
 
+	#[test]
+	fn parse_request_with_amount_populates_onchain_oneof() {
+		let request: OnchainSendRequest = parse_request_with_amount(
+			json!({
+				"address": "bc1qexample",
+				"amount_sats": "all"
+			}),
+			"amount_sats",
+		)
+		.unwrap();
+
+		assert!(matches!(request.amount, Some(onchain_send_request::Amount::AllFunds(_))));
+	}
+
 	#[test]
 	fn parse_request_with_route_parameters_fills_missing_defaults() {
 		let request: Bolt11SendRequest = parse_request_with_route_parameters(

ldk-server-mcp/src/tools/schema.rs

@@ -163,19 +163,18 @@ pub fn onchain_send_schema() -> Value {
 				"description": "The Bitcoin address to send coins to"
 			},
 			"amount_sats": {
-				"type": "integer",
-				"description": "The amount in satoshis to send. Respects on-chain reserve for anchor channels"
-			},
-			"send_all": {
-				"type": "boolean",
-				"description": "If true, send all available balance while retaining on-chain reserves for anchor channels (amount_sats must be unset)"
+				"oneOf": [
+					{"type": "integer"},
+					{"type": "string", "const": "all"}
+				],
+				"description": "The amount in satoshis to send, or 'all' to use all available on-chain funds. Respects on-chain reserve for anchor channels"
 			},
 			"fee_rate_sat_per_vb": {
 				"type": "integer",
 				"description": "Fee rate in satoshis per virtual byte. If not set, a reasonable estimate will be used"
 			}
 		},
-		"required": ["address"]
+		"required": ["address", "amount_sats"]
 	})
 }
 

ldk-server/src/api/onchain_send.rs

@@ -11,10 +11,12 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use ldk_node::bitcoin::{Address, FeeRate};
+use ldk_server_grpc::api::onchain_send_request::Amount;
 use ldk_server_grpc::api::{OnchainSendRequest, OnchainSendResponse};
 
 use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
+use crate::api::require_amount;
 use crate::service::Context;
 
 pub(crate) async fn handle_onchain_send_request(
@@ -31,19 +33,13 @@ pub(crate) async fn handle_onchain_send_request(
 		})?;
 
 	let fee_rate = request.fee_rate_sat_per_vb.and_then(FeeRate::from_sat_per_vb);
-	let txid = match (request.amount_sats, request.send_all) {
-		(Some(amount_sats), None) => {
+	let txid = match require_amount(request.amount)? {
+		Amount::AmountSats(amount_sats) => {
 			context.node.onchain_payment().send_to_address(&address, amount_sats, fee_rate)?
 		},
-		(None, Some(true)) => {
+		Amount::AllFunds(_) => {
 			context.node.onchain_payment().send_all_to_address(&address, true, fee_rate)?
 		},
-		_ => {
-			return Err(LdkServerError::new(
-				InvalidRequestError,
-				"Must specify either `send_all` or `amount_sats`, but not both or neither",
-			))
-		},
 	};
 	let response = OnchainSendResponse { txid: txid.to_string() };
 	Ok(response)