Check fees in multiparty process_proposal

The distinction beetween 1s1r async payjoin and ns1r is that the sender
checks the proposal before the receiver signs in the first round
of communication, so the receiver inputs won't yet be finalized. Therefore,
in order to share functionality, the receiver input finalized check needs
to be triggered by a condition. This does that.

Author: node-smithxby72w

payjoin/src/core/send/mod.rs

@@ -88,7 +88,7 @@ fn ensure<T>(condition: bool, error: T) -> Result<(), T> {
 impl PsbtContext {
     fn process_proposal(self, mut proposal: Psbt) -> InternalResult<Psbt> {
         self.basic_checks(&proposal)?;
-        self.check_inputs(&proposal)?;
+        self.check_inputs(&proposal, true)?;
         let contributed_fee = self.check_outputs(&proposal)?;
         self.restore_original_utxos(&mut proposal)?;
         self.check_fees(&proposal, contributed_fee)?;
@@ -161,7 +161,11 @@ impl PsbtContext {
         Ok(())
     }
 
-    fn check_inputs(&self, proposal: &Psbt) -> InternalResult<()> {
+    fn check_inputs(
+        &self,
+        proposal: &Psbt,
+        ensure_receiver_input_finalized: bool,
+    ) -> InternalResult<()> {
         let mut original_inputs = self.original_psbt.input_pairs().peekable();
 
         for proposed in proposal.input_pairs() {
@@ -200,12 +204,14 @@ impl PsbtContext {
                         .input_pairs()
                         .next()
                         .ok_or(InternalProposalError::NoInputs)?;
-                    // Verify the PSBT input is finalized
-                    ensure(
-                        proposed.psbtin.final_script_sig.is_some()
-                            || proposed.psbtin.final_script_witness.is_some(),
-                        InternalProposalError::ReceiverTxinNotFinalized,
-                    )?;
+                    if ensure_receiver_input_finalized {
+                        // Verify the PSBT input is finalized
+                        ensure(
+                            proposed.psbtin.final_script_sig.is_some()
+                                || proposed.psbtin.final_script_witness.is_some(),
+                            InternalProposalError::ReceiverTxinNotFinalized,
+                        )?;
+                    }
                     // Verify that non_witness_utxo or witness_utxo are filled in.
                     ensure(
                         proposed.psbtin.witness_utxo.is_some()

payjoin/src/core/send/multiparty/mod.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 use url::Url;
 
 use super::v2::{self, extract_request, EncapsulationError, HpkeContext};
-use super::{serialize_url, AdditionalFeeContribution, BuildSenderError, InternalResult};
+use super::{serialize_url, AdditionalFeeContribution, BuildSenderError};
 use crate::hpke::decrypt_message_b;
 use crate::ohttp::{process_get_res, process_post_res};
 use crate::output_substitution::OutputSubstitution;
@@ -137,7 +137,7 @@ impl GetContext {
         ohttp_ctx: ohttp::ClientResponse,
         finalize_psbt: impl Fn(&Psbt) -> Result<Psbt, ImplementationError>,
     ) -> Result<FinalizeContext, FinalizedError> {
-        let psbt_ctx = PsbtContext { inner: self.0.psbt_ctx.clone() };
+        let psbt_ctx = self.0.psbt_ctx.clone();
         let body = match process_get_res(response, ohttp_ctx)? {
             Some(body) => body,
             None => return Err(FinalizedError::from(InternalFinalizedError::MissingResponse)),
@@ -150,7 +150,8 @@ impl GetContext {
         .map_err(InternalFinalizedError::Hpke)?;
 
         let proposal = Psbt::deserialize(&psbt).map_err(InternalFinalizedError::Psbt)?;
-        let psbt = psbt_ctx.process_proposal(proposal).map_err(InternalFinalizedError::Proposal)?;
+        let psbt =
+            process_proposal(psbt_ctx, proposal).map_err(InternalFinalizedError::Proposal)?;
         let finalized_psbt = finalize_psbt(&psbt).map_err(InternalFinalizedError::FinalizePsbt)?;
         Ok(FinalizeContext {
             hpke_ctx: self.0.hpke_ctx.clone(),
@@ -207,21 +208,17 @@ impl FinalizeContext {
     }
 }
 
-pub(crate) struct PsbtContext {
-    inner: crate::send::PsbtContext,
-}
-
-impl PsbtContext {
-    fn process_proposal(self, mut proposal: Psbt) -> InternalResult<Psbt> {
-        // TODO(armins) add multiparty check fees modeled after crate::send::PsbtContext::check_fees
-        // The problem with this is that some of the inputs will be missing witness_utxo or non_witness_utxo field in the psbt so the default psbt.fee() will fail
-        // Similarly we need to implement a check for the inputs. It would be useful to have all the checks as crate::send::PsbtContext::check_inputs
-        // However that method expects the receiver to have provided witness for their inputs. In a ns1r the receiver will not sign any inputs of the optimistic merged psbt
-        self.inner.basic_checks(&proposal)?;
-        self.inner.check_outputs(&proposal)?;
-        self.inner.restore_original_utxos(&mut proposal)?;
-        Ok(proposal)
-    }
+/// The same as `crate::send::PsbtContext::process_proposal` but without checking receiver input finalization
+fn process_proposal(
+    psbt_ctx: crate::send::PsbtContext,
+    mut proposal: Psbt,
+) -> crate::send::InternalResult<Psbt> {
+    psbt_ctx.basic_checks(&proposal)?;
+    psbt_ctx.check_inputs(&proposal, false)?;
+    let contributed_fee = psbt_ctx.check_outputs(&proposal)?;
+    psbt_ctx.restore_original_utxos(&mut proposal)?;
+    psbt_ctx.check_fees(&proposal, contributed_fee)?;
+    Ok(proposal)
 }
 
 fn append_optimisitic_merge_query_param(url: &mut Url) {