diff --git a/docs/api-guide.md b/docs/api-guide.md index d1752257..0cfd580e 100644 --- a/docs/api-guide.md +++ b/docs/api-guide.md @@ -230,11 +230,22 @@ a channel just-in-time when the invoice is paid. | RPC | Description | |--------------------------|-------------------------------------------------------------------------| | `Bolt12Receive` | Create a BOLT12 offer (fixed or variable amount) | +| `Bolt12ReceiveAsync` | Retrieve the offer for receiving while this node is offline | +| `Bolt12SetPathsToStaticInvoiceServer` | Configure serialized blinded paths to a static invoice server | +| `Bolt12BlindedPathsForAsyncRecipient` | Create serialized blinded paths for an async recipient | | `Bolt12Send` | Pay a BOLT12 offer (with optional quantity, payer note, routing config) | | `Bolt12SendRefund` | Create a BOLT12 refund that this node will pay | | `Bolt12ReceiveRefund` | Request an incoming payment for a BOLT12 refund | | `Bolt12CreatePayerProof` | Create a BOLT 12 payer proof from a successful payment | +Async receive is experimental. `Bolt12ReceiveAsync` and `Bolt12SetPathsToStaticInvoiceServer` +require the node's async-payments role to be set to `Client`; configure paths to a static +invoice server before requesting an offer. `Bolt12ReceiveAsync` returns an offer only after the +static invoice server has successfully completed building its static invoice. +`Bolt12BlindedPathsForAsyncRecipient` requires the role to be set to `Server`. +The blinded path fields use LDK's lightning serialization for `Vec`; the CLI +accepts and returns these byte values as hex, while gRPC transports them as bytes. + ### Spontaneous and Unified Send | RPC | Description | diff --git a/ldk-server-cli/src/main.rs b/ldk-server-cli/src/main.rs index 1ef6edc8..c7937a7f 100644 --- a/ldk-server-cli/src/main.rs +++ b/ldk-server-cli/src/main.rs @@ -37,21 +37,24 @@ use ldk_server_client::ldk_server_grpc::api::{ Bolt11ReceiveViaJitChannelForHashResponse, Bolt11ReceiveViaJitChannelRequest, Bolt11ReceiveViaJitChannelResponse, Bolt11SendProbesRequest, Bolt11SendProbesResponse, Bolt11SendRequest, Bolt11SendResponse, Bolt11SendUnderpayingRequest, - Bolt11SendUnderpayingResponse, Bolt12CreatePayerProofRequest, Bolt12CreatePayerProofResponse, + Bolt11SendUnderpayingResponse, Bolt12BlindedPathsForAsyncRecipientRequest, + Bolt12BlindedPathsForAsyncRecipientResponse, Bolt12CreatePayerProofRequest, + Bolt12CreatePayerProofResponse, Bolt12ReceiveAsyncRequest, Bolt12ReceiveAsyncResponse, Bolt12ReceiveRefundRequest, Bolt12ReceiveRefundResponse, Bolt12ReceiveRequest, Bolt12ReceiveResponse, Bolt12SendRefundRequest, Bolt12SendRefundResponse, Bolt12SendRequest, - Bolt12SendResponse, BumpChannelFundingFeeRequest, BumpChannelFundingFeeResponse, - CloseChannelRequest, CloseChannelResponse, ConnectPeerRequest, ConnectPeerResponse, - CreateMacaroonRequest, CreateMacaroonResponse, DecodeInvoiceRequest, DecodeInvoiceResponse, - DecodeOfferRequest, DecodeOfferResponse, DisconnectPeerRequest, DisconnectPeerResponse, - ExportPathfindingScoresRequest, ForceCloseChannelRequest, ForceCloseChannelResponse, - GetBalancesRequest, GetBalancesResponse, GetChannelForwardingStatsRequest, - GetChannelForwardingStatsResponse, GetForwardedPaymentDetailsRequest, - GetForwardedPaymentDetailsResponse, GetForwardedPaymentTrackingModeRequest, - GetForwardedPaymentTrackingModeResponse, GetNodeInfoRequest, GetNodeInfoResponse, - GetPaymentDetailsRequest, GetPaymentDetailsResponse, GetPermissionsRequest, - GetPermissionsResponse, GraphGetChannelRequest, GraphGetChannelResponse, GraphGetNodeRequest, - GraphGetNodeResponse, GraphListChannelsRequest, GraphListChannelsResponse, + Bolt12SendResponse, Bolt12SetPathsToStaticInvoiceServerRequest, + Bolt12SetPathsToStaticInvoiceServerResponse, BumpChannelFundingFeeRequest, + BumpChannelFundingFeeResponse, CloseChannelRequest, CloseChannelResponse, ConnectPeerRequest, + ConnectPeerResponse, CreateMacaroonRequest, CreateMacaroonResponse, DecodeInvoiceRequest, + DecodeInvoiceResponse, DecodeOfferRequest, DecodeOfferResponse, DisconnectPeerRequest, + DisconnectPeerResponse, ExportPathfindingScoresRequest, ForceCloseChannelRequest, + ForceCloseChannelResponse, GetBalancesRequest, GetBalancesResponse, + GetChannelForwardingStatsRequest, GetChannelForwardingStatsResponse, + GetForwardedPaymentDetailsRequest, GetForwardedPaymentDetailsResponse, + GetForwardedPaymentTrackingModeRequest, GetForwardedPaymentTrackingModeResponse, + GetNodeInfoRequest, GetNodeInfoResponse, GetPaymentDetailsRequest, GetPaymentDetailsResponse, + GetPermissionsRequest, GetPermissionsResponse, GraphGetChannelRequest, GraphGetChannelResponse, + GraphGetNodeRequest, GraphGetNodeResponse, GraphListChannelsRequest, GraphListChannelsResponse, GraphListNodesRequest, GraphListNodesResponse, ListChannelForwardingStatsRequest, ListChannelPairForwardingStatsRequest, ListChannelsRequest, ListChannelsResponse, ListForwardedPaymentsRequest, ListMacaroonsRequest, ListMacaroonsResponse, ListPaymentsRequest, @@ -385,6 +388,18 @@ enum Commands { )] quantity: Option, }, + #[command(about = "Retrieve the BOLT12 offer for receiving while this node is offline")] + Bolt12ReceiveAsync, + #[command(about = "Set serialized blinded message paths for the static invoice server")] + Bolt12SetPathsToStaticInvoiceServer { + #[arg(help = "Hex-encoded LDK serialization of Vec")] + blinded_paths: String, + }, + #[command(about = "Create blinded message paths for an asynchronous recipient")] + Bolt12BlindedPathsForAsyncRecipient { + #[arg(help = "Hex-encoded opaque recipient identifier")] + recipient_id: String, + }, #[command(about = "Send a payment for a BOLT12 offer")] Bolt12Send { #[arg(help = "A BOLT12 offer for a payment within the Lightning Network")] @@ -1191,6 +1206,37 @@ async fn main() { .await, ); }, + Commands::Bolt12ReceiveAsync => { + handle_response_result::<_, Bolt12ReceiveAsyncResponse>( + client.bolt12_receive_async(Bolt12ReceiveAsyncRequest {}).await, + ); + }, + Commands::Bolt12SetPathsToStaticInvoiceServer { blinded_paths } => { + let blinded_paths = Vec::::from_hex(&blinded_paths) + .unwrap_or_else(|e| handle_error_msg(format!("invalid blinded_paths hex: {e}"))); + handle_response_result::<_, Bolt12SetPathsToStaticInvoiceServerResponse>( + client + .bolt12_set_paths_to_static_invoice_server( + Bolt12SetPathsToStaticInvoiceServerRequest { + blinded_paths: blinded_paths.into(), + }, + ) + .await, + ); + }, + Commands::Bolt12BlindedPathsForAsyncRecipient { recipient_id } => { + let recipient_id = Vec::::from_hex(&recipient_id) + .unwrap_or_else(|e| handle_error_msg(format!("invalid recipient_id hex: {e}"))); + handle_response_result::<_, Bolt12BlindedPathsForAsyncRecipientResponse>( + client + .bolt12_blinded_paths_for_async_recipient( + Bolt12BlindedPathsForAsyncRecipientRequest { + recipient_id: recipient_id.into(), + }, + ) + .await, + ); + }, Commands::Bolt12Send { offer, amount, diff --git a/ldk-server-client/src/client.rs b/ldk-server-client/src/client.rs index 89074ef5..511eb2ed 100644 --- a/ldk-server-client/src/client.rs +++ b/ldk-server-client/src/client.rs @@ -22,15 +22,18 @@ use ldk_server_grpc::api::{ Bolt11ReceiveViaJitChannelForHashResponse, Bolt11ReceiveViaJitChannelRequest, Bolt11ReceiveViaJitChannelResponse, Bolt11SendProbesRequest, Bolt11SendProbesResponse, Bolt11SendRequest, Bolt11SendResponse, Bolt11SendUnderpayingRequest, - Bolt11SendUnderpayingResponse, Bolt12CreatePayerProofRequest, Bolt12CreatePayerProofResponse, + Bolt11SendUnderpayingResponse, Bolt12BlindedPathsForAsyncRecipientRequest, + Bolt12BlindedPathsForAsyncRecipientResponse, Bolt12CreatePayerProofRequest, + Bolt12CreatePayerProofResponse, Bolt12ReceiveAsyncRequest, Bolt12ReceiveAsyncResponse, Bolt12ReceiveRefundRequest, Bolt12ReceiveRefundResponse, Bolt12ReceiveRequest, Bolt12ReceiveResponse, Bolt12SendRefundRequest, Bolt12SendRefundResponse, Bolt12SendRequest, - Bolt12SendResponse, BumpChannelFundingFeeRequest, BumpChannelFundingFeeResponse, - CloseChannelRequest, CloseChannelResponse, ConnectPeerRequest, ConnectPeerResponse, - CreateMacaroonRequest, CreateMacaroonResponse, DecodeInvoiceRequest, DecodeInvoiceResponse, - DecodeOfferRequest, DecodeOfferResponse, DisconnectPeerRequest, DisconnectPeerResponse, - ExportPathfindingScoresRequest, ExportPathfindingScoresResponse, ForceCloseChannelRequest, - ForceCloseChannelResponse, GetBalancesRequest, GetBalancesResponse, + Bolt12SendResponse, Bolt12SetPathsToStaticInvoiceServerRequest, + Bolt12SetPathsToStaticInvoiceServerResponse, BumpChannelFundingFeeRequest, + BumpChannelFundingFeeResponse, CloseChannelRequest, CloseChannelResponse, ConnectPeerRequest, + ConnectPeerResponse, CreateMacaroonRequest, CreateMacaroonResponse, DecodeInvoiceRequest, + DecodeInvoiceResponse, DecodeOfferRequest, DecodeOfferResponse, DisconnectPeerRequest, + DisconnectPeerResponse, ExportPathfindingScoresRequest, ExportPathfindingScoresResponse, + ForceCloseChannelRequest, ForceCloseChannelResponse, GetBalancesRequest, GetBalancesResponse, GetChannelForwardingStatsRequest, GetChannelForwardingStatsResponse, GetForwardedPaymentDetailsRequest, GetForwardedPaymentDetailsResponse, GetForwardedPaymentTrackingModeRequest, GetForwardedPaymentTrackingModeResponse, @@ -57,20 +60,21 @@ use ldk_server_grpc::endpoints::{ BOLT11_RECEIVE_VARIABLE_AMOUNT_VIA_JIT_CHANNEL_PATH, BOLT11_RECEIVE_VIA_JIT_CHANNEL_FOR_HASH_PATH, BOLT11_RECEIVE_VIA_JIT_CHANNEL_PATH, BOLT11_SEND_PATH, BOLT11_SEND_PROBES_PATH, BOLT11_SEND_UNDERPAYING_PATH, - BOLT12_CREATE_PAYER_PROOF_PATH, BOLT12_RECEIVE_PATH, BOLT12_RECEIVE_REFUND_PATH, - BOLT12_SEND_PATH, BOLT12_SEND_REFUND_PATH, BUMP_CHANNEL_FUNDING_FEE_PATH, CLOSE_CHANNEL_PATH, - CONNECT_PEER_PATH, CREATE_MACAROON_PATH, DECODE_INVOICE_PATH, DECODE_OFFER_PATH, - DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH, FORCE_CLOSE_CHANNEL_PATH, - GET_BALANCES_PATH, GET_CHANNEL_FORWARDING_STATS_PATH, GET_FORWARDED_PAYMENT_DETAILS_PATH, - GET_FORWARDED_PAYMENT_TRACKING_MODE_PATH, GET_METRICS_PATH, GET_NODE_INFO_PATH, - GET_PAYMENT_DETAILS_PATH, GET_PERMISSIONS_PATH, GRAPH_GET_CHANNEL_PATH, GRAPH_GET_NODE_PATH, - GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH, GRPC_SERVICE_PREFIX, LIST_CHANNELS_PATH, - LIST_CHANNEL_FORWARDING_STATS_PATH, LIST_CHANNEL_PAIR_FORWARDING_STATS_PATH, - LIST_FORWARDED_PAYMENTS_PATH, LIST_MACAROONS_PATH, LIST_PAYMENTS_PATH, LIST_PEERS_PATH, - ONCHAIN_BUMP_FEE_PATH, ONCHAIN_RECEIVE_PATH, ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, - REVOKE_MACAROON_PATH, SIGN_MESSAGE_PATH, SPLICE_IN_PATH, SPLICE_OUT_PATH, - SPONTANEOUS_SEND_PATH, SPONTANEOUS_SEND_PROBES_PATH, SUBSCRIBE_EVENTS_PATH, UNIFIED_SEND_PATH, - UPDATE_CHANNEL_CONFIG_PATH, VERIFY_SIGNATURE_PATH, + BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH, BOLT12_CREATE_PAYER_PROOF_PATH, + BOLT12_RECEIVE_ASYNC_PATH, BOLT12_RECEIVE_PATH, BOLT12_RECEIVE_REFUND_PATH, BOLT12_SEND_PATH, + BOLT12_SEND_REFUND_PATH, BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH, + BUMP_CHANNEL_FUNDING_FEE_PATH, CLOSE_CHANNEL_PATH, CONNECT_PEER_PATH, CREATE_MACAROON_PATH, + DECODE_INVOICE_PATH, DECODE_OFFER_PATH, DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH, + FORCE_CLOSE_CHANNEL_PATH, GET_BALANCES_PATH, GET_CHANNEL_FORWARDING_STATS_PATH, + GET_FORWARDED_PAYMENT_DETAILS_PATH, GET_FORWARDED_PAYMENT_TRACKING_MODE_PATH, GET_METRICS_PATH, + GET_NODE_INFO_PATH, GET_PAYMENT_DETAILS_PATH, GET_PERMISSIONS_PATH, GRAPH_GET_CHANNEL_PATH, + GRAPH_GET_NODE_PATH, GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH, GRPC_SERVICE_PREFIX, + LIST_CHANNELS_PATH, LIST_CHANNEL_FORWARDING_STATS_PATH, + LIST_CHANNEL_PAIR_FORWARDING_STATS_PATH, LIST_FORWARDED_PAYMENTS_PATH, LIST_MACAROONS_PATH, + LIST_PAYMENTS_PATH, LIST_PEERS_PATH, ONCHAIN_BUMP_FEE_PATH, ONCHAIN_RECEIVE_PATH, + ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, REVOKE_MACAROON_PATH, SIGN_MESSAGE_PATH, SPLICE_IN_PATH, + SPLICE_OUT_PATH, SPONTANEOUS_SEND_PATH, SPONTANEOUS_SEND_PROBES_PATH, SUBSCRIBE_EVENTS_PATH, + UNIFIED_SEND_PATH, UPDATE_CHANNEL_CONFIG_PATH, VERIFY_SIGNATURE_PATH, }; use ldk_server_grpc::events::EventEnvelope; use ldk_server_grpc::grpc::{ @@ -298,6 +302,27 @@ impl LdkServerClient { self.grpc_unary(&request, BOLT12_RECEIVE_PATH).await } + /// Retrieve the BOLT12 offer for receiving payments while this node is offline. + pub async fn bolt12_receive_async( + &self, request: Bolt12ReceiveAsyncRequest, + ) -> Result { + self.grpc_unary(&request, BOLT12_RECEIVE_ASYNC_PATH).await + } + + /// Set the blinded paths used to interact with a static invoice server. + pub async fn bolt12_set_paths_to_static_invoice_server( + &self, request: Bolt12SetPathsToStaticInvoiceServerRequest, + ) -> Result { + self.grpc_unary(&request, BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH).await + } + + /// Create blinded message paths for an asynchronous recipient. + pub async fn bolt12_blinded_paths_for_async_recipient( + &self, request: Bolt12BlindedPathsForAsyncRecipientRequest, + ) -> Result { + self.grpc_unary(&request, BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH).await + } + /// Send a payment for a BOLT12 offer. pub async fn bolt12_send( &self, request: Bolt12SendRequest, diff --git a/ldk-server-grpc/src/api.rs b/ldk-server-grpc/src/api.rs index 03d44f73..b0bee52d 100644 --- a/ldk-server-grpc/src/api.rs +++ b/ldk-server-grpc/src/api.rs @@ -605,6 +605,69 @@ pub struct Bolt12ReceiveResponse { #[prost(string, tag = "2")] pub offer_id: ::prost::alloc::string::String, } +/// Retrieve an offer for receiving payments while this node is offline. +/// Async payments support is experimental. The node must be configured as an async client, and +/// paths to a static invoice server must have been set. An offer is returned only after the static +/// invoice server has successfully completed building its static invoice. +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))] +#[cfg_attr(feature = "serde", serde(default))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Bolt12ReceiveAsyncRequest {} +/// The offer generated for asynchronous payments. +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))] +#[cfg_attr(feature = "serde", serde(default))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Bolt12ReceiveAsyncResponse { + /// An offer for a payment within the Lightning Network. + #[prost(string, tag = "1")] + pub offer: ::prost::alloc::string::String, + /// The hex-encoded offer id. + #[prost(string, tag = "2")] + pub offer_id: ::prost::alloc::string::String, +} +/// Set the blinded message paths used to interact with a static invoice server. +/// blinded_paths must be encoded using the LDK lightning serialization format for Vec. +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))] +#[cfg_attr(feature = "serde", serde(default))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Bolt12SetPathsToStaticInvoiceServerRequest { + /// Serialized Vec. + #[prost(bytes = "bytes", tag = "1")] + pub blinded_paths: ::prost::bytes::Bytes, +} +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))] +#[cfg_attr(feature = "serde", serde(default))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Bolt12SetPathsToStaticInvoiceServerResponse {} +/// Create blinded message paths for an asynchronous recipient. +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))] +#[cfg_attr(feature = "serde", serde(default))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Bolt12BlindedPathsForAsyncRecipientRequest { + /// Opaque recipient identifier used to derive the blinded paths. + #[prost(bytes = "bytes", tag = "1")] + pub recipient_id: ::prost::bytes::Bytes, +} +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))] +#[cfg_attr(feature = "serde", serde(default))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Bolt12BlindedPathsForAsyncRecipientResponse { + /// Serialized Vec in the LDK lightning serialization format. + #[prost(bytes = "bytes", tag = "1")] + pub blinded_paths: ::prost::bytes::Bytes, +} /// Send a payment for a BOLT12 offer. /// See more: /// - diff --git a/ldk-server-grpc/src/endpoints.rs b/ldk-server-grpc/src/endpoints.rs index eaad6c47..2ccc77be 100644 --- a/ldk-server-grpc/src/endpoints.rs +++ b/ldk-server-grpc/src/endpoints.rs @@ -29,6 +29,11 @@ pub const BOLT11_SEND_PATH: &str = "Bolt11Send"; pub const BOLT11_SEND_PROBES_PATH: &str = "Bolt11SendProbes"; pub const BOLT11_SEND_UNDERPAYING_PATH: &str = "Bolt11SendUnderpaying"; pub const BOLT12_RECEIVE_PATH: &str = "Bolt12Receive"; +pub const BOLT12_RECEIVE_ASYNC_PATH: &str = "Bolt12ReceiveAsync"; +pub const BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH: &str = + "Bolt12SetPathsToStaticInvoiceServer"; +pub const BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH: &str = + "Bolt12BlindedPathsForAsyncRecipient"; pub const BOLT12_SEND_PATH: &str = "Bolt12Send"; pub const BOLT12_SEND_REFUND_PATH: &str = "Bolt12SendRefund"; pub const BOLT12_RECEIVE_REFUND_PATH: &str = "Bolt12ReceiveRefund"; diff --git a/ldk-server-grpc/src/permissions.rs b/ldk-server-grpc/src/permissions.rs index ee7059c7..92d83809 100644 --- a/ldk-server-grpc/src/permissions.rs +++ b/ldk-server-grpc/src/permissions.rs @@ -13,19 +13,21 @@ use crate::endpoints::{ BOLT11_RECEIVE_VARIABLE_AMOUNT_VIA_JIT_CHANNEL_PATH, BOLT11_RECEIVE_VIA_JIT_CHANNEL_FOR_HASH_PATH, BOLT11_RECEIVE_VIA_JIT_CHANNEL_PATH, BOLT11_SEND_PATH, BOLT11_SEND_PROBES_PATH, BOLT11_SEND_UNDERPAYING_PATH, - BOLT12_CREATE_PAYER_PROOF_PATH, BOLT12_RECEIVE_PATH, BOLT12_RECEIVE_REFUND_PATH, - BOLT12_SEND_PATH, BOLT12_SEND_REFUND_PATH, BUMP_CHANNEL_FUNDING_FEE_PATH, CLOSE_CHANNEL_PATH, - CONNECT_PEER_PATH, CREATE_MACAROON_PATH, DECODE_INVOICE_PATH, DECODE_OFFER_PATH, - DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH, FORCE_CLOSE_CHANNEL_PATH, - GET_BALANCES_PATH, GET_CHANNEL_FORWARDING_STATS_PATH, GET_FORWARDED_PAYMENT_DETAILS_PATH, - GET_FORWARDED_PAYMENT_TRACKING_MODE_PATH, GET_NODE_INFO_PATH, GET_PAYMENT_DETAILS_PATH, - GET_PERMISSIONS_PATH, GRAPH_GET_CHANNEL_PATH, GRAPH_GET_NODE_PATH, GRAPH_LIST_CHANNELS_PATH, - GRAPH_LIST_NODES_PATH, LIST_CHANNELS_PATH, LIST_CHANNEL_FORWARDING_STATS_PATH, - LIST_CHANNEL_PAIR_FORWARDING_STATS_PATH, LIST_FORWARDED_PAYMENTS_PATH, LIST_MACAROONS_PATH, - LIST_PAYMENTS_PATH, LIST_PEERS_PATH, ONCHAIN_BUMP_FEE_PATH, ONCHAIN_RECEIVE_PATH, - ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, REVOKE_MACAROON_PATH, SIGN_MESSAGE_PATH, SPLICE_IN_PATH, - SPLICE_OUT_PATH, SPONTANEOUS_SEND_PATH, SPONTANEOUS_SEND_PROBES_PATH, SUBSCRIBE_EVENTS_PATH, - UNIFIED_SEND_PATH, UPDATE_CHANNEL_CONFIG_PATH, VERIFY_SIGNATURE_PATH, + BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH, BOLT12_CREATE_PAYER_PROOF_PATH, + BOLT12_RECEIVE_ASYNC_PATH, BOLT12_RECEIVE_PATH, BOLT12_RECEIVE_REFUND_PATH, BOLT12_SEND_PATH, + BOLT12_SEND_REFUND_PATH, BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH, + BUMP_CHANNEL_FUNDING_FEE_PATH, CLOSE_CHANNEL_PATH, CONNECT_PEER_PATH, CREATE_MACAROON_PATH, + DECODE_INVOICE_PATH, DECODE_OFFER_PATH, DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH, + FORCE_CLOSE_CHANNEL_PATH, GET_BALANCES_PATH, GET_CHANNEL_FORWARDING_STATS_PATH, + GET_FORWARDED_PAYMENT_DETAILS_PATH, GET_FORWARDED_PAYMENT_TRACKING_MODE_PATH, + GET_NODE_INFO_PATH, GET_PAYMENT_DETAILS_PATH, GET_PERMISSIONS_PATH, GRAPH_GET_CHANNEL_PATH, + GRAPH_GET_NODE_PATH, GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH, LIST_CHANNELS_PATH, + LIST_CHANNEL_FORWARDING_STATS_PATH, LIST_CHANNEL_PAIR_FORWARDING_STATS_PATH, + LIST_FORWARDED_PAYMENTS_PATH, LIST_MACAROONS_PATH, LIST_PAYMENTS_PATH, LIST_PEERS_PATH, + ONCHAIN_BUMP_FEE_PATH, ONCHAIN_RECEIVE_PATH, ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, + REVOKE_MACAROON_PATH, SIGN_MESSAGE_PATH, SPLICE_IN_PATH, SPLICE_OUT_PATH, + SPONTANEOUS_SEND_PATH, SPONTANEOUS_SEND_PROBES_PATH, SUBSCRIBE_EVENTS_PATH, UNIFIED_SEND_PATH, + UPDATE_CHANNEL_CONFIG_PATH, VERIFY_SIGNATURE_PATH, }; pub const ADMIN_PERMISSION: &str = "admin"; @@ -170,6 +172,9 @@ pub fn method_authorization(method: &str) -> MethodAuthorization { | BOLT11_RECEIVE_VIA_JIT_CHANNEL_FOR_HASH_PATH | BOLT11_RECEIVE_VARIABLE_AMOUNT_VIA_JIT_CHANNEL_FOR_HASH_PATH | BOLT12_RECEIVE_PATH + | BOLT12_RECEIVE_ASYNC_PATH + | BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH + | BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH | BOLT12_RECEIVE_REFUND_PATH => MethodAuthorization::Permission(INVOICES_CREATE_PERMISSION), BOLT11_CLAIM_FOR_ID_PATH | BOLT11_FAIL_FOR_ID_PATH => { MethodAuthorization::Permission(PAYMENTS_CLAIM_PERMISSION) diff --git a/ldk-server-grpc/src/proto/api.proto b/ldk-server-grpc/src/proto/api.proto index f1b8491d..3001af00 100644 --- a/ldk-server-grpc/src/proto/api.proto +++ b/ldk-server-grpc/src/proto/api.proto @@ -460,6 +460,45 @@ message Bolt12ReceiveResponse { string offer_id = 2; } +// Retrieve an offer for receiving payments while this node is offline. +// Async payments support is experimental. The node must be configured as an async client, and +// paths to a static invoice server must have been set. An offer is returned only after the static +// invoice server has successfully completed building its static invoice. +message Bolt12ReceiveAsyncRequest {} + +// The offer generated for asynchronous payments. +message Bolt12ReceiveAsyncResponse { + + // An offer for a payment within the Lightning Network. + string offer = 1; + + // The hex-encoded offer id. + string offer_id = 2; +} + +// Set the blinded message paths used to interact with a static invoice server. +// blinded_paths must be encoded using the LDK lightning serialization format for Vec. +message Bolt12SetPathsToStaticInvoiceServerRequest { + + // Serialized Vec. + bytes blinded_paths = 1; +} + +message Bolt12SetPathsToStaticInvoiceServerResponse {} + +// Create blinded message paths for an asynchronous recipient. +message Bolt12BlindedPathsForAsyncRecipientRequest { + + // Opaque recipient identifier used to derive the blinded paths. + bytes recipient_id = 1; +} + +message Bolt12BlindedPathsForAsyncRecipientResponse { + + // Serialized Vec in the LDK lightning serialization format. + bytes blinded_paths = 1; +} + // Send a payment for a BOLT12 offer. // See more: // - https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt12Payment.html#method.send @@ -1309,6 +1348,9 @@ service LightningNode { rpc Bolt11SendUnderpaying(Bolt11SendUnderpayingRequest) returns (Bolt11SendUnderpayingResponse); // Return a BOLT12 offer. rpc Bolt12Receive(Bolt12ReceiveRequest) returns (Bolt12ReceiveResponse); + rpc Bolt12ReceiveAsync(Bolt12ReceiveAsyncRequest) returns (Bolt12ReceiveAsyncResponse); + rpc Bolt12SetPathsToStaticInvoiceServer(Bolt12SetPathsToStaticInvoiceServerRequest) returns (Bolt12SetPathsToStaticInvoiceServerResponse); + rpc Bolt12BlindedPathsForAsyncRecipient(Bolt12BlindedPathsForAsyncRecipientRequest) returns (Bolt12BlindedPathsForAsyncRecipientResponse); // Send a payment for a BOLT12 offer. rpc Bolt12Send(Bolt12SendRequest) returns (Bolt12SendResponse); // Return a BOLT12 refund that this node will pay. diff --git a/ldk-server-mcp/src/tools/handlers.rs b/ldk-server-mcp/src/tools/handlers.rs index 3e90f15c..f1dc840a 100644 --- a/ldk-server-mcp/src/tools/handlers.rs +++ b/ldk-server-mcp/src/tools/handlers.rs @@ -14,14 +14,16 @@ use ldk_server_client::ldk_server_grpc::api::{ Bolt11ReceiveRequest, Bolt11ReceiveVariableAmountViaJitChannelForHashRequest, Bolt11ReceiveVariableAmountViaJitChannelRequest, Bolt11ReceiveViaJitChannelForHashRequest, Bolt11ReceiveViaJitChannelRequest, Bolt11SendProbesRequest, Bolt11SendRequest, - Bolt11SendUnderpayingRequest, Bolt12CreatePayerProofRequest, Bolt12ReceiveRefundRequest, - Bolt12ReceiveRequest, Bolt12SendRefundRequest, Bolt12SendRequest, BumpChannelFundingFeeRequest, - CloseChannelRequest, ConnectPeerRequest, CreateMacaroonRequest, DecodeInvoiceRequest, - DecodeOfferRequest, DisconnectPeerRequest, ExportPathfindingScoresRequest, - ForceCloseChannelRequest, GetBalancesRequest, GetChannelForwardingStatsRequest, - GetForwardedPaymentDetailsRequest, GetForwardedPaymentTrackingModeRequest, GetNodeInfoRequest, - GetPaymentDetailsRequest, GetPermissionsRequest, GraphGetChannelRequest, GraphGetNodeRequest, - GraphListChannelsRequest, GraphListNodesRequest, ListChannelForwardingStatsRequest, + Bolt11SendUnderpayingRequest, Bolt12BlindedPathsForAsyncRecipientRequest, + Bolt12CreatePayerProofRequest, Bolt12ReceiveAsyncRequest, Bolt12ReceiveRefundRequest, + Bolt12ReceiveRequest, Bolt12SendRefundRequest, Bolt12SendRequest, + Bolt12SetPathsToStaticInvoiceServerRequest, BumpChannelFundingFeeRequest, CloseChannelRequest, + ConnectPeerRequest, CreateMacaroonRequest, DecodeInvoiceRequest, DecodeOfferRequest, + DisconnectPeerRequest, ExportPathfindingScoresRequest, ForceCloseChannelRequest, + GetBalancesRequest, GetChannelForwardingStatsRequest, GetForwardedPaymentDetailsRequest, + GetForwardedPaymentTrackingModeRequest, GetNodeInfoRequest, GetPaymentDetailsRequest, + GetPermissionsRequest, GraphGetChannelRequest, GraphGetNodeRequest, GraphListChannelsRequest, + GraphListNodesRequest, ListChannelForwardingStatsRequest, ListChannelPairForwardingStatsRequest, ListChannelsRequest, ListForwardedPaymentsRequest, ListMacaroonsRequest, ListPaymentsRequest, ListPeersRequest, OnchainBumpFeeRequest, OnchainReceiveRequest, OnchainSendRequest, OpenChannelRequest, RevokeMacaroonRequest, @@ -321,6 +323,32 @@ pub async fn handle_bolt12_receive( serialize_response(response) } +pub async fn handle_bolt12_receive_async( + client: &LdkServerClient, args: Value, +) -> Result { + let request: Bolt12ReceiveAsyncRequest = parse_request(args)?; + let response = client.bolt12_receive_async(request).await.map_err(McpError::from)?; + serialize_response(response) +} + +pub async fn handle_bolt12_set_paths_to_static_invoice_server( + client: &LdkServerClient, args: Value, +) -> Result { + let request: Bolt12SetPathsToStaticInvoiceServerRequest = parse_request(args)?; + let response = + client.bolt12_set_paths_to_static_invoice_server(request).await.map_err(McpError::from)?; + serialize_response(response) +} + +pub async fn handle_bolt12_blinded_paths_for_async_recipient( + client: &LdkServerClient, args: Value, +) -> Result { + let request: Bolt12BlindedPathsForAsyncRecipientRequest = parse_request(args)?; + let response = + client.bolt12_blinded_paths_for_async_recipient(request).await.map_err(McpError::from)?; + serialize_response(response) +} + pub async fn handle_bolt12_send(client: &LdkServerClient, args: Value) -> Result { let request: Bolt12SendRequest = parse_request_with_route_parameters(args, |request: &mut Bolt12SendRequest| { diff --git a/ldk-server-mcp/src/tools/mod.rs b/ldk-server-mcp/src/tools/mod.rs index f2b5deb9..055db038 100644 --- a/ldk-server-mcp/src/tools/mod.rs +++ b/ldk-server-mcp/src/tools/mod.rs @@ -22,18 +22,20 @@ use ldk_server_client::ldk_server_grpc::endpoints::{ BOLT11_RECEIVE_VARIABLE_AMOUNT_VIA_JIT_CHANNEL_PATH, BOLT11_RECEIVE_VIA_JIT_CHANNEL_FOR_HASH_PATH, BOLT11_RECEIVE_VIA_JIT_CHANNEL_PATH, BOLT11_SEND_PATH, BOLT11_SEND_PROBES_PATH, BOLT11_SEND_UNDERPAYING_PATH, - BOLT12_CREATE_PAYER_PROOF_PATH, BOLT12_RECEIVE_PATH, BOLT12_RECEIVE_REFUND_PATH, - BOLT12_SEND_PATH, BOLT12_SEND_REFUND_PATH, BUMP_CHANNEL_FUNDING_FEE_PATH, CLOSE_CHANNEL_PATH, - CONNECT_PEER_PATH, CREATE_MACAROON_PATH, DECODE_INVOICE_PATH, DECODE_OFFER_PATH, - DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH, FORCE_CLOSE_CHANNEL_PATH, - GET_BALANCES_PATH, GET_CHANNEL_FORWARDING_STATS_PATH, GET_FORWARDED_PAYMENT_DETAILS_PATH, - GET_FORWARDED_PAYMENT_TRACKING_MODE_PATH, GET_NODE_INFO_PATH, GET_PAYMENT_DETAILS_PATH, - GET_PERMISSIONS_PATH, GRAPH_GET_CHANNEL_PATH, GRAPH_GET_NODE_PATH, GRAPH_LIST_CHANNELS_PATH, - GRAPH_LIST_NODES_PATH, LIST_CHANNELS_PATH, LIST_CHANNEL_FORWARDING_STATS_PATH, - LIST_CHANNEL_PAIR_FORWARDING_STATS_PATH, LIST_FORWARDED_PAYMENTS_PATH, LIST_MACAROONS_PATH, - LIST_PAYMENTS_PATH, LIST_PEERS_PATH, ONCHAIN_BUMP_FEE_PATH, ONCHAIN_RECEIVE_PATH, - ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, REVOKE_MACAROON_PATH, SIGN_MESSAGE_PATH, SPLICE_IN_PATH, - SPLICE_OUT_PATH, SPONTANEOUS_SEND_PATH, SPONTANEOUS_SEND_PROBES_PATH, UNIFIED_SEND_PATH, + BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH, BOLT12_CREATE_PAYER_PROOF_PATH, + BOLT12_RECEIVE_ASYNC_PATH, BOLT12_RECEIVE_PATH, BOLT12_RECEIVE_REFUND_PATH, BOLT12_SEND_PATH, + BOLT12_SEND_REFUND_PATH, BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH, + BUMP_CHANNEL_FUNDING_FEE_PATH, CLOSE_CHANNEL_PATH, CONNECT_PEER_PATH, CREATE_MACAROON_PATH, + DECODE_INVOICE_PATH, DECODE_OFFER_PATH, DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH, + FORCE_CLOSE_CHANNEL_PATH, GET_BALANCES_PATH, GET_CHANNEL_FORWARDING_STATS_PATH, + GET_FORWARDED_PAYMENT_DETAILS_PATH, GET_FORWARDED_PAYMENT_TRACKING_MODE_PATH, + GET_NODE_INFO_PATH, GET_PAYMENT_DETAILS_PATH, GET_PERMISSIONS_PATH, GRAPH_GET_CHANNEL_PATH, + GRAPH_GET_NODE_PATH, GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH, LIST_CHANNELS_PATH, + LIST_CHANNEL_FORWARDING_STATS_PATH, LIST_CHANNEL_PAIR_FORWARDING_STATS_PATH, + LIST_FORWARDED_PAYMENTS_PATH, LIST_MACAROONS_PATH, LIST_PAYMENTS_PATH, LIST_PEERS_PATH, + ONCHAIN_BUMP_FEE_PATH, ONCHAIN_RECEIVE_PATH, ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, + REVOKE_MACAROON_PATH, SIGN_MESSAGE_PATH, SPLICE_IN_PATH, SPLICE_OUT_PATH, + SPONTANEOUS_SEND_PATH, SPONTANEOUS_SEND_PROBES_PATH, UNIFIED_SEND_PATH, UPDATE_CHANNEL_CONFIG_PATH, VERIFY_SIGNATURE_PATH, }; use ldk_server_client::ldk_server_grpc::permissions::{ @@ -283,6 +285,31 @@ pub fn build_tool_registry() -> ToolRegistry { schema::bolt12_receive_schema, |client, args| Box::pin(handlers::handle_bolt12_receive(client, args)), ), + tool_spec( + "bolt12_receive_async", + BOLT12_RECEIVE_ASYNC_PATH, + "Retrieve the BOLT12 offer for receiving payments while this node is offline; requires async client configuration, static invoice server paths, and successful static invoice construction", + schema::bolt12_receive_async_schema, + |client, args| Box::pin(handlers::handle_bolt12_receive_async(client, args)), + ), + tool_spec( + "bolt12_set_paths_to_static_invoice_server", + BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH, + "For an async client, set LDK-serialized blinded message paths used to communicate with a static invoice server", + schema::bolt12_set_paths_to_static_invoice_server_schema, + |client, args| { + Box::pin(handlers::handle_bolt12_set_paths_to_static_invoice_server(client, args)) + }, + ), + tool_spec( + "bolt12_blinded_paths_for_async_recipient", + BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH, + "For an async server, create LDK-serialized blinded message paths for an asynchronous recipient", + schema::bolt12_blinded_paths_for_async_recipient_schema, + |client, args| { + Box::pin(handlers::handle_bolt12_blinded_paths_for_async_recipient(client, args)) + }, + ), tool_spec( "bolt12_send", BOLT12_SEND_PATH, diff --git a/ldk-server-mcp/src/tools/schema.rs b/ldk-server-mcp/src/tools/schema.rs index 223f4dc0..9d5898c6 100644 --- a/ldk-server-mcp/src/tools/schema.rs +++ b/ldk-server-mcp/src/tools/schema.rs @@ -462,6 +462,38 @@ pub fn bolt12_receive_schema() -> Value { }) } +pub fn bolt12_receive_async_schema() -> Value { + json!({ "type": "object", "properties": {}, "required": [] }) +} + +pub fn bolt12_set_paths_to_static_invoice_server_schema() -> Value { + json!({ + "type": "object", + "properties": { + "blinded_paths": { + "type": "array", + "items": {"type": "integer", "minimum": 0, "maximum": 255}, + "description": "LDK lightning serialization of Vec" + } + }, + "required": ["blinded_paths"] + }) +} + +pub fn bolt12_blinded_paths_for_async_recipient_schema() -> Value { + json!({ + "type": "object", + "properties": { + "recipient_id": { + "type": "array", + "items": {"type": "integer", "minimum": 0, "maximum": 255}, + "description": "Opaque recipient identifier bytes" + } + }, + "required": ["recipient_id"] + }) +} + pub fn bolt12_send_schema() -> Value { json!({ "type": "object", diff --git a/ldk-server-mcp/tests/integration.rs b/ldk-server-mcp/tests/integration.rs index 48c4bc5c..9e27e508 100644 --- a/ldk-server-mcp/tests/integration.rs +++ b/ldk-server-mcp/tests/integration.rs @@ -11,7 +11,7 @@ use std::io::{BufRead, BufReader, Write}; use serde_json::{json, Value}; -const NUM_TOOLS: usize = 56; +const NUM_TOOLS: usize = 59; const EXPECTED_TOOLS: [&str; NUM_TOOLS] = [ "bolt11_claim_for_id", "bolt11_fail_for_id", @@ -26,6 +26,9 @@ const EXPECTED_TOOLS: [&str; NUM_TOOLS] = [ "bolt11_send_underpaying", "bolt12_create_payer_proof", "bolt12_receive", + "bolt12_receive_async", + "bolt12_set_paths_to_static_invoice_server", + "bolt12_blinded_paths_for_async_recipient", "bolt12_receive_refund", "bolt12_send", "bolt12_send_refund", diff --git a/ldk-server/src/api/bolt12_async_receive.rs b/ldk-server/src/api/bolt12_async_receive.rs new file mode 100644 index 00000000..53068ced --- /dev/null +++ b/ldk-server/src/api/bolt12_async_receive.rs @@ -0,0 +1,56 @@ +// This file is Copyright its original authors, visible in version control +// history. +// +// This file is licensed under the Apache License, Version 2.0 or the MIT license +// , at your option. +// You may not use this file except in accordance with one or both of these +// licenses. + +use std::sync::Arc; + +use hex::DisplayHex; +use ldk_node::lightning::blinded_path::message::BlindedMessagePath; +use ldk_node::lightning::util::ser::{Readable, Writeable}; +use ldk_server_grpc::api::{ + Bolt12BlindedPathsForAsyncRecipientRequest, Bolt12BlindedPathsForAsyncRecipientResponse, + Bolt12ReceiveAsyncRequest, Bolt12ReceiveAsyncResponse, + Bolt12SetPathsToStaticInvoiceServerRequest, Bolt12SetPathsToStaticInvoiceServerResponse, +}; + +use crate::api::error::LdkServerError; +use crate::service::Context; + +pub(crate) async fn handle_bolt12_receive_async_request( + context: Arc, _request: Bolt12ReceiveAsyncRequest, +) -> Result { + let offer = context.node.bolt12_payment().receive_async()?; + let offer_id = offer.id().0.to_lower_hex_string(); + + Ok(Bolt12ReceiveAsyncResponse { offer: offer.to_string(), offer_id }) +} + +pub(crate) async fn handle_bolt12_set_paths_to_static_invoice_server_request( + context: Arc, request: Bolt12SetPathsToStaticInvoiceServerRequest, +) -> Result { + let mut encoded_paths = &request.blinded_paths[..]; + let paths = Vec::::read(&mut encoded_paths) + .map_err(|_| ldk_node::NodeError::InvalidBlindedPaths)?; + if !encoded_paths.is_empty() { + return Err(ldk_node::NodeError::InvalidBlindedPaths.into()); + } + context.node.bolt12_payment().set_paths_to_static_invoice_server(paths)?; + + Ok(Bolt12SetPathsToStaticInvoiceServerResponse {}) +} + +pub(crate) async fn handle_bolt12_blinded_paths_for_async_recipient_request( + context: Arc, request: Bolt12BlindedPathsForAsyncRecipientRequest, +) -> Result { + let paths = context + .node + .bolt12_payment() + .blinded_paths_for_async_recipient(request.recipient_id.to_vec())?; + + Ok(Bolt12BlindedPathsForAsyncRecipientResponse { blinded_paths: paths.encode().into() }) +} diff --git a/ldk-server/src/api/mod.rs b/ldk-server/src/api/mod.rs index 04a92c87..77547edc 100644 --- a/ldk-server/src/api/mod.rs +++ b/ldk-server/src/api/mod.rs @@ -25,6 +25,7 @@ pub(crate) mod bolt11_receive; pub(crate) mod bolt11_receive_for_hash; pub(crate) mod bolt11_receive_via_jit_channel; pub(crate) mod bolt11_send; +pub(crate) mod bolt12_async_receive; pub(crate) mod bolt12_create_payer_proof; pub(crate) mod bolt12_receive; pub(crate) mod bolt12_refund; diff --git a/ldk-server/src/macaroons/authorization.rs b/ldk-server/src/macaroons/authorization.rs index b8b222be..8298d5e7 100644 --- a/ldk-server/src/macaroons/authorization.rs +++ b/ldk-server/src/macaroons/authorization.rs @@ -42,6 +42,9 @@ mod tests { ("Bolt11SendProbes", Some("payments:send")), ("Bolt11SendUnderpaying", Some("payments:send")), ("Bolt12Receive", Some("invoices:create")), + ("Bolt12ReceiveAsync", Some("invoices:create")), + ("Bolt12SetPathsToStaticInvoiceServer", Some("invoices:create")), + ("Bolt12BlindedPathsForAsyncRecipient", Some("invoices:create")), ("Bolt12Send", Some("payments:send")), ("Bolt12SendRefund", Some("payments:send")), ("Bolt12ReceiveRefund", Some("invoices:create")), diff --git a/ldk-server/src/service.rs b/ldk-server/src/service.rs index 79c642e8..05ec651d 100644 --- a/ldk-server/src/service.rs +++ b/ldk-server/src/service.rs @@ -22,14 +22,15 @@ use ldk_server_grpc::endpoints::{ BOLT11_RECEIVE_VARIABLE_AMOUNT_VIA_JIT_CHANNEL_PATH, BOLT11_RECEIVE_VIA_JIT_CHANNEL_FOR_HASH_PATH, BOLT11_RECEIVE_VIA_JIT_CHANNEL_PATH, BOLT11_SEND_PATH, BOLT11_SEND_PROBES_PATH, BOLT11_SEND_UNDERPAYING_PATH, - BOLT12_CREATE_PAYER_PROOF_PATH, BOLT12_RECEIVE_PATH, BOLT12_RECEIVE_REFUND_PATH, - BOLT12_SEND_PATH, BOLT12_SEND_REFUND_PATH, BUMP_CHANNEL_FUNDING_FEE_PATH, CLOSE_CHANNEL_PATH, - CONNECT_PEER_PATH, CREATE_MACAROON_PATH, DECODE_INVOICE_PATH, DECODE_OFFER_PATH, - DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH, FORCE_CLOSE_CHANNEL_PATH, - GET_BALANCES_PATH, GET_CHANNEL_FORWARDING_STATS_PATH, GET_FORWARDED_PAYMENT_DETAILS_PATH, - GET_FORWARDED_PAYMENT_TRACKING_MODE_PATH, GET_METRICS_PATH, GET_NODE_INFO_PATH, - GET_PAYMENT_DETAILS_PATH, GET_PERMISSIONS_PATH, GRAPH_GET_CHANNEL_PATH, GRAPH_GET_NODE_PATH, - GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH, LIST_CHANNELS_PATH, + BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH, BOLT12_CREATE_PAYER_PROOF_PATH, + BOLT12_RECEIVE_ASYNC_PATH, BOLT12_RECEIVE_PATH, BOLT12_RECEIVE_REFUND_PATH, BOLT12_SEND_PATH, + BOLT12_SEND_REFUND_PATH, BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH, + BUMP_CHANNEL_FUNDING_FEE_PATH, CLOSE_CHANNEL_PATH, CONNECT_PEER_PATH, CREATE_MACAROON_PATH, + DECODE_INVOICE_PATH, DECODE_OFFER_PATH, DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH, + FORCE_CLOSE_CHANNEL_PATH, GET_BALANCES_PATH, GET_CHANNEL_FORWARDING_STATS_PATH, + GET_FORWARDED_PAYMENT_DETAILS_PATH, GET_FORWARDED_PAYMENT_TRACKING_MODE_PATH, GET_METRICS_PATH, + GET_NODE_INFO_PATH, GET_PAYMENT_DETAILS_PATH, GET_PERMISSIONS_PATH, GRAPH_GET_CHANNEL_PATH, + GRAPH_GET_NODE_PATH, GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH, LIST_CHANNELS_PATH, LIST_CHANNEL_FORWARDING_STATS_PATH, LIST_CHANNEL_PAIR_FORWARDING_STATS_PATH, LIST_FORWARDED_PAYMENTS_PATH, LIST_MACAROONS_PATH, LIST_PAYMENTS_PATH, LIST_PEERS_PATH, ONCHAIN_BUMP_FEE_PATH, ONCHAIN_RECEIVE_PATH, ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, @@ -59,6 +60,10 @@ use crate::api::bolt11_receive_via_jit_channel::{ handle_bolt11_receive_via_jit_channel_request, }; use crate::api::bolt11_send::{handle_bolt11_send_request, handle_bolt11_send_underpaying_request}; +use crate::api::bolt12_async_receive::{ + handle_bolt12_blinded_paths_for_async_recipient_request, handle_bolt12_receive_async_request, + handle_bolt12_set_paths_to_static_invoice_server_request, +}; use crate::api::bolt12_create_payer_proof::handle_bolt12_create_payer_proof_request; use crate::api::bolt12_receive::handle_bolt12_receive_request; use crate::api::bolt12_refund::{ @@ -317,6 +322,26 @@ impl Service> for NodeService { BOLT12_RECEIVE_PATH => { handle_grpc_unary(context, body_bytes, handle_bolt12_receive_request).await }, + BOLT12_RECEIVE_ASYNC_PATH => { + handle_grpc_unary(context, body_bytes, handle_bolt12_receive_async_request) + .await + }, + BOLT12_SET_PATHS_TO_STATIC_INVOICE_SERVER_PATH => { + handle_grpc_unary( + context, + body_bytes, + handle_bolt12_set_paths_to_static_invoice_server_request, + ) + .await + }, + BOLT12_BLINDED_PATHS_FOR_ASYNC_RECIPIENT_PATH => { + handle_grpc_unary( + context, + body_bytes, + handle_bolt12_blinded_paths_for_async_recipient_request, + ) + .await + }, BOLT12_SEND_PATH => { handle_grpc_unary(context, body_bytes, handle_bolt12_send_request).await },