Handle payjoin errors

Author: DanGould

mutiny-core/src/lib.rs

@@ -1056,59 +1056,21 @@ impl<S: MutinyStorage> MutinyWallet<S> {
             return Err(MutinyError::WalletOperationFailed);
         };
 
-        let pj = {
-            use anyhow::anyhow;
-            // DANGER! TODO get from &self config, do not get config directly from PAYJOIN_DIR ohttp-gateway
-            // That would reveal IP address
-
-            let http_client = reqwest::Client::builder().build().unwrap();
-
-            let ohttp_config_base64 = http_client
-                .get(format!("{}/ohttp-config", crate::payjoin::PAYJOIN_DIR))
-                .send()
-                .await
-                .unwrap()
-                .text()
-                .await
-                .unwrap();
-
-            let mut enroller = pj::receive::v2::Enroller::from_relay_config(
-                crate::payjoin::PAYJOIN_DIR,
-                &ohttp_config_base64,
-                crate::payjoin::OHTTP_RELAYS[0], // TODO pick ohttp relay at random
-            );
-
-            // enroll client
-            let (req, context) = enroller.extract_req().unwrap();
-            let ohttp_response = http_client
-                .post(req.url)
-                .body(req.body)
-                .send()
-                .await
-                .unwrap();
-            let ohttp_response = ohttp_response.bytes().await.unwrap();
-            let enrolled = enroller
-                .process_res(ohttp_response.as_ref(), context)
-                .map_err(|e| anyhow!("parse error {}", e))
-                .unwrap();
-            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, storage, session)
-                    .await
-                    .unwrap();
-                log::info!("Received payjoin txid: {}", pj_txid);
-            });
-            Some(pj_uri)
+        let pj = match self.node_manager.start_payjoin_session().await {
+            Ok(enrolled) => {
+                let session = self
+                    .node_manager
+                    .storage
+                    .persist_payjoin(enrolled.clone())?;
+                let pj_uri = session.enrolled.fallback_target();
+                log_debug!(self.logger, "{pj_uri}");
+                self.node_manager.spawn_payjoin_receiver(session);
+                Some(pj_uri)
+            }
+            Err(e) => {
+                log_error!(self.logger, "Error enrolling payjoin: {e}");
+                None
+            }
         };
 
         Ok(MutinyBip21RawMaterials {

mutiny-core/src/nodemanager.rs

@@ -1,7 +1,7 @@
 use crate::event::HTLCStatus;
 use crate::labels::LabelStorage;
 use crate::logging::LOGGING_KEY;
-use crate::payjoin::PayjoinStorage;
+use crate::payjoin::{Error as PayjoinError, PayjoinStorage};
 use crate::utils::{sleep, spawn};
 use crate::ActivityItem;
 use crate::MutinyInvoice;
@@ -48,6 +48,7 @@ use lightning::util::logger::*;
 use lightning::{log_debug, log_error, log_info, log_warn};
 use lightning_invoice::Bolt11Invoice;
 use lightning_transaction_sync::EsploraSyncClient;
+use payjoin::receive::v2::Enrolled;
 use payjoin::Uri;
 use reqwest::Client;
 use serde::{Deserialize, Serialize};
@@ -580,15 +581,7 @@ impl<S: MutinyStorage> NodeManager<S> {
     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();
-            let storage = Arc::new(nm.storage.clone());
-            utils::spawn(async move {
-                let pj_txid = Self::receive_payjoin(wallet, stop, storage, payjoin)
-                    .await
-                    .unwrap();
-                log::info!("Received payjoin txid: {}", pj_txid);
-            });
+            nm.clone().spawn_payjoin_receiver(payjoin);
         }
     }
 
@@ -680,6 +673,31 @@ impl<S: MutinyStorage> NodeManager<S> {
         Err(MutinyError::WalletOperationFailed)
     }
 
+    pub async fn start_payjoin_session(&self) -> Result<Enrolled, PayjoinError> {
+        // DANGER! TODO get from &self config, do not get config directly from PAYJOIN_DIR ohttp-gateway
+        // That would reveal IP address
+
+        let http_client = reqwest::Client::builder().build()?;
+
+        let ohttp_config_base64 = http_client
+            .get(format!("{}/ohttp-config", crate::payjoin::PAYJOIN_DIR))
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        let mut enroller = payjoin::receive::v2::Enroller::from_relay_config(
+            crate::payjoin::PAYJOIN_DIR,
+            &ohttp_config_base64,
+            crate::payjoin::OHTTP_RELAYS[0], // TODO pick ohttp relay at random
+        );
+        // enroll client
+        let (req, context) = enroller.extract_req()?;
+        let ohttp_response = http_client.post(req.url).body(req.body).send().await?;
+        let ohttp_response = ohttp_response.bytes().await?;
+        Ok(enroller.process_res(ohttp_response.as_ref(), context)?)
+    }
+
     // Send v1 payjoin request
     pub async fn send_payjoin(
         &self,
@@ -753,38 +771,45 @@ impl<S: MutinyStorage> NodeManager<S> {
         Ok(txid)
     }
 
+    pub fn spawn_payjoin_receiver(&self, session: crate::payjoin::Session) {
+        let logger = self.logger.clone();
+        let wallet = self.wallet.clone();
+        let stop = self.stop.clone();
+        let storage = Arc::new(self.storage.clone());
+        utils::spawn(async move {
+            match Self::receive_payjoin(wallet, stop, storage, session).await {
+                Ok(txid) => log_info!(logger, "Received payjoin txid: {txid}"),
+                Err(e) => log_error!(logger, "Error receiving payjoin: {e}"),
+            };
+        });
+    }
+
     /// Poll the payjoin relay to maintain a payjoin session and create a payjoin proposal.
-    pub async fn receive_payjoin(
+    async fn receive_payjoin(
         wallet: Arc<OnChainWallet<S>>,
         stop: Arc<AtomicBool>,
         storage: Arc<S>,
         mut session: crate::payjoin::Session,
-    ) -> Result<Txid, MutinyError> {
+    ) -> Result<Txid, PayjoinError> {
         let http_client = reqwest::Client::builder()
             //.danger_accept_invalid_certs(true) ? is tls unchecked :O
-            .build()
-            .unwrap();
+            .build()?;
         let proposal: payjoin::receive::v2::UncheckedProposal =
             Self::poll_for_fallback_psbt(stop, storage, &http_client, &mut session)
                 .await
                 .unwrap();
-        let payjoin_proposal = wallet.process_payjoin_proposal(proposal).unwrap();
+        let payjoin_proposal = wallet
+            .process_payjoin_proposal(proposal)
+            .map_err(PayjoinError::Wallet)?;
 
-        let (req, ohttp_ctx) = payjoin_proposal.extract_v2_req().unwrap(); // extraction failed
-        let res = http_client
-            .post(req.url)
-            .body(req.body)
-            .send()
-            .await
-            .unwrap();
-        let res = res.bytes().await.unwrap();
+        let (req, ohttp_ctx) = payjoin_proposal.extract_v2_req()?; // extraction failed
+        let res = http_client.post(req.url).body(req.body).send().await?;
+        let res = res.bytes().await?;
         // enroll must succeed
-        let _res = payjoin_proposal
-            .deserialize_res(res.to_vec(), ohttp_ctx)
-            .unwrap();
+        let _res = payjoin_proposal.deserialize_res(res.to_vec(), ohttp_ctx)?;
         // convert from bitcoin 29 to 30
         let txid = payjoin_proposal.psbt().clone().extract_tx().txid();
-        let txid = Txid::from_str(&txid.to_string()).unwrap();
+        let txid = Txid::from_str(&txid.to_string()).map_err(PayjoinError::Txid)?;
         Ok(txid)
     }
 

mutiny-core/src/payjoin.rs

@@ -61,3 +61,44 @@ impl<S: MutinyStorage> PayjoinStorage for S {
         self.delete(&[get_payjoin_key(id)])
     }
 }
+
+#[derive(Debug)]
+pub enum Error {
+    Reqwest(reqwest::Error),
+    ReceiverStateMachine(payjoin::receive::Error),
+    V2Encapsulation(payjoin::v2::Error),
+    Wallet(payjoin::Error),
+    Txid(bitcoin::hashes::hex::Error),
+}
+
+impl std::error::Error for Error {}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match &self {
+            Error::Reqwest(e) => write!(f, "Reqwest error: {}", e),
+            Error::ReceiverStateMachine(e) => write!(f, "Payjoin error: {}", e),
+            Error::V2Encapsulation(e) => write!(f, "Payjoin v2 error: {}", e),
+            Error::Wallet(e) => write!(f, "Payjoin wallet error: {}", e),
+            Error::Txid(e) => write!(f, "Payjoin txid error: {}", e),
+        }
+    }
+}
+
+impl From<reqwest::Error> for Error {
+    fn from(e: reqwest::Error) -> Self {
+        Error::Reqwest(e)
+    }
+}
+
+impl From<payjoin::receive::Error> for Error {
+    fn from(e: payjoin::receive::Error) -> Self {
+        Error::ReceiverStateMachine(e)
+    }
+}
+
+impl From<payjoin::v2::Error> for Error {
+    fn from(e: payjoin::v2::Error) -> Self {
+        Error::V2Encapsulation(e)
+    }
+}