Rename ReceiverTypeState to ReceiveSession

DanGould · DanGould · commit a05afa0762c1 · 2025-06-26T18:53:33.000-04:00
It contains every possible state of a session including initialized
Receiver types. Include the module `Receive` name to disambiguate
the public type used in payjoin-ffi where namespacing is not yet
available.
diff --git a/payjoin-cli/src/app/v2/mod.rs b/payjoin-cli/src/app/v2/mod.rs
@@ -6,8 +6,8 @@ use payjoin::bitcoin::{Amount, FeeRate};
 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, Receiver,
-    ReceiverTypeState, SessionHistory, UncheckedProposal, WantsInputs, WantsOutputs,
+    MaybeInputsSeen, OutputsUnknown, PayjoinProposal, ProvisionalProposal, ReceiveSession,
+    Receiver, SessionHistory, UncheckedProposal, WantsInputs, WantsOutputs,
 };
 use payjoin::send::v2::{
     replay_event_log as replay_sender_event_log, Sender, SenderBuilder, SenderTypeState,
@@ -114,7 +114,7 @@ impl AppTrait for App {
         println!("Request Payjoin by sharing this Payjoin Uri:");
         println!("{}", pj_uri);
 
-        self.process_receiver_session(ReceiverTypeState::Initialized(session.clone()), &persister)
+        self.process_receiver_session(ReceiveSession::Initialized(session.clone()), &persister)
             .await?;
         Ok(())
     }
@@ -282,32 +282,32 @@ impl App {
 
     async fn process_receiver_session(
         &self,
-        session: ReceiverTypeState,
+        session: ReceiveSession,
         persister: &ReceiverPersister,
     ) -> Result<()> {
         let res = {
             match session {
-                ReceiverTypeState::Initialized(proposal) =>
+                ReceiveSession::Initialized(proposal) =>
                     self.read_from_directory(proposal, persister).await,
-                ReceiverTypeState::UncheckedProposal(proposal) =>
+                ReceiveSession::UncheckedProposal(proposal) =>
                     self.check_proposal(proposal, persister).await,
-                ReceiverTypeState::MaybeInputsOwned(proposal) =>
+                ReceiveSession::MaybeInputsOwned(proposal) =>
                     self.check_inputs_not_owned(proposal, persister).await,
-                ReceiverTypeState::MaybeInputsSeen(proposal) =>
+                ReceiveSession::MaybeInputsSeen(proposal) =>
                     self.check_no_inputs_seen_before(proposal, persister).await,
-                ReceiverTypeState::OutputsUnknown(proposal) =>
+                ReceiveSession::OutputsUnknown(proposal) =>
                     self.identify_receiver_outputs(proposal, persister).await,
-                ReceiverTypeState::WantsOutputs(proposal) =>
+                ReceiveSession::WantsOutputs(proposal) =>
                     self.commit_outputs(proposal, persister).await,
-                ReceiverTypeState::WantsInputs(proposal) =>
+                ReceiveSession::WantsInputs(proposal) =>
                     self.contribute_inputs(proposal, persister).await,
-                ReceiverTypeState::ProvisionalProposal(proposal) =>
+                ReceiveSession::ProvisionalProposal(proposal) =>
                     self.finalize_proposal(proposal, persister).await,
-                ReceiverTypeState::PayjoinProposal(proposal) =>
+                ReceiveSession::PayjoinProposal(proposal) =>
                     self.send_payjoin_proposal(proposal, persister).await,
-                ReceiverTypeState::Uninitialized(_) =>
+                ReceiveSession::Uninitialized(_) =>
                     return Err(anyhow!("Uninitialized receiver session")),
-                ReceiverTypeState::TerminalFailure =>
+                ReceiveSession::TerminalFailure =>
                     return Err(anyhow!("Terminal receiver session")),
             }
         };
diff --git a/payjoin-ffi/python/test/test_payjoin_integration_test.py b/payjoin-ffi/python/test/test_payjoin_integration_test.py
@@ -60,7 +60,7 @@ def setUpClass(cls):
         cls.receiver = cls.env.get_receiver()
         cls.sender = cls.env.get_sender()
 
-    async def process_receiver_proposal(self, receiver: ReceiverTypeState, recv_persister: InMemoryReceiverSessionEventLog, ohttp_relay: Url) -> Optional[ReceiverTypeState]:
+    async def process_receiver_proposal(self, receiver: ReceiveSession, recv_persister: InMemoryReceiverSessionEventLog, ohttp_relay: Url) -> Optional[ReceiveSession]:
         if receiver.is_INITIALIZED():
             res = await self.retrieve_receiver_proposal(receiver.inner, recv_persister, ohttp_relay)
             if res is None:
@@ -131,7 +131,7 @@ async def process_wants_inputs(self, proposal: WantsInputs, recv_persister: InMe
     
     async def process_provisional_proposal(self, proposal: ProvisionalProposal, recv_persister: InMemoryReceiverSessionEventLog):
         payjoin_proposal = proposal.finalize_proposal(ProcessPsbtCallback(self.receiver), 1, 10).save(recv_persister)
-        return ReceiverTypeState.PAYJOIN_PROPOSAL(payjoin_proposal)
+        return ReceiveSession.PAYJOIN_PROPOSAL(payjoin_proposal)
  
     async def test_integration_v2_to_v2(self):
         try:
@@ -150,7 +150,7 @@ async def test_integration_v2_to_v2(self):
             recv_persister = InMemoryReceiverSessionEventLog(1)
             sender_persister = InMemorySenderPersister(1)
             session = self.create_receiver_context(receiver_address, directory, ohttp_keys, recv_persister)
-            process_response = await self.process_receiver_proposal(ReceiverTypeState.INITIALIZED(session), recv_persister, ohttp_relay)
+            process_response = await self.process_receiver_proposal(ReceiveSession.INITIALIZED(session), recv_persister, ohttp_relay)
             print(f"session: {session.to_json()}")
             self.assertIsNone(process_response)
 
@@ -173,7 +173,7 @@ async def test_integration_v2_to_v2(self):
             # Inside the Receiver:
 
             # GET fallback psbt
-            payjoin_proposal = await self.process_receiver_proposal(ReceiverTypeState.INITIALIZED(session), recv_persister, ohttp_relay)
+            payjoin_proposal = await self.process_receiver_proposal(ReceiveSession.INITIALIZED(session), recv_persister, ohttp_relay)
             self.assertIsNotNone(payjoin_proposal)
             self.assertEqual(payjoin_proposal.is_PAYJOIN_PROPOSAL(), True)
 
diff --git a/payjoin-ffi/src/receive/mod.rs b/payjoin-ffi/src/receive/mod.rs
@@ -31,15 +31,15 @@ impl From<SessionEvent> for payjoin::receive::v2::SessionEvent {
     fn from(event: SessionEvent) -> Self { event.0 }
 }
 
-pub struct ReceiverTypeState(pub payjoin::receive::v2::ReceiverTypeState);
+pub struct ReceiveSession(pub payjoin::receive::v2::ReceiveSession);
 
-impl From<payjoin::receive::v2::ReceiverTypeState> for ReceiverTypeState {
-    fn from(value: payjoin::receive::v2::ReceiverTypeState) -> Self { Self(value) }
+impl From<payjoin::receive::v2::ReceiveSession> for ReceiveSession {
+    fn from(value: payjoin::receive::v2::ReceiveSession) -> Self { Self(value) }
 }
 
 pub fn replay_event_log<P>(
     persister: &P,
-) -> Result<(ReceiverTypeState, SessionHistory), ReceiverReplayError>
+) -> Result<(ReceiveSession, SessionHistory), ReceiverReplayError>
 where
     P: SessionPersister,
     P::SessionEvent: Into<payjoin::receive::v2::SessionEvent> + Clone,
diff --git a/payjoin-ffi/src/receive/uni.rs b/payjoin-ffi/src/receive/uni.rs
@@ -35,7 +35,7 @@ impl ReceiverSessionEvent {
 }
 
 #[derive(Clone, uniffi::Enum)]
-pub enum ReceiverTypeState {
+pub enum ReceiveSession {
     Uninitialized,
     Initialized { inner: Arc<Initialized> },
     UncheckedProposal { inner: Arc<UncheckedProposal> },
@@ -49,9 +49,9 @@ pub enum ReceiverTypeState {
     TerminalFailure,
 }
 
-impl From<super::ReceiverTypeState> for ReceiverTypeState {
-    fn from(value: super::ReceiverTypeState) -> Self {
-        use payjoin::receive::v2::ReceiverTypeState::*;
+impl From<super::ReceiveSession> for ReceiveSession {
+    fn from(value: super::ReceiveSession) -> Self {
+        use payjoin::receive::v2::ReceiveSession::*;
         match value.0 {
             Uninitialized(_) => Self::Uninitialized,
             Initialized(inner) =>
@@ -150,13 +150,13 @@ impl SessionHistory {
 
 #[derive(uniffi::Object)]
 pub struct ReplayResult {
-    state: ReceiverTypeState,
+    state: ReceiveSession,
     session_history: SessionHistory,
 }
 
 #[uniffi::export]
 impl ReplayResult {
-    pub fn state(&self) -> ReceiverTypeState { self.state.clone() }
+    pub fn state(&self) -> ReceiveSession { self.state.clone() }
 
     pub fn session_history(&self) -> SessionHistory { self.session_history.clone() }
 }
diff --git a/payjoin/src/receive/v2/mod.rs b/payjoin/src/receive/v2/mod.rs
@@ -83,10 +83,13 @@ fn subdir_path_from_pubkey(pubkey: &HpkePublicKey) -> ShortId {
 }
 
 /// Represents the various states of a Payjoin receiver session during the protocol flow.
-/// Each variant wraps a `Receiver` with a specific state type, except for [`ReceiverTypeState::TerminalFailure`] which
-/// indicates the session has ended or is invalid.
+/// Each variant wraps 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.
+///
+/// This provides type erasure for the receive session state, allowing for the session to be replayed
+/// and the state to be updated with the next event over a uniform interface.
 #[derive(Debug, Clone, PartialEq)]
-pub enum ReceiverTypeState {
+pub enum ReceiveSession {
     Uninitialized(Receiver<UninitializedReceiver>),
     Initialized(Receiver<Initialized>),
     UncheckedProposal(Receiver<UncheckedProposal>),
@@ -100,50 +103,46 @@ pub enum ReceiverTypeState {
     TerminalFailure,
 }
 
-impl ReceiverTypeState {
-    fn process_event(self, event: SessionEvent) -> Result<ReceiverTypeState, ReplayError> {
+impl ReceiveSession {
+    fn process_event(self, event: SessionEvent) -> Result<ReceiveSession, ReplayError> {
         match (self, event) {
-            (ReceiverTypeState::Uninitialized(_), SessionEvent::Created(context)) =>
-                Ok(ReceiverTypeState::Initialized(Receiver { state: Initialized { context } })),
+            (ReceiveSession::Uninitialized(_), SessionEvent::Created(context)) =>
+                Ok(ReceiveSession::Initialized(Receiver { state: Initialized { context } })),
 
             (
-                ReceiverTypeState::Initialized(state),
+                ReceiveSession::Initialized(state),
                 SessionEvent::UncheckedProposal((proposal, reply_key)),
             ) => Ok(state.apply_unchecked_from_payload(proposal, reply_key)?),
 
-            (
-                ReceiverTypeState::UncheckedProposal(state),
-                SessionEvent::MaybeInputsOwned(inputs),
-            ) => Ok(state.apply_maybe_inputs_owned(inputs)),
+            (ReceiveSession::UncheckedProposal(state), SessionEvent::MaybeInputsOwned(inputs)) =>
+                Ok(state.apply_maybe_inputs_owned(inputs)),
 
             (
-                ReceiverTypeState::MaybeInputsOwned(state),
+                ReceiveSession::MaybeInputsOwned(state),
                 SessionEvent::MaybeInputsSeen(maybe_inputs_seen),
             ) => Ok(state.apply_maybe_inputs_seen(maybe_inputs_seen)),
 
             (
-                ReceiverTypeState::MaybeInputsSeen(state),
+                ReceiveSession::MaybeInputsSeen(state),
                 SessionEvent::OutputsUnknown(outputs_unknown),
             ) => Ok(state.apply_outputs_unknown(outputs_unknown)),
 
-            (
-                ReceiverTypeState::OutputsUnknown(state),
-                SessionEvent::WantsOutputs(wants_outputs),
-            ) => Ok(state.apply_wants_outputs(wants_outputs)),
+            (ReceiveSession::OutputsUnknown(state), SessionEvent::WantsOutputs(wants_outputs)) =>
+                Ok(state.apply_wants_outputs(wants_outputs)),
 
-            (ReceiverTypeState::WantsOutputs(state), SessionEvent::WantsInputs(wants_inputs)) =>
+            (ReceiveSession::WantsOutputs(state), SessionEvent::WantsInputs(wants_inputs)) =>
                 Ok(state.apply_wants_inputs(wants_inputs)),
 
             (
-                ReceiverTypeState::WantsInputs(state),
+                ReceiveSession::WantsInputs(state),
                 SessionEvent::ProvisionalProposal(provisional_proposal),
             ) => Ok(state.apply_provisional_proposal(provisional_proposal)),
 
             (
-                ReceiverTypeState::ProvisionalProposal(state),
+                ReceiveSession::ProvisionalProposal(state),
                 SessionEvent::PayjoinProposal(payjoin_proposal),
             ) => Ok(state.apply_payjoin_proposal(payjoin_proposal)),
-            (_, SessionEvent::SessionInvalid(_, _)) => Ok(ReceiverTypeState::TerminalFailure),
+            (_, SessionEvent::SessionInvalid(_, _)) => Ok(ReceiveSession::TerminalFailure),
             (current_state, event) => Err(InternalReplayError::InvalidStateAndEvent(
                 Box::new(current_state),
                 Box::new(event),
@@ -404,7 +403,7 @@ impl Receiver<Initialized> {
         self,
         event: v1::UncheckedProposal,
         reply_key: Option<HpkePublicKey>,
-    ) -> Result<ReceiverTypeState, InternalReplayError> {
+    ) -> Result<ReceiveSession, InternalReplayError> {
         if self.state.context.expiry < SystemTime::now() {
             // Session is expired, close the session
             return Err(InternalReplayError::SessionExpired(self.state.context.expiry));
@@ -417,7 +416,7 @@ impl Receiver<Initialized> {
             },
         };
 
-        Ok(ReceiverTypeState::UncheckedProposal(new_state))
+        Ok(ReceiveSession::UncheckedProposal(new_state))
     }
 }
 
@@ -485,10 +484,10 @@ impl Receiver<UncheckedProposal> {
         )
     }
 
-    pub(crate) fn apply_maybe_inputs_owned(self, v1: v1::MaybeInputsOwned) -> ReceiverTypeState {
+    pub(crate) fn apply_maybe_inputs_owned(self, v1: v1::MaybeInputsOwned) -> ReceiveSession {
         let new_state =
             Receiver { state: MaybeInputsOwned { v1, context: self.state.context.clone() } };
-        ReceiverTypeState::MaybeInputsOwned(new_state)
+        ReceiveSession::MaybeInputsOwned(new_state)
     }
 }
 
@@ -538,10 +537,10 @@ impl Receiver<MaybeInputsOwned> {
         )
     }
 
-    pub(crate) fn apply_maybe_inputs_seen(self, v1: v1::MaybeInputsSeen) -> ReceiverTypeState {
+    pub(crate) fn apply_maybe_inputs_seen(self, v1: v1::MaybeInputsSeen) -> ReceiveSession {
         let new_state =
             Receiver { state: MaybeInputsSeen { v1, context: self.state.context.clone() } };
-        ReceiverTypeState::MaybeInputsSeen(new_state)
+        ReceiveSession::MaybeInputsSeen(new_state)
     }
 }
 
@@ -584,10 +583,10 @@ impl Receiver<MaybeInputsSeen> {
         )
     }
 
-    pub(crate) fn apply_outputs_unknown(self, inner: v1::OutputsUnknown) -> ReceiverTypeState {
+    pub(crate) fn apply_outputs_unknown(self, inner: v1::OutputsUnknown) -> ReceiveSession {
         let new_state =
             Receiver { state: OutputsUnknown { inner, context: self.state.context.clone() } };
-        ReceiverTypeState::OutputsUnknown(new_state)
+        ReceiveSession::OutputsUnknown(new_state)
     }
 }
 
@@ -629,10 +628,10 @@ impl Receiver<OutputsUnknown> {
         )
     }
 
-    pub(crate) fn apply_wants_outputs(self, v1: v1::WantsOutputs) -> ReceiverTypeState {
+    pub(crate) fn apply_wants_outputs(self, v1: v1::WantsOutputs) -> ReceiveSession {
         let new_state =
             Receiver { state: WantsOutputs { v1, context: self.state.context.clone() } };
-        ReceiverTypeState::WantsOutputs(new_state)
+        ReceiveSession::WantsOutputs(new_state)
     }
 }
 
@@ -684,9 +683,9 @@ impl Receiver<WantsOutputs> {
         )
     }
 
-    pub(crate) fn apply_wants_inputs(self, v1: v1::WantsInputs) -> ReceiverTypeState {
+    pub(crate) fn apply_wants_inputs(self, v1: v1::WantsInputs) -> ReceiveSession {
         let new_state = Receiver { state: WantsInputs { v1, context: self.state.context.clone() } };
-        ReceiverTypeState::WantsInputs(new_state)
+        ReceiveSession::WantsInputs(new_state)
     }
 }
 
@@ -742,13 +741,10 @@ impl Receiver<WantsInputs> {
         )
     }
 
-    pub(crate) fn apply_provisional_proposal(
-        self,
-        v1: v1::ProvisionalProposal,
-    ) -> ReceiverTypeState {
+    pub(crate) fn apply_provisional_proposal(self, v1: v1::ProvisionalProposal) -> ReceiveSession {
         let new_state =
             Receiver { state: ProvisionalProposal { v1, context: self.state.context.clone() } };
-        ReceiverTypeState::ProvisionalProposal(new_state)
+        ReceiveSession::ProvisionalProposal(new_state)
     }
 }
 
@@ -795,10 +791,10 @@ impl Receiver<ProvisionalProposal> {
         )
     }
 
-    pub(crate) fn apply_payjoin_proposal(self, v1: v1::PayjoinProposal) -> ReceiverTypeState {
+    pub(crate) fn apply_payjoin_proposal(self, v1: v1::PayjoinProposal) -> ReceiveSession {
         let new_state =
             Receiver { state: PayjoinProposal { v1, context: self.state.context.clone() } };
-        ReceiverTypeState::PayjoinProposal(new_state)
+        ReceiveSession::PayjoinProposal(new_state)
     }
 }
 
diff --git a/payjoin/src/receive/v2/session.rs b/payjoin/src/receive/v2/session.rs

Original file line number	Diff line number	Diff line change
`@@ -83,10 +83,13 @@ fn subdir_path_from_pubkey(pubkey: &HpkePublicKey) -> ShortId {`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`/// Represents the various states of a Payjoin receiver session during the protocol flow.`
`86`		-/// Each variant wraps a `Receiver` with a specific state type, except for [`ReceiverTypeState::TerminalFailure`] which
`87`		`-/// indicates the session has ended or is invalid.`
	`86`	+/// Each variant wraps a `Receiver` with a specific state type, except for [`ReceiveSession::Uninitialized`] which
	`87`	+/// has no context yet and [`ReceiveSession::TerminalFailure`] which indicates the session has ended or is invalid.
	`88`	`+///`
	`89`	`+/// This provides type erasure for the receive session state, allowing for the session to be replayed`
	`90`	`+/// and the state to be updated with the next event over a uniform interface.`
`88`	`91`	`#[derive(Debug, Clone, PartialEq)]`
`89`		`-pub enum ReceiverTypeState {`
	`92`	`+pub enum ReceiveSession {`
`90`	`93`	`Uninitialized(Receiver<UninitializedReceiver>),`
`91`	`94`	`Initialized(Receiver<Initialized>),`
`92`	`95`	`UncheckedProposal(Receiver<UncheckedProposal>),`
`@@ -100,50 +103,46 @@ pub enum ReceiverTypeState {`
`100`	`103`	`TerminalFailure,`
`101`	`104`	`}`
`102`	`105`
`103`		`-impl ReceiverTypeState {`
`104`		`- fn process_event(self, event: SessionEvent) -> Result<ReceiverTypeState, ReplayError> {`
	`106`	`+impl ReceiveSession {`
	`107`	`+ fn process_event(self, event: SessionEvent) -> Result<ReceiveSession, ReplayError> {`
`105`	`108`	`match (self, event) {`
`106`		`- (ReceiverTypeState::Uninitialized(_), SessionEvent::Created(context)) =>`
`107`		`- Ok(ReceiverTypeState::Initialized(Receiver { state: Initialized { context } })),`
	`109`	`+ (ReceiveSession::Uninitialized(_), SessionEvent::Created(context)) =>`
	`110`	`+ Ok(ReceiveSession::Initialized(Receiver { state: Initialized { context } })),`
`108`	`111`
`109`	`112`	`(`
`110`		`- ReceiverTypeState::Initialized(state),`
	`113`	`+ ReceiveSession::Initialized(state),`
`111`	`114`	`SessionEvent::UncheckedProposal((proposal, reply_key)),`
`112`	`115`	`) => Ok(state.apply_unchecked_from_payload(proposal, reply_key)?),`
`113`	`116`
`114`		`- (`
`115`		`- ReceiverTypeState::UncheckedProposal(state),`
`116`		`- SessionEvent::MaybeInputsOwned(inputs),`
`117`		`- ) => Ok(state.apply_maybe_inputs_owned(inputs)),`
	`117`	`+ (ReceiveSession::UncheckedProposal(state), SessionEvent::MaybeInputsOwned(inputs)) =>`
	`118`	`+ Ok(state.apply_maybe_inputs_owned(inputs)),`
`118`	`119`
`119`	`120`	`(`
`120`		`- ReceiverTypeState::MaybeInputsOwned(state),`
	`121`	`+ ReceiveSession::MaybeInputsOwned(state),`
`121`	`122`	`SessionEvent::MaybeInputsSeen(maybe_inputs_seen),`
`122`	`123`	`) => Ok(state.apply_maybe_inputs_seen(maybe_inputs_seen)),`
`123`	`124`
`124`	`125`	`(`
`125`		`- ReceiverTypeState::MaybeInputsSeen(state),`
	`126`	`+ ReceiveSession::MaybeInputsSeen(state),`
`126`	`127`	`SessionEvent::OutputsUnknown(outputs_unknown),`
`127`	`128`	`) => Ok(state.apply_outputs_unknown(outputs_unknown)),`
`128`	`129`
`129`		`- (`
`130`		`- ReceiverTypeState::OutputsUnknown(state),`
`131`		`- SessionEvent::WantsOutputs(wants_outputs),`
`132`		`- ) => Ok(state.apply_wants_outputs(wants_outputs)),`
	`130`	`+ (ReceiveSession::OutputsUnknown(state), SessionEvent::WantsOutputs(wants_outputs)) =>`
	`131`	`+ Ok(state.apply_wants_outputs(wants_outputs)),`
`133`	`132`
`134`		`- (ReceiverTypeState::WantsOutputs(state), SessionEvent::WantsInputs(wants_inputs)) =>`
	`133`	`+ (ReceiveSession::WantsOutputs(state), SessionEvent::WantsInputs(wants_inputs)) =>`
`135`	`134`	`Ok(state.apply_wants_inputs(wants_inputs)),`
`136`	`135`
`137`	`136`	`(`
`138`		`- ReceiverTypeState::WantsInputs(state),`
	`137`	`+ ReceiveSession::WantsInputs(state),`
`139`	`138`	`SessionEvent::ProvisionalProposal(provisional_proposal),`
`140`	`139`	`) => Ok(state.apply_provisional_proposal(provisional_proposal)),`
`141`	`140`
`142`	`141`	`(`
`143`		`- ReceiverTypeState::ProvisionalProposal(state),`
	`142`	`+ ReceiveSession::ProvisionalProposal(state),`
`144`	`143`	`SessionEvent::PayjoinProposal(payjoin_proposal),`
`145`	`144`	`) => Ok(state.apply_payjoin_proposal(payjoin_proposal)),`
`146`		`- (_, SessionEvent::SessionInvalid(_, _)) => Ok(ReceiverTypeState::TerminalFailure),`
	`145`	`+ (_, SessionEvent::SessionInvalid(_, _)) => Ok(ReceiveSession::TerminalFailure),`
`147`	`146`	`(current_state, event) => Err(InternalReplayError::InvalidStateAndEvent(`
`148`	`147`	`Box::new(current_state),`
`149`	`148`	`Box::new(event),`
`@@ -404,7 +403,7 @@ impl Receiver<Initialized> {`
`404`	`403`	`self,`
`405`	`404`	`event: v1::UncheckedProposal,`
`406`	`405`	`reply_key: Option<HpkePublicKey>,`
`407`		`- ) -> Result<ReceiverTypeState, InternalReplayError> {`
	`406`	`+ ) -> Result<ReceiveSession, InternalReplayError> {`
`408`	`407`	`if self.state.context.expiry < SystemTime::now() {`
`409`	`408`	`// Session is expired, close the session`
`410`	`409`	`return Err(InternalReplayError::SessionExpired(self.state.context.expiry));`
`@@ -417,7 +416,7 @@ impl Receiver<Initialized> {`
`417`	`416`	`},`
`418`	`417`	`};`
`419`	`418`
`420`		`- Ok(ReceiverTypeState::UncheckedProposal(new_state))`
	`419`	`+ Ok(ReceiveSession::UncheckedProposal(new_state))`
`421`	`420`	`}`
`422`	`421`	`}`
`423`	`422`
`@@ -485,10 +484,10 @@ impl Receiver<UncheckedProposal> {`
`485`	`484`	`)`
`486`	`485`	`}`
`487`	`486`
`488`		`- pub(crate) fn apply_maybe_inputs_owned(self, v1: v1::MaybeInputsOwned) -> ReceiverTypeState {`
	`487`	`+ pub(crate) fn apply_maybe_inputs_owned(self, v1: v1::MaybeInputsOwned) -> ReceiveSession {`
`489`	`488`	`let new_state =`
`490`	`489`	`Receiver { state: MaybeInputsOwned { v1, context: self.state.context.clone() } };`
`491`		`- ReceiverTypeState::MaybeInputsOwned(new_state)`
	`490`	`+ ReceiveSession::MaybeInputsOwned(new_state)`
`492`	`491`	`}`
`493`	`492`	`}`
`494`	`493`
`@@ -538,10 +537,10 @@ impl Receiver<MaybeInputsOwned> {`
`538`	`537`	`)`
`539`	`538`	`}`
`540`	`539`
`541`		`- pub(crate) fn apply_maybe_inputs_seen(self, v1: v1::MaybeInputsSeen) -> ReceiverTypeState {`
	`540`	`+ pub(crate) fn apply_maybe_inputs_seen(self, v1: v1::MaybeInputsSeen) -> ReceiveSession {`
`542`	`541`	`let new_state =`
`543`	`542`	`Receiver { state: MaybeInputsSeen { v1, context: self.state.context.clone() } };`
`544`		`- ReceiverTypeState::MaybeInputsSeen(new_state)`
	`543`	`+ ReceiveSession::MaybeInputsSeen(new_state)`
`545`	`544`	`}`
`546`	`545`	`}`
`547`	`546`
`@@ -584,10 +583,10 @@ impl Receiver<MaybeInputsSeen> {`
`584`	`583`	`)`
`585`	`584`	`}`
`586`	`585`
`587`		`- pub(crate) fn apply_outputs_unknown(self, inner: v1::OutputsUnknown) -> ReceiverTypeState {`
	`586`	`+ pub(crate) fn apply_outputs_unknown(self, inner: v1::OutputsUnknown) -> ReceiveSession {`
`588`	`587`	`let new_state =`
`589`	`588`	`Receiver { state: OutputsUnknown { inner, context: self.state.context.clone() } };`
`590`		`- ReceiverTypeState::OutputsUnknown(new_state)`
	`589`	`+ ReceiveSession::OutputsUnknown(new_state)`
`591`	`590`	`}`
`592`	`591`	`}`
`593`	`592`
`@@ -629,10 +628,10 @@ impl Receiver<OutputsUnknown> {`
`629`	`628`	`)`
`630`	`629`	`}`
`631`	`630`
`632`		`- pub(crate) fn apply_wants_outputs(self, v1: v1::WantsOutputs) -> ReceiverTypeState {`
	`631`	`+ pub(crate) fn apply_wants_outputs(self, v1: v1::WantsOutputs) -> ReceiveSession {`
`633`	`632`	`let new_state =`
`634`	`633`	`Receiver { state: WantsOutputs { v1, context: self.state.context.clone() } };`
`635`		`- ReceiverTypeState::WantsOutputs(new_state)`
	`634`	`+ ReceiveSession::WantsOutputs(new_state)`
`636`	`635`	`}`
`637`	`636`	`}`
`638`	`637`
`@@ -684,9 +683,9 @@ impl Receiver<WantsOutputs> {`
`684`	`683`	`)`
`685`	`684`	`}`
`686`	`685`
`687`		`- pub(crate) fn apply_wants_inputs(self, v1: v1::WantsInputs) -> ReceiverTypeState {`
	`686`	`+ pub(crate) fn apply_wants_inputs(self, v1: v1::WantsInputs) -> ReceiveSession {`
`688`	`687`	`let new_state = Receiver { state: WantsInputs { v1, context: self.state.context.clone() } };`
`689`		`- ReceiverTypeState::WantsInputs(new_state)`
	`688`	`+ ReceiveSession::WantsInputs(new_state)`
`690`	`689`	`}`
`691`	`690`	`}`
`692`	`691`
`@@ -742,13 +741,10 @@ impl Receiver<WantsInputs> {`
`742`	`741`	`)`
`743`	`742`	`}`
`744`	`743`
`745`		`- pub(crate) fn apply_provisional_proposal(`
`746`		`- self,`
`747`		`- v1: v1::ProvisionalProposal,`
`748`		`- ) -> ReceiverTypeState {`
	`744`	`+ pub(crate) fn apply_provisional_proposal(self, v1: v1::ProvisionalProposal) -> ReceiveSession {`
`749`	`745`	`let new_state =`
`750`	`746`	`Receiver { state: ProvisionalProposal { v1, context: self.state.context.clone() } };`
`751`		`- ReceiverTypeState::ProvisionalProposal(new_state)`
	`747`	`+ ReceiveSession::ProvisionalProposal(new_state)`
`752`	`748`	`}`
`753`	`749`	`}`
`754`	`750`
`@@ -795,10 +791,10 @@ impl Receiver<ProvisionalProposal> {`
`795`	`791`	`)`
`796`	`792`	`}`
`797`	`793`
`798`		`- pub(crate) fn apply_payjoin_proposal(self, v1: v1::PayjoinProposal) -> ReceiverTypeState {`
	`794`	`+ pub(crate) fn apply_payjoin_proposal(self, v1: v1::PayjoinProposal) -> ReceiveSession {`
`799`	`795`	`let new_state =`
`800`	`796`	`Receiver { state: PayjoinProposal { v1, context: self.state.context.clone() } };`
`801`		`- ReceiverTypeState::PayjoinProposal(new_state)`
	`797`	`+ ReceiveSession::PayjoinProposal(new_state)`
`802`	`798`	`}`
`803`	`799`	`}`
`804`	`800`