Introduce PaymentStore to store external payment information

Author: andrei-21

libs/sdk-core/src/breez_services.rs

@@ -37,6 +37,7 @@ use crate::models::{
 };
 use crate::node_api::NodeAPI;
 use crate::persist::db::SqliteStorage;
+use crate::persist::payment_store::PaymentStore;
 use crate::persist::swap::SwapStorage;
 use crate::persist::transactions::PaymentStorage;
 use crate::receiver::{PaymentReceiver, Receiver};
@@ -144,6 +145,7 @@ pub struct BreezServices {
     config: Config,
     started: Mutex<bool>,
     node_api: Arc<dyn NodeAPI>,
+    payment_store: Arc<dyn PaymentStore>,
     lsp_api: Arc<dyn LspAPI>,
     receiver: Arc<dyn Receiver>,
     fiat_api: Arc<dyn FiatAPI>,
@@ -297,6 +299,17 @@ impl BreezServices {
             return Err(SendPaymentError::AlreadyPaid);
         }
 
+        let info = LnPaymentInfo {
+            bolt11: parsed_invoice.bolt11.clone(),
+            payment_hash: parsed_invoice.payment_hash.clone(),
+            destination_pubkey: parsed_invoice.payee_pubkey.clone(),
+            description: parsed_invoice.description.clone(),
+            keysend: false,
+        };
+        self.payment_store
+            .set_ln_info(&parsed_invoice.payment_hash, &info)
+            .await?;
+
         self.persist_pending_payment(&parsed_invoice, amount_msat)?;
 
         debug!("attempting normal payment");
@@ -414,9 +427,24 @@ impl BreezServices {
 
                 let lnurl_pay_domain = match req.data.ln_address {
                     Some(_) => None,
-                    None => Some(req.data.domain),
+                    None => Some(req.data.domain.clone()),
                 };
                 // Store SA (if available) + LN Address in separate table, associated to payment_hash
+                let target = match &req.data.ln_address {
+                    Some(address) => LnUrlPayTarget::LnAddress(address.clone()),
+                    None => LnUrlPayTarget::Domain(req.data.domain),
+                };
+                let info = LnUrlPayInfo {
+                    target,
+                    metadata: req.data.metadata_str.clone(),
+                    comment: req.comment.clone(),
+                    success_action: maybe_sa_processed.clone(),
+                };
+                let info = LnUrlInfo::Pay(info);
+                self.payment_store
+                    .set_lnurl_info(&invoice.payment_hash, &info)
+                    .await?;
+
                 self.persister.insert_payment_external_info(
                     &details.payment_hash,
                     PaymentExternalInfo {
@@ -465,6 +493,14 @@ impl BreezServices {
         let res = validate_lnurl_withdraw(self.rest_client.as_ref(), req.data, invoice).await?;
 
         if let LnUrlWithdrawResult::Ok { ref data } = res {
+            let info = LnUrlWithdrawInfo {
+                endpoint: lnurl_w_endpoint.clone(),
+            };
+            let info = LnUrlInfo::Withdraw(info);
+            self.payment_store
+                .set_lnurl_info(&data.invoice.payment_hash, &info)
+                .await?;
+
             // If endpoint was successfully called, store the LNURL-withdraw endpoint URL as metadata linked to the invoice
             self.persister.insert_payment_external_info(
                 &data.invoice.payment_hash,
@@ -1887,6 +1923,7 @@ struct BreezServicesBuilder {
     node_api: Option<Arc<dyn NodeAPI>>,
     backup_transport: Option<Arc<dyn BackupTransport>>,
     seed: Option<Vec<u8>>,
+    payment_store: Option<Arc<dyn PaymentStore>>,
     lsp_api: Option<Arc<dyn LspAPI>>,
     fiat_api: Option<Arc<dyn FiatAPI>>,
     persister: Option<Arc<SqliteStorage>>,
@@ -1908,6 +1945,7 @@ impl BreezServicesBuilder {
             config,
             node_api: None,
             seed: None,
+            payment_store: None,
             lsp_api: None,
             fiat_api: None,
             persister: None,
@@ -1927,6 +1965,11 @@ impl BreezServicesBuilder {
         self
     }
 
+    pub fn payment_store(&mut self, payment_store: Arc<dyn PaymentStore>) -> &mut Self {
+        self.payment_store = Some(payment_store);
+        self
+    }
+
     #[cfg(test)]
     pub fn lsp_api(&mut self, lsp_api: Arc<dyn LspAPI>) -> &mut Self {
         self.lsp_api = Some(lsp_api.clone());
@@ -2023,6 +2066,7 @@ impl BreezServicesBuilder {
         let mut node_api = self.node_api.clone();
         let mut backup_transport = self.backup_transport.clone();
         let mut lsp_api = self.lsp_api.clone();
+        let mut payment_store = self.payment_store.clone();
         if node_api.is_none() {
             let node_impls = node_builder::build_node(
                 self.config.clone(),
@@ -2034,7 +2078,11 @@ impl BreezServicesBuilder {
             node_api = Some(node_impls.node);
             backup_transport = backup_transport.or(Some(node_impls.backup_transport));
             lsp_api = lsp_api.or(node_impls.lsp);
+            payment_store = payment_store.or(Some(node_impls.payment_store));
         }
+        let payment_store = payment_store.ok_or(ConnectError::Generic {
+            err: "Payment store should be provided".into(),
+        })?;
         let lsp_api = lsp_api.ok_or(ConnectError::Generic {
             err: "LSP Api should be provided".into(),
         })?;
@@ -2149,6 +2197,7 @@ impl BreezServicesBuilder {
             config: self.config.clone(),
             started: Mutex::new(false),
             node_api: unwrapped_node_api.clone(),
+            payment_store,
             lsp_api,
             receiver,
             fiat_api: self
@@ -2542,6 +2591,7 @@ pub(crate) mod tests {
             .fiat_api(Arc::new(MockBreezServer {}))
             .node_api(node_api)
             .persister(persister)
+            .payment_store(Arc::new(MockPaymentStore::default()))
             .backup_transport(Arc::new(MockBackupTransport::new()))
             .build(None, None)
             .await?;
@@ -2705,6 +2755,7 @@ pub(crate) mod tests {
             .persister(persister)
             .node_api(node_api)
             .rest_client(rest_client)
+            .payment_store(Arc::new(MockPaymentStore::default()))
             .backup_transport(Arc::new(MockBackupTransport::new()))
             .build(None, None)
             .await?;

libs/sdk-core/src/ldk/node_api.rs

@@ -38,6 +38,7 @@ use crate::models::{Config, LspAPI, NodeState, OpeningFeeParams, OpeningFeeParam
 use crate::node_api::{
     CreateInvoiceRequest, FetchBolt11Result, IncomingPayment, NodeAPI, NodeError, NodeResult,
 };
+use crate::persist::payment_store::PaymentStore;
 use crate::{
     CustomMessage, LspInformation, MaxChannelAmount, Payment, PaymentResponse,
     PrepareRedeemOnchainFundsRequest, PrepareRedeemOnchainFundsResponse, RouteHintHop, TlvEntry,
@@ -129,6 +130,10 @@ impl Ldk {
             remote_lock_shutdown_tx,
         })
     }
+
+    pub fn get_payment_store(&self) -> Arc<dyn PaymentStore> {
+        Arc::new(self.store.clone())
+    }
 }
 
 #[tonic::async_trait]

libs/sdk-core/src/ldk/store/kv_store.rs

@@ -1,16 +1,22 @@
 use core::convert::TryInto;
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use bitcoin::io::{Error, ErrorKind};
-use ldk_node::lightning::util::persist::KVStoreSync;
+use ldk_node::lightning::util::persist::{KVStore as KVStoreAsync, KVStoreSync};
 use ldk_node::lightning_types::payment::{PaymentHash, PaymentPreimage};
 use ldk_node::DynStore;
 
+use crate::error::{SdkError, SdkResult};
 use crate::ldk::utils::Hex;
+use crate::persist::payment_store::PaymentStore;
+use crate::{LnPaymentInfo, LnUrlInfo};
 
 pub(crate) const BREEZ_NS: &str = "breez";
 pub(crate) const BOLT11_NS: &str = "bolt11";
 pub(crate) const PREIMAGES_NS: &str = "preimages";
+pub(crate) const LN_INFOS_NS: &str = "ln_infos";
+pub(crate) const LNURL_INFOS_NS: &str = "lnurl_infos";
 
 pub(crate) type KVStore = Arc<DynStore>;
 
@@ -69,3 +75,57 @@ impl Store {
         }
     }
 }
+
+#[tonic::async_trait]
+impl PaymentStore for Store {
+    async fn set_ln_info(&self, payment_id: &str, info: &LnPaymentInfo) -> SdkResult<()> {
+        let info = serde_json::to_vec(info)?;
+        KVStoreAsync::write(
+            self.kv_store.as_ref(),
+            BREEZ_NS,
+            LN_INFOS_NS,
+            payment_id,
+            info,
+        )
+        .await
+        .map_err(Into::into)
+    }
+
+    async fn set_lnurl_info(&self, payment_id: &str, info: &LnUrlInfo) -> SdkResult<()> {
+        let info = serde_json::to_vec(info)?;
+        KVStoreAsync::write(
+            self.kv_store.as_ref(),
+            BREEZ_NS,
+            LNURL_INFOS_NS,
+            payment_id,
+            info,
+        )
+        .await
+        .map_err(Into::into)
+    }
+
+    async fn get_info(&self, payment_ids: &[&str]) -> SdkResult<HashMap<String, LnPaymentInfo>> {
+        let mut infos = HashMap::new();
+        for payment_id in payment_ids {
+            match KVStoreAsync::read(self.kv_store.as_ref(), BREEZ_NS, LN_INFOS_NS, payment_id)
+                .await
+            {
+                Ok(raw) => {
+                    let info = serde_json::from_slice::<LnPaymentInfo>(&raw)?;
+                    infos.insert((*payment_id).to_string(), info);
+                }
+                Err(err) if err.kind() == ErrorKind::NotFound => {}
+                Err(err) => return Err(SdkError::generic(&err.to_string())),
+            }
+        }
+        Ok(infos)
+    }
+}
+
+impl From<Error> for SdkError {
+    fn from(err: Error) -> Self {
+        SdkError::Generic {
+            err: err.to_string(),
+        }
+    }
+}

libs/sdk-core/src/models.rs

@@ -672,6 +672,40 @@ pub(crate) struct PaymentExternalInfo {
     pub attempted_error: Option<String>,
 }
 
+#[derive(Clone, Serialize, Deserialize)]
+pub(crate) enum LnUrlPayTarget {
+    LnAddress(String),
+    Domain(String),
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub(crate) struct LnUrlPayInfo {
+    pub target: LnUrlPayTarget,
+    pub metadata: String,
+    pub comment: Option<String>,
+    pub success_action: Option<SuccessActionProcessed>,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub(crate) struct LnUrlWithdrawInfo {
+    pub endpoint: String,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub(crate) enum LnUrlInfo {
+    Pay(LnUrlPayInfo),
+    Withdraw(LnUrlWithdrawInfo),
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub(crate) struct LnPaymentInfo {
+    pub bolt11: String,
+    pub payment_hash: String,
+    pub destination_pubkey: String,
+    pub description: Option<String>,
+    pub keysend: bool,
+}
+
 /// Represents a list payments request.
 #[derive(Default)]
 pub struct ListPaymentsRequest {

libs/sdk-core/src/node_builder.rs

@@ -5,11 +5,13 @@ use crate::ldk::{Ldk, LdkBackupTransport};
 use crate::models::{Config, LspAPI};
 use crate::node_api::{NodeAPI, NodeResult};
 use crate::persist::db::SqliteStorage;
+use crate::persist::payment_store::PaymentStore;
 
 pub struct NodeImpls {
     pub node: Arc<dyn NodeAPI>,
     pub backup_transport: Arc<dyn BackupTransport>,
     pub lsp: Option<Arc<dyn LspAPI>>,
+    pub payment_store: Arc<dyn PaymentStore>,
 }
 
 #[allow(unused_variables)]
@@ -23,9 +25,11 @@ pub async fn build_node(
     let ldk = Ldk::build(config, &seed, restore_only).await?;
     let ldk = Arc::new(ldk);
     let lsp: Option<Arc<dyn LspAPI>> = Some(ldk.clone());
+    let payment_store = ldk.get_payment_store();
     Ok(NodeImpls {
         node: ldk,
         backup_transport,
         lsp,
+        payment_store,
     })
 }

libs/sdk-core/src/persist/mod.rs

@@ -2,6 +2,7 @@ pub(crate) mod cache;
 pub(crate) mod db;
 pub(crate) mod error;
 pub(crate) mod migrations;
+pub(crate) mod payment_store;
 pub(crate) mod reverseswap;
 pub(crate) mod send_pays;
 pub(crate) mod settings;

libs/sdk-core/src/persist/payment_store.rs

@@ -0,0 +1,12 @@
+use std::collections::HashMap;
+
+use crate::error::SdkResult;
+use crate::models::LnPaymentInfo;
+use crate::LnUrlInfo;
+
+#[tonic::async_trait]
+pub trait PaymentStore: Send + Sync {
+    async fn set_ln_info(&self, payment_id: &str, info: &LnPaymentInfo) -> SdkResult<()>;
+    async fn set_lnurl_info(&self, payment_id: &str, info: &LnUrlInfo) -> SdkResult<()>;
+    async fn get_info(&self, payment_ids: &[&str]) -> SdkResult<HashMap<String, LnPaymentInfo>>;
+}

libs/sdk-core/src/test_utils.rs

@@ -41,12 +41,13 @@ use crate::lightning::bitcoin::secp256k1 as ldk_secp256k1;
 use crate::lightning_invoice::{Currency, InvoiceBuilder, PaymentSecret, RawBolt11Invoice};
 use crate::lsp::LspInformation;
 use crate::models::{
-    LnPaymentDetails, LspAPI, NodeState, Payment, PaymentDetails, PaymentStatus, PaymentType,
-    ReverseSwapServiceAPI, SwapperAPI, TlvEntry,
+    LnPaymentDetails, LnPaymentInfo, LnUrlInfo, LspAPI, NodeState, Payment, PaymentDetails,
+    PaymentStatus, PaymentType, ReverseSwapServiceAPI, SwapperAPI, TlvEntry,
 };
 use crate::node_api::{
     CreateInvoiceRequest, FetchBolt11Result, IncomingPayment, NodeAPI, NodeError, NodeResult,
 };
+use crate::persist::payment_store::PaymentStore;
 use crate::swap_in::TaprootSwapperAPI;
 use crate::swap_out::boltzswap::{BoltzApiCreateReverseSwapResponse, BoltzApiReverseSwapStatus};
 use crate::swap_out::error::{ReverseSwapError, ReverseSwapResult};
@@ -164,6 +165,42 @@ impl ReverseSwapServiceAPI for MockReverseSwapperAPI {
     }
 }
 
+#[derive(Default)]
+pub struct MockPaymentStore {
+    ln_info: std::sync::Mutex<HashMap<String, LnPaymentInfo>>,
+    lnurl_info: std::sync::Mutex<HashMap<String, LnUrlInfo>>,
+}
+
+#[tonic::async_trait]
+impl PaymentStore for MockPaymentStore {
+    async fn set_ln_info(&self, payment_id: &str, info: &LnPaymentInfo) -> SdkResult<()> {
+        self.ln_info
+            .lock()
+            .unwrap()
+            .insert(payment_id.to_string(), info.clone());
+        Ok(())
+    }
+
+    async fn set_lnurl_info(&self, payment_id: &str, info: &LnUrlInfo) -> SdkResult<()> {
+        self.lnurl_info
+            .lock()
+            .unwrap()
+            .insert(payment_id.to_string(), info.clone());
+        Ok(())
+    }
+
+    async fn get_info(&self, payment_ids: &[&str]) -> SdkResult<HashMap<String, LnPaymentInfo>> {
+        let ln_info = self.ln_info.lock().unwrap();
+        let mut res = HashMap::new();
+        for payment_id in payment_ids {
+            if let Some(info) = ln_info.get(*payment_id) {
+                res.insert((*payment_id).to_string(), info.clone());
+            }
+        }
+        Ok(res)
+    }
+}
+
 #[derive(Clone)]
 pub struct MockChainService {
     pub tip: u32,