Add force_close_channel API endpoint and handler

Introduce ForceCloseChannelRequest and ForceCloseChannelResponse to the API,
implement the handle_force_close_channel_request function, and register the new
endpoint in the service router.

Author: moisesPompilio

ldk-server-protos/src/api.rs

@@ -286,6 +286,26 @@ pub struct CloseChannelRequest {
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CloseChannelResponse {}
+/// Force closes the channel specified by given request.
+/// See more: <https://docs.rs/ldk-node/latest/ldk_node/struct.Node.html#method.force_close_channel>
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ForceCloseChannelRequest {
+	/// The local `user_channel_id` of this channel.
+	#[prost(string, tag = "1")]
+	pub user_channel_id: ::prost::alloc::string::String,
+	/// The hex-encoded public key of the node to close a channel with.
+	#[prost(string, tag = "2")]
+	pub counterparty_node_id: ::prost::alloc::string::String,
+	/// The reason for force-closing.
+	#[prost(string, optional, tag = "3")]
+	pub force_close_reason: ::core::option::Option<::prost::alloc::string::String>,
+}
+/// The response `content` for the `ForceCloseChannel` API, when HttpStatusCode is OK (200).
+/// When HttpStatusCode is not OK (non-200), the response `content` contains a serialized `ErrorResponse`.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ForceCloseChannelResponse {}
 /// Returns a list of known channels.
 /// See more: <https://docs.rs/ldk-node/latest/ldk_node/struct.Node.html#method.list_channels>
 #[allow(clippy::derive_partial_eq_without_eq)]

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

@@ -275,6 +275,21 @@ message CloseChannelRequest {
 // When HttpStatusCode is not OK (non-200), the response `content` contains a serialized `ErrorResponse`.
 message CloseChannelResponse {}
 
+// Force closes the channel specified by given request.
+// See more: https://docs.rs/ldk-node/latest/ldk_node/struct.Node.html#method.force_close_channel
+message ForceCloseChannelRequest {
+  // The local `user_channel_id` of this channel.
+  string user_channel_id = 1;
+  // The hex-encoded public key of the node to close a channel with.
+  string counterparty_node_id = 2;
+  // The reason for force-closing.
+  optional string force_close_reason = 3;
+}
+
+// The response `content` for the `ForceCloseChannel` API, when HttpStatusCode is OK (200).
+// When HttpStatusCode is not OK (non-200), the response `content` contains a serialized `ErrorResponse`.
+message ForceCloseChannelResponse {}
+
 // Returns a list of known channels.
 // See more: https://docs.rs/ldk-node/latest/ldk_node/struct.Node.html#method.list_channels
 message ListChannelsRequest {}

ldk-server/src/api/close_channel.rs

@@ -3,26 +3,53 @@ use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
 use ldk_node::bitcoin::secp256k1::PublicKey;
 use ldk_node::UserChannelId;
-use ldk_server_protos::api::{CloseChannelRequest, CloseChannelResponse};
+use ldk_server_protos::api::{
+	CloseChannelRequest, CloseChannelResponse, ForceCloseChannelRequest, ForceCloseChannelResponse,
+};
 use std::str::FromStr;
 
 pub(crate) const CLOSE_CHANNEL_PATH: &str = "CloseChannel";
 
 pub(crate) fn handle_close_channel_request(
 	context: Context, request: CloseChannelRequest,
 ) -> Result<CloseChannelResponse, LdkServerError> {
-	let user_channel_id =
-		UserChannelId((&request.user_channel_id).parse::<u128>().map_err(|_| {
-			LdkServerError::new(InvalidRequestError, "Invalid UserChannelId.".to_string())
-		})?);
-	let counterparty_node_id = PublicKey::from_str(&request.counterparty_node_id).map_err(|e| {
+	let user_channel_id = parse_user_channel_id(&request.user_channel_id)?;
+	let counterparty_node_id = parse_counterparty_node_id(&request.counterparty_node_id)?;
+
+	context.node.close_channel(&user_channel_id, counterparty_node_id)?;
+
+	Ok(CloseChannelResponse {})
+}
+
+pub(crate) const FORCE_CLOSE_CHANNEL_PATH: &str = "ForceCloseChannel";
+
+pub(crate) fn handle_force_close_channel_request(
+	context: Context, request: ForceCloseChannelRequest,
+) -> Result<ForceCloseChannelResponse, LdkServerError> {
+	let user_channel_id = parse_user_channel_id(&request.user_channel_id)?;
+	let counterparty_node_id = parse_counterparty_node_id(&request.counterparty_node_id)?;
+
+	context.node.force_close_channel(
+		&user_channel_id,
+		counterparty_node_id,
+		request.force_close_reason,
+	)?;
+
+	Ok(ForceCloseChannelResponse {})
+}
+
+fn parse_user_channel_id(id: &str) -> Result<UserChannelId, LdkServerError> {
+	let parsed = id.parse::<u128>().map_err(|_| {
+		LdkServerError::new(InvalidRequestError, "Invalid UserChannelId.".to_string())
+	})?;
+	Ok(UserChannelId(parsed))
+}
+
+fn parse_counterparty_node_id(id: &str) -> Result<PublicKey, LdkServerError> {
+	PublicKey::from_str(id).map_err(|e| {
 		LdkServerError::new(
 			InvalidRequestError,
 			format!("Invalid counterparty node ID, error: {}", e),
 		)
-	})?;
-	context.node.close_channel(&user_channel_id, counterparty_node_id)?;
-
-	let response = CloseChannelResponse {};
-	Ok(response)
+	})
 }

ldk-server/src/service.rs

@@ -11,7 +11,10 @@ use crate::api::bolt11_receive::{handle_bolt11_receive_request, BOLT11_RECEIVE_P
 use crate::api::bolt11_send::{handle_bolt11_send_request, BOLT11_SEND_PATH};
 use crate::api::bolt12_receive::{handle_bolt12_receive_request, BOLT12_RECEIVE_PATH};
 use crate::api::bolt12_send::{handle_bolt12_send_request, BOLT12_SEND_PATH};
-use crate::api::close_channel::{handle_close_channel_request, CLOSE_CHANNEL_PATH};
+use crate::api::close_channel::{
+	handle_close_channel_request, handle_force_close_channel_request, CLOSE_CHANNEL_PATH,
+	FORCE_CLOSE_CHANNEL_PATH,
+};
 use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::api::get_balances::{handle_get_balances_request, GET_BALANCES};
@@ -85,6 +88,9 @@ impl Service<Request<Incoming>> for NodeService {
 			CLOSE_CHANNEL_PATH => {
 				Box::pin(handle_request(context, req, handle_close_channel_request))
 			},
+			FORCE_CLOSE_CHANNEL_PATH => {
+				Box::pin(handle_request(context, req, handle_force_close_channel_request))
+			},
 			LIST_CHANNELS_PATH => {
 				Box::pin(handle_request(context, req, handle_list_channels_request))
 			},