WIP - remove uninitialized receiver session variant

Author: arminsabouri

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

@@ -345,8 +345,6 @@ impl App {
                     self.finalize_proposal(proposal, persister).await,
                 ReceiveSession::PayjoinProposal(proposal) =>
                     self.send_payjoin_proposal(proposal, persister).await,
-                ReceiveSession::Uninitialized =>
-                    return Err(anyhow!("Uninitialized receiver session")),
                 ReceiveSession::TerminalFailure =>
                     return Err(anyhow!("Terminal receiver session")),
             }

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

@@ -108,6 +108,14 @@ fn short_id_from_pubkey(pubkey: &HpkePublicKey) -> ShortId {
     sha256::Hash::hash(&pubkey.to_compressed_bytes()).into()
 }
 
+pub(crate) fn process_initial_event(event: SessionEvent) -> Result<ReceiveSession, ReplayError> {
+    match event {
+        SessionEvent::Created(context) =>
+            Ok(ReceiveSession::Initialized(Receiver { state: Initialized { context } })),
+        _ => Err(InternalReplayError::InvalidEventForUninitializedSession(Box::new(event)).into()),
+    }
+}
+
 /// Represents the various states of a Payjoin receiver session during the protocol flow.
 /// Each variant parameterizes a `Receiver` with a specific state type, except for [`ReceiveSession::Uninitialized`] which
 /// has no context yet and [`ReceiveSession::TerminalFailure`] which indicates the session has ended or is invalid.
@@ -116,7 +124,6 @@ fn short_id_from_pubkey(pubkey: &HpkePublicKey) -> ShortId {
 /// and the state to be updated with the next event over a uniform interface.
 #[derive(Debug, Clone, PartialEq)]
 pub enum ReceiveSession {
-    Uninitialized,
     Initialized(Receiver<Initialized>),
     UncheckedProposal(Receiver<UncheckedProposal>),
     MaybeInputsOwned(Receiver<MaybeInputsOwned>),

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

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use super::{ReceiveSession, SessionContext};
 use crate::output_substitution::OutputSubstitution;
 use crate::persist::SessionPersister;
-use crate::receive::v2::{extract_err_req, SessionError};
+use crate::receive::v2::{extract_err_req, process_initial_event, SessionError};
 use crate::receive::{v1, JsonReply, Original};
 use crate::{ImplementationError, IntoUrl, PjUri, Request};
 
@@ -18,6 +18,9 @@ impl std::fmt::Display for ReplayError {
         use InternalReplayError::*;
         match &self.0 {
             SessionExpired(expiry) => write!(f, "Session expired at {expiry:?}"),
+            NoEvents => write!(f, "No events found in session"),
+            InvalidEventForUninitializedSession(event) =>
+                write!(f, "Invalid event ({event:?}) for uninitialized session",),
             InvalidStateAndEvent(state, event) => write!(
                 f,
                 "Invalid combination of state ({state:?}) and event ({event:?}) during replay",
@@ -36,6 +39,10 @@ impl From<InternalReplayError> for ReplayError {
 pub(crate) enum InternalReplayError {
     /// Session expired
     SessionExpired(SystemTime),
+    /// No events found in session
+    NoEvents,
+    /// Invalid event for uninitialized session
+    InvalidEventForUninitializedSession(Box<SessionEvent>),
     /// Invalid combination of state and event
     InvalidStateAndEvent(Box<ReceiveSession>, Box<SessionEvent>),
     /// Application storage error
@@ -49,10 +56,13 @@ where
     P: SessionPersister,
     P::SessionEvent: Into<SessionEvent> + Clone,
 {
-    let logs = persister
+    let mut logs = persister
         .load()
         .map_err(|e| InternalReplayError::PersistenceFailure(ImplementationError::new(e)))?;
-    let mut receiver = ReceiveSession::Uninitialized;
+
+    let mut receiver =
+        process_initial_event(logs.next().ok_or(InternalReplayError::NoEvents)?.into())
+            .expect("Session should be initialized");
     let mut history = SessionHistory::default();
 
     for event in logs {

payjoin/tests/integration.rs

@@ -364,7 +364,9 @@ mod integration {
                 let check_broadcast_suitability = || {
                     proposal
                         .clone()
-                        .check_broadcast_suitability(None, |_| Ok(false))
+                        .check_broadcast_suitability(None, |_| {
+                            Err(ImplementationError::from("this should cause a fatal error"))
+                        })
                         .save(&persister)
                 };
                 let server_error = check_broadcast_suitability()
@@ -373,7 +375,9 @@ mod integration {
                     .expect("expected api error");
                 // TODO: this should be replaced by comparing the error itself once the error types impl PartialEq
                 // Issue: https://github.com/payjoin/rust-payjoin/issues/645
+                // TODO: fix this
                 assert_eq!(server_error.to_string(), "Can't broadcast. PSBT rejected by mempool.");
+                // assert_eq!(server_error.to_string(), "Internal Server Error: this should cause a fatal error");
 
                 let (_, session_history) = replay_receiver_event_log(&persister)?;
                 let (err_req, err_ctx) = session_history