Return Closed state during replays

We want to avoid returning the current state if a closed event was
processed from the log. The application may just perform the event that
caused the error instead of treating the session as terminally closed.

Author: arminsabouri

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

@@ -8,12 +8,12 @@ use payjoin::persist::OptionalTransitionOutcome;
 use payjoin::receive::v2::{
     replay_event_log as replay_receiver_event_log, HasReplyableError, Initialized,
     MaybeInputsOwned, MaybeInputsSeen, OutputsUnknown, PayjoinProposal, ProvisionalProposal,
-    ReceiveSession, Receiver, ReceiverBuilder, UncheckedOriginalPayload, WantsFeeRange,
-    WantsInputs, WantsOutputs,
+    ReceiveSession, Receiver, ReceiverBuilder, SessionOutcome as ReceiverSessionOutcome,
+    UncheckedOriginalPayload, WantsFeeRange, WantsInputs, WantsOutputs,
 };
 use payjoin::send::v2::{
     replay_event_log as replay_sender_event_log, PollingForProposal, SendSession, Sender,
-    SenderBuilder, WithReplyKey,
+    SenderBuilder, SessionOutcome as SenderSessionOutcome, WithReplyKey,
 };
 use payjoin::{ImplementationError, PjParam, Uri};
 use tokio::sync::watch;
@@ -52,7 +52,11 @@ impl StatusText for SendSession {
             SendSession::WithReplyKey(_) | SendSession::PollingForProposal(_) =>
                 "Waiting for proposal",
             SendSession::ProposalReceived(_) => "Proposal received",
-            SendSession::TerminalFailure => "Session failure",
+            SendSession::Closed(session_outcome) => match session_outcome {
+                SenderSessionOutcome::Failure => "Session failure",
+                SenderSessionOutcome::Success => "Session success",
+                SenderSessionOutcome::Cancel => "Session cancelled",
+            },
         }
     }
 }
@@ -70,7 +74,13 @@ impl StatusText for ReceiveSession {
             | ReceiveSession::WantsFeeRange(_)
             | ReceiveSession::ProvisionalProposal(_) => "Processing original proposal",
             ReceiveSession::PayjoinProposal(_) => "Payjoin proposal sent",
-            ReceiveSession::HasReplyableError(_) => "Session failure",
+            ReceiveSession::HasReplyableError(_) =>
+                "Session failure, waiting to post error response",
+            ReceiveSession::Closed(session_outcome) => match session_outcome {
+                ReceiverSessionOutcome::Failure => "Session failure",
+                ReceiverSessionOutcome::Success => "Session success",
+                ReceiverSessionOutcome::Cancel => "Session cancelled",
+            },
         }
     }
 }
@@ -523,6 +533,7 @@ impl App {
                     self.send_payjoin_proposal(proposal, persister).await,
                 ReceiveSession::HasReplyableError(error) =>
                     self.handle_error(error, persister).await,
+                ReceiveSession::Closed(_) => return Err(anyhow!("Session closed")),
             }
         };
         res

payjoin-ffi/src/receive/mod.rs

@@ -66,6 +66,19 @@ impl ReceiverSessionEvent {
     }
 }
 
+#[derive(Clone, uniffi::Object)]
+pub struct ReceiverSessionOutcome {
+    inner: payjoin::receive::v2::SessionOutcome,
+}
+
+impl From<payjoin::receive::v2::SessionOutcome> for ReceiverSessionOutcome {
+    fn from(value: payjoin::receive::v2::SessionOutcome) -> Self { Self { inner: value } }
+}
+
+impl From<ReceiverSessionOutcome> for payjoin::receive::v2::SessionOutcome {
+    fn from(value: ReceiverSessionOutcome) -> Self { value.inner }
+}
+
 #[derive(Clone, uniffi::Enum)]
 pub enum ReceiveSession {
     Initialized { inner: Arc<Initialized> },
@@ -79,6 +92,7 @@ pub enum ReceiveSession {
     ProvisionalProposal { inner: Arc<ProvisionalProposal> },
     PayjoinProposal { inner: Arc<PayjoinProposal> },
     HasReplyableError { inner: Arc<HasReplyableError> },
+    Closed { inner: Arc<ReceiverSessionOutcome> },
 }
 
 impl From<payjoin::receive::v2::ReceiveSession> for ReceiveSession {
@@ -107,6 +121,8 @@ impl From<payjoin::receive::v2::ReceiveSession> for ReceiveSession {
                 Self::PayjoinProposal { inner: Arc::new(inner.into()) },
             ReceiveSession::HasReplyableError(inner) =>
                 Self::HasReplyableError { inner: Arc::new(inner.into()) },
+            ReceiveSession::Closed(session_outcome) =>
+                Self::Closed { inner: Arc::new(session_outcome.into()) },
         }
     }
 }

payjoin-ffi/src/send/mod.rs

@@ -57,12 +57,25 @@ impl SenderSessionEvent {
     }
 }
 
+#[derive(Clone, uniffi::Object)]
+pub struct SenderSessionOutcome {
+    inner: payjoin::send::v2::SessionOutcome,
+}
+
+impl From<payjoin::send::v2::SessionOutcome> for SenderSessionOutcome {
+    fn from(value: payjoin::send::v2::SessionOutcome) -> Self { Self { inner: value } }
+}
+
+impl From<SenderSessionOutcome> for payjoin::send::v2::SessionOutcome {
+    fn from(value: SenderSessionOutcome) -> Self { value.inner }
+}
+
 #[derive(Clone, uniffi::Enum)]
 pub enum SendSession {
     WithReplyKey { inner: Arc<WithReplyKey> },
     PollingForProposal { inner: Arc<PollingForProposal> },
     ProposalReceived { inner: Arc<Psbt> },
-    TerminalFailure,
+    Closed { inner: Arc<SenderSessionOutcome> },
 }
 
 impl From<payjoin::send::v2::SendSession> for SendSession {
@@ -75,7 +88,8 @@ impl From<payjoin::send::v2::SendSession> for SendSession {
                 Self::PollingForProposal { inner: Arc::new(inner.into()) },
             SendSession::ProposalReceived(inner) =>
                 Self::ProposalReceived { inner: Arc::new(inner.into()) },
-            SendSession::TerminalFailure => Self::TerminalFailure,
+            SendSession::Closed(session_outcome) =>
+                Self::Closed { inner: Arc::new(session_outcome.into()) },
         }
     }
 }

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

@@ -34,7 +34,7 @@ pub(crate) use error::InternalSessionError;
 pub use error::SessionError;
 use serde::de::Deserializer;
 use serde::{Deserialize, Serialize};
-pub use session::{replay_event_log, SessionEvent, SessionHistory, SessionStatus};
+pub use session::{replay_event_log, SessionEvent, SessionHistory, SessionOutcome, SessionStatus};
 use url::Url;
 
 use super::error::{Error, InputContributionError};
@@ -51,7 +51,6 @@ use crate::persist::{
     MaybeFatalTransition, MaybeFatalTransitionWithNoResults, MaybeSuccessTransition,
     MaybeTransientTransition, NextStateTransition,
 };
-use crate::receive::v2::session::SessionOutcome;
 use crate::receive::{parse_payload, InputPair, OriginalPayload, PsbtContext};
 use crate::time::Time;
 use crate::uri::ShortId;
@@ -139,6 +138,7 @@ pub enum ReceiveSession {
     ProvisionalProposal(Receiver<ProvisionalProposal>),
     PayjoinProposal(Receiver<PayjoinProposal>),
     HasReplyableError(Receiver<HasReplyableError>),
+    Closed(SessionOutcome),
 }
 
 impl ReceiveSession {
@@ -188,6 +188,9 @@ impl ReceiveSession {
                 SessionEvent::FinalizedProposal(payjoin_proposal),
             ) => Ok(state.apply_finalized_proposal(payjoin_proposal)),
 
+            (_, SessionEvent::Closed(session_outcome)) =>
+                Ok(ReceiveSession::Closed(session_outcome)),
+
             (session, SessionEvent::GotReplyableError(error)) =>
                 Ok(ReceiveSession::HasReplyableError(Receiver {
                     state: HasReplyableError { error_reply: error.clone() },
@@ -203,11 +206,10 @@ impl ReceiveSession {
                         ReceiveSession::ProvisionalProposal(r) => r.session_context,
                         ReceiveSession::PayjoinProposal(r) => r.session_context,
                         ReceiveSession::HasReplyableError(r) => r.session_context,
+                        ReceiveSession::Closed(_) => unreachable!(),
                     },
                 })),
 
-            (current_state, SessionEvent::Closed(_)) => Ok(current_state),
-
             (current_state, event) => Err(InternalReplayError::InvalidEvent(
                 Box::new(event),
                 Some(Box::new(current_state)),

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

@@ -189,8 +189,7 @@ mod tests {
     use crate::receive::tests::original_from_test_vector;
     use crate::receive::v2::test::{mock_err, SHARED_CONTEXT};
     use crate::receive::v2::{
-        HasReplyableError, Initialized, MaybeInputsOwned, PayjoinProposal, ProvisionalProposal,
-        Receiver, UncheckedOriginalPayload,
+        Initialized, MaybeInputsOwned, ProvisionalProposal, Receiver, UncheckedOriginalPayload,
     };
     use crate::receive::{InternalPayloadError, PayloadError};
 
@@ -554,10 +553,7 @@ mod tests {
                 fallback_tx: Some(expected_fallback),
                 expected_status: SessionStatus::Completed,
             },
-            expected_receiver_state: ReceiveSession::PayjoinProposal(Receiver {
-                state: PayjoinProposal { psbt: payjoin_proposal.psbt().clone() },
-                session_context: SessionContext { reply_key, ..session_context },
-            }),
+            expected_receiver_state: ReceiveSession::Closed(SessionOutcome::Success),
         };
         run_session_history_test(test)
     }
@@ -592,10 +588,7 @@ mod tests {
                 fallback_tx: None,
                 expected_status: SessionStatus::Failed,
             },
-            expected_receiver_state: ReceiveSession::HasReplyableError(Receiver {
-                state: HasReplyableError { error_reply: (&expected_error).into() },
-                session_context: SessionContext { reply_key, ..session_context },
-            }),
+            expected_receiver_state: ReceiveSession::Closed(SessionOutcome::Failure),
         };
         run_session_history_test(test)
     }

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

@@ -34,7 +34,7 @@ pub use error::{CreateRequestError, EncapsulationError};
 use error::{InternalCreateRequestError, InternalEncapsulationError};
 use ohttp::ClientResponse;
 use serde::{Deserialize, Serialize};
-pub use session::{replay_event_log, SessionEvent, SessionHistory};
+pub use session::{replay_event_log, SessionEvent, SessionHistory, SessionOutcome};
 use url::Url;
 
 use super::error::BuildSenderError;
@@ -45,7 +45,6 @@ use crate::ohttp::{ohttp_encapsulate, process_get_res, process_post_res};
 use crate::persist::{
     MaybeFatalTransition, MaybeSuccessTransitionWithNoResults, NextStateTransition,
 };
-use crate::send::v2::session::SessionOutcome;
 use crate::uri::v2::PjParam;
 use crate::uri::ShortId;
 use crate::{HpkeKeyPair, HpkePublicKey, IntoUrl, OhttpKeys, PjUri, Request};
@@ -215,7 +214,7 @@ pub enum SendSession {
     WithReplyKey(Sender<WithReplyKey>),
     PollingForProposal(Sender<PollingForProposal>),
     ProposalReceived(Psbt),
-    TerminalFailure,
+    Closed(SessionOutcome),
 }
 
 impl SendSession {
@@ -232,8 +231,7 @@ impl SendSession {
                 SendSession::PollingForProposal(_state),
                 SessionEvent::ReceivedProposalPsbt(proposal),
             ) => Ok(SendSession::ProposalReceived(proposal)),
-            (_, SessionEvent::Closed(SessionOutcome::Failure)) => Ok(SendSession::TerminalFailure),
-            (current_state, SessionEvent::Closed(_)) => Ok(current_state),
+            (_, SessionEvent::Closed(session_outcome)) => Ok(SendSession::Closed(session_outcome)),
             (current_state, event) => Err(InternalReplayError::InvalidEvent(
                 Box::new(event),
                 Some(Box::new(current_state)),