ark_serde_compat/
lib.rs

1#![doc = include_str!("../README.md")]
2//! ## Usage
3//!
4//! This crate is intended to be used with serde's `#[serde(serialize_with = "ark_serde_compat")]`, `#[serde(deserialize_with = "ark_serde_compat")]`, and `#[serde(with = "ark_serde_compat")]`. Please see serde's documentation on how to use these attributes.
5
6#![cfg_attr(not(feature = "std"), no_std)]
7#![warn(missing_docs)]
8#![warn(clippy::use_self)]
9
10#[cfg(not(feature = "std"))]
11extern crate alloc;
12
13#[cfg(not(feature = "std"))]
14use alloc::vec::Vec;
15use core::{any::type_name, fmt, marker::PhantomData};
16
17use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
18use serde::{
19    Deserializer, Serializer,
20    de::{self, Visitor},
21    ser::Error as _,
22};
23
24/// Serialize and deserialize to and from compressed representations.
25pub mod compressed {
26    use super::*;
27
28    struct ByteVisitor<T>(PhantomData<T>);
29
30    impl<T> Visitor<'_> for ByteVisitor<T>
31    where
32        T: CanonicalDeserialize,
33    {
34        type Value = T;
35
36        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
37            write!(formatter, "{}", type_name::<T>())
38        }
39
40        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
41        where
42            E: de::Error,
43        {
44            T::deserialize_compressed(v)
45                .map_err(|_| de::Error::invalid_value(de::Unexpected::Bytes(v), &self))
46        }
47    }
48
49    /// Serialize a value to its compressed representation.
50    pub fn serialize<V, S>(value: &V, ser: S) -> Result<S::Ok, S::Error>
51    where
52        V: CanonicalSerialize,
53        S: Serializer,
54    {
55        let mut dst = Vec::new();
56        value
57            .serialize_compressed(&mut dst)
58            .map_err(|_| S::Error::custom("serialize_compressed failed"))?;
59        ser.serialize_bytes(&dst)
60    }
61
62    /// Deserialize a value from its compressed representation.
63    pub fn deserialize<'de, V, D>(de: D) -> Result<V, D::Error>
64    where
65        V: CanonicalDeserialize,
66        D: Deserializer<'de>,
67    {
68        de.deserialize_bytes(ByteVisitor(PhantomData))
69    }
70}
71
72/// Serialize and deserialize to and from uncompressed representations.
73pub mod uncompressed {
74    use super::*;
75
76    struct ByteVisitor<T>(PhantomData<T>);
77
78    impl<T> Visitor<'_> for ByteVisitor<T>
79    where
80        T: CanonicalDeserialize,
81    {
82        type Value = T;
83
84        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
85            write!(formatter, "{}", type_name::<T>())
86        }
87
88        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
89        where
90            E: de::Error,
91        {
92            T::deserialize_uncompressed(v)
93                .map_err(|_| de::Error::invalid_value(de::Unexpected::Bytes(v), &self))
94        }
95    }
96
97    /// Serialize a value to its uncompressed representation.
98    pub fn serialize<V, S>(value: &V, ser: S) -> Result<S::Ok, S::Error>
99    where
100        V: CanonicalSerialize,
101        S: Serializer,
102    {
103        let mut dst = Vec::new();
104        value
105            .serialize_uncompressed(&mut dst)
106            .map_err(|_| S::Error::custom("serialize_uncompressed failed"))?;
107        ser.serialize_bytes(&dst)
108    }
109
110    /// Deserialize a value from its uncompressed representation.
111    pub fn deserialize<'de, V, D>(de: D) -> Result<V, D::Error>
112    where
113        V: CanonicalDeserialize,
114        D: Deserializer<'de>,
115    {
116        de.deserialize_bytes(ByteVisitor(PhantomData))
117    }
118}
119
120#[cfg(feature = "std")]
121/// Serialize and deserialize vectors of serializable values.
122pub mod vec {
123    use super::*;
124
125    use serde::{Deserialize, Serialize};
126
127    #[derive(Serialize, Deserialize)]
128    struct Wrapper<T>(#[serde(with = "compressed")] T)
129    where
130        T: CanonicalSerialize + CanonicalDeserialize;
131
132    /// Serialize values to their compressed represnetation.
133    pub fn serialize<T, S>(value: &[T], ser: S) -> Result<S::Ok, S::Error>
134    where
135        T: CanonicalSerialize + CanonicalDeserialize + Copy,
136        S: Serializer,
137    {
138        let tmp: Vec<_> = value.iter().map(|v| Wrapper(*v)).collect();
139        tmp.serialize(ser)
140    }
141
142    /// Deserializes values to their compressed represnetation.
143    pub fn deserialize<'de, T, D>(de: D) -> Result<Vec<T>, D::Error>
144    where
145        T: CanonicalSerialize + CanonicalDeserialize,
146        D: Deserializer<'de>,
147    {
148        Vec::<Wrapper<T>>::deserialize(de).map(|w| w.into_iter().map(|w| w.0).collect())
149    }
150}
151
152pub use compressed::{deserialize, serialize};
153
154#[cfg(test)]
155mod test {
156    use super::*;
157
158    use fmt::Debug;
159
160    use ark_bls12_381::Bls12_381;
161    use ark_ec::pairing::{Pairing, PairingOutput};
162    use ark_ff::UniformRand;
163    use bincode::config;
164    use serde::{Deserialize, Serialize};
165
166    type G1Affine = <Bls12_381 as Pairing>::G1Affine;
167    type G1Projective = <Bls12_381 as Pairing>::G1;
168    type G2Affine = <Bls12_381 as Pairing>::G2Affine;
169    type G2Projective = <Bls12_381 as Pairing>::G2;
170    type Gt = PairingOutput<Bls12_381>;
171    type Scalar = <Bls12_381 as Pairing>::ScalarField;
172
173    #[derive(Serialize, Deserialize, Eq, PartialEq, Debug)]
174    struct Wrapper<T>(#[serde(with = "super")] T)
175    where
176        T: CanonicalSerialize + CanonicalDeserialize + Eq + PartialEq + Debug;
177
178    #[derive(Serialize, Deserialize, Eq, PartialEq, Debug)]
179    struct UncommpressedWrapper<T>(#[serde(with = "uncompressed")] T)
180    where
181        T: CanonicalSerialize + CanonicalDeserialize + Eq + PartialEq + Debug;
182
183    #[test]
184    fn g1() {
185        let mut rng = rand::thread_rng();
186        let v = Wrapper(G1Affine::rand(&mut rng));
187
188        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
189        let (v_deserialized, len) =
190            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
191        assert_eq!(v, v_deserialized);
192        assert_eq!(bin.len(), len);
193    }
194
195    #[test]
196    fn uncompressed_g1() {
197        let mut rng = rand::thread_rng();
198        let v = UncommpressedWrapper(G1Affine::rand(&mut rng));
199
200        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
201        let (v_deserialized, len) =
202            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
203        assert_eq!(v, v_deserialized);
204        assert_eq!(bin.len(), len);
205    }
206
207    #[test]
208    fn g1_projective() {
209        let mut rng = rand::thread_rng();
210        let v = Wrapper(G1Affine::rand(&mut rng));
211
212        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
213        let (v_deserialized, len) =
214            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
215        assert_eq!(v, v_deserialized);
216        assert_eq!(bin.len(), len);
217    }
218
219    #[test]
220    fn uncompressed_g1_projective() {
221        let mut rng = rand::thread_rng();
222        let v = UncommpressedWrapper(G1Projective::rand(&mut rng));
223
224        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
225        let (v_deserialized, len) =
226            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
227        assert_eq!(v, v_deserialized);
228        assert_eq!(bin.len(), len);
229    }
230
231    #[test]
232    fn g2() {
233        let mut rng = rand::thread_rng();
234        let v = Wrapper(G2Affine::rand(&mut rng));
235
236        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
237        let (v_deserialized, len) =
238            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
239        assert_eq!(v, v_deserialized);
240        assert_eq!(bin.len(), len);
241    }
242
243    #[test]
244    fn uncompressed_g2() {
245        let mut rng = rand::thread_rng();
246        let v = UncommpressedWrapper(G2Affine::rand(&mut rng));
247
248        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
249        let (v_deserialized, len) =
250            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
251        assert_eq!(v, v_deserialized);
252        assert_eq!(bin.len(), len);
253    }
254
255    #[test]
256    fn g2_projective() {
257        let mut rng = rand::thread_rng();
258        let v = Wrapper(G2Projective::rand(&mut rng));
259
260        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
261        let (v_deserialized, len) =
262            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
263        assert_eq!(v, v_deserialized);
264        assert_eq!(bin.len(), len);
265    }
266
267    #[test]
268    fn uncompressed_g2_projective() {
269        let mut rng = rand::thread_rng();
270        let v = UncommpressedWrapper(G2Projective::rand(&mut rng));
271
272        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
273        let (v_deserialized, len) =
274            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
275        assert_eq!(v, v_deserialized);
276        assert_eq!(bin.len(), len);
277    }
278
279    #[test]
280    fn gt() {
281        let mut rng = rand::thread_rng();
282        let v = Wrapper(Gt::rand(&mut rng));
283
284        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
285        let (v_deserialized, len) =
286            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
287        assert_eq!(v, v_deserialized);
288        assert_eq!(bin.len(), len);
289    }
290
291    #[test]
292    fn uncompressed_gt() {
293        let mut rng = rand::thread_rng();
294        let v = UncommpressedWrapper(Gt::rand(&mut rng));
295
296        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
297        let (v_deserialized, len) =
298            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
299        assert_eq!(v, v_deserialized);
300        assert_eq!(bin.len(), len);
301    }
302
303    #[test]
304    fn scalar() {
305        let mut rng = rand::thread_rng();
306        let v = Wrapper(Scalar::rand(&mut rng));
307        let v_uncompressed = UncommpressedWrapper(v.0);
308
309        let bin = bincode::serde::encode_to_vec(&v, config::standard()).unwrap();
310        assert_eq!(
311            bin,
312            bincode::serde::encode_to_vec(&v_uncompressed, config::standard()).unwrap()
313        );
314
315        let (v_deserialized, len) =
316            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
317        assert_eq!(v, v_deserialized);
318        assert_eq!(bin.len(), len);
319
320        let (v_deserialized, len) =
321            bincode::serde::decode_from_slice(&bin, config::standard()).unwrap();
322        assert_eq!(v_uncompressed, v_deserialized);
323        assert_eq!(bin.len(), len);
324    }
325}
ark_serde_compat/lib.rs

ark_serde_compat/
lib.rs
