Use LdkServerError for error handling in all APIs.

ldk-server-cli/src/main.rs

@@ -1,6 +1,9 @@
 use clap::{Parser, Subcommand};
 use ldk_server_client::client::LdkServerClient;
 use ldk_server_client::error::LdkServerError;
+use ldk_server_client::error::LdkServerErrorCode::{
+	AuthError, InternalError, InternalServerError, InvalidRequestError, LightningError,
+};
 use ldk_server_client::ldk_server_protos::api::{
 	Bolt11ReceiveRequest, Bolt11SendRequest, Bolt12ReceiveRequest, Bolt12SendRequest,
 	GetBalancesRequest, GetNodeInfoRequest, ListChannelsRequest, ListPaymentsRequest,
@@ -123,7 +126,8 @@ async fn main() {
 					kind: Some(bolt11_invoice_description::Kind::Hash(hash)),
 				}),
 				(Some(_), Some(_)) => {
-					handle_error(LdkServerError::InternalError(
+					handle_error(LdkServerError::new(
+						InternalError,
 						"Only one of description or description_hash can be set.".to_string(),
 					));
 				},
@@ -191,15 +195,22 @@ async fn main() {
 fn handle_response_result<Rs: ::prost::Message>(response: Result<Rs, LdkServerError>) {
 	match response {
 		Ok(response) => {
-			println!("{:?}", response);
+			println!("Success: {:?}", response);
 		},
 		Err(e) => {
 			handle_error(e);
 		},
-	};
+	}
 }
 
 fn handle_error(e: LdkServerError) -> ! {
-	eprintln!("Error executing command: {:?}", e);
+	let error_type = match e.error_code {
+		InvalidRequestError => "Invalid Request",
+		AuthError => "Authentication Error",
+		LightningError => "Lightning Error",
+		InternalServerError => "Internal Server Error",
+		InternalError => "Internal Error",
+	};
+	eprintln!("Error ({}): {}", error_type, e.message);
 	std::process::exit(1); // Exit with status code 1 on error.
 }

ldk-server-client/src/client.rs

@@ -1,6 +1,9 @@
 use prost::Message;
 
 use crate::error::LdkServerError;
+use crate::error::LdkServerErrorCode::{
+	AuthError, InternalError, InternalServerError, InvalidRequestError, LightningError,
+};
 use ldk_server_protos::api::{
 	Bolt11ReceiveRequest, Bolt11ReceiveResponse, Bolt11SendRequest, Bolt11SendResponse,
 	Bolt12ReceiveRequest, Bolt12ReceiveResponse, Bolt12SendRequest, Bolt12SendResponse,
@@ -9,6 +12,7 @@ use ldk_server_protos::api::{
 	ListPaymentsRequest, ListPaymentsResponse, OnchainReceiveRequest, OnchainReceiveResponse,
 	OnchainSendRequest, OnchainSendResponse, OpenChannelRequest, OpenChannelResponse,
 };
+use ldk_server_protos::error::{ErrorCode, ErrorResponse};
 use reqwest::header::CONTENT_TYPE;
 use reqwest::Client;
 
@@ -152,27 +156,46 @@ impl LdkServerClient {
 		&self, request: &Rq, url: &str,
 	) -> Result<Rs, LdkServerError> {
 		let request_body = request.encode_to_vec();
-		let response_raw = match self
+		let response_raw = self
 			.client
 			.post(url)
 			.header(CONTENT_TYPE, APPLICATION_OCTET_STREAM)
 			.body(request_body)
 			.send()
 			.await
-		{
-			Ok(response) => response,
-			Err(e) => {
-				return Err(LdkServerError::InternalError(e.to_string()));
-			},
-		};
+			.map_err(|e| {
+				LdkServerError::new(InternalError, format!("HTTP request failed: {}", e))
+			})?;
+
 		let status = response_raw.status();
-		let payload = response_raw.bytes().await?;
+		let payload = response_raw.bytes().await.map_err(|e| {
+			LdkServerError::new(InternalError, format!("Failed to read response body: {}", e))
+		})?;
 
 		if status.is_success() {
-			Ok(Rs::decode(&payload[..])?)
+			Ok(Rs::decode(&payload[..]).map_err(|e| {
+				LdkServerError::new(
+					InternalError,
+					format!("Failed to decode success response: {}", e),
+				)
+			})?)
 		} else {
-			//TODO: Error handling and error response parsing.
-			Err(LdkServerError::InternalError("Unknown Error".to_string()))
+			let error_response = ErrorResponse::decode(&payload[..]).map_err(|e| {
+				LdkServerError::new(
+					InternalError,
+					format!("Failed to decode error response (status {}): {}", status, e),
+				)
+			})?;
+
+			let error_code = match ErrorCode::from_i32(error_response.error_code) {
+				Some(ErrorCode::InvalidRequestError) => InvalidRequestError,
+				Some(ErrorCode::AuthError) => AuthError,
+				Some(ErrorCode::LightningError) => LightningError,
+				Some(ErrorCode::InternalServerError) => InternalServerError,
+				Some(ErrorCode::UnknownError) | None => InternalError,
+			};
+
+			Err(LdkServerError::new(error_code, error_response.message))
 		}
 	}
 }

ldk-server-client/src/error.rs

@@ -1,20 +1,62 @@
-use prost::DecodeError;
+use std::fmt;
 
-/// When there is an error in request to LDK Server, the response contains a relevant error code.
-#[derive(Debug)]
-pub enum LdkServerError {
-	/// There is an unknown error. (Placeholder until error handling is done.)
-	InternalError(String),
+/// Represents an error returned by the LDK server.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LdkServerError {
+	/// The error message containing a generic description of the error condition in English.
+	/// It is intended for a human audience only and should not be parsed to extract any information
+	/// programmatically. Client-side code may use it for logging only.
+	pub message: String,
+
+	/// The error code uniquely identifying an error condition.
+	/// It is meant to be read and understood programmatically by code that detects/handles errors by
+	/// type.
+	pub error_code: LdkServerErrorCode,
+}
+
+impl LdkServerError {
+	/// Creates a new [`LdkServerError`] with the given error code and message.
+	pub fn new(error_code: LdkServerErrorCode, message: impl Into<String>) -> Self {
+		Self { error_code, message: message.into() }
+	}
 }
 
-impl From<DecodeError> for LdkServerError {
-	fn from(err: DecodeError) -> Self {
-		LdkServerError::InternalError(err.to_string())
+impl std::error::Error for LdkServerError {}
+
+impl fmt::Display for LdkServerError {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "Error: [{}]: {}", self.error_code, self.message)
 	}
 }
 
-impl From<reqwest::Error> for LdkServerError {
-	fn from(err: reqwest::Error) -> Self {
-		LdkServerError::InternalError(err.to_string())
+/// Defines error codes for categorizing LDK server errors.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum LdkServerErrorCode {
+	/// Please refer to [`ldk_server_protos::error::ErrorCode::InvalidRequestError`].
+	InvalidRequestError,
+
+	/// Please refer to [`ldk_server_protos::error::ErrorCode::AuthError`].
+	AuthError,
+
+	/// Please refer to [`ldk_server_protos::error::ErrorCode::LightningError`].
+	LightningError,
+
+	/// Please refer to [`ldk_server_protos::error::ErrorCode::InternalServerError`].
+	InternalServerError,
+
+	/// There is an unknown error, it could be a client-side bug, unrecognized error-code, network error
+	/// or something else.
+	InternalError,
+}
+
+impl fmt::Display for LdkServerErrorCode {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			LdkServerErrorCode::InvalidRequestError => write!(f, "InvalidRequestError"),
+			LdkServerErrorCode::AuthError => write!(f, "AuthError"),
+			LdkServerErrorCode::LightningError => write!(f, "LightningError"),
+			LdkServerErrorCode::InternalServerError => write!(f, "InternalServerError"),
+			LdkServerErrorCode::InternalError => write!(f, "InternalError"),
+		}
 	}
 }

ldk-server/src/api/bolt11_receive.rs

@@ -1,3 +1,4 @@
+use crate::api::error::LdkServerError;
 use crate::service::Context;
 use crate::util::proto_adapter::proto_to_bolt11_description;
 use ldk_server_protos::api::{Bolt11ReceiveRequest, Bolt11ReceiveResponse};
@@ -6,7 +7,7 @@ pub(crate) const BOLT11_RECEIVE_PATH: &str = "Bolt11Receive";
 
 pub(crate) fn handle_bolt11_receive_request(
 	context: Context, request: Bolt11ReceiveRequest,
-) -> Result<Bolt11ReceiveResponse, ldk_node::NodeError> {
+) -> Result<Bolt11ReceiveResponse, LdkServerError> {
 	let description = proto_to_bolt11_description(request.description)?;
 	let invoice = match request.amount_msat {
 		Some(amount_msat) => {

ldk-server/src/api/bolt11_send.rs

@@ -1,3 +1,4 @@
+use crate::api::error::LdkServerError;
 use crate::service::Context;
 use bytes::Bytes;
 use ldk_node::lightning_invoice::Bolt11Invoice;
@@ -8,7 +9,7 @@ pub(crate) const BOLT11_SEND_PATH: &str = "Bolt11Send";
 
 pub(crate) fn handle_bolt11_send_request(
 	context: Context, request: Bolt11SendRequest,
-) -> Result<Bolt11SendResponse, ldk_node::NodeError> {
+) -> Result<Bolt11SendResponse, LdkServerError> {
 	let invoice = Bolt11Invoice::from_str(&request.invoice.as_str())
 		.map_err(|_| ldk_node::NodeError::InvalidInvoice)?;
 

ldk-server/src/api/bolt12_receive.rs

@@ -1,11 +1,12 @@
+use crate::api::error::LdkServerError;
 use crate::service::Context;
 use ldk_server_protos::api::{Bolt12ReceiveRequest, Bolt12ReceiveResponse};
 
 pub(crate) const BOLT12_RECEIVE_PATH: &str = "Bolt12Receive";
 
 pub(crate) fn handle_bolt12_receive_request(
 	context: Context, request: Bolt12ReceiveRequest,
-) -> Result<Bolt12ReceiveResponse, ldk_node::NodeError> {
+) -> Result<Bolt12ReceiveResponse, LdkServerError> {
 	let offer = match request.amount_msat {
 		Some(amount_msat) => context.node.bolt12_payment().receive(
 			amount_msat,

ldk-server/src/api/bolt12_send.rs

@@ -1,3 +1,4 @@
+use crate::api::error::LdkServerError;
 use crate::service::Context;
 use bytes::Bytes;
 use ldk_node::lightning::offers::offer::Offer;
@@ -8,7 +9,7 @@ pub(crate) const BOLT12_SEND_PATH: &str = "Bolt12Send";
 
 pub(crate) fn handle_bolt12_send_request(
 	context: Context, request: Bolt12SendRequest,
-) -> Result<Bolt12SendResponse, ldk_node::NodeError> {
+) -> Result<Bolt12SendResponse, LdkServerError> {
 	let offer =
 		Offer::from_str(&request.offer.as_str()).map_err(|_| ldk_node::NodeError::InvalidOffer)?;
 

ldk-server/src/api/close_channel.rs

@@ -1,3 +1,5 @@
+use crate::api::error::LdkServerError;
+use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
 use ldk_node::bitcoin::secp256k1::PublicKey;
 use ldk_node::UserChannelId;
@@ -8,13 +10,17 @@ pub(crate) const CLOSE_CHANNEL_PATH: &str = "CloseChannel";
 
 pub(crate) fn handle_close_channel_request(
 	context: Context, request: CloseChannelRequest,
-) -> Result<CloseChannelResponse, ldk_node::NodeError> {
+) -> Result<CloseChannelResponse, LdkServerError> {
 	//TODO: Should this be string?
 	let mut user_channel_id_bytes = [0u8; 16];
 	user_channel_id_bytes.copy_from_slice(&request.user_channel_id);
 	let user_channel_id = UserChannelId(u128::from_be_bytes(user_channel_id_bytes));
-	let counterparty_node_id = PublicKey::from_str(&request.counterparty_node_id)
-		.map_err(|_| ldk_node::NodeError::InvalidPublicKey)?;
+	let counterparty_node_id = PublicKey::from_str(&request.counterparty_node_id).map_err(|e| {
+		LdkServerError::new(
+			InvalidRequestError,
+			format!("Invalid counterparty node ID, error: {}", e),
+		)
+	})?;
 
 	match request.force_close {
 		Some(true) => context.node.force_close_channel(

ldk-server/src/api/error.rs

@@ -1,3 +1,7 @@
+use ldk_node::NodeError;
+use std::fmt;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct LdkServerError {
 	// The error message containing a generic description of the error condition in English.
 	// It is intended for a human audience only and should not be parsed to extract any information
@@ -10,6 +14,21 @@ pub(crate) struct LdkServerError {
 	pub(crate) error_code: LdkServerErrorCode,
 }
 
+impl LdkServerError {
+	pub(crate) fn new(error_code: LdkServerErrorCode, message: impl Into<String>) -> Self {
+		Self { error_code, message: message.into() }
+	}
+}
+
+impl std::error::Error for LdkServerError {}
+
+impl fmt::Display for LdkServerError {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "Error: [{}]: {}", self.error_code, self.message)
+	}
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum LdkServerErrorCode {
 	/// Please refer to [`protos::error::ErrorCode::InvalidRequestError`].
 	InvalidRequestError,
@@ -23,3 +42,78 @@ pub(crate) enum LdkServerErrorCode {
 	/// Please refer to [`protos::error::ErrorCode::InternalServerError`].
 	InternalServerError,
 }
+
+impl fmt::Display for LdkServerErrorCode {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			LdkServerErrorCode::InvalidRequestError => write!(f, "InvalidRequestError"),
+			LdkServerErrorCode::AuthError => write!(f, "AuthError"),
+			LdkServerErrorCode::LightningError => write!(f, "LightningError"),
+			LdkServerErrorCode::InternalServerError => write!(f, "InternalServerError"),
+		}
+	}
+}
+
+impl From<NodeError> for LdkServerError {
+	fn from(error: NodeError) -> Self {
+		let (message, error_code) = match error {
+			NodeError::InvalidAddress
+			| NodeError::InvalidSocketAddress
+			| NodeError::InvalidPublicKey
+			| NodeError::InvalidSecretKey
+			| NodeError::InvalidOfferId
+			| NodeError::InvalidNodeId
+			| NodeError::InvalidPaymentId
+			| NodeError::InvalidPaymentHash
+			| NodeError::InvalidPaymentPreimage
+			| NodeError::InvalidPaymentSecret
+			| NodeError::InvalidAmount
+			| NodeError::InvalidInvoice
+			| NodeError::InvalidOffer
+			| NodeError::InvalidRefund
+			| NodeError::InvalidChannelId
+			| NodeError::InvalidNetwork
+			| NodeError::InvalidUri
+			| NodeError::InvalidQuantity
+			| NodeError::InvalidNodeAlias
+			| NodeError::InvalidDateTime
+			| NodeError::InvalidFeeRate
+			| NodeError::UriParameterParsingFailed => {
+				(error.to_string(), LdkServerErrorCode::InvalidRequestError)
+			},
+
+			NodeError::ConnectionFailed
+			| NodeError::InvoiceCreationFailed
+			| NodeError::InvoiceRequestCreationFailed
+			| NodeError::OfferCreationFailed
+			| NodeError::RefundCreationFailed
+			| NodeError::PaymentSendingFailed
+			| NodeError::InvalidCustomTlvs
+			| NodeError::ProbeSendingFailed
+			| NodeError::ChannelCreationFailed
+			| NodeError::ChannelClosingFailed
+			| NodeError::ChannelConfigUpdateFailed
+			| NodeError::DuplicatePayment
+			| NodeError::InsufficientFunds
+			| NodeError::UnsupportedCurrency
+			| NodeError::LiquidityFeeTooHigh => (error.to_string(), LdkServerErrorCode::LightningError),
+
+			NodeError::AlreadyRunning
+			| NodeError::NotRunning
+			| NodeError::PersistenceFailed
+			| NodeError::FeerateEstimationUpdateFailed
+			| NodeError::FeerateEstimationUpdateTimeout
+			| NodeError::WalletOperationFailed
+			| NodeError::WalletOperationTimeout
+			| NodeError::GossipUpdateFailed
+			| NodeError::GossipUpdateTimeout
+			| NodeError::LiquiditySourceUnavailable
+			| NodeError::LiquidityRequestFailed
+			| NodeError::OnchainTxCreationFailed
+			| NodeError::OnchainTxSigningFailed
+			| NodeError::TxSyncFailed
+			| NodeError::TxSyncTimeout => (error.to_string(), LdkServerErrorCode::InternalServerError),
+		};
+		LdkServerError::new(error_code, message)
+	}
+}