Update process_event to return internal err

We can get rid of the hacky `ProtocolError` variant off
`InternalReplayError` if we seperate event processing events from replay
errors.

Author: arminsabouri

payjoin/src/core/error.rs

@@ -68,7 +68,6 @@ impl<SessionState: Debug, SessionEvent: Debug, SessionHistory: Debug> std::fmt::
             },
             Expired(time, _) => write!(f, "Session expired at {time:?}"),
             PersistenceFailure(e) => write!(f, "Persistence failure: {e}"),
-            ProtocolError() => write!(f, "Protocol error"),
             TerminalFailure(_) => write!(f, "Terminal failure"),
         }
     }
@@ -100,9 +99,12 @@ pub(crate) enum InternalReplayError<SessionState, SessionEvent, SessionHistory>
     Expired(crate::time::Time, SessionHistory),
     /// Application storage error
     PersistenceFailure(ImplementationError),
-    /// Protocol error
-    // TODO: should this include a deserialize / string representation of the error?
-    ProtocolError(),
     /// Terminal failure with session history
     TerminalFailure(SessionHistory),
 }
+
+#[cfg(feature = "v2")]
+pub(crate) enum InternalProcessEventError<SessionState, SessionEvent> {
+    InvalidEvent(Box<SessionEvent>, Option<Box<SessionState>>),
+    ProtocolError(),
+}

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

@@ -41,7 +41,7 @@ use super::error::{Error, InputContributionError};
 use super::{
     common, InternalPayloadError, JsonReply, OutputSubstitutionError, ProtocolError, SelectionError,
 };
-use crate::error::{InternalReplayError, ReplayError};
+use crate::error::InternalProcessEventError;
 use crate::hpke::{decrypt_message_a, encrypt_message_b, HpkeKeyPair, HpkePublicKey};
 use crate::ohttp::{
     ohttp_encapsulate, process_get_res, process_post_res, OhttpEncapsulationError, OhttpKeys,
@@ -149,7 +149,7 @@ impl ReceiveSession {
     fn process_event(
         self,
         event: SessionEvent,
-    ) -> Result<ReceiveSession, ReplayError<Self, SessionEvent, SessionHistory>> {
+    ) -> Result<ReceiveSession, InternalProcessEventError<Self, SessionEvent>> {
         match (self, event) {
             (
                 ReceiveSession::Initialized(state),
@@ -206,13 +206,12 @@ impl ReceiveSession {
                     },
                 })),
             (_, SessionEvent::Closed(SessionOutcome::Failure)) =>
-                Err(InternalReplayError::ProtocolError().into()),
+                Err(InternalProcessEventError::ProtocolError()),
             (current_state, SessionEvent::Closed(_)) => Ok(current_state),
-            (current_state, event) => Err(InternalReplayError::InvalidEvent(
+            (current_state, event) => Err(InternalProcessEventError::InvalidEvent(
                 Box::new(event),
                 Some(Box::new(current_state)),
-            )
-            .into()),
+            )),
         }
     }
 }

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

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use super::{ReceiveSession, SessionContext};
-use crate::error::{InternalReplayError, ReplayError};
+use crate::error::{InternalProcessEventError, InternalReplayError, ReplayError};
 use crate::output_substitution::OutputSubstitution;
 use crate::persist::SessionPersister;
 use crate::receive::{InputPair, JsonReply, OriginalPayload, PsbtContext};
@@ -40,13 +40,17 @@ where
                 persister.close().map_err(|e| {
                     InternalReplayError::PersistenceFailure(ImplementationError::new(e))
                 })?;
-                if let InternalReplayError::ProtocolError() = e.0 {
-                    return Err(InternalReplayError::TerminalFailure(SessionHistory::new(
-                        session_events,
-                    ))
-                    .into());
+                match e {
+                    InternalProcessEventError::ProtocolError() => {
+                        return Err(InternalReplayError::TerminalFailure(SessionHistory::new(
+                            session_events,
+                        ))
+                        .into());
+                    }
+                    InternalProcessEventError::InvalidEvent(event, session) => {
+                        return Err(InternalReplayError::InvalidEvent(event, session).into());
+                    }
                 }
-                break;
             }
         }
     }

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

@@ -39,7 +39,7 @@ use url::Url;
 
 use super::error::BuildSenderError;
 use super::*;
-use crate::error::{InternalReplayError, ReplayError};
+use crate::error::InternalProcessEventError;
 use crate::hpke::{decrypt_message_b, encrypt_message_a, HpkeSecretKey};
 use crate::ohttp::{ohttp_encapsulate, process_get_res, process_post_res};
 use crate::persist::{
@@ -223,7 +223,7 @@ impl SendSession {
     fn process_event(
         self,
         event: SessionEvent,
-    ) -> Result<SendSession, ReplayError<Self, SessionEvent, SessionHistory>> {
+    ) -> Result<SendSession, InternalProcessEventError<Self, SessionEvent>> {
         match (self, event) {
             (SendSession::WithReplyKey(state), SessionEvent::PollingForProposal()) =>
                 Ok(state.apply_polling_for_proposal()),
@@ -232,13 +232,12 @@ impl SendSession {
                 SessionEvent::ReceivedProposalPsbt(proposal),
             ) => Ok(SendSession::ProposalReceived(proposal)),
             (_, SessionEvent::Closed(SessionOutcome::Failure)) =>
-                Err(InternalReplayError::ProtocolError().into()),
+                Err(InternalProcessEventError::ProtocolError()),
             (current_state, SessionEvent::Closed(_)) => Ok(current_state),
-            (current_state, event) => Err(InternalReplayError::InvalidEvent(
+            (current_state, event) => Err(InternalProcessEventError::InvalidEvent(
                 Box::new(event),
                 Some(Box::new(current_state)),
-            )
-            .into()),
+            )),
         }
     }
 }

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

@@ -1,5 +1,5 @@
 use super::WithReplyKey;
-use crate::error::{InternalReplayError, ReplayError};
+use crate::error::{InternalProcessEventError, InternalReplayError, ReplayError};
 use crate::persist::SessionPersister;
 use crate::send::v2::SendSession;
 use crate::uri::v2::PjParam;
@@ -32,13 +32,17 @@ where
                 persister.close().map_err(|e| {
                     InternalReplayError::PersistenceFailure(ImplementationError::new(e))
                 })?;
-                if let InternalReplayError::ProtocolError() = e.0 {
-                    return Err(InternalReplayError::TerminalFailure(SessionHistory::new(
-                        session_events,
-                    ))
-                    .into());
+                match e {
+                    InternalProcessEventError::ProtocolError() => {
+                        return Err(InternalReplayError::TerminalFailure(SessionHistory::new(
+                            session_events,
+                        ))
+                        .into());
+                    }
+                    InternalProcessEventError::InvalidEvent(event, session) => {
+                        return Err(InternalReplayError::InvalidEvent(event, session).into());
+                    }
                 }
-                break;
             }
         }
     }