Stop payjoin session with nodemanager

Author: DanGould

mutiny-core/src/nodemanager.rs

@@ -841,6 +841,11 @@ impl<S: MutinyStorage> NodeManager<S> {
         Ok(())
     }
 
+    /// 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();
+    }
+
     /// 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
@@ -1075,11 +1080,11 @@ impl<S: MutinyStorage> NodeManager<S> {
                 .unwrap();
             let pj_uri = enrolled.fallback_target();
             log_debug!(self.logger, "{pj_uri}");
-            let wallet = self.wallet.clone();
             // run await payjoin task in the background as it'll keep polling the relay
+            let wallet = self.wallet.clone();
+            let stop = self.stop.clone();
             utils::spawn(async move {
-                let wallet = wallet.clone();
-                let pj_txid = Self::receive_payjoin(wallet, enrolled).await.unwrap();
+                let pj_txid = Self::receive_payjoin(wallet, stop, enrolled).await.unwrap();
                 log::info!("Received payjoin txid: {}", pj_txid);
             });
             Some(pj_uri)
@@ -1170,19 +1175,20 @@ impl<S: MutinyStorage> NodeManager<S> {
     /// Poll the payjoin relay to maintain a payjoin session and create a payjoin proposal.
     pub async fn receive_payjoin(
         wallet: Arc<OnChainWallet<S>>,
+        stop: Arc<AtomicBool>,
         mut enrolled: payjoin::receive::v2::Enrolled,
     ) -> 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(&http_client, &mut enrolled)
+            Self::poll_for_fallback_psbt(stop, &http_client, &mut enrolled)
                 .await
                 .unwrap();
         let payjoin_proposal = wallet.process_payjoin_proposal(proposal).unwrap();
 
-        let (req, ohttp_ctx) = payjoin_proposal.extract_v2_req().unwrap();
+        let (req, ohttp_ctx) = payjoin_proposal.extract_v2_req().unwrap(); // extraction failed
         let res = http_client
             .post(req.url)
             .body(req.body)
@@ -1201,10 +1207,14 @@ impl<S: MutinyStorage> NodeManager<S> {
     }
 
     async fn poll_for_fallback_psbt(
+        stop: Arc<AtomicBool>,
         client: &reqwest::Client,
         enroller: &mut payjoin::receive::v2::Enrolled,
     ) -> Result<payjoin::receive::v2::UncheckedProposal, ()> {
         loop {
+            if stop.load(Ordering::Relaxed) {
+                return Err(()); // stopped
+            }
             let (req, context) = enroller.extract_req().unwrap();
             let ohttp_response = client.post(req.url).body(req.body).send().await.unwrap();
             let ohttp_response = ohttp_response.bytes().await.unwrap();