Use reply key for replyable errors to v2 senders

payjoin-cli/src/app/v1.rs

@@ -13,7 +13,7 @@ use hyper::{Method, Request, Response, StatusCode};
 use hyper_util::rt::TokioIo;
 use payjoin::bitcoin::psbt::Psbt;
 use payjoin::bitcoin::{Amount, FeeRate};
-use payjoin::receive::v1::{PayjoinProposal, UncheckedProposal};
+use payjoin::receive::v1::{PayjoinProposal, UncheckedOriginalPayload};
 use payjoin::receive::ReplyableError::{self, Implementation, V1};
 use payjoin::send::v1::SenderBuilder;
 use payjoin::{ImplementationError, IntoUrl, Uri, UriExt};
@@ -301,7 +301,7 @@ impl App {
             .await
             .map_err(|e| Implementation(ImplementationError::new(e)))?
             .to_bytes();
-        let proposal = UncheckedProposal::from_request(&body, query_string, headers)?;
+        let proposal = UncheckedOriginalPayload::from_request(&body, query_string, headers)?;
 
         let payjoin_proposal = self.process_v1_proposal(proposal)?;
         let psbt = payjoin_proposal.psbt();
@@ -315,7 +315,7 @@ impl App {
 
     fn process_v1_proposal(
         &self,
-        proposal: UncheckedProposal,
+        proposal: UncheckedOriginalPayload,
     ) -> Result<PayjoinProposal, ReplyableError> {
         let wallet = self.wallet();
 

payjoin-cli/src/app/v2/mod.rs

@@ -7,8 +7,8 @@ use payjoin::persist::OptionalTransitionOutcome;
 use payjoin::receive::v2::{
     process_err_res, replay_event_log as replay_receiver_event_log, Initialized, MaybeInputsOwned,
     MaybeInputsSeen, OutputsUnknown, PayjoinProposal, ProvisionalProposal, ReceiveSession,
-    Receiver, ReceiverBuilder, SessionHistory, UncheckedProposal, WantsFeeRange, WantsInputs,
-    WantsOutputs,
+    Receiver, ReceiverBuilder, SessionHistory, UncheckedOriginalPayload, WantsFeeRange,
+    WantsInputs, WantsOutputs,
 };
 use payjoin::send::v2::{
     replay_event_log as replay_sender_event_log, SendSession, Sender, SenderBuilder, V2GetContext,
@@ -297,7 +297,7 @@ impl App {
         &self,
         session: Receiver<Initialized>,
         persister: &ReceiverPersister,
-    ) -> Result<Receiver<UncheckedProposal>> {
+    ) -> Result<Receiver<UncheckedOriginalPayload>> {
         let ohttp_relay = self
             .unwrap_relay_or_else_fetch(Some(session.pj_uri().extras.endpoint().clone()))
             .await?;
@@ -333,7 +333,7 @@ impl App {
             match session {
                 ReceiveSession::Initialized(proposal) =>
                     self.read_from_directory(proposal, persister).await,
-                ReceiveSession::UncheckedProposal(proposal) =>
+                ReceiveSession::UncheckedOriginalPayload(proposal) =>
                     self.check_proposal(proposal, persister).await,
                 ReceiveSession::MaybeInputsOwned(proposal) =>
                     self.check_inputs_not_owned(proposal, persister).await,
@@ -393,7 +393,7 @@ impl App {
 
     async fn check_proposal(
         &self,
-        proposal: Receiver<UncheckedProposal>,
+        proposal: Receiver<UncheckedOriginalPayload>,
         persister: &ReceiverPersister,
     ) -> Result<()> {
         let wallet = self.wallet();

payjoin-ffi/dart/test/test_payjoin_integration_test.dart

@@ -233,7 +233,7 @@ Future<payjoin.PayjoinProposalReceiveSession> process_maybe_inputs_owned(
 }
 
 Future<payjoin.PayjoinProposalReceiveSession> process_unchecked_proposal(
-    payjoin.UncheckedProposal proposal,
+    payjoin.UncheckedOriginalPayload proposal,
     InMemoryReceiverPersister recv_persister) async {
   final unchecked_proposal = proposal
       .checkBroadcastSuitability(null, MempoolAcceptanceCallback(receiver))
@@ -258,7 +258,7 @@ Future<payjoin.ReceiveSession?> retrieve_receiver_proposal(
   }
   var proposal = res.success();
   return await process_unchecked_proposal(
-      proposal as payjoin.UncheckedProposal, recv_persister);
+      proposal as payjoin.UncheckedOriginalPayload, recv_persister);
 }
 
 Future<payjoin.ReceiveSession?> process_receiver_proposal(
@@ -274,7 +274,7 @@ Future<payjoin.ReceiveSession?> process_receiver_proposal(
     return res;
   }
 
-  if (receiver is payjoin.UncheckedProposalReceiveSession) {
+  if (receiver is payjoin.UncheckedOriginalPayloadReceiveSession) {
     return await process_unchecked_proposal(receiver.inner, recv_persister);
   }
   if (receiver is payjoin.MaybeInputsOwnedReceiveSession) {

payjoin-ffi/python/test/test_payjoin_integration_test.py

@@ -101,7 +101,7 @@ async def retrieve_receiver_proposal(self, receiver: Initialized, recv_persister
         proposal = res.success()
         return await self.process_unchecked_proposal(proposal, recv_persister)
 
-    async def process_unchecked_proposal(self, proposal: UncheckedProposal, recv_persister: InMemoryReceiverSessionEventLog) :
+    async def process_unchecked_proposal(self, proposal: UncheckedOriginalPayload, recv_persister: InMemoryReceiverSessionEventLog) :
         receiver = proposal.check_broadcast_suitability(None, MempoolAcceptanceCallback(self.receiver)).save(recv_persister)
         return await self.process_maybe_inputs_owned(receiver, recv_persister)
 

payjoin-ffi/src/receive/mod.rs

@@ -77,7 +77,7 @@ impl ReceiverSessionEvent {
 pub enum ReceiveSession {
     Uninitialized,
     Initialized { inner: Arc<Initialized> },
-    UncheckedProposal { inner: Arc<UncheckedProposal> },
+    UncheckedOriginalPayload { inner: Arc<UncheckedOriginalPayload> },
     MaybeInputsOwned { inner: Arc<MaybeInputsOwned> },
     MaybeInputsSeen { inner: Arc<MaybeInputsSeen> },
     OutputsUnknown { inner: Arc<OutputsUnknown> },
@@ -96,8 +96,8 @@ impl From<payjoin::receive::v2::ReceiveSession> for ReceiveSession {
             ReceiveSession::Uninitialized => Self::Uninitialized,
             ReceiveSession::Initialized(inner) =>
                 Self::Initialized { inner: Arc::new(inner.into()) },
-            ReceiveSession::UncheckedProposal(inner) =>
-                Self::UncheckedProposal { inner: Arc::new(inner.into()) },
+            ReceiveSession::UncheckedOriginalPayload(inner) =>
+                Self::UncheckedOriginalPayload { inner: Arc::new(inner.into()) },
             ReceiveSession::MaybeInputsOwned(inner) =>
                 Self::MaybeInputsOwned { inner: Arc::new(inner.into()) },
             ReceiveSession::MaybeInputsSeen(inner) =>
@@ -308,7 +308,7 @@ pub struct InitializedTransition(
             Option<
                 payjoin::persist::MaybeFatalTransitionWithNoResults<
                     payjoin::receive::v2::SessionEvent,
-                    payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedProposal>,
+                    payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedOriginalPayload>,
                     payjoin::receive::v2::Receiver<payjoin::receive::v2::Initialized>,
                     payjoin::receive::Error,
                 >,
@@ -339,7 +339,7 @@ impl InitializedTransition {
 #[derive(uniffi::Object)]
 pub struct InitializedTransitionOutcome(
     payjoin::persist::OptionalTransitionOutcome<
-        payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedProposal>,
+        payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedOriginalPayload>,
         payjoin::receive::v2::Receiver<payjoin::receive::v2::Initialized>,
     >,
 );
@@ -350,22 +350,22 @@ impl InitializedTransitionOutcome {
 
     pub fn is_success(&self) -> bool { self.0.is_success() }
 
-    pub fn success(&self) -> Option<Arc<UncheckedProposal>> {
+    pub fn success(&self) -> Option<Arc<UncheckedOriginalPayload>> {
         self.0.success().map(|r| Arc::new(r.clone().into()))
     }
 }
 
 impl
     From<
         payjoin::persist::OptionalTransitionOutcome<
-            payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedProposal>,
+            payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedOriginalPayload>,
             payjoin::receive::v2::Receiver<payjoin::receive::v2::Initialized>,
         >,
     > for InitializedTransitionOutcome
 {
     fn from(
         value: payjoin::persist::OptionalTransitionOutcome<
-            payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedProposal>,
+            payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedOriginalPayload>,
             payjoin::receive::v2::Receiver<payjoin::receive::v2::Initialized>,
         >,
     ) -> Self {
@@ -396,7 +396,7 @@ impl Initialized {
             .map_err(Into::into)
     }
 
-    /// The response can either be an UncheckedProposal or an ACCEPTED message indicating no UncheckedProposal is available yet.
+    /// The response can either be an UncheckedOriginalPayload or an ACCEPTED message indicating no UncheckedOriginalPayload is available yet.
     pub fn process_response(&self, body: &[u8], ctx: &ClientResponse) -> InitializedTransition {
         InitializedTransition(Arc::new(RwLock::new(Some(
             self.0.clone().process_response(body, ctx.into()),
@@ -414,29 +414,29 @@ impl Initialized {
 }
 
 #[derive(Clone, uniffi::Object)]
-pub struct UncheckedProposal(
-    payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedProposal>,
+pub struct UncheckedOriginalPayload(
+    payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedOriginalPayload>,
 );
 
-impl From<payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedProposal>>
-    for UncheckedProposal
+impl From<payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedOriginalPayload>>
+    for UncheckedOriginalPayload
 {
     fn from(
-        value: payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedProposal>,
+        value: payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedOriginalPayload>,
     ) -> Self {
         Self(value)
     }
 }
 
-impl From<UncheckedProposal>
-    for payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedProposal>
+impl From<UncheckedOriginalPayload>
+    for payjoin::receive::v2::Receiver<payjoin::receive::v2::UncheckedOriginalPayload>
 {
-    fn from(value: UncheckedProposal) -> Self { value.0 }
+    fn from(value: UncheckedOriginalPayload) -> Self { value.0 }
 }
 
 #[derive(uniffi::Object)]
 #[allow(clippy::type_complexity)]
-pub struct UncheckedProposalTransition(
+pub struct UncheckedOriginalPayloadTransition(
     Arc<
         RwLock<
             Option<
@@ -450,7 +450,7 @@ pub struct UncheckedProposalTransition(
     >,
 );
 
-impl_save_for_transition!(UncheckedProposalTransition, MaybeInputsOwned);
+impl_save_for_transition!(UncheckedOriginalPayloadTransition, MaybeInputsOwned);
 
 #[derive(uniffi::Object)]
 #[allow(clippy::type_complexity)]
@@ -475,13 +475,13 @@ pub trait CanBroadcast: Send + Sync {
 }
 
 #[uniffi::export]
-impl UncheckedProposal {
+impl UncheckedOriginalPayload {
     pub fn check_broadcast_suitability(
         &self,
         min_fee_rate: Option<u64>,
         can_broadcast: Arc<dyn CanBroadcast>,
-    ) -> UncheckedProposalTransition {
-        UncheckedProposalTransition(Arc::new(RwLock::new(Some(
+    ) -> UncheckedOriginalPayloadTransition {
+        UncheckedOriginalPayloadTransition(Arc::new(RwLock::new(Some(
             self.0.clone().check_broadcast_suitability(
                 min_fee_rate.map(FeeRate::from_sat_per_kwu),
                 |transaction| {

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

@@ -18,7 +18,7 @@ use super::optional_parameters::Params;
 use super::{InputPair, OutputSubstitutionError, ReplyableError, SelectionError};
 use crate::output_substitution::OutputSubstitution;
 use crate::psbt::PsbtExt;
-use crate::receive::{InternalPayloadError, Original, PsbtContext};
+use crate::receive::{InternalPayloadError, OriginalPayload, PsbtContext};
 
 /// Typestate which the receiver may substitute or add outputs to.
 ///
@@ -38,11 +38,11 @@ pub struct WantsOutputs {
 }
 
 impl WantsOutputs {
-    /// Create a new [`WantsOutputs`] typestate from an [`Original`] typestate and a list of
+    /// Create a new [`WantsOutputs`] typestate from an [`OriginalPayload`] typestate and a list of
     /// owned outputs.
     ///
     /// The first output in the `owned_vouts` list is used as the `change_vout`.
-    pub(crate) fn new(original: Original, owned_vouts: Vec<usize>) -> Self {
+    pub(crate) fn new(original: OriginalPayload, owned_vouts: Vec<usize>) -> Self {
         Self {
             original_psbt: original.psbt.clone(),
             payjoin_psbt: original.psbt,
@@ -670,7 +670,7 @@ mod tests {
         assert_eq!(original.psbt_fee_rate().unwrap().to_sat_per_vb_floor(), 2);
         // Specify excessive fee rate in sender params
         original_params.min_fee_rate = FeeRate::from_sat_per_vb_unchecked(1000);
-        let updated_original = Original { psbt: original.psbt, params: original_params };
+        let updated_original = OriginalPayload { psbt: original.psbt, params: original_params };
 
         let proposal_psbt = Psbt::from_str(RECEIVER_INPUT_CONTRIBUTION).unwrap();
         let input = InputPair::new(

payjoin/src/core/receive/mod.rs

@@ -336,12 +336,12 @@ impl PsbtContext {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct Original {
+pub struct OriginalPayload {
     psbt: Psbt,
     params: Params,
 }
 
-impl Original {
+impl OriginalPayload {
     // Calculates the fee rate of the original proposal PSBT.
     fn psbt_fee_rate(&self) -> Result<FeeRate, InternalPayloadError> {
         let original_psbt_fee = self.psbt.fee().map_err(|e| {
@@ -475,11 +475,11 @@ pub(crate) mod tests {
     // We should pub(crate) it and moved to a common place.
     const NON_WITNESS_DATA_WEIGHT: Weight = Weight::from_non_witness_data_size(32 + 4 + 4);
 
-    pub(crate) fn original_from_test_vector() -> Original {
+    pub(crate) fn original_from_test_vector() -> OriginalPayload {
         let pairs = url::form_urlencoded::parse(QUERY_PARAMS.as_bytes());
         let params = Params::from_query_pairs(pairs, &[Version::One])
             .expect("Could not parse params from query pairs");
-        Original { psbt: PARSED_ORIGINAL_PSBT.clone(), params }
+        OriginalPayload { psbt: PARSED_ORIGINAL_PSBT.clone(), params }
     }
 
     #[test]