0.24 name audit part 2 (payjoin#810)

I was also getting confused by the similar `Receiver<State>` and
`ReceiverTypeState` type names, so I went with `ReceiveSession` for the
enum, which may not have initialized a `Receiver` yet, and might have
even failed. This rename pattern was applied to `SenderTypeState` as
well. I kept "Receive" in "ReceiveSession" to disambiguate between
Sessions for payjoin-ffi since the disambiguation applies to
payjoin-cli/v2 for the time being until that module is separated into
send/receive submodules as well.

Author: spacebear21

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

@@ -6,12 +6,12 @@ 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,
-    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();
@@ -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(())
     }
@@ -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(());
             }
@@ -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")),
             }
         };

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)
 

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,

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() }
 }

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() }
 }