Track pending payjoin transactions in wallet

A receiver payjoin proposal PSBT are tracked as pending since it awaits
a sender signature. This lets the pending TX display in the UI as an
ActivityItem.

Author: DanGould

mutiny-core/src/nodemanager.rs

@@ -715,7 +715,6 @@ impl<S: MutinyStorage> NodeManager<S> {
             .map_err(|_| MutinyError::IncorrectNetwork)?;
         let address = uri.address.clone();
         let original_psbt = self.wallet.create_signed_psbt(address, amount, fee_rate)?;
-
         let fee_rate = if let Some(rate) = fee_rate {
             FeeRate::from_sat_per_vb(rate)
         } else {
@@ -800,10 +799,16 @@ impl<S: MutinyStorage> NodeManager<S> {
         let http_client = reqwest::Client::builder()
             .build()
             .map_err(PayjoinError::Reqwest)?;
-        let proposal: payjoin::receive::v2::UncheckedProposal =
-            Self::poll_for_fallback_psbt(stop, storage, &http_client, &mut session).await?;
+        let proposal: payjoin::receive::v2::UncheckedProposal = Self::poll_for_fallback_psbt(
+            stop,
+            wallet.clone(),
+            storage.clone(),
+            &http_client,
+            &mut session,
+        )
+        .await?;
         let original_tx = proposal.extract_tx_to_schedule_broadcast();
-        let mut payjoin_proposal = match wallet.process_payjoin_proposal(proposal) {
+        let mut payjoin_proposal = match wallet.process_payjoin_proposal(proposal).await {
             Ok(p) => p,
             Err(e) => {
                 wallet.broadcast_transaction(original_tx).await?;
@@ -826,11 +831,23 @@ impl<S: MutinyStorage> NodeManager<S> {
         let _res = payjoin_proposal
             .deserialize_res(res.to_vec(), ohttp_ctx)
             .map_err(|e| PayjoinError::ReceiverStateMachine(e.to_string()))?;
-        Ok(payjoin_proposal.psbt().clone().extract_tx().txid())
+        let payjoin_tx = payjoin_proposal.psbt().clone().extract_tx();
+        let payjoin_txid = payjoin_tx.txid();
+        wallet
+            .insert_tx(
+                payjoin_tx.clone(),
+                ConfirmationTime::unconfirmed(utils::now().as_secs()),
+                None,
+            )
+            .await?;
+        session.payjoin_tx = Some(payjoin_tx);
+        storage.update_recv_session(session)?;
+        Ok(payjoin_txid)
     }
 
     async fn poll_for_fallback_psbt(
         stop: Arc<AtomicBool>,
+        wallet: Arc<OnChainWallet<S>>,
         storage: Arc<S>,
         client: &reqwest::Client,
         session: &mut crate::payjoin::RecvSession,
@@ -841,6 +858,11 @@ impl<S: MutinyStorage> NodeManager<S> {
             }
 
             if session.expiry < utils::now() {
+                if let Some(payjoin_tx) = &session.payjoin_tx {
+                    wallet
+                        .cancel_tx(payjoin_tx)
+                        .map_err(|_| crate::payjoin::Error::CancelPayjoinTx)?;
+                }
                 let _ = storage.delete_recv_session(&session.enrolled.pubkey());
                 return Err(crate::payjoin::Error::SessionExpired);
             }

mutiny-core/src/onchain.rs

@@ -355,6 +355,12 @@ impl<S: MutinyStorage> OnChainWallet<S> {
         Ok(())
     }
 
+    pub(crate) fn cancel_tx(&self, tx: &Transaction) -> Result<(), MutinyError> {
+        let mut wallet = self.wallet.try_write()?;
+        wallet.cancel_tx(tx);
+        Ok(())
+    }
+
     fn is_mine(&self, script: &Script) -> Result<bool, MutinyError> {
         Ok(self.wallet.try_read()?.is_mine(script))
     }
@@ -363,7 +369,7 @@ impl<S: MutinyStorage> OnChainWallet<S> {
         Ok(self.wallet.try_read()?.list_unspent().collect())
     }
 
-    pub fn process_payjoin_proposal(
+    pub async fn process_payjoin_proposal(
         &self,
         proposal: payjoin::receive::v2::UncheckedProposal,
     ) -> Result<payjoin::receive::v2::PayjoinProposal, payjoin::Error> {
@@ -407,21 +413,26 @@ impl<S: MutinyStorage> OnChainWallet<S> {
         let payjoin_proposal = provisional_payjoin.finalize_proposal(
             |psbt| {
                 let mut psbt = psbt.clone();
-                let wallet = self
-                    .wallet
-                    .try_read()
-                    .map_err(|_| Error::Server(MutinyError::WalletSigningFailed.into()))?;
-                wallet
+                self.wallet
+                    .try_write()
+                    .map_err(|_| Error::Server(MutinyError::WalletSigningFailed.into()))?
                     .sign(&mut psbt, SignOptions::default())
                     .map_err(|_| Error::Server(MutinyError::WalletSigningFailed.into()))?;
                 Ok(psbt)
             },
             Some(min_pj_fee_rate),
         )?;
-        let payjoin_proposal_psbt = payjoin_proposal.psbt();
+        let payjoin_psbt_tx = payjoin_proposal.psbt().clone().extract_tx();
+        self.insert_tx(
+            payjoin_psbt_tx,
+            ConfirmationTime::unconfirmed(crate::utils::now().as_secs()),
+            None,
+        )
+        .await
+        .map_err(|_| Error::Server(MutinyError::WalletOperationFailed.into()))?;
         log::debug!(
             "Receiver's Payjoin proposal PSBT Rsponse: {:#?}",
-            payjoin_proposal_psbt
+            payjoin_proposal.psbt()
         );
         Ok(payjoin_proposal)
     }

mutiny-core/src/payjoin.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use crate::error::MutinyError;
 use crate::storage::MutinyStorage;
+use bitcoin::Transaction;
 use core::time::Duration;
 use hex_conservative::DisplayHex;
 use once_cell::sync::Lazy;
@@ -29,6 +30,7 @@ pub(crate) static PAYJOIN_DIR: Lazy<Url> =
 pub struct RecvSession {
     pub enrolled: Enrolled,
     pub expiry: Duration,
+    pub payjoin_tx: Option<Transaction>,
 }
 
 impl RecvSession {
@@ -39,6 +41,7 @@ impl RecvSession {
 pub trait PayjoinStorage {
     fn list_recv_sessions(&self) -> Result<Vec<RecvSession>, MutinyError>;
     fn store_new_recv_session(&self, session: Enrolled) -> Result<RecvSession, MutinyError>;
+    fn update_recv_session(&self, session: RecvSession) -> Result<(), MutinyError>;
     fn delete_recv_session(&self, id: &[u8; 33]) -> Result<(), MutinyError>;
 }
 
@@ -59,11 +62,16 @@ impl<S: MutinyStorage> PayjoinStorage for S {
         let session = RecvSession {
             enrolled,
             expiry: in_24_hours,
+            payjoin_tx: None,
         };
         self.set_data(get_payjoin_key(&session.pubkey()), session.clone(), None)
             .map(|_| session)
     }
 
+    fn update_recv_session(&self, session: RecvSession) -> Result<(), MutinyError> {
+        self.set_data(get_payjoin_key(&session.pubkey()), session, None)
+    }
+
     fn delete_recv_session(&self, id: &[u8; 33]) -> Result<(), MutinyError> {
         self.delete(&[get_payjoin_key(id)])
     }
@@ -89,6 +97,10 @@ pub enum Error {
     OhttpDecodeFailed,
     Shutdown,
     SessionExpired,
+    BadDirectoryHost,
+    BadOhttpWsHost,
+    RequestFailed(String),
+    CancelPayjoinTx,
 }
 
 impl std::error::Error for Error {}
@@ -102,6 +114,10 @@ impl std::fmt::Display for Error {
             Error::OhttpDecodeFailed => write!(f, "Failed to decode ohttp keys"),
             Error::Shutdown => write!(f, "Payjoin stopped by application shutdown"),
             Error::SessionExpired => write!(f, "Payjoin session expired. Create a new payment request and have the sender try again."),
+            Error::BadDirectoryHost => write!(f, "Bad directory host"),
+            Error::BadOhttpWsHost => write!(f, "Bad ohttp ws host"),
+            Error::RequestFailed(e) => write!(f, "Request failed: {}", e),
+            Error::CancelPayjoinTx => write!(f, "Failed to cancel payjoin tx in wallet"),
         }
     }
 }