Persistence follow ups

payjoin/src/receive/v2/mod.rs

@@ -1,5 +1,4 @@
 //! Receive BIP 77 Payjoin v2
-use std::fmt::{self, Display};
 use std::str::FromStr;
 use std::time::{Duration, SystemTime};
 
@@ -8,6 +7,7 @@ use bitcoin::psbt::Psbt;
 use bitcoin::{Address, FeeRate, OutPoint, Script, TxOut};
 pub(crate) use error::InternalSessionError;
 pub use error::SessionError;
+pub use persist::ReceiverToken;
 use serde::de::Deserializer;
 use serde::{Deserialize, Serialize};
 use url::Url;
@@ -20,12 +20,13 @@ use super::{
 use crate::hpke::{decrypt_message_a, encrypt_message_b, HpkeKeyPair, HpkePublicKey};
 use crate::ohttp::{ohttp_decapsulate, ohttp_encapsulate, OhttpEncapsulationError, OhttpKeys};
 use crate::output_substitution::OutputSubstitution;
-use crate::persist::{self, Persister};
+use crate::persist::Persister;
 use crate::receive::{parse_payload, InputPair};
 use crate::uri::ShortId;
 use crate::{IntoUrl, IntoUrlError, Request};
 
 mod error;
+mod persist;
 
 const SUPPORTED_VERSIONS: &[usize] = &[1, 2];
 
@@ -129,28 +130,6 @@ pub struct Receiver {
     context: SessionContext,
 }
 
-/// Opaque key type for the receiver
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ReceiverToken(ShortId);
-
-impl Display for ReceiverToken {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.0) }
-}
-
-impl From<Receiver> for ReceiverToken {
-    fn from(receiver: Receiver) -> Self { ReceiverToken(id(&receiver.context.s)) }
-}
-
-impl AsRef<[u8]> for ReceiverToken {
-    fn as_ref(&self) -> &[u8] { self.0.as_bytes() }
-}
-
-impl persist::Value for Receiver {
-    type Key = ReceiverToken;
-
-    fn key(&self) -> Self::Key { ReceiverToken(id(&self.context.s)) }
-}
-
 impl Receiver {
     /// Loads a [`Receiver`] from the provided persister using the storage token.
     pub fn load<P: Persister<Receiver>>(

payjoin/src/receive/v2/persist.rs

@@ -0,0 +1,27 @@
+use std::fmt::{self, Display};
+
+use super::{id, Receiver};
+use crate::persist::{self};
+use crate::uri::ShortId;
+
+/// Opaque key type for the receiver
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ReceiverToken(ShortId);
+
+impl Display for ReceiverToken {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.0) }
+}
+
+impl From<Receiver> for ReceiverToken {
+    fn from(receiver: Receiver) -> Self { ReceiverToken(id(&receiver.context.s)) }
+}
+
+impl AsRef<[u8]> for ReceiverToken {
+    fn as_ref(&self) -> &[u8] { self.0.as_bytes() }
+}
+
+impl persist::Value for Receiver {
+    type Key = ReceiverToken;
+
+    fn key(&self) -> Self::Key { ReceiverToken(id(&self.context.s)) }
+}

payjoin/src/send/multiparty/mod.rs

@@ -1,5 +1,3 @@
-use std::fmt::{self, Display};
-
 use bitcoin::{FeeRate, Psbt};
 use error::{
     CreateRequestError, FinalizeResponseError, FinalizedError, InternalCreateRequestError,
@@ -13,12 +11,12 @@ use super::{serialize_url, AdditionalFeeContribution, BuildSenderError, Internal
 use crate::hpke::decrypt_message_b;
 use crate::ohttp::ohttp_decapsulate;
 use crate::output_substitution::OutputSubstitution;
-use crate::persist::{self, Persister};
 use crate::send::v2::{ImplementationError, V2PostContext};
 use crate::uri::UrlExt;
 use crate::{PjUri, Request};
 
 mod error;
+mod persist;
 
 #[derive(Clone)]
 pub struct SenderBuilder<'a>(v2::SenderBuilder<'a>);
@@ -34,49 +32,10 @@ impl<'a> SenderBuilder<'a> {
 
 pub struct NewSender(v2::NewSender);
 
-impl NewSender {
-    pub fn persist<P: Persister<Sender>>(
-        &self,
-        persister: &mut P,
-    ) -> Result<P::Token, ImplementationError> {
-        let sender =
-            Sender(v2::Sender { v1: self.0.v1.clone(), reply_key: self.0.reply_key.clone() });
-        persister.save(sender).map_err(ImplementationError::from)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct SenderToken(Url);
-
-impl Display for SenderToken {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.0) }
-}
-
-impl From<Sender> for SenderToken {
-    fn from(sender: Sender) -> Self { SenderToken(sender.0.endpoint().clone()) }
-}
-
-impl AsRef<[u8]> for SenderToken {
-    fn as_ref(&self) -> &[u8] { self.0.as_str().as_bytes() }
-}
-
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Sender(v2::Sender);
 
-impl persist::Value for Sender {
-    type Key = SenderToken;
-
-    fn key(&self) -> Self::Key { SenderToken(self.0.endpoint().clone()) }
-}
-
 impl Sender {
-    pub fn load<P: Persister<Sender>>(
-        token: P::Token,
-        persister: &P,
-    ) -> Result<Self, ImplementationError> {
-        let sender = persister.load(token).map_err(ImplementationError::from)?;
-        Ok(sender)
-    }
     pub fn extract_v2(
         &self,
         ohttp_relay: Url,

payjoin/src/send/multiparty/persist.rs

@@ -0,0 +1,30 @@
+use crate::persist::{self, Persister};
+use crate::send::multiparty::{ImplementationError, NewSender, Sender};
+use crate::send::v2::{self, SenderToken};
+
+impl NewSender {
+    pub fn persist<P: Persister<Sender>>(
+        &self,
+        persister: &mut P,
+    ) -> Result<P::Token, ImplementationError> {
+        let sender =
+            Sender(v2::Sender { v1: self.0.v1.clone(), reply_key: self.0.reply_key.clone() });
+        persister.save(sender).map_err(ImplementationError::from)
+    }
+}
+
+impl persist::Value for Sender {
+    type Key = SenderToken;
+
+    fn key(&self) -> Self::Key { SenderToken(self.0.endpoint().clone()) }
+}
+
+impl Sender {
+    pub fn load<P: Persister<Sender>>(
+        token: P::Token,
+        persister: &P,
+    ) -> Result<Self, ImplementationError> {
+        let sender = persister.load(token).map_err(ImplementationError::from)?;
+        Ok(sender)
+    }
+}

payjoin/src/send/v2/mod.rs

@@ -21,25 +21,25 @@
 //! [`bitmask-core`](https://github.com/diba-io/bitmask-core) BDK integration. Bring your own
 //! wallet and http client.
 
-use std::fmt::{self, Display};
-
 use bitcoin::hashes::{sha256, Hash};
 pub use error::{CreateRequestError, EncapsulationError, ImplementationError};
 use error::{InternalCreateRequestError, InternalEncapsulationError};
 use ohttp::ClientResponse;
+pub use persist::SenderToken;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
 use super::error::BuildSenderError;
 use super::*;
 use crate::hpke::{decrypt_message_b, encrypt_message_a, HpkeSecretKey};
 use crate::ohttp::{ohttp_decapsulate, ohttp_encapsulate};
-use crate::persist::{Persister, Value};
+use crate::persist::Persister;
 use crate::send::v1;
 use crate::uri::{ShortId, UrlExt};
 use crate::{HpkeKeyPair, HpkePublicKey, IntoUrl, OhttpKeys, PjUri, Request};
 
 mod error;
+mod persist;
 
 /// A builder to construct the properties of a [`Sender`].
 #[derive(Clone)]
@@ -152,28 +152,6 @@ pub struct Sender {
     pub(crate) reply_key: HpkeSecretKey,
 }
 
-/// Opaque key type for the sender
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SenderToken(Url);
-
-impl Display for SenderToken {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.0) }
-}
-
-impl From<Sender> for SenderToken {
-    fn from(sender: Sender) -> Self { SenderToken(sender.endpoint().clone()) }
-}
-
-impl AsRef<[u8]> for SenderToken {
-    fn as_ref(&self) -> &[u8] { self.0.as_str().as_bytes() }
-}
-
-impl Value for Sender {
-    type Key = SenderToken;
-
-    fn key(&self) -> Self::Key { SenderToken(self.endpoint().clone()) }
-}
-
 impl Sender {
     /// Loads a [`Sender`] from the provided persister using the storage token.
     pub fn load<P: Persister<Sender>>(

payjoin/src/send/v2/persist.rs

@@ -0,0 +1,28 @@
+use std::fmt::{self, Display};
+
+use url::Url;
+
+use super::Sender;
+use crate::persist::Value;
+
+/// Opaque key type for the sender
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SenderToken(pub(crate) Url);
+
+impl Display for SenderToken {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.0) }
+}
+
+impl From<Sender> for SenderToken {
+    fn from(sender: Sender) -> Self { SenderToken(sender.endpoint().clone()) }
+}
+
+impl AsRef<[u8]> for SenderToken {
+    fn as_ref(&self) -> &[u8] { self.0.as_str().as_bytes() }
+}
+
+impl Value for Sender {
+    type Key = SenderToken;
+
+    fn key(&self) -> Self::Key { SenderToken(self.endpoint().clone()) }
+}