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 redshift;
 pub mod scorer;
@@ -55,6 +57,7 @@ use crate::nostr::nwc::{
     BudgetPeriod, BudgetedSpendingConditions, NwcProfileTag, SpendingConditions,
 };
 use crate::nostr::MUTINY_PLUS_SUBSCRIPTION_LABEL;
+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};
@@ -431,6 +434,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 {
@@ -691,7 +695,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
@@ -710,13 +714,19 @@ 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();
             let stop = self.node_manager.stop.clone();
             // run await payjoin task in the background as it'll keep polling the relay
             utils::spawn(async move {
-                let pj_txid = NodeManager::receive_payjoin(wallet, stop, enrolled).await.unwrap();
+                let pj_txid = NodeManager::receive_payjoin(wallet, stop, enrolled)
+                    .await
+                    .unwrap();
                 log::info!("Received payjoin txid: {}", pj_txid);
             });
             Some(pj_uri)
@@ -727,7 +737,7 @@ impl<S: MutinyStorage> MutinyWallet<S> {
             invoice,
             btc_amount: amount.map(|amount| bitcoin::Amount::from_sat(amount).to_btc().to_string()),
             labels,
-            pj
+            pj,
         })
     }
 

mutiny-core/src/nodemanager.rs

@@ -1,4 +1,5 @@
 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};
@@ -704,6 +705,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

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)
+    }
+}