Account for Bolt11InvoiceDescription.

Author: G8XSU

ldk-server-cli/src/main.rs

@@ -6,6 +6,9 @@ use ldk_server_client::ldk_server_protos::api::{
 	GetBalancesRequest, GetNodeInfoRequest, ListChannelsRequest, ListPaymentsRequest,
 	OnchainReceiveRequest, OnchainSendRequest, OpenChannelRequest,
 };
+use ldk_server_client::ldk_server_protos::types::{
+	bolt11_invoice_description, Bolt11InvoiceDescription,
+};
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -32,7 +35,9 @@ enum Commands {
 	},
 	Bolt11Receive {
 		#[arg(short, long)]
-		description: String,
+		description: Option<String>,
+		#[arg(short, long)]
+		description_hash: Option<String>,
 		#[arg(short, long)]
 		expiry_secs: u32,
 		#[arg(long)]
@@ -87,31 +92,47 @@ async fn main() {
 
 	match cli.command {
 		Commands::GetNodeInfo => {
-			handle_response(client.get_node_info(GetNodeInfoRequest {}).await);
+			handle_response_result(client.get_node_info(GetNodeInfoRequest {}).await);
 		},
 		Commands::GetBalances => {
-			handle_response(client.get_balances(GetBalancesRequest {}).await);
+			handle_response_result(client.get_balances(GetBalancesRequest {}).await);
 		},
 		Commands::OnchainReceive => {
-			handle_response(client.onchain_receive(OnchainReceiveRequest {}).await);
+			handle_response_result(client.onchain_receive(OnchainReceiveRequest {}).await);
 		},
 		Commands::OnchainSend { address, amount_sats, send_all } => {
-			handle_response(
+			handle_response_result(
 				client.onchain_send(OnchainSendRequest { address, amount_sats, send_all }).await,
 			);
 		},
-		Commands::Bolt11Receive { description, expiry_secs, amount_msat } => {
-			handle_response(
-				client
-					.bolt11_receive(Bolt11ReceiveRequest { description, expiry_secs, amount_msat })
-					.await,
-			);
+		Commands::Bolt11Receive { description, description_hash, expiry_secs, amount_msat } => {
+			let invoice_description = match (description, description_hash) {
+				(Some(desc), None) => Some(Bolt11InvoiceDescription {
+					kind: Some(bolt11_invoice_description::Kind::Direct(desc)),
+				}),
+				(None, Some(hash)) => Some(Bolt11InvoiceDescription {
+					kind: Some(bolt11_invoice_description::Kind::Hash(hash)),
+				}),
+				(Some(_), Some(_)) => {
+					handle_error(LdkServerError::InternalError(
+						"Only one of description or description_hash can be set.".to_string(),
+					));
+				},
+				(None, None) => None,
+			};
+
+			let request =
+				Bolt11ReceiveRequest { description: invoice_description, expiry_secs, amount_msat };
+
+			handle_response_result(client.bolt11_receive(request).await);
 		},
 		Commands::Bolt11Send { invoice, amount_msat } => {
-			handle_response(client.bolt11_send(Bolt11SendRequest { invoice, amount_msat }).await);
+			handle_response_result(
+				client.bolt11_send(Bolt11SendRequest { invoice, amount_msat }).await,
+			);
 		},
 		Commands::Bolt12Receive { description, amount_msat, expiry_secs, quantity } => {
-			handle_response(
+			handle_response_result(
 				client
 					.bolt12_receive(Bolt12ReceiveRequest {
 						description,
@@ -123,7 +144,7 @@ async fn main() {
 			);
 		},
 		Commands::Bolt12Send { offer, amount_msat, quantity, payer_note } => {
-			handle_response(
+			handle_response_result(
 				client
 					.bolt12_send(Bolt12SendRequest { offer, amount_msat, quantity, payer_note })
 					.await,
@@ -136,7 +157,7 @@ async fn main() {
 			push_to_counterparty_msat,
 			announce_channel,
 		} => {
-			handle_response(
+			handle_response_result(
 				client
 					.open_channel(OpenChannelRequest {
 						node_pubkey,
@@ -150,22 +171,26 @@ async fn main() {
 			);
 		},
 		Commands::ListChannels => {
-			handle_response(client.list_channels(ListChannelsRequest {}).await);
+			handle_response_result(client.list_channels(ListChannelsRequest {}).await);
 		},
 		Commands::ListPayments => {
-			handle_response(client.list_payments(ListPaymentsRequest {}).await);
+			handle_response_result(client.list_payments(ListPaymentsRequest {}).await);
 		},
 	}
 }
 
-fn handle_response<Rs: ::prost::Message>(response: Result<Rs, LdkServerError>) {
+fn handle_response_result<Rs: ::prost::Message>(response: Result<Rs, LdkServerError>) {
 	match response {
 		Ok(response) => {
 			println!("{:?}", response);
 		},
 		Err(e) => {
-			eprintln!("Error executing command: {:?}", e);
-			std::process::exit(1); // Exit with status code 1 on error.
+			handle_error(e);
 		},
 	};
 }
+
+fn handle_error(e: LdkServerError) -> ! {
+	eprintln!("Error executing command: {:?}", e);
+	std::process::exit(1); // Exit with status code 1 on error.
+}

ldk-server-protos/src/api.rs

@@ -107,8 +107,8 @@ pub struct Bolt11ReceiveRequest {
 	pub amount_msat: ::core::option::Option<u64>,
 	/// An optional description to attach along with the invoice.
 	/// Will be set in the description field of the encoded payment request.
-	#[prost(string, tag = "2")]
-	pub description: ::prost::alloc::string::String,
+	#[prost(message, optional, tag = "2")]
+	pub description: ::core::option::Option<super::types::Bolt11InvoiceDescription>,
 	/// Invoice expiry time in seconds.
 	#[prost(uint32, tag = "3")]
 	pub expiry_secs: u32,

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

@@ -107,7 +107,7 @@ message Bolt11ReceiveRequest {
 
   // An optional description to attach along with the invoice.
   // Will be set in the description field of the encoded payment request.
-  string description = 2;
+  types.Bolt11InvoiceDescription description = 2;
 
   // Invoice expiry time in seconds.
   uint32 expiry_secs = 3;

ldk-server-protos/src/proto/types.proto

@@ -636,3 +636,10 @@ message PageToken {
   string token = 1;
   int64 index = 2;
 }
+
+message Bolt11InvoiceDescription {
+  oneof kind {
+    string direct = 1;
+    string hash = 2;
+  }
+}

ldk-server-protos/src/types.rs

@@ -708,6 +708,23 @@ pub struct PageToken {
 	#[prost(int64, tag = "2")]
 	pub index: i64,
 }
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Bolt11InvoiceDescription {
+	#[prost(oneof = "bolt11_invoice_description::Kind", tags = "1, 2")]
+	pub kind: ::core::option::Option<bolt11_invoice_description::Kind>,
+}
+/// Nested message and enum types in `Bolt11InvoiceDescription`.
+pub mod bolt11_invoice_description {
+	#[allow(clippy::derive_partial_eq_without_eq)]
+	#[derive(Clone, PartialEq, ::prost::Oneof)]
+	pub enum Kind {
+		#[prost(string, tag = "1")]
+		Direct(::prost::alloc::string::String),
+		#[prost(string, tag = "2")]
+		Hash(::prost::alloc::string::String),
+	}
+}
 /// Represents the direction of a payment.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]

ldk-server/src/api/bolt11_receive.rs

@@ -1,21 +1,21 @@
 use crate::service::Context;
+use crate::util::proto_adapter::proto_to_bolt11_description;
 use ldk_server_protos::api::{Bolt11ReceiveRequest, Bolt11ReceiveResponse};
 
 pub(crate) const BOLT11_RECEIVE_PATH: &str = "Bolt11Receive";
 
 pub(crate) fn handle_bolt11_receive_request(
 	context: Context, request: Bolt11ReceiveRequest,
 ) -> Result<Bolt11ReceiveResponse, ldk_node::NodeError> {
+	let description = proto_to_bolt11_description(request.description)?;
 	let invoice = match request.amount_msat {
-		Some(amount_msat) => context.node.bolt11_payment().receive(
-			amount_msat,
-			&request.description,
-			request.expiry_secs,
-		)?,
+		Some(amount_msat) => {
+			context.node.bolt11_payment().receive(amount_msat, &description, request.expiry_secs)?
+		},
 		None => context
 			.node
 			.bolt11_payment()
-			.receive_variable_amount(&request.description, request.expiry_secs)?,
+			.receive_variable_amount(&description, request.expiry_secs)?,
 	};
 
 	let response = Bolt11ReceiveResponse { invoice: invoice.to_string() };

ldk-server/src/util/proto_adapter.rs

@@ -1,10 +1,12 @@
 use bytes::Bytes;
 use hex::prelude::*;
+use ldk_node::bitcoin::hashes::sha256;
 use ldk_node::bitcoin::secp256k1::PublicKey;
 use ldk_node::config::{ChannelConfig, MaxDustHTLCExposure};
 use ldk_node::lightning::ln::types::ChannelId;
+use ldk_node::lightning_invoice::{Bolt11InvoiceDescription, Description, Sha256};
 use ldk_node::payment::{PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus};
-use ldk_node::{ChannelDetails, Event, LightningBalance, PendingSweepBalance, UserChannelId};
+use ldk_node::{ChannelDetails, LightningBalance, NodeError, PendingSweepBalance, UserChannelId};
 use ldk_server_protos::types::lightning_balance::BalanceType::{
 	ClaimableAwaitingConfirmations, ClaimableOnChannelClose, ContentiousClaimable,
 	CounterpartyRevokedOutputClaimable, MaybePreimageClaimableHtlc, MaybeTimeoutClaimableHtlc,
@@ -15,7 +17,9 @@ use ldk_server_protos::types::payment_kind::Kind::{
 use ldk_server_protos::types::pending_sweep_balance::BalanceType::{
 	AwaitingThresholdConfirmations, BroadcastAwaitingConfirmation, PendingBroadcast,
 };
-use ldk_server_protos::types::{Channel, ForwardedPayment, LspFeeLimits, OutPoint, Payment};
+use ldk_server_protos::types::{
+	bolt11_invoice_description, Channel, ForwardedPayment, LspFeeLimits, OutPoint, Payment,
+};
 
 pub(crate) fn channel_to_proto(channel: ChannelDetails) -> Channel {
 	Channel {
@@ -346,3 +350,18 @@ pub(crate) fn forwarded_payment_to_proto(
 		outbound_amount_forwarded_msat,
 	}
 }
+
+pub(crate) fn proto_to_bolt11_description(
+	description: Option<ldk_server_protos::types::Bolt11InvoiceDescription>,
+) -> Result<Bolt11InvoiceDescription, NodeError> {
+	Ok(match description.and_then(|d| d.kind) {
+		Some(bolt11_invoice_description::Kind::Direct(s)) => {
+			Bolt11InvoiceDescription::Direct(Description::new(s).unwrap())
+		},
+		Some(bolt11_invoice_description::Kind::Hash(h)) => {
+			let hash_bytes = <[u8; 32]>::from_hex(&h).map_err(|_| NodeError::InvalidInvoice)?;
+			Bolt11InvoiceDescription::Hash(Sha256(*sha256::Hash::from_bytes_ref(&hash_bytes)))
+		},
+		None => Bolt11InvoiceDescription::Direct(Description::new("".to_string()).unwrap()),
+	})
+}