sendpayment Part 2: Channel open, Get invoice

common/Cargo.toml

@@ -76,6 +76,7 @@ rustls-pemfile = "1"
 secrecy = "0.8"
 # Serialization / deserialization framework
 serde = { version = "1", features = ["derive"] }
+serde_with = { version = "2", default-features = false, features = ["macros"] }
 serde_qs = "0"
 serde_json = "1"
 # Core SGX types

common/src/api/auth.rs

@@ -177,12 +177,12 @@ impl OpaqueUserAuthToken {
 mod test {
     use super::*;
     use crate::test_utils::roundtrip::{
-        bcs_roundtrip_proptest, signed_roundtrip_proptest,
+        serde_roundtrip_proptest, signed_roundtrip_proptest,
     };
 
     #[test]
     fn test_user_signup_request_canonical() {
-        bcs_roundtrip_proptest::<UserSignupRequest>();
+        serde_roundtrip_proptest::<UserSignupRequest>();
     }
 
     #[test]
@@ -192,7 +192,7 @@ mod test {
 
     #[test]
     fn test_user_auth_request_canonical() {
-        bcs_roundtrip_proptest::<UserAuthRequest>();
+        serde_roundtrip_proptest::<UserAuthRequest>();
     }
 
     #[test]

common/src/api/node.rs → common/src/api/command.rs

@@ -16,3 +16,9 @@ pub struct NodeInfo {
 pub struct ListChannels {
     pub channel_details: Vec<LxChannelDetails>,
 }
+
+#[derive(Serialize, Deserialize)]
+pub struct GetInvoiceRequest {
+    pub amt_msat: Option<u64>,
+    pub expiry_secs: u32,
+}

common/src/api/def.rs

@@ -20,8 +20,8 @@
 
 use async_trait::async_trait;
 
+use crate::api::command::{GetInvoiceRequest, ListChannels, NodeInfo};
 use crate::api::error::{BackendApiError, NodeApiError, RunnerApiError};
-use crate::api::node::{ListChannels, NodeInfo};
 use crate::api::ports::UserPorts;
 use crate::api::provision::{
     Instance, Node, NodeInstanceSeed, NodeProvisionRequest, SealedSeed,
@@ -30,6 +30,7 @@ use crate::api::provision::{
 use crate::api::vfs::{NodeDirectory, NodeFile, NodeFileId};
 use crate::api::UserPk;
 use crate::enclave::Measurement;
+use crate::ln::invoice::LxInvoice;
 
 /// Defines the api that the backend exposes to the node.
 #[async_trait]
@@ -142,4 +143,10 @@ pub trait OwnerNodeRunApi {
     ///
     /// [`EmptyData`]: super::qs::EmptyData
     async fn list_channels(&self) -> Result<ListChannels, NodeApiError>;
+
+    /// POST /owner/get_invoice [`GetInvoiceRequest`] -> [`ListChannels`]
+    async fn get_invoice(
+        &self,
+        req: GetInvoiceRequest,
+    ) -> Result<LxInvoice, NodeApiError>;
 }

common/src/api/error.rs

@@ -222,15 +222,17 @@ pub enum NodeErrorKind {
     #[error("Other reqwest error")]
     Reqwest,
 
+    #[error("Could not proxy request to node")]
+    Proxy,
+
     #[error("Wrong user pk")]
     WrongUserPk,
     #[error("Given node pk doesn't match node pk derived from seed")]
     WrongNodePk,
     #[error("Error occurred during provisioning")]
     Provision,
-
-    #[error("Could not proxy request to node")]
-    Proxy,
+    #[error("Error while executing command")]
+    Command,
 }
 
 /// All variants of errors that the LSP can return.
@@ -499,10 +501,11 @@ impl ErrorCodeConvertible for NodeErrorKind {
             Self::Timeout => 3,
             Self::Decode => 4,
             Self::Reqwest => 5,
-            Self::WrongUserPk => 6,
-            Self::WrongNodePk => 7,
-            Self::Provision => 8,
-            Self::Proxy => 9,
+            Self::Proxy => 6,
+            Self::WrongUserPk => 7,
+            Self::WrongNodePk => 8,
+            Self::Provision => 9,
+            Self::Command => 10,
         }
     }
     fn from_code(code: ErrorCode) -> Self {
@@ -513,10 +516,11 @@ impl ErrorCodeConvertible for NodeErrorKind {
             3 => Self::Timeout,
             4 => Self::Decode,
             5 => Self::Reqwest,
-            6 => Self::WrongUserPk,
-            7 => Self::WrongNodePk,
-            8 => Self::Provision,
-            9 => Self::Proxy,
+            6 => Self::Proxy,
+            7 => Self::WrongUserPk,
+            8 => Self::WrongNodePk,
+            9 => Self::Provision,
+            10 => Self::Command,
             _ => Self::Unknown,
         }
     }
@@ -611,11 +615,12 @@ impl HasStatusCode for NodeApiError {
             Connect => SERVER_503_SERVICE_UNAVAILABLE,
             Timeout => SERVER_504_GATEWAY_TIMEOUT,
             Decode => SERVER_502_BAD_GATEWAY,
+            Proxy => SERVER_502_BAD_GATEWAY,
             Reqwest => CLIENT_400_BAD_REQUEST,
             WrongUserPk => CLIENT_400_BAD_REQUEST,
             WrongNodePk => CLIENT_400_BAD_REQUEST,
             Provision => SERVER_500_INTERNAL_SERVER_ERROR,
-            Proxy => SERVER_502_BAD_GATEWAY,
+            Command => SERVER_500_INTERNAL_SERVER_ERROR,
         }
     }
 }

common/src/api/mod.rs

@@ -20,13 +20,12 @@ use crate::{const_ref_cast, ed25519, hexstr_or_bytes};
 
 /// Authentication and User Signup.
 pub mod auth;
+/// Data types used in APIs for top level commands.
+pub mod command;
 /// Traits defining the various REST API interfaces.
 pub mod def;
 /// Enums for the API errors returned by the various services.
 pub mod error;
-/// Minor data types defining what is returned by APIs exposed by the node.
-/// Bigger / more fundamental LN types should go under [`crate::ln`].
-pub mod node;
 /// `Port`, `Ports`, `UserPorts`, `RunPorts`, etc.
 pub mod ports;
 /// Data types specific to provisioning.
@@ -192,7 +191,7 @@ mod test {
 
     #[test]
     fn user_pk_bcs() {
-        roundtrip::bcs_roundtrip_proptest::<UserPk>();
+        roundtrip::serde_roundtrip_proptest::<UserPk>();
     }
 
     #[test]
@@ -202,6 +201,6 @@ mod test {
 
     #[test]
     fn node_pk_bcs() {
-        roundtrip::bcs_roundtrip_proptest::<NodePk>();
+        roundtrip::serde_roundtrip_proptest::<NodePk>();
     }
 }

common/src/api/rest.rs

@@ -27,15 +27,20 @@ pub const POST: Method = Method::POST;
 pub const DELETE: Method = Method::DELETE;
 
 /// A warp helper that converts `Result<T, E>` into [`Response<Body>`].
-/// This function should be used in all warp routes because:
+/// This function should be used after all *fallible* warp handlers because:
 ///
 /// 1) `RestClient::send_and_deserialize` relies on the HTTP status code to
 ///    determine whether a response should be deserialized as the requested
-///    object or as the error type.
-/// 2) Using this function voids the need to call reply::json(&resp) in every
-///    warp handler or to manually set the error code in every response.
+///    object or as the error type. This function handles this automatically and
+///    consistently across all Lexe APIs.
+/// 2) It saves time; there is no need to call reply::json(&resp) in every warp
+///    handler or to manually set the error code in every response.
+/// 3) Removing the [`warp::Reply`] serialization step from the warp handlers
+///    allows each handler to be independently unit and integration tested.
 ///
-/// This function can be used at the end of a warp filter chain like so:
+/// For infallible handlers, use [`into_succ_response`] instead.
+///
+/// ## Usage
 ///
 /// ```ignore
 /// let status = warp::path("status")
@@ -54,6 +59,24 @@ pub fn into_response<T: Serialize, E: HasStatusCode + Into<ErrorResponse>>(
     }
 }
 
+/// Like [`into_response`], but converts `T` into [`Response<Body>`]. This fn
+/// should be used for the same reasons that [`into_response`] is used, but
+/// applies only to *infallible* handlers.
+///
+/// ## Usage
+///
+/// ```ignore
+/// let node_info = warp::path("node_info")
+///     .and(warp::get())
+///     .and(inject::channel_manager(channel_manager.clone()))
+///     .and(inject::peer_manager(peer_manager))
+///     .map(command::node_info)
+///     .map(into_succ_response);
+/// ```
+pub fn into_succ_response<T: Serialize>(data: T) -> Response<Body> {
+    build_json_response(StatusCode::OK, &data)
+}
+
 /// A warp helper for recovering one of our [`api::error`](crate::api::error)
 /// types if it was emitted from an intermediate filter's rejection and then
 /// converting into the standard json error response.

common/src/client/mod.rs

@@ -7,14 +7,15 @@ pub mod tls;
 use anyhow::Context;
 use async_trait::async_trait;
 
+use crate::api::command::{GetInvoiceRequest, ListChannels, NodeInfo};
 use crate::api::def::{OwnerNodeProvisionApi, OwnerNodeRunApi};
 use crate::api::error::NodeApiError;
-use crate::api::node::{ListChannels, NodeInfo};
 use crate::api::provision::NodeProvisionRequest;
 use crate::api::qs::EmptyData;
 use crate::api::rest::{RestClient, GET, POST};
 use crate::api::UserPk;
 use crate::attest;
+use crate::ln::invoice::LxInvoice;
 use crate::rng::Crng;
 use crate::root_seed::RootSeed;
 
@@ -93,4 +94,14 @@ impl OwnerNodeRunApi for NodeClient {
 
         self.rest.request(GET, url, &data).await
     }
+
+    async fn get_invoice(
+        &self,
+        req: GetInvoiceRequest,
+    ) -> Result<LxInvoice, NodeApiError> {
+        let run_url = &self.run_url;
+        let url = format!("{run_url}/owner/get_invoice");
+
+        self.rest.request(POST, url, &req).await
+    }
 }

common/src/constants.rs

@@ -10,6 +10,8 @@ use crate::ln::peer::ChannelPeer;
 use crate::rng::SysRng;
 use crate::root_seed::RootSeed;
 
+pub const DEFAULT_CHANNEL_SIZE: usize = 256;
+
 pub const DEFAULT_BACKEND_URL: &str = "http://127.0.0.1:3030";
 pub const DEFAULT_GATEWAY_URL: &str = "http://127.0.0.1:4040";
 pub const DEFAULT_RUNNER_URL: &str = "http://127.0.0.1:5050";