Change handler signatures to borrow Context

benthecarman · claude · benthecarman · commit 0a374155f4e4 · 2026-04-07T17:12:27.000-05:00
Take &amp;Context instead of Context by value in all 37 handler
functions. The handlers only read from context.node and
context.paginated_kv_store (both Arc), so borrowing avoids
unnecessary Arc clones per request and prepares for the gRPC
service rewrite where Context lives in the service struct.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/ldk-server/src/api/bolt11_claim_for_hash.rs b/ldk-server/src/api/bolt11_claim_for_hash.rs
@@ -15,9 +15,10 @@ use ldk_server_protos::api::{Bolt11ClaimForHashRequest, Bolt11ClaimForHashRespon
 use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_bolt11_claim_for_hash_request(
-	context: Context, request: Bolt11ClaimForHashRequest,
+pub(crate) async fn handle_bolt11_claim_for_hash_request(
+	context: Arc<Context>, request: Bolt11ClaimForHashRequest,
 ) -> Result<Bolt11ClaimForHashResponse, LdkServerError> {
 	let preimage_bytes = <[u8; 32]>::from_hex(&request.preimage).map_err(|_| {
 		LdkServerError::new(
diff --git a/ldk-server/src/api/bolt11_fail_for_hash.rs b/ldk-server/src/api/bolt11_fail_for_hash.rs
@@ -14,9 +14,10 @@ use ldk_server_protos::api::{Bolt11FailForHashRequest, Bolt11FailForHashResponse
 use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_bolt11_fail_for_hash_request(
-	context: Context, request: Bolt11FailForHashRequest,
+pub(crate) async fn handle_bolt11_fail_for_hash_request(
+	context: Arc<Context>, request: Bolt11FailForHashRequest,
 ) -> Result<Bolt11FailForHashResponse, LdkServerError> {
 	let hash_bytes = <[u8; 32]>::from_hex(&request.payment_hash).map_err(|_| {
 		LdkServerError::new(
diff --git a/ldk-server/src/api/bolt11_receive.rs b/ldk-server/src/api/bolt11_receive.rs
@@ -13,9 +13,10 @@ use ldk_server_protos::api::{Bolt11ReceiveRequest, Bolt11ReceiveResponse};
 use crate::api::error::LdkServerError;
 use crate::service::Context;
 use crate::util::proto_adapter::proto_to_bolt11_description;
+use std::sync::Arc;
 
-pub(crate) fn handle_bolt11_receive_request(
-	context: Context, request: Bolt11ReceiveRequest,
+pub(crate) async fn handle_bolt11_receive_request(
+	context: Arc<Context>, request: Bolt11ReceiveRequest,
 ) -> Result<Bolt11ReceiveResponse, LdkServerError> {
 	let description = proto_to_bolt11_description(request.description)?;
 	let invoice = match request.amount_msat {
diff --git a/ldk-server/src/api/bolt11_receive_for_hash.rs b/ldk-server/src/api/bolt11_receive_for_hash.rs
@@ -15,9 +15,10 @@ use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
 use crate::util::proto_adapter::proto_to_bolt11_description;
+use std::sync::Arc;
 
-pub(crate) fn handle_bolt11_receive_for_hash_request(
-	context: Context, request: Bolt11ReceiveForHashRequest,
+pub(crate) async fn handle_bolt11_receive_for_hash_request(
+	context: Arc<Context>, request: Bolt11ReceiveForHashRequest,
 ) -> Result<Bolt11ReceiveForHashResponse, LdkServerError> {
 	let description = proto_to_bolt11_description(request.description)?;
 	let hash_bytes = <[u8; 32]>::from_hex(&request.payment_hash).map_err(|_| {
diff --git a/ldk-server/src/api/bolt11_receive_via_jit_channel.rs b/ldk-server/src/api/bolt11_receive_via_jit_channel.rs
@@ -16,9 +16,10 @@ use ldk_server_protos::api::{
 use crate::api::error::LdkServerError;
 use crate::service::Context;
 use crate::util::proto_adapter::proto_to_bolt11_description;
+use std::sync::Arc;
 
-pub(crate) fn handle_bolt11_receive_via_jit_channel_request(
-	context: Context, request: Bolt11ReceiveViaJitChannelRequest,
+pub(crate) async fn handle_bolt11_receive_via_jit_channel_request(
+	context: Arc<Context>, request: Bolt11ReceiveViaJitChannelRequest,
 ) -> Result<Bolt11ReceiveViaJitChannelResponse, LdkServerError> {
 	let description = proto_to_bolt11_description(request.description)?;
 	let invoice = context.node.bolt11_payment().receive_via_jit_channel(
@@ -31,8 +32,8 @@ pub(crate) fn handle_bolt11_receive_via_jit_channel_request(
 	Ok(Bolt11ReceiveViaJitChannelResponse { invoice: invoice.to_string() })
 }
 
-pub(crate) fn handle_bolt11_receive_variable_amount_via_jit_channel_request(
-	context: Context, request: Bolt11ReceiveVariableAmountViaJitChannelRequest,
+pub(crate) async fn handle_bolt11_receive_variable_amount_via_jit_channel_request(
+	context: Arc<Context>, request: Bolt11ReceiveVariableAmountViaJitChannelRequest,
 ) -> Result<Bolt11ReceiveVariableAmountViaJitChannelResponse, LdkServerError> {
 	let description = proto_to_bolt11_description(request.description)?;
 	let invoice = context.node.bolt11_payment().receive_variable_amount_via_jit_channel(
diff --git a/ldk-server/src/api/bolt11_send.rs b/ldk-server/src/api/bolt11_send.rs
@@ -15,9 +15,10 @@ use ldk_server_protos::api::{Bolt11SendRequest, Bolt11SendResponse};
 use crate::api::build_route_parameters_config_from_proto;
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_bolt11_send_request(
-	context: Context, request: Bolt11SendRequest,
+pub(crate) async fn handle_bolt11_send_request(
+	context: Arc<Context>, request: Bolt11SendRequest,
 ) -> Result<Bolt11SendResponse, LdkServerError> {
 	let invoice = Bolt11Invoice::from_str(request.invoice.as_str())
 		.map_err(|_| ldk_node::NodeError::InvalidInvoice)?;
diff --git a/ldk-server/src/api/bolt12_receive.rs b/ldk-server/src/api/bolt12_receive.rs
@@ -12,9 +12,10 @@ use ldk_server_protos::api::{Bolt12ReceiveRequest, Bolt12ReceiveResponse};
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_bolt12_receive_request(
-	context: Context, request: Bolt12ReceiveRequest,
+pub(crate) async fn handle_bolt12_receive_request(
+	context: Arc<Context>, request: Bolt12ReceiveRequest,
 ) -> Result<Bolt12ReceiveResponse, LdkServerError> {
 	let offer = match request.amount_msat {
 		Some(amount_msat) => context.node.bolt12_payment().receive(
diff --git a/ldk-server/src/api/bolt12_send.rs b/ldk-server/src/api/bolt12_send.rs
@@ -15,9 +15,10 @@ use ldk_server_protos::api::{Bolt12SendRequest, Bolt12SendResponse};
 use crate::api::build_route_parameters_config_from_proto;
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_bolt12_send_request(
-	context: Context, request: Bolt12SendRequest,
+pub(crate) async fn handle_bolt12_send_request(
+	context: Arc<Context>, request: Bolt12SendRequest,
 ) -> Result<Bolt12SendResponse, LdkServerError> {
 	let offer =
 		Offer::from_str(request.offer.as_str()).map_err(|_| ldk_node::NodeError::InvalidOffer)?;
diff --git a/ldk-server/src/api/close_channel.rs b/ldk-server/src/api/close_channel.rs
@@ -18,9 +18,10 @@ use ldk_server_protos::api::{
 use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_close_channel_request(
-	context: Context, request: CloseChannelRequest,
+pub(crate) async fn handle_close_channel_request(
+	context: Arc<Context>, request: CloseChannelRequest,
 ) -> Result<CloseChannelResponse, 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)?;
@@ -30,8 +31,8 @@ pub(crate) fn handle_close_channel_request(
 	Ok(CloseChannelResponse {})
 }
 
-pub(crate) fn handle_force_close_channel_request(
-	context: Context, request: ForceCloseChannelRequest,
+pub(crate) async fn handle_force_close_channel_request(
+	context: Arc<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)?;
diff --git a/ldk-server/src/api/connect_peer.rs b/ldk-server/src/api/connect_peer.rs
@@ -15,9 +15,10 @@ use ldk_server_protos::api::{ConnectPeerRequest, ConnectPeerResponse};
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_connect_peer(
-	context: Context, request: ConnectPeerRequest,
+pub(crate) async fn handle_connect_peer(
+	context: Arc<Context>, request: ConnectPeerRequest,
 ) -> Result<ConnectPeerResponse, LdkServerError> {
 	let node_id = PublicKey::from_str(&request.node_pubkey)
 		.map_err(|_| ldk_node::NodeError::InvalidPublicKey)?;
diff --git a/ldk-server/src/api/decode_invoice.rs b/ldk-server/src/api/decode_invoice.rs
@@ -18,9 +18,10 @@ use ldk_server_protos::types::{Bolt11HopHint, Bolt11RouteHint};
 use crate::api::decode_features;
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_decode_invoice_request(
-	_context: Context, request: DecodeInvoiceRequest,
+pub(crate) async fn handle_decode_invoice_request(
+	_context: Arc<Context>, request: DecodeInvoiceRequest,
 ) -> Result<DecodeInvoiceResponse, LdkServerError> {
 	let invoice = Bolt11Invoice::from_str(request.invoice.as_str())
 		.map_err(|_| ldk_node::NodeError::InvalidInvoice)?;
diff --git a/ldk-server/src/api/decode_offer.rs b/ldk-server/src/api/decode_offer.rs
@@ -22,9 +22,10 @@ use ldk_server_protos::types::{BlindedPath, CurrencyAmount, OfferAmount, OfferQu
 use crate::api::decode_features;
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_decode_offer_request(
-	_context: Context, request: DecodeOfferRequest,
+pub(crate) async fn handle_decode_offer_request(
+	_context: Arc<Context>, request: DecodeOfferRequest,
 ) -> Result<DecodeOfferResponse, LdkServerError> {
 	let offer =
 		Offer::from_str(request.offer.as_str()).map_err(|_| ldk_node::NodeError::InvalidOffer)?;
diff --git a/ldk-server/src/api/disconnect_peer.rs b/ldk-server/src/api/disconnect_peer.rs
@@ -14,9 +14,10 @@ use ldk_server_protos::api::{DisconnectPeerRequest, DisconnectPeerResponse};
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_disconnect_peer(
-	context: Context, request: DisconnectPeerRequest,
+pub(crate) async fn handle_disconnect_peer(
+	context: Arc<Context>, request: DisconnectPeerRequest,
 ) -> Result<DisconnectPeerResponse, LdkServerError> {
 	let node_id = PublicKey::from_str(&request.node_pubkey)
 		.map_err(|_| ldk_node::NodeError::InvalidPublicKey)?;
diff --git a/ldk-server/src/api/export_pathfinding_scores.rs b/ldk-server/src/api/export_pathfinding_scores.rs
@@ -11,9 +11,10 @@ use ldk_server_protos::api::{ExportPathfindingScoresRequest, ExportPathfindingSc
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_export_pathfinding_scores_request(
-	context: Context, _request: ExportPathfindingScoresRequest,
+pub(crate) async fn handle_export_pathfinding_scores_request(
+	context: Arc<Context>, _request: ExportPathfindingScoresRequest,
 ) -> Result<ExportPathfindingScoresResponse, LdkServerError> {
 	let scores = context.node.export_pathfinding_scores()?;
 
diff --git a/ldk-server/src/api/get_balances.rs b/ldk-server/src/api/get_balances.rs
@@ -12,9 +12,10 @@ use ldk_server_protos::api::{GetBalancesRequest, GetBalancesResponse};
 use crate::api::error::LdkServerError;
 use crate::service::Context;
 use crate::util::proto_adapter::{lightning_balance_to_proto, pending_sweep_balance_to_proto};
+use std::sync::Arc;
 
-pub(crate) fn handle_get_balances_request(
-	context: Context, _request: GetBalancesRequest,
+pub(crate) async fn handle_get_balances_request(
+	context: Arc<Context>, _request: GetBalancesRequest,
 ) -> Result<GetBalancesResponse, LdkServerError> {
 	let balance_details = context.node.list_balances();
 
diff --git a/ldk-server/src/api/get_node_info.rs b/ldk-server/src/api/get_node_info.rs
@@ -12,9 +12,10 @@ use ldk_server_protos::types::BestBlock;
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_get_node_info_request(
-	context: Context, _request: GetNodeInfoRequest,
+pub(crate) async fn handle_get_node_info_request(
+	context: Arc<Context>, _request: GetNodeInfoRequest,
 ) -> Result<GetNodeInfoResponse, LdkServerError> {
 	let node_status = context.node.status();
 
diff --git a/ldk-server/src/api/get_payment_details.rs b/ldk-server/src/api/get_payment_details.rs
@@ -15,9 +15,10 @@ use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
 use crate::util::proto_adapter::payment_to_proto;
+use std::sync::Arc;
 
-pub(crate) fn handle_get_payment_details_request(
-	context: Context, request: GetPaymentDetailsRequest,
+pub(crate) async fn handle_get_payment_details_request(
+	context: Arc<Context>, request: GetPaymentDetailsRequest,
 ) -> Result<GetPaymentDetailsResponse, LdkServerError> {
 	let payment_id_bytes =
 		<[u8; PaymentId::LENGTH]>::from_hex(&request.payment_id).map_err(|_| {
diff --git a/ldk-server/src/api/graph_get_channel.rs b/ldk-server/src/api/graph_get_channel.rs
@@ -13,9 +13,10 @@ use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
 use crate::util::proto_adapter::graph_channel_to_proto;
+use std::sync::Arc;
 
-pub(crate) fn handle_graph_get_channel_request(
-	context: Context, request: GraphGetChannelRequest,
+pub(crate) async fn handle_graph_get_channel_request(
+	context: Arc<Context>, request: GraphGetChannelRequest,
 ) -> Result<GraphGetChannelResponse, LdkServerError> {
 	let channel_info =
 		context.node.network_graph().channel(request.short_channel_id).ok_or_else(|| {
diff --git a/ldk-server/src/api/graph_get_node.rs b/ldk-server/src/api/graph_get_node.rs
@@ -14,9 +14,10 @@ use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
 use crate::util::proto_adapter::graph_node_to_proto;
+use std::sync::Arc;
 
-pub(crate) fn handle_graph_get_node_request(
-	context: Context, request: GraphGetNodeRequest,
+pub(crate) async fn handle_graph_get_node_request(
+	context: Arc<Context>, request: GraphGetNodeRequest,
 ) -> Result<GraphGetNodeResponse, LdkServerError> {
 	let node_id: NodeId = request.node_id.parse().map_err(|_| {
 		LdkServerError::new(
diff --git a/ldk-server/src/api/graph_list_channels.rs b/ldk-server/src/api/graph_list_channels.rs
@@ -11,9 +11,10 @@ use ldk_server_protos::api::{GraphListChannelsRequest, GraphListChannelsResponse
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_graph_list_channels_request(
-	context: Context, _request: GraphListChannelsRequest,
+pub(crate) async fn handle_graph_list_channels_request(
+	context: Arc<Context>, _request: GraphListChannelsRequest,
 ) -> Result<GraphListChannelsResponse, LdkServerError> {
 	let short_channel_ids = context.node.network_graph().list_channels();
 
diff --git a/ldk-server/src/api/graph_list_nodes.rs b/ldk-server/src/api/graph_list_nodes.rs
@@ -11,9 +11,10 @@ use ldk_server_protos::api::{GraphListNodesRequest, GraphListNodesResponse};
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_graph_list_nodes_request(
-	context: Context, _request: GraphListNodesRequest,
+pub(crate) async fn handle_graph_list_nodes_request(
+	context: Arc<Context>, _request: GraphListNodesRequest,
 ) -> Result<GraphListNodesResponse, LdkServerError> {
 	let node_ids =
 		context.node.network_graph().list_nodes().into_iter().map(|n| n.to_string()).collect();
diff --git a/ldk-server/src/api/list_channels.rs b/ldk-server/src/api/list_channels.rs
@@ -12,9 +12,10 @@ use ldk_server_protos::api::{ListChannelsRequest, ListChannelsResponse};
 use crate::api::error::LdkServerError;
 use crate::service::Context;
 use crate::util::proto_adapter::channel_to_proto;
+use std::sync::Arc;
 
-pub(crate) fn handle_list_channels_request(
-	context: Context, _request: ListChannelsRequest,
+pub(crate) async fn handle_list_channels_request(
+	context: Arc<Context>, _request: ListChannelsRequest,
 ) -> Result<ListChannelsResponse, LdkServerError> {
 	let channels = context.node.list_channels().into_iter().map(channel_to_proto).collect();
 
diff --git a/ldk-server/src/api/list_forwarded_payments.rs b/ldk-server/src/api/list_forwarded_payments.rs
@@ -19,9 +19,10 @@ use crate::io::persist::{
 	FORWARDED_PAYMENTS_PERSISTENCE_SECONDARY_NAMESPACE,
 };
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_list_forwarded_payments_request(
-	context: Context, request: ListForwardedPaymentsRequest,
+pub(crate) async fn handle_list_forwarded_payments_request(
+	context: Arc<Context>, request: ListForwardedPaymentsRequest,
 ) -> Result<ListForwardedPaymentsResponse, LdkServerError> {
 	let page_token = request.page_token.map(|p| (p.token, p.index));
 	let list_response = context
diff --git a/ldk-server/src/api/list_payments.rs b/ldk-server/src/api/list_payments.rs
@@ -18,9 +18,10 @@ use crate::io::persist::{
 	PAYMENTS_PERSISTENCE_PRIMARY_NAMESPACE, PAYMENTS_PERSISTENCE_SECONDARY_NAMESPACE,
 };
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_list_payments_request(
-	context: Context, request: ListPaymentsRequest,
+pub(crate) async fn handle_list_payments_request(
+	context: Arc<Context>, request: ListPaymentsRequest,
 ) -> Result<ListPaymentsResponse, LdkServerError> {
 	let page_token = request.page_token.map(|p| (p.token, p.index));
 	let list_response = context
diff --git a/ldk-server/src/api/list_peers.rs b/ldk-server/src/api/list_peers.rs
@@ -12,9 +12,10 @@ use ldk_server_protos::api::{ListPeersRequest, ListPeersResponse};
 use crate::api::error::LdkServerError;
 use crate::service::Context;
 use crate::util::proto_adapter::peer_to_proto;
+use std::sync::Arc;
 
-pub(crate) fn handle_list_peers_request(
-	context: Context, _request: ListPeersRequest,
+pub(crate) async fn handle_list_peers_request(
+	context: Arc<Context>, _request: ListPeersRequest,
 ) -> Result<ListPeersResponse, LdkServerError> {
 	let peers = context.node.list_peers().into_iter().map(peer_to_proto).collect();
 
diff --git a/ldk-server/src/api/onchain_receive.rs b/ldk-server/src/api/onchain_receive.rs
@@ -11,9 +11,10 @@ use ldk_server_protos::api::{OnchainReceiveRequest, OnchainReceiveResponse};
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_onchain_receive_request(
-	context: Context, _request: OnchainReceiveRequest,
+pub(crate) async fn handle_onchain_receive_request(
+	context: Arc<Context>, _request: OnchainReceiveRequest,
 ) -> Result<OnchainReceiveResponse, LdkServerError> {
 	let response = OnchainReceiveResponse {
 		address: context.node.onchain_payment().new_address()?.to_string(),
diff --git a/ldk-server/src/api/onchain_send.rs b/ldk-server/src/api/onchain_send.rs
@@ -15,9 +15,10 @@ use ldk_server_protos::api::{OnchainSendRequest, OnchainSendResponse};
 use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_onchain_send_request(
-	context: Context, request: OnchainSendRequest,
+pub(crate) async fn handle_onchain_send_request(
+	context: Arc<Context>, request: OnchainSendRequest,
 ) -> Result<OnchainSendResponse, LdkServerError> {
 	let address = Address::from_str(&request.address)
 		.map_err(|_| ldk_node::NodeError::InvalidAddress)?
diff --git a/ldk-server/src/api/open_channel.rs b/ldk-server/src/api/open_channel.rs
@@ -17,9 +17,10 @@ use ldk_server_protos::api::{OpenChannelRequest, OpenChannelResponse};
 use crate::api::build_channel_config_from_proto;
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_open_channel(
-	context: Context, request: OpenChannelRequest,
+pub(crate) async fn handle_open_channel(
+	context: Arc<Context>, request: OpenChannelRequest,
 ) -> Result<OpenChannelResponse, LdkServerError> {
 	let node_id = PublicKey::from_str(&request.node_pubkey)
 		.map_err(|_| ldk_node::NodeError::InvalidPublicKey)?;
diff --git a/ldk-server/src/api/sign_message.rs b/ldk-server/src/api/sign_message.rs
@@ -11,9 +11,10 @@ use ldk_server_protos::api::{SignMessageRequest, SignMessageResponse};
 
 use crate::api::error::LdkServerError;
 use crate::service::Context;
+use std::sync::Arc;
 
-pub(crate) fn handle_sign_message_request(
-	context: Context, request: SignMessageRequest,
+pub(crate) async fn handle_sign_message_request(
+	context: Arc<Context>, request: SignMessageRequest,
 ) -> Result<SignMessageResponse, LdkServerError> {
 	let signature = context.node.sign_message(&request.message);
 
diff --git a/ldk-server/src/api/splice_channel.rs b/ldk-server/src/api/splice_channel.rs
diff --git a/ldk-server/src/api/spontaneous_send.rs b/ldk-server/src/api/spontaneous_send.rs
diff --git a/ldk-server/src/api/unified_send.rs b/ldk-server/src/api/unified_send.rs
diff --git a/ldk-server/src/api/update_channel_config.rs b/ldk-server/src/api/update_channel_config.rs
diff --git a/ldk-server/src/api/verify_signature.rs b/ldk-server/src/api/verify_signature.rs
diff --git a/ldk-server/src/service.rs b/ldk-server/src/service.rs
