[vrf] derive bincode/serde with spaghetti bounds

Author: LLFourn

vrf_fun/src/vrf.rs

@@ -1,6 +1,5 @@
 //! Generic VRF implementation that can work with different transcript types
 
-use core::marker::PhantomData;
 use secp256kfun::{KeyPair, Scalar, prelude::*};
 use sigma_fun::{
     CompactProof, FiatShamir, ProverTranscript, Transcript,
@@ -15,12 +14,23 @@ use sigma_fun::{
 #[cfg_attr(
     feature = "serde",
     derive(serde::Serialize, serde::Deserialize),
-    serde(bound(serialize = "", deserialize = ""))
+    serde(bound(
+        deserialize = "L: ArrayLength<u8>, CompactProof<Scalar<Public, Zero>, L>: serde::Deserialize<'de>",
+        serialize = "L: ArrayLength<u8>, CompactProof<Scalar<Public, Zero>, L>: serde::Serialize",
+    ))
+)]
+#[cfg_attr(
+    feature = "bincode",
+    derive(bincode::Encode, bincode::Decode),
+    bincode(
+        encode_bounds = "L: ArrayLength<u8>, CompactProof<Scalar<Public, Zero>, L>: bincode::Encode",
+        decode_bounds = "L: ArrayLength<u8>, CompactProof<Scalar<Public, Zero>, L>: bincode::Decode<__Context>",
+        borrow_decode_bounds = "L: ArrayLength<u8>, CompactProof<Scalar<Public, Zero>, L>: bincode::BorrowDecode<'__de, __Context>"
+    )
 )]
 pub struct VrfProof<L = U16>
 where
-    L: ArrayLength<u8> + IsLessOrEqual<U32>,
-    <L as IsLessOrEqual<U32>>::Output: NonZero,
+    L: ArrayLength<u8>,
 {
     /// The VRF output point.
     ///
@@ -30,65 +40,16 @@ where
     pub proof: CompactProof<Scalar<Public, Zero>, L>,
 }
 
-#[cfg(feature = "bincode")]
-impl<L> bincode::Encode for VrfProof<L>
-where
-    L: ArrayLength<u8> + IsLessOrEqual<U32>,
-    <L as IsLessOrEqual<U32>>::Output: NonZero,
-{
-    fn encode<E: bincode::enc::Encoder>(
-        &self,
-        encoder: &mut E,
-    ) -> Result<(), bincode::error::EncodeError> {
-        self.gamma.encode(encoder)?;
-        self.proof.encode(encoder)?;
-        Ok(())
-    }
-}
-
-#[cfg(feature = "bincode")]
-impl<L, Context> bincode::Decode<Context> for VrfProof<L>
-where
-    L: ArrayLength<u8> + IsLessOrEqual<U32>,
-    <L as IsLessOrEqual<U32>>::Output: NonZero,
-{
-    fn decode<D: bincode::de::Decoder<Context = Context>>(
-        decoder: &mut D,
-    ) -> Result<Self, bincode::error::DecodeError> {
-        let gamma = Point::decode(decoder)?;
-        let proof = CompactProof::<Scalar<Public, Zero>, L>::decode(decoder)?;
-        Ok(VrfProof { gamma, proof })
-    }
-}
-
-#[cfg(feature = "bincode")]
-impl<'a, L, Context> bincode::BorrowDecode<'a, Context> for VrfProof<L>
-where
-    L: ArrayLength<u8> + IsLessOrEqual<U32>,
-    <L as IsLessOrEqual<U32>>::Output: NonZero,
-{
-    fn borrow_decode<D: bincode::de::BorrowDecoder<'a, Context = Context>>(
-        decoder: &mut D,
-    ) -> Result<Self, bincode::error::DecodeError> {
-        <Self as bincode::Decode<Context>>::decode(decoder)
-    }
-}
-
 /// Verified random output that ensures gamma has been verified
 #[derive(Debug, Clone)]
 pub struct VerifiedRandomOutput {
     pub gamma: Point,
 }
 
 /// Generic VRF implementation
-pub struct Vrf<T, ChallengeLength = U16>
-where
-    ChallengeLength: ArrayLength<u8> + IsLessOrEqual<U32>,
-    <ChallengeLength as IsLessOrEqual<U32>>::Output: NonZero,
-{
+pub struct Vrf<T, ChallengeLength = U16> {
     dleq: crate::VrfDleq<ChallengeLength>,
     pub transcript: T,
-    _phantom: PhantomData<ChallengeLength>,
 }
 
 impl<T: Clone, ChallengeLength> Vrf<T, ChallengeLength>
@@ -103,7 +64,6 @@ where
         Self {
             dleq: Eq::new(DLG::default(), DL::default()),
             transcript,
-            _phantom: PhantomData,
         }
     }
 }

vrf_fun/tests/codec.rs

@@ -0,0 +1,31 @@
+use secp256kfun::{KeyPair, prelude::*};
+use vrf_fun::VrfProof;
+
+#[cfg(feature = "bincode")]
+#[test]
+fn test_vrf_proof_bincode_roundtrip() {
+    let keypair = KeyPair::new(Scalar::random(&mut rand::thread_rng()));
+    let proof = vrf_fun::rfc9381::sswu::prove::<sha2::Sha256>(&keypair, b"test message");
+
+    let encoded = bincode::encode_to_vec(&proof, bincode::config::standard()).unwrap();
+    let (decoded, _): (VrfProof, _) =
+        bincode::decode_from_slice(&encoded, bincode::config::standard()).unwrap();
+
+    assert_eq!(proof, decoded);
+}
+
+#[cfg(all(feature = "bincode", feature = "serde"))]
+#[test]
+fn test_vrf_proof_serde_roundtrip() {
+    use bincode::serde::Compat;
+
+    let keypair = KeyPair::new(Scalar::random(&mut rand::thread_rng()));
+    let proof = vrf_fun::rfc9381::sswu::prove::<sha2::Sha256>(&keypair, b"test message");
+
+    let compat_proof = Compat(&proof);
+    let encoded = bincode::encode_to_vec(compat_proof, bincode::config::standard()).unwrap();
+    let (decoded, _): (Compat<VrfProof>, _) =
+        bincode::decode_from_slice(&encoded, bincode::config::standard()).unwrap();
+
+    assert_eq!(proof, decoded.0);
+}