Create ProvisionalProposal non-blocking interface

Author: xstoicunicornx

payjoin/src/core/receive/common/mod.rs

@@ -862,8 +862,7 @@ mod tests {
             .commit_inputs()
             .calculate_psbt_context_with_fee_range(None, None)
             .expect("Contributed inputs should allow for valid fee contributions");
-        let payjoin_proposal =
-            psbt_context.finalize_proposal(|_| Ok(processed_psbt.clone())).expect("Valid psbt");
+        let payjoin_proposal = psbt_context.finalize_proposal(&processed_psbt).expect("Valid psbt");
 
         assert!(payjoin_proposal.xpub.is_empty());
 

payjoin/src/core/receive/mod.rs

@@ -255,12 +255,12 @@ pub struct PsbtContext {
 
 impl PsbtContext {
     /// Prepare the PSBT by creating a new PSBT and copying only the fields allowed by the [spec](https://github.com/bitcoin/bips/blob/master/bip-0078.mediawiki#senders-payjoin-proposal-checklist)
-    fn prepare_psbt(self, processed_psbt: Psbt) -> Psbt {
+    fn prepare_psbt(self, processed_psbt: &Psbt) -> Psbt {
         tracing::trace!("Original PSBT from callback: {processed_psbt:#?}");
 
         // Create a new PSBT and copy only the allowed fields
         let mut filtered_psbt = Psbt {
-            unsigned_tx: processed_psbt.unsigned_tx,
+            unsigned_tx: processed_psbt.unsigned_tx.clone(),
             version: processed_psbt.version,
             xpub: BTreeMap::new(),
             proprietary: BTreeMap::new(),
@@ -313,33 +313,33 @@ impl PsbtContext {
         sender_input_indexes
     }
 
-    /// Finalizes the Payjoin proposal into a PSBT which the sender will find acceptable before
-    /// they sign the transaction and broadcast it to the network.
-    ///
-    /// Finalization consists of two steps:
-    ///   1. Remove all sender signatures which were received with the original PSBT as these signatures are now invalid.
-    ///   2. Sign and finalize the resulting PSBT using the passed `wallet_process_psbt` signing function.
-    fn finalize_proposal(
-        self,
-        wallet_process_psbt: impl Fn(&Psbt) -> Result<Psbt, ImplementationError>,
-    ) -> Result<Psbt, ImplementationError> {
+    /// Return the payjoin PSBT that is ready for signing
+    fn payjoin_psbt_without_sender_signatures(&self) -> Psbt {
         let mut psbt = self.payjoin_psbt.clone();
         // Remove now-invalid sender signatures before applying the receiver signatures
         for i in self.sender_input_indexes() {
-            tracing::trace!("Clearing sender input {i}");
             psbt.inputs[i].final_script_sig = None;
             psbt.inputs[i].final_script_witness = None;
             psbt.inputs[i].tap_key_sig = None;
         }
-        let finalized_psbt = wallet_process_psbt(&psbt)?;
+        psbt
+    }
+
+    /// Finalizes the Payjoin proposal into a PSBT which the sender will find acceptable before
+    /// they sign the transaction and broadcast it to the network.
+    ///
+    /// Finalization consists of two steps:
+    ///   1. Validate that signed psbt contains expected inputs and outputs
+    ///   2. Prepare the psbt to be sent to sender
+    fn finalize_proposal(self, signed_psbt: &Psbt) -> Result<Psbt, ImplementationError> {
         let expected_ntxid = self.payjoin_psbt.unsigned_tx.compute_ntxid();
-        let actual_ntxid = finalized_psbt.unsigned_tx.compute_ntxid();
+        let actual_ntxid = signed_psbt.unsigned_tx.compute_ntxid();
         if expected_ntxid != actual_ntxid {
             return Err(ImplementationError::from(
                 format!("Ntxid mismatch: expected {expected_ntxid}, got {actual_ntxid}").as_str(),
             ));
         }
-        let payjoin_proposal = self.prepare_psbt(finalized_psbt);
+        let payjoin_proposal = self.prepare_psbt(signed_psbt);
         Ok(payjoin_proposal)
     }
 }

payjoin/src/core/receive/v1/mod.rs

@@ -365,7 +365,10 @@ impl crate::receive::common::WantsFeeRange {
 /// by the receiver. The receiver may sign and finalize the Payjoin proposal which will be sent to
 /// the sender for their signature.
 ///
-/// Call [`Self::finalize_proposal`] to return a finalized [`PayjoinProposal`].
+/// Call [`Self::finalize_proposal`] to return a finalized [`PayjoinProposal`]. If caller needs to use
+/// non-blocking calls for signing the payjoin proposal psbt call [`Self::psbt_to_sign`] to
+/// extract the psbt to be signed and [`Self::finalize_signed_proposal`] to return the
+/// receiver signed proposal psbt and proceed to the next state.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct ProvisionalProposal {
     psbt_context: PsbtContext,
@@ -382,19 +385,25 @@ impl ProvisionalProposal {
         self,
         wallet_process_psbt: impl Fn(&Psbt) -> Result<Psbt, ImplementationError>,
     ) -> Result<PayjoinProposal, Error> {
-        let finalized_psbt = self
-            .psbt_context
-            .finalize_proposal(wallet_process_psbt)
-            .map_err(|e| Error::Implementation(ImplementationError::new(e)))?;
-        Ok(PayjoinProposal { payjoin_psbt: finalized_psbt })
+        let psbt = self.psbt_context.payjoin_psbt_without_sender_signatures();
+        let signed_psbt = wallet_process_psbt(&psbt)?;
+        self.finalize_signed_proposal(&signed_psbt)
     }
 
     /// The Payjoin proposal PSBT that the receiver needs to sign
     ///
-    /// In some applications the entity that progresses the typestate
-    /// is different from the entity that has access to the private keys,
-    /// so the PSBT to sign must be accessible to such implementers.
-    pub fn psbt_to_sign(&self) -> Psbt { self.psbt_context.payjoin_psbt.clone() }
+    /// Use this for non-blocking signing of psbt
+    pub fn psbt_to_sign(&self) -> Psbt {
+        self.psbt_context.payjoin_psbt_without_sender_signatures()
+    }
+
+    /// Process receiver signed payjoin proposal
+    ///
+    /// Use this for non-blocking signing of psbt
+    pub fn finalize_signed_proposal(self, signed_psbt: &Psbt) -> Result<PayjoinProposal, Error> {
+        let finalized_psbt = self.psbt_context.finalize_proposal(signed_psbt)?;
+        Ok(PayjoinProposal { payjoin_psbt: finalized_psbt })
+    }
 }
 
 /// A finalized Payjoin proposal, complete with fees and receiver signatures, that the sender

payjoin/src/core/receive/v2/mod.rs

@@ -1158,6 +1158,10 @@ pub struct ProvisionalProposal {
 /// the sender for their signature.
 ///
 /// Call [`Receiver<ProvisionalProposal>::finalize_proposal`] to return a finalized [`PayjoinProposal`].
+/// If caller needs to use non-blocking calls for signing the payjoin proposal psbt call
+/// [`Receiver<ProvisionalProposal>::psbt_to_sign`] to extract the psbt to be signed and
+/// [`Receiver<ProvisionalProposal>::finalize_signed_proposal`] to return the receiver signed proposal
+/// psbt and proceed to the next state.
 impl Receiver<ProvisionalProposal> {
     /// Finalizes the Payjoin proposal into a PSBT which the sender will find acceptable before
     /// they re-sign the transaction and broadcast it to the network.
@@ -1169,9 +1173,32 @@ impl Receiver<ProvisionalProposal> {
         self,
         wallet_process_psbt: impl Fn(&Psbt) -> Result<Psbt, ImplementationError>,
     ) -> MaybeTransientTransition<SessionEvent, Receiver<PayjoinProposal>, ImplementationError>
+    {
+        let psbt = self.state.psbt_context.payjoin_psbt_without_sender_signatures();
+        let signed_psbt = wallet_process_psbt(&psbt);
+        match signed_psbt {
+            Ok(signed_psbt) => self.finalize_signed_proposal(&signed_psbt),
+            Err(e) => MaybeTransientTransition::transient(e),
+        }
+    }
+
+    /// The Payjoin proposal PSBT that the receiver needs to sign
+    ///
+    /// Use this for non-blocking signing of psbt
+    pub fn psbt_to_sign(&self) -> Psbt {
+        self.psbt_context.payjoin_psbt_without_sender_signatures()
+    }
+
+    /// Process receiver signed payjoin proposal
+    ///
+    /// Use this for non-blocking signing of psbt
+    pub fn finalize_signed_proposal(
+        self,
+        signed_psbt: &Psbt,
+    ) -> MaybeTransientTransition<SessionEvent, Receiver<PayjoinProposal>, ImplementationError>
     {
         let original_psbt = self.state.psbt_context.original_psbt.clone();
-        let inner = match self.state.psbt_context.finalize_proposal(wallet_process_psbt) {
+        let inner = match self.state.psbt_context.finalize_proposal(signed_psbt) {
             Ok(inner) => inner,
             Err(e) => {
                 return MaybeTransientTransition::transient(e);
@@ -1185,13 +1212,6 @@ impl Receiver<ProvisionalProposal> {
         )
     }
 
-    /// The Payjoin proposal PSBT that the receiver needs to sign
-    ///
-    /// In some applications the entity that progresses the typestate
-    /// is different from the entity that has access to the private keys,
-    /// so the PSBT to sign must be accessible to such implementers.
-    pub fn psbt_to_sign(&self) -> Psbt { self.state.psbt_context.payjoin_psbt.clone() }
-
     pub(crate) fn apply_payjoin_proposal(self, payjoin_psbt: Psbt) -> ReceiveSession {
         let psbt_context = PsbtContext {
             payjoin_psbt,