Simplify Deserializer logic

Author: fjarri

Cargo.lock

@@ -1,9 +1,6 @@
 extern crate alloc;
 
-mod format;
 pub mod simple;
 
 #[cfg(test)]
 mod simple_malicious;
-
-pub use format::Binary;

examples/src/format.rs

@@ -391,13 +391,12 @@ mod tests {
 
     use manul::{
         session::{signature::Keypair, SessionOutcome},
-        testing::{run_sync, TestSessionParams, TestSigner, TestVerifier},
+        testing::{run_sync, Binary, TestSessionParams, TestSigner, TestVerifier},
     };
     use rand_core::OsRng;
     use tracing_subscriber::EnvFilter;
 
     use super::{Inputs, Round1};
-    use crate::Binary;
 
     #[test]
     fn round() {

examples/src/lib.rs

@@ -7,15 +7,14 @@ use manul::{
         Round,
     },
     session::{signature::Keypair, Serializer},
-    testing::{round_override, run_sync, RoundOverride, RoundWrapper, TestSessionParams, TestSigner, TestVerifier},
+    testing::{
+        round_override, run_sync, Binary, RoundOverride, RoundWrapper, TestSessionParams, TestSigner, TestVerifier,
+    },
 };
 use rand_core::{CryptoRngCore, OsRng};
 use tracing_subscriber::EnvFilter;
 
-use crate::{
-    simple::{Inputs, Round1, Round1Message, Round2, Round2Message},
-    Binary,
-};
+use crate::simple::{Inputs, Round1, Round1Message, Round2, Round2Message};
 
 #[derive(Debug, Clone, Copy)]
 enum Behavior {

examples/src/simple.rs

@@ -10,12 +10,9 @@ use manul::{
         signature::Keypair, CanFinalize, LocalError, MessageBundle, RoundOutcome, Session, SessionId,
         SessionParameters, SessionReport,
     },
-    testing::{TestSessionParams, TestSigner},
-};
-use manul_example::{
-    simple::{Inputs, Round1, SimpleProtocol},
-    Binary,
+    testing::{Binary, TestSessionParams, TestSigner},
 };
+use manul_example::simple::{Inputs, Round1, SimpleProtocol};
 use rand::Rng;
 use rand_core::OsRng;
 use tokio::{

examples/src/simple_malicious.rs

@@ -20,6 +20,7 @@ rand_core = { version = "0.6.4", default-features = false }
 tracing = { version = "0.1", default-features = false }
 displaydoc = { version = "0.2", default-features = false }
 rand = { version = "0.8", default-features = false, optional = true }
+serde-persistent-deserializer = { version = "0.2", optional = true }
 postcard = { version = "1", default-features = false, features = ["alloc"], optional = true }
 
 [dev-dependencies]
@@ -28,9 +29,11 @@ rand = { version = "0.8", default-features = false }
 serde_asn1_der = "0.8"
 serde_json = "1"
 criterion = "0.5"
+serde-persistent-deserializer = "0.2"
+postcard = { version = "1", default-features = false, features = ["alloc"] }
 
 [features]
-testing = ["rand", "postcard"]
+testing = ["rand", "postcard", "serde-persistent-deserializer"]
 
 [package.metadata.docs.rs]
 all-features = true

examples/tests/async_runner.rs

@@ -8,7 +8,7 @@ use super::{
     message::{MessageVerificationError, MissingMessage, SignedMessage},
     session::SessionParameters,
     transcript::Transcript,
-    wire_format::{Deserializer, WireFormat},
+    wire_format::Deserializer,
     LocalError,
 };
 use crate::{
@@ -233,10 +233,7 @@ where
         &self.description
     }
 
-    pub fn verify(&self, party: &SP::Verifier) -> Result<(), EvidenceError>
-    where
-        for<'a, 'de> &'a mut <<SP as SessionParameters>::WireFormat as WireFormat>::Des<'de>: serde::Deserializer<'de>,
-    {
+    pub fn verify(&self, party: &SP::Verifier) -> Result<(), EvidenceError> {
         let deserializer = Deserializer::new::<SP::WireFormat>();
         match &self.evidence {
             EvidenceEnum::Protocol(evidence) => evidence.verify::<SP>(party, &deserializer),

manul/Cargo.toml

@@ -148,7 +148,6 @@ where
     ) -> Result<Self, LocalError>
     where
         R: FirstRound<SP::Verifier> + Round<SP::Verifier, Protocol = P>,
-        for<'a, 'de> &'a mut <<SP as SessionParameters>::WireFormat as WireFormat>::Des<'de>: serde::Deserializer<'de>,
     {
         let verifier = signer.verifying_key();
         let first_round = Box::new(ObjectSafeRoundWrapper::new(R::new(

manul/src/session/evidence.rs

@@ -11,12 +11,10 @@ pub trait WireFormat: 'static + Send + Sync + Debug {
     fn serialize<T: Serialize>(value: T) -> Result<Box<[u8]>, LocalError>;
 
     /// The deserializer type.
-    type Des<'de>: 'de;
+    type Des<'de>: serde::Deserializer<'de>;
 
     /// Creates a `serde` deserializer given a bytestring.
-    fn deserializer<'de>(bytes: &'de [u8]) -> Self::Des<'de>
-    where
-        for<'a> &'a mut Self::Des<'de>: serde::Deserializer<'de>;
+    fn deserializer(bytes: &[u8]) -> Self::Des<'_>;
 }
 
 // Serialization
@@ -56,35 +54,16 @@ impl Serializer {
 struct DeserializerFactoryWrapper<F>(PhantomData<F>);
 
 trait ObjectSafeDeserializerFactory: Debug {
-    fn make_deserializer<'de>(&self, bytes: &'de [u8]) -> Box<dyn ObjectSafeDeserializer<'de> + 'de>;
+    fn make_erased_deserializer<'de>(&self, bytes: &'de [u8]) -> Box<dyn erased_serde::Deserializer<'de> + 'de>;
 }
 
 impl<F> ObjectSafeDeserializerFactory for DeserializerFactoryWrapper<F>
 where
     F: WireFormat,
-    for<'a, 'de> &'a mut F::Des<'de>: serde::Deserializer<'de>,
 {
-    fn make_deserializer<'de>(&self, bytes: &'de [u8]) -> Box<dyn ObjectSafeDeserializer<'de> + 'de> {
+    fn make_erased_deserializer<'de>(&self, bytes: &'de [u8]) -> Box<dyn erased_serde::Deserializer<'de> + 'de> {
         let deserializer = F::deserializer(bytes);
-        Box::new(deserializer)
-    }
-}
-
-trait ObjectSafeDeserializer<'de> {
-    fn get_erased<'s>(&'s mut self) -> Box<dyn erased_serde::Deserializer<'de> + 's>
-    where
-        'de: 's;
-}
-
-impl<'de, D: 'de> ObjectSafeDeserializer<'de> for D
-where
-    for<'any> &'any mut D: serde::Deserializer<'de>,
-{
-    fn get_erased<'s>(&'s mut self) -> Box<dyn erased_serde::Deserializer<'de> + 's>
-    where
-        'de: 's,
-    {
-        Box::new(<dyn erased_serde::Deserializer<'_>>::erase(self))
+        Box::new(<dyn erased_serde::Deserializer<'_>>::erase(deserializer))
     }
 }
 
@@ -96,19 +75,17 @@ impl Deserializer {
     pub(crate) fn new<F>() -> Self
     where
         F: WireFormat,
-        for<'a, 'de> &'a mut F::Des<'de>: serde::Deserializer<'de>,
     {
-        Self(Box::new(DeserializerFactoryWrapper(PhantomData)))
+        Self(Box::new(DeserializerFactoryWrapper(PhantomData::<F>)))
     }
 
     /// Deserializes a `serde`-deserializable object.
     pub fn deserialize<'de, T>(&self, bytes: &'de [u8]) -> Result<T, DeserializationError>
     where
         T: Deserialize<'de>,
     {
-        let mut deserializer = self.0.make_deserializer(bytes);
-        let mut erased = deserializer.get_erased();
-        erased_serde::deserialize::<T>(&mut erased)
+        let mut deserializer = self.0.make_erased_deserializer(bytes);
+        erased_serde::deserialize::<T>(&mut deserializer)
             .map_err(|err| DeserializationError::new(format!("Deserialization error: {err:?}")))
     }
 }

manul/src/session/session.rs

@@ -1,26 +1,42 @@
 use alloc::{boxed::Box, string::ToString};
 
 use serde::Serialize;
+use serde_persistent_deserializer::{AsTransientDeserializer, PersistentDeserializer};
 
 use crate::{protocol::LocalError, session::WireFormat};
 
 /// A binary format to use in tests.
 #[derive(Debug, Clone, Copy)]
 pub struct Binary;
 
+#[allow(missing_debug_implementations)]
+pub struct PostcardDeserializer<'de>(postcard::Deserializer<'de, postcard::de_flavors::Slice<'de>>);
+
+impl<'de> AsTransientDeserializer<'de> for PostcardDeserializer<'de> {
+    type Error = postcard::Error;
+
+    fn as_transient_deserializer<'a>(&'a mut self) -> impl serde::Deserializer<'de, Error = Self::Error> {
+        &mut self.0
+    }
+
+    fn is_human_readable(&self) -> bool {
+        false
+    }
+}
+
 impl WireFormat for Binary {
     fn serialize<T: Serialize>(value: T) -> Result<Box<[u8]>, LocalError> {
         postcard::to_allocvec(&value)
             .map(|vec| vec.into())
             .map_err(|err| LocalError::new(err.to_string()))
     }
 
-    type Des<'de> = postcard::Deserializer<'de, postcard::de_flavors::Slice<'de>>;
+    type Des<'de> = PersistentDeserializer<PostcardDeserializer<'de>>;
 
-    fn deserializer<'de>(bytes: &'de [u8]) -> Self::Des<'de>
-    where
-        for<'a> &'a mut Self::Des<'de>: serde::Deserializer<'de>,
-    {
-        postcard::Deserializer::from_flavor(postcard::de_flavors::Slice::new(bytes))
+    fn deserializer(bytes: &[u8]) -> Self::Des<'_> {
+        let flavor = postcard::de_flavors::Slice::new(bytes);
+        let deserializer = postcard::Deserializer::from_flavor(flavor);
+        let persistent = PersistentDeserializer::new(PostcardDeserializer(deserializer));
+        persistent
     }
 }

manul/src/session/wire_format.rs

@@ -11,7 +11,7 @@ use crate::{
     protocol::{FirstRound, Protocol},
     session::{
         CanFinalize, LocalError, MessageBundle, RoundAccumulator, RoundOutcome, Session, SessionId, SessionParameters,
-        SessionReport, WireFormat,
+        SessionReport,
     },
 };
 
@@ -98,7 +98,6 @@ pub fn run_sync<R, SP>(
 where
     R: 'static + FirstRound<SP::Verifier>,
     SP: 'static + SessionParameters + Debug,
-    for<'a, 'de> &'a mut <<SP as SessionParameters>::WireFormat as WireFormat>::Des<'de>: serde::Deserializer<'de>,
 {
     let session_id = SessionId::random::<SP>(rng);