Rename SenderTypeState to SendSession

It contains every possible state of a session including
Sender types. Include the module `Send` name to disambiguate
the public type used in payjoin-ffi where namespacing is not yet
available.

Author: DanGould

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

@@ -10,8 +10,8 @@ use payjoin::receive::v2::{
     Receiver, SessionHistory, UncheckedProposal, WantsInputs, WantsOutputs,
 };
 use payjoin::send::v2::{
-    replay_event_log as replay_sender_event_log, Sender, SenderBuilder, SenderTypeState,
-    V2GetContext, WithReplyKey,
+    replay_event_log as replay_sender_event_log, SendSession, Sender, SenderBuilder, V2GetContext,
+    WithReplyKey,
 };
 use payjoin::Uri;
 use tokio::sync::watch;
@@ -81,7 +81,7 @@ impl AppTrait for App {
                     .build_recommended(fee_rate)
                     .save(&persister)?;
 
-                (SenderTypeState::WithReplyKey(sender), persister)
+                (SendSession::WithReplyKey(sender), persister)
             }
         };
         let mut interrupt = self.interrupt.clone();
@@ -173,11 +173,11 @@ impl AppTrait for App {
 impl App {
     async fn process_sender_session(
         &self,
-        session: SenderTypeState,
+        session: SendSession,
         persister: &SenderPersister,
     ) -> Result<()> {
         match session {
-            SenderTypeState::WithReplyKey(context) => {
+            SendSession::WithReplyKey(context) => {
                 // TODO: can we handle the fall back case in `post_original_proposal`. That way we don't have to clone here
                 match self.post_original_proposal(context.clone(), persister).await {
                     Ok(()) => (),
@@ -192,9 +192,9 @@ impl App {
                 }
                 return Ok(());
             }
-            SenderTypeState::V2GetContext(context) =>
+            SendSession::V2GetContext(context) =>
                 self.get_proposed_payjoin_psbt(context, persister).await?,
-            SenderTypeState::ProposalReceived(proposal) => {
+            SendSession::ProposalReceived(proposal) => {
                 self.process_pj_response(proposal.clone())?;
                 return Ok(());
             }

payjoin-ffi/src/send/mod.rs

@@ -27,13 +27,13 @@ impl From<payjoin::send::v2::SessionEvent> for SessionEvent {
 }
 
 #[derive(Debug, Clone)]
-pub struct SenderTypeState(payjoin::send::v2::SenderTypeState);
+pub struct SendSession(payjoin::send::v2::SendSession);
 
-impl From<payjoin::send::v2::SenderTypeState> for SenderTypeState {
-    fn from(value: payjoin::send::v2::SenderTypeState) -> Self { Self(value) }
+impl From<payjoin::send::v2::SendSession> for SendSession {
+    fn from(value: payjoin::send::v2::SendSession) -> Self { Self(value) }
 }
 
-pub fn replay_event_log<P>(persister: &P) -> Result<(SenderTypeState, SessionHistory), SenderReplayError>
+pub fn replay_event_log<P>(persister: &P) -> Result<(SendSession, SessionHistory), SenderReplayError>
 where
     P: SessionPersister + Clone,
     P::SessionEvent: Into<payjoin::send::v2::SessionEvent> + Clone,

payjoin-ffi/src/send/uni.rs

@@ -34,17 +34,17 @@ impl SenderSessionEvent {
 }
 
 #[derive(Clone, uniffi::Enum)]
-pub enum SenderTypeState {
+pub enum SendSession {
     Uninitialized,
     WithReplyKey { inner: Arc<WithReplyKey> },
     V2GetContext { inner: Arc<V2GetContext> },
     ProposalReceived { inner: Arc<Psbt> },
     TerminalFailure,
 }
 
-impl From<super::SenderTypeState> for SenderTypeState {
-    fn from(value: super::SenderTypeState) -> Self {
-        use payjoin::send::v2::SenderTypeState::*;
+impl From<super::SendSession> for SendSession {
+    fn from(value: super::SendSession) -> Self {
+        use payjoin::send::v2::SendSession::*;
         match value.0 {
             Uninitialized => Self::Uninitialized,
             WithReplyKey(inner) =>
@@ -82,13 +82,13 @@ impl SenderSessionHistory {
 
 #[derive(uniffi::Object)]
 pub struct SenderReplayResult {
-    state: SenderTypeState,
+    state: SendSession,
     session_history: SenderSessionHistory,
 }
 
 #[uniffi::export]
 impl SenderReplayResult {
-    pub fn state(&self) -> SenderTypeState { self.state.clone() }
+    pub fn state(&self) -> SendSession { self.state.clone() }
 
     pub fn session_history(&self) -> SenderSessionHistory { self.session_history.clone() }
 }

payjoin/src/send/v2/mod.rs

@@ -161,27 +161,29 @@ impl<State> core::ops::DerefMut for Sender<State> {
     fn deref_mut(&mut self) -> &mut Self::Target { &mut self.state }
 }
 
+/// Represents the various states of a Payjoin send session during the protocol flow.
+///
+/// This provides type erasure for the send session state, allowing the session to be replayed
+/// and the state to be updated with the next event over a uniform interface.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum SenderTypeState {
+pub enum SendSession {
     Uninitialized,
     WithReplyKey(Sender<WithReplyKey>),
     V2GetContext(Sender<V2GetContext>),
     ProposalReceived(Psbt),
     TerminalFailure,
 }
 
-impl SenderTypeState {
-    fn process_event(self, event: SessionEvent) -> Result<SenderTypeState, ReplayError> {
+impl SendSession {
+    fn process_event(self, event: SessionEvent) -> Result<SendSession, ReplayError> {
         match (self, event) {
-            (
-                SenderTypeState::Uninitialized,
-                SessionEvent::CreatedReplyKey(sender_with_reply_key),
-            ) => Ok(SenderTypeState::WithReplyKey(Sender { state: sender_with_reply_key })),
-            (SenderTypeState::WithReplyKey(state), SessionEvent::V2GetContext(v2_get_context)) =>
+            (SendSession::Uninitialized, SessionEvent::CreatedReplyKey(sender_with_reply_key)) =>
+                Ok(SendSession::WithReplyKey(Sender { state: sender_with_reply_key })),
+            (SendSession::WithReplyKey(state), SessionEvent::V2GetContext(v2_get_context)) =>
                 Ok(state.apply_v2_get_context(v2_get_context)),
-            (SenderTypeState::V2GetContext(_state), SessionEvent::ProposalReceived(proposal)) =>
-                Ok(SenderTypeState::ProposalReceived(proposal)),
-            (_, SessionEvent::SessionInvalid(_)) => Ok(SenderTypeState::TerminalFailure),
+            (SendSession::V2GetContext(_state), SessionEvent::ProposalReceived(proposal)) =>
+                Ok(SendSession::ProposalReceived(proposal)),
+            (_, SessionEvent::SessionInvalid(_)) => Ok(SendSession::TerminalFailure),
             (current_state, event) => Err(InternalReplayError::InvalidStateAndEvent(
                 Box::new(current_state),
                 Box::new(event),
@@ -303,8 +305,8 @@ impl Sender<WithReplyKey> {
     /// The endpoint in the Payjoin URI
     pub fn endpoint(&self) -> &Url { self.v1.endpoint() }
 
-    pub(crate) fn apply_v2_get_context(self, v2_get_context: V2GetContext) -> SenderTypeState {
-        SenderTypeState::V2GetContext(Sender { state: v2_get_context })
+    pub(crate) fn apply_v2_get_context(self, v2_get_context: V2GetContext) -> SendSession {
+        SendSession::V2GetContext(Sender { state: v2_get_context })
     }
 }
 

payjoin/src/send/v2/session.rs

@@ -2,7 +2,7 @@ use url::Url;
 
 use super::WithReplyKey;
 use crate::persist::SessionPersister;
-use crate::send::v2::{SenderTypeState, V2GetContext};
+use crate::send::v2::{SendSession, V2GetContext};
 use crate::ImplementationError;
 /// Errors that can occur when replaying a sender event log
 #[derive(Debug)]
@@ -29,12 +29,12 @@ impl From<InternalReplayError> for ReplayError {
 #[derive(Debug)]
 pub(crate) enum InternalReplayError {
     /// Invalid combination of state and event
-    InvalidStateAndEvent(Box<SenderTypeState>, Box<SessionEvent>),
+    InvalidStateAndEvent(Box<SendSession>, Box<SessionEvent>),
     /// Application storage error
     PersistenceFailure(ImplementationError),
 }
 
-pub fn replay_event_log<P>(persister: &P) -> Result<(SenderTypeState, SessionHistory), ReplayError>
+pub fn replay_event_log<P>(persister: &P) -> Result<(SendSession, SessionHistory), ReplayError>
 where
     P: SessionPersister + Clone,
     P::SessionEvent: Into<SessionEvent> + Clone,
@@ -43,7 +43,7 @@ where
         .load()
         .map_err(|e| InternalReplayError::PersistenceFailure(Box::new(e).into()))?;
 
-    let mut sender = SenderTypeState::Uninitialized;
+    let mut sender = SendSession::Uninitialized;
     let mut history = SessionHistory::default();
     for log in logs {
         history.events.push(log.clone().into());
@@ -163,7 +163,7 @@ mod tests {
     struct SessionHistoryTest {
         events: Vec<SessionEvent>,
         expected_session_history: SessionHistoryExpectedOutcome,
-        expected_sender_state: SenderTypeState,
+        expected_sender_state: SendSession,
     }
 
     fn run_session_history_test(test: SessionHistoryTest) {
@@ -203,7 +203,7 @@ mod tests {
                 fallback_tx: Some(fallback_tx),
                 endpoint: Some(endpoint),
             },
-            expected_sender_state: SenderTypeState::WithReplyKey(sender),
+            expected_sender_state: SendSession::WithReplyKey(sender),
         };
         run_session_history_test(test);
     }