add pay_offer phoenixd

Author: ntheile

bindings/lni_nodejs/index.d.ts

@@ -175,6 +175,7 @@ export declare class PhoenixdNode {
   getInfo(): Promise<NodeInfo>
   makeInvoice(params: PhoenixdMakeInvoiceParams): Promise<Transaction>
   lookupInvoice(paymentHash: string): Promise<Transaction>
+  payOffer(offer: string, amount: number, payerNote?: string | undefined | null): Promise<PayInvoiceResponse>
   listTransactions(params: ListTransactionsParams): Promise<Array<Transaction>>
 }
 export declare class Db {

bindings/lni_nodejs/main.mjs

@@ -21,9 +21,12 @@ const invoice = await node.makeInvoice({
 });
 console.log("Invoice:", invoice);
 
-const lookupInvoice = await node.lookupInvoice(config.test_hash);
+const lookupInvoice = await node.lookupInvoice(process.env.PHOENIXD_TEST_PAYMENT_HASH);
 console.log("lookupInvoice:", lookupInvoice);
 
+const payOffer = await node.payOffer(process.env.TEST_OFFER, 22, 'payment from lni nodejs');
+console.log("payOffer:", payOffer);
+
 const txns = await node.listTransactions({
   from: 0,
   until: 0,

bindings/lni_nodejs/src/phoenixd.rs

@@ -70,7 +70,28 @@ impl PhoenixdNode {
   }
 
   #[napi]
-  pub async fn list_transactions(&self, params: lni::phoenixd::lib::ListTransactionsParams) -> napi::Result<Vec<lni::Transaction>> {
+  pub async fn pay_offer(
+    &self,
+    offer: String,
+    amount: i64,
+    payer_note: Option<String>,
+  ) -> napi::Result<lni::PayInvoiceResponse> {
+    let offer = lni::phoenixd::api::pay_offer(
+      self.inner.url.clone(),
+      self.inner.password.clone(),
+      offer,
+      amount,
+      payer_note,
+    ).await
+    .map_err(|e| napi::Error::from_reason(e.to_string()))?;
+    Ok(offer)
+  }
+
+  #[napi]
+  pub async fn list_transactions(
+    &self,
+    params: lni::phoenixd::lib::ListTransactionsParams,
+  ) -> napi::Result<Vec<lni::Transaction>> {
     let txns = lni::phoenixd::api::list_transactions(
       self.inner.url.clone(),
       self.inner.password.clone(),

bindings/lni_uniffi/src/lni.udl

@@ -14,6 +14,10 @@ interface PhoenixdNode {
 
     [Throws=ApiError, Async]
     sequence<Transaction> list_transactions(ListTransactionsParams params);
+
+    [Throws=ApiError, Async]
+    PayInvoiceResponse pay_offer(string offer, i64 amount, string? payer_note );
+
 };
 
 interface Db {

crates/lni/phoenixd/api.rs

@@ -1,7 +1,7 @@
-use crate::{ApiError, InvoiceType, NodeInfo, Transaction};
+use super::lib::Bolt11Resp;
+use crate::{ApiError, InvoiceType, NodeInfo, PayInvoiceResponse, Transaction};
 use serde::{Deserialize, Serialize};
 use serde_urlencoded;
-use super::lib::Bolt11Resp;
 
 /// https://phoenix.acinq.co/server/api
 
@@ -75,6 +75,17 @@ pub struct OutgoingPaymentResponse {
     pub is_paid: bool,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PayResponse {
+    #[serde(rename = "paymentId")]
+    pub payment_id: String,
+    #[serde(rename = "paymentPreimage")]
+    pub preimage: String,
+    #[serde(rename = "paymentHash")]
+    pub payment_hash: String,
+    #[serde(rename = "routingFeeSat")]
+    pub routing_fee_sat: i64,
+}
 
 pub fn get_info(url: String, password: String) -> Result<NodeInfo, ApiError> {
     let url = format!("{}/getinfo", url);
@@ -114,8 +125,8 @@ pub async fn make_invoice(
                 description: description.clone(),
                 amount_sat: amount,
                 expiry_seconds: expiry.unwrap_or(3600),
-                external_id: None, // TODO 
-                webhook_url: None, // TODO 
+                external_id: None, // TODO
+                webhook_url: None, // TODO
             };
 
             let response: reqwest::blocking::Response = client
@@ -128,7 +139,7 @@ pub async fn make_invoice(
             println!("Status: {}", response.status());
 
             let invoice_str = response.text().unwrap();
-            let invoice_str = invoice_str.as_str(); 
+            let invoice_str = invoice_str.as_str();
             println!("Bolt11 {}", &invoice_str.to_string());
 
             let bolt11_resp: Bolt11Resp =
@@ -175,6 +186,37 @@ pub async fn make_invoice(
     }
 }
 
+pub async fn pay_offer(
+    url: String,
+    password: String,
+    offer: String,
+    amount: i64,
+    payer_note: Option<String>,
+) -> Result<PayInvoiceResponse, ApiError> {
+    let client = reqwest::blocking::Client::new();
+    let req_url = format!("{}/payoffer", url);
+    let response: reqwest::blocking::Response = client
+        .post(&req_url)
+        .basic_auth("", Some(password))
+        .form(&[
+            ("amountSat", amount.to_string()),
+            ("offer", offer),
+            ("message", payer_note.unwrap_or_default()),
+        ])
+        .send()
+        .unwrap();
+    let response_text = response.text().unwrap();
+    let response_text = response_text.as_str();
+    let pay_resp: PayResponse = match serde_json::from_str(&response_text) {
+        Ok(resp) => resp,
+        Err(e) => return Err(ApiError::Json { reason: e.to_string() }),
+    };
+    Ok(PayInvoiceResponse {
+        preimage: pay_resp.preimage,
+        fee: pay_resp.routing_fee_sat,
+    })
+}
+
 pub fn lookup_invoice(
     url: String,
     password: String,
@@ -203,7 +245,6 @@ pub fn lookup_invoice(
     Ok(txn)
 }
 
-
 pub fn list_transactions(
     url: String,
     password: String,
@@ -263,10 +304,10 @@ pub fn list_transactions(
                 amount: inv.received_sat,
                 fees_paid: inv.fees * 1000,
                 created_at: (inv.created_at / 1000) as i64,
-                expires_at: 0, // TODO 
+                expires_at: 0, // TODO
                 settled_at: settled_at.unwrap_or(0),
                 description: inv.payer_note.unwrap_or_default(), // TODO description or payer_note?
-                description_hash: "".to_string(), // or parse if needed
+                description_hash: "".to_string(),                // or parse if needed
             }
         })
         .collect();
@@ -298,7 +339,8 @@ pub fn list_transactions(
         .send();
     let outgoing_text = outgoing_resp.unwrap().text().unwrap();
     let outgoing_text = outgoing_text.as_str();
-    let outgoing_payments: Vec<OutgoingPaymentResponse> = serde_json::from_str(&outgoing_text).unwrap();
+    let outgoing_payments: Vec<OutgoingPaymentResponse> =
+        serde_json::from_str(&outgoing_text).unwrap();
 
     // Convert outgoing payments into "outgoing" Transaction
     for payment in outgoing_payments {
@@ -309,15 +351,15 @@ pub fn list_transactions(
         };
         transactions.push(Transaction {
             type_: "outgoing".to_string(),
-            invoice: "".to_string(), // TODO 
+            invoice: "".to_string(), // TODO
             preimage: payment.preimage,
             payment_hash: payment.payment_hash,
             amount: payment.sent * 1000,
             fees_paid: payment.fees * 1000,
             created_at: (payment.created_at / 1000) as i64,
             expires_at: 0, // TODO
             settled_at: settled_at.unwrap_or(0),
-            description: "".to_string(),  // not in OutgoingPaymentResponse data
+            description: "".to_string(), // not in OutgoingPaymentResponse data
             description_hash: "".to_string(),
         });
     }
@@ -327,4 +369,3 @@ pub fn list_transactions(
 
     Ok(transactions)
 }
-

crates/lni/phoenixd/lib.rs

@@ -1,7 +1,7 @@
 #[cfg(feature = "napi_rs")]
 use napi_derive::napi;
 
-use crate::{phoenixd::api::*, ApiError, InvoiceType, Transaction};
+use crate::{phoenixd::api::*, ApiError, InvoiceType, PayInvoiceResponse, Transaction};
 use serde::{Deserialize, Serialize};
 
 #[cfg_attr(feature = "napi_rs", napi(object))]
@@ -76,7 +76,26 @@ impl PhoenixdNode {
         .await
     }
 
-    pub async fn lookup_invoice(&self, payment_hash: String) -> Result<crate::Transaction, ApiError> {
+    pub async fn pay_offer(
+        &self,
+        offer: String,
+        amount: i64,
+        payer_note: Option<String>,
+    ) -> Result<PayInvoiceResponse, ApiError> {
+        crate::phoenixd::api::pay_offer(
+            self.url.clone(),
+            self.password.clone(),
+            offer,
+            amount,
+            payer_note,
+        )
+        .await
+    }
+
+    pub async fn lookup_invoice(
+        &self,
+        payment_hash: String,
+    ) -> Result<crate::Transaction, ApiError> {
         crate::phoenixd::api::lookup_invoice(self.url.clone(), self.password.clone(), payment_hash)
     }
 
@@ -124,6 +143,10 @@ mod tests {
             dotenv().ok();
             env::var("PHOENIXD_TEST_PAYMENT_HASH").expect("PHOENIXD_TEST_PAYMENT_HASH must be set")
         };
+        static ref TEST_OFFER: String = {
+            dotenv().ok();
+            env::var("TEST_OFFER").expect("TEST_OFFER must be set")
+        };
     }
 
     #[test]
@@ -164,6 +187,22 @@ mod tests {
         }
     }
 
+    #[test]
+    async fn test_pay_offer() {
+        match NODE
+            .pay_offer(TEST_OFFER.to_string(), 11, Some("payment from lni".to_string()))
+            .await
+        {
+            Ok(resp) => {
+                println!("Pay invoice resp: {:?}", resp);
+                assert!(!resp.preimage.is_empty(), "Preimage should not be empty");
+            }
+            Err(e) => {
+                panic!("Failed to pay offer: {:?}", e);
+            }
+        }
+    }
+
     #[test]
     async fn test_list_transactions() {
         let params = ListTransactionsParams {

readme.md

@@ -40,6 +40,7 @@ let cln_rune = cln_node.key();
 ```rust
 lni.create_invoice(amount, expiration, memo, BOLT11 | BOLT12)
 lni.pay_invoice()
+lni.pay_offer(offer)
 lni.fetch_invoice_from_offer('lno***')
 lni.decode_invoice(invoice)
 lni.check_invoice_status(invoice)
@@ -119,6 +120,7 @@ node main.mjs
 PHOENIXD_URL=http://localhost:9740
 PHOENIXD_PASSWORD=YOUR_HTTP_PASSWORD
 PHOENIXD_TEST_PAYMENT_HASH=YOUR_TEST_PAYMENT_HASH
+TEST_OFFER=lno***
 ```
 
 Bindings
@@ -127,7 +129,8 @@ Bindings
 - nodejs 
     - napi_rs
     - https://napi.rs/docs/introduction/simple-package
-    - `cd bindings/lni_nodejs && cargo build`
+    - `cd bindings/lni_nodejs && cargo build && yarn build`
+    - test `node main.mjs`
 
 - react-native 
     - uniffi-bindgen-react-native