Enable payjoin expiration

Author: DanGould

mutiny-core/src/lib.rs

@@ -714,17 +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
+            let session = 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();
+            let storage = Arc::new(self.node_manager.storage.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)
+                let pj_txid = NodeManager::receive_payjoin(wallet, stop, storage, session)
                     .await
                     .unwrap();
                 log::info!("Received payjoin txid: {}", pj_txid);

mutiny-core/src/nodemanager.rs

@@ -711,8 +711,11 @@ impl<S: MutinyStorage> NodeManager<S> {
         for payjoin in all {
             let wallet = nm.wallet.clone();
             let stop = nm.stop.clone();
+            let storage = Arc::new(nm.storage.clone());
             utils::spawn(async move {
-                let pj_txid = Self::receive_payjoin(wallet, stop, payjoin).await.unwrap();
+                let pj_txid = Self::receive_payjoin(wallet, stop, storage, payjoin)
+                    .await
+                    .unwrap();
                 log::info!("Received payjoin txid: {}", pj_txid);
             });
         }
@@ -953,14 +956,15 @@ impl<S: MutinyStorage> NodeManager<S> {
     pub async fn receive_payjoin(
         wallet: Arc<OnChainWallet<S>>,
         stop: Arc<AtomicBool>,
-        mut enrolled: payjoin::receive::v2::Enrolled,
+        storage: Arc<S>,
+        mut session: crate::payjoin::Session,
     ) -> Result<Txid, MutinyError> {
         let http_client = reqwest::Client::builder()
             //.danger_accept_invalid_certs(true) ? is tls unchecked :O
             .build()
             .unwrap();
         let proposal: payjoin::receive::v2::UncheckedProposal =
-            Self::poll_for_fallback_psbt(stop, &http_client, &mut enrolled)
+            Self::poll_for_fallback_psbt(stop, storage, &http_client, &mut session)
                 .await
                 .unwrap();
         let payjoin_proposal = wallet.process_payjoin_proposal(proposal).unwrap();
@@ -985,17 +989,23 @@ impl<S: MutinyStorage> NodeManager<S> {
 
     async fn poll_for_fallback_psbt(
         stop: Arc<AtomicBool>,
+        storage: Arc<S>,
         client: &reqwest::Client,
-        enroller: &mut payjoin::receive::v2::Enrolled,
+        session: &mut crate::payjoin::Session,
     ) -> Result<payjoin::receive::v2::UncheckedProposal, ()> {
         loop {
             if stop.load(Ordering::Relaxed) {
                 return Err(()); // stopped
             }
-            let (req, context) = enroller.extract_req().unwrap();
+            if session.expiry < utils::now() {
+                let _ = storage.delete_payjoin(&session.enrolled.pubkey());
+                return Err(()); // expired
+            }
+            let (req, context) = session.enrolled.extract_req().unwrap();
             let ohttp_response = client.post(req.url).body(req.body).send().await.unwrap();
             let ohttp_response = ohttp_response.bytes().await.unwrap();
-            let proposal = enroller
+            let proposal = session
+                .enrolled
                 .process_res(ohttp_response.as_ref(), context)
                 .map_err(|e| anyhow!("parse error {}", e))
                 .unwrap();

mutiny-core/src/payjoin.rs

@@ -1,19 +1,28 @@
 use crate::error::MutinyError;
 use crate::storage::MutinyStorage;
 use bitcoin::hashes::hex::ToHex;
+use core::time::Duration;
 use payjoin::receive::v2::Enrolled;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-// #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-// pub struct Session {
-//     pub id: [u8; 16],
-//     pub enrolled: Enrolled,
-// }
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Session {
+    pub enrolled: Enrolled,
+    pub expiry: Duration,
+}
+
+impl Session {
+    pub fn pubkey(&self) -> [u8; 33] {
+        self.enrolled.pubkey()
+    }
+}
 
 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>;
+    fn get_payjoin(&self, id: &[u8; 33]) -> Result<Option<Session>, MutinyError>;
+    fn get_payjoins(&self) -> Result<Vec<Session>, MutinyError>;
+    fn persist_payjoin(&self, session: Enrolled) -> Result<Session, MutinyError>;
+    fn delete_payjoin(&self, id: &[u8; 33]) -> Result<(), MutinyError>;
 }
 
 const PAYJOIN_KEY_PREFIX: &str = "payjoin/";
@@ -23,17 +32,27 @@ fn get_payjoin_key(id: &[u8; 33]) -> String {
 }
 
 impl<S: MutinyStorage> PayjoinStorage for S {
-    fn get_payjoin(&self, id: &[u8; 33]) -> Result<Option<Enrolled>, MutinyError> {
+    fn get_payjoin(&self, id: &[u8; 33]) -> Result<Option<Session>, 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)?;
+    fn get_payjoins(&self) -> Result<Vec<Session>, MutinyError> {
+        let map: HashMap<String, Session> = 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)
+    fn persist_payjoin(&self, enrolled: Enrolled) -> Result<Session, MutinyError> {
+        let in_24_hours = crate::utils::now() + Duration::from_secs(60 * 60 * 24);
+        let session = Session {
+            enrolled,
+            expiry: in_24_hours,
+        };
+        self.set_data(get_payjoin_key(&session.pubkey()), session.clone(), None)
+            .map(|_| session)
+    }
+
+    fn delete_payjoin(&self, id: &[u8; 33]) -> Result<(), MutinyError> {
+        self.delete(&[get_payjoin_key(id)])
     }
 }