Persist payjoin sessions

Author: DanGould

mutiny-core/src/lib.rs

@@ -8,6 +8,7 @@
     type_alias_bounds
 )]
 extern crate core;
+extern crate payjoin as pj;
 
 pub mod auth;
 mod chain;
@@ -30,6 +31,7 @@ mod node;
 pub mod nodemanager;
 pub mod nostr;
 mod onchain;
+mod payjoin;
 mod peermanager;
 pub mod scorer;
 pub mod sql;
@@ -46,6 +48,7 @@ pub use crate::gossip::{GOSSIP_SYNC_TIME_KEY, NETWORK_GRAPH_KEY, PROB_SCORER_KEY
 pub use crate::keymanager::generate_seed;
 pub use crate::ldkstorage::{CHANNEL_MANAGER_KEY, MONITORS_PREFIX_KEY};
 
+use crate::payjoin::PayjoinStorage;
 use crate::storage::{MutinyStorage, DEVICE_ID_KEY, EXPECTED_NETWORK_KEY, NEED_FULL_SYNC_KEY};
 use crate::{auth::MutinyAuthClient, logging::MutinyLogger};
 use crate::{error::MutinyError, nostr::ReservedProfile};
@@ -661,6 +664,7 @@ impl<S: MutinyStorage> MutinyWallet<S> {
         // when we restart, gen a new session id
         self.node_manager = Arc::new(nm_builder.build().await?);
         NodeManager::start_sync(self.node_manager.clone());
+        NodeManager::resume_payjoins(self.node_manager.clone());
 
         Ok(())
     }
@@ -929,7 +933,7 @@ impl<S: MutinyStorage> MutinyWallet<S> {
                 .await
                 .unwrap();
 
-            let mut enroller = payjoin::receive::v2::Enroller::from_relay_config(
+            let mut enroller = pj::receive::v2::Enroller::from_relay_config(
                 PAYJOIN_DIR,
                 &ohttp_config_base64,
                 OHTTP_RELAYS[0], // TODO pick ohttp relay at random
@@ -948,6 +952,10 @@ impl<S: MutinyStorage> MutinyWallet<S> {
                 .process_res(ohttp_response.as_ref(), context)
                 .map_err(|e| anyhow!("parse error {}", e))
                 .unwrap();
+            self.node_manager
+                .storage
+                .persist_payjoin(enrolled.clone())
+                .unwrap();
             let pj_uri = enrolled.fallback_target();
             log_debug!(self.logger, "{pj_uri}");
             let wallet = self.node_manager.wallet.clone();

mutiny-core/src/nodemanager.rs

@@ -1,6 +1,7 @@
 use crate::event::{HTLCStatus, PaymentInfo};
 use crate::labels::LabelStorage;
 use crate::logging::LOGGING_KEY;
+use crate::payjoin::PayjoinStorage;
 use crate::utils::{sleep, spawn};
 use crate::ActivityItem;
 use crate::MutinyWalletConfig;
@@ -688,6 +689,19 @@ impl<S: MutinyStorage> NodeManager<S> {
         Ok(())
     }
 
+    /// Starts a background task to poll payjoin sessions to attempt receiving.
+    pub(crate) fn resume_payjoins(nm: Arc<NodeManager<S>>) {
+        let all = nm.storage.get_payjoins().unwrap_or_default();
+        for payjoin in all {
+            let wallet = nm.wallet.clone();
+            let stop = nm.stop.clone();
+            utils::spawn(async move {
+                let pj_txid = Self::receive_payjoin(wallet, stop, payjoin).await.unwrap();
+                log::info!("Received payjoin txid: {}", pj_txid);
+            });
+        }
+    }
+
     /// Creates a background process that will sync the wallet with the blockchain.
     /// This will also update the fee estimates every 10 minutes.
     pub fn start_sync(nm: Arc<NodeManager<S>>) {

mutiny-core/src/payjoin.rs

@@ -0,0 +1,33 @@
+use crate::error::MutinyError;
+use crate::storage::MutinyStorage;
+use bitcoin::hashes::hex::ToHex;
+use payjoin::receive::v2::Enrolled;
+use std::collections::HashMap;
+
+pub trait PayjoinStorage {
+    fn get_payjoin(&self, id: &[u8; 33]) -> Result<Option<Enrolled>, MutinyError>;
+    fn get_payjoins(&self) -> Result<Vec<Enrolled>, MutinyError>;
+    fn persist_payjoin(&self, session: Enrolled) -> Result<(), MutinyError>;
+}
+
+const PAYJOIN_KEY_PREFIX: &str = "payjoin/";
+
+fn get_payjoin_key(id: &[u8; 33]) -> String {
+    format!("{PAYJOIN_KEY_PREFIX}{}", id.to_hex())
+}
+
+impl<S: MutinyStorage> PayjoinStorage for S {
+    fn get_payjoin(&self, id: &[u8; 33]) -> Result<Option<Enrolled>, MutinyError> {
+        let sessions = self.get_data(get_payjoin_key(id))?;
+        Ok(sessions)
+    }
+
+    fn get_payjoins(&self) -> Result<Vec<Enrolled>, MutinyError> {
+        let map: HashMap<String, Enrolled> = self.scan(PAYJOIN_KEY_PREFIX, None)?;
+        Ok(map.values().map(|v| v.to_owned()).collect())
+    }
+
+    fn persist_payjoin(&self, session: Enrolled) -> Result<(), MutinyError> {
+        self.set_data(get_payjoin_key(&session.pubkey()), session, None)
+    }
+}