Persist payjoin sessions

Author: DanGould

Cargo.lock

@@ -41,7 +41,8 @@ cbc = { version = "0.1", features = ["alloc"] }
 aes = { version = "0.8" }
 jwt-compact = { version = "0.8.0-beta.1", features = ["es256k"] }
 argon2 = { version = "0.5.0", features = ["password-hash", "alloc"] }
-payjoin = { git = "https://github.com/DanGould/rust-payjoin.git", branch = "serverless-payjoin", features = ["v2", "send", "receive", "base64"] }
+#payjoin = { git = "https://github.com/DanGould/rust-payjoin.git", branch = "serverless-payjoin", features = ["v2", "send", "receive", "base64"] }
+payjoin = { path = "../../payjoin/payjoin", features = ["v2", "send", "receive", "base64"] }
 hashbrown = { version = "0.8" }
 base64 = "0.13.0"
 pbkdf2 = "0.11"

mutiny-core/Cargo.toml

@@ -32,6 +32,7 @@ mod node;
 pub mod nodemanager;
 pub mod nostr;
 mod onchain;
+mod payjoin;
 mod peermanager;
 pub mod redshift;
 pub mod scorer;
@@ -226,6 +227,7 @@ impl<S: MutinyStorage> MutinyWallet<S> {
         self.node_manager =
             Arc::new(NodeManager::new(self.config.clone(), self.storage.clone(), None).await?);
         NodeManager::start_sync(self.node_manager.clone());
+        NodeManager::start_payjoins(self.node_manager.clone());
 
         // Redshifts disabled in safe mode
         if !self.config.safe_mode {

mutiny-core/src/lib.rs

@@ -1,6 +1,7 @@
 use crate::lnurlauth::AuthManager;
 use crate::logging::LOGGING_KEY;
 use crate::multiesplora::MultiEsploraClient;
+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};
@@ -844,6 +845,14 @@ impl<S: MutinyStorage> NodeManager<S> {
     /// Starts a background tasks to poll payjoin directory to attempt receiving.
     pub(crate) fn start_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.
@@ -1078,6 +1087,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/nodemanager.rs

@@ -359,7 +359,7 @@ impl<S: MutinyStorage> OnChainWallet<S> {
 
     fn try_contributing_inputs(
         &self,
-        payjoin: &mut payjoin::receive::ProvisionalProposal,
+        payjoin: &mut payjoin::receive::v2::ProvisionalProposal,
     ) -> Result<(), MutinyError> {
         use payjoin::bitcoin::{Amount, OutPoint};
 

mutiny-core/src/onchain.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)
+    }
+}