Persist payjoin sessions

Author: DanGould

mutiny-core/src/lib.rs

@@ -28,6 +28,7 @@ mod node;
 pub mod nodemanager;
 pub mod nostr;
 mod onchain;
+mod payjoin;
 mod peermanager;
 pub mod redshift;
 pub mod scorer;
@@ -253,6 +254,7 @@ impl<S: MutinyStorage> MutinyWallet<S> {
             .await?,
         );
         NodeManager::start_sync(self.node_manager.clone());
+        NodeManager::resume_payjoins(self.node_manager.clone());
 
         // Redshifts disabled in safe mode
         if !self.config.safe_mode {

mutiny-core/src/nodemanager.rs

@@ -1,5 +1,6 @@
 use crate::lnurlauth::AuthManager;
 use crate::logging::LOGGING_KEY;
+use crate::payjoin::PayjoinStorage;
 use crate::redshift::{RedshiftManager, RedshiftStatus, RedshiftStorage};
 use crate::storage::{MutinyStorage, DEVICE_ID_KEY, KEYCHAIN_STORE_KEY, NEED_FULL_SYNC_KEY};
 use crate::utils::{sleep, spawn};
@@ -802,6 +803,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);
+            });
+        }
+    }
+
     /// Starts a background tasks to poll redshifts until they are ready and then start attempting payments.
     ///
     /// This function will first find redshifts that are in the [RedshiftStatus::AttemptingPayments] state and start attempting payments
@@ -1043,6 +1057,7 @@ impl<S: MutinyStorage> NodeManager<S> {
                 .process_res(ohttp_response.as_ref(), context)
                 .map_err(|e| anyhow!("parse error {}", e))
                 .unwrap();
+            self.storage.persist_payjoin(enrolled.clone()).unwrap();
             let pj_uri = enrolled.fallback_target();
             log_debug!(self.logger, "{pj_uri}");
             // run await payjoin task in the background as it'll keep polling the relay

mutiny-core/src/payjoin.rs

@@ -0,0 +1,39 @@
+use crate::error::MutinyError;
+use crate::storage::MutinyStorage;
+use bitcoin::hashes::hex::ToHex;
+use payjoin::receive::v2::Enrolled;
+use std::collections::HashMap;
+
+// #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+// pub struct Session {
+//     pub id: [u8; 16],
+//     pub enrolled: Enrolled,
+// }
+
+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)
+    }
+}