feat: serde-compatible adapters (#967)

* feat: serde-compatible wrappers

* clean up a bit with macros

* add impl From<T> for *compressed*checked<T>

* refmt

* serde-encoded-bytes to base64

right now it serializes in JSON to [1, 2, 3, 4] instead of a string.

this crate is efficient in both binary and text formats.

* serialize: missing instances for &T/&mut T

* serialize: serde_with and Vec converters

* re-hide the serde module

* optional feature

Co-authored-by: Pratyush Mishra <pratyush795@gmail.com>

* doc the new wrappers in README

* move Valid impl

* add simple serde_json test

* README.md newline

---------

Co-authored-by: Pratyush Mishra <pratyush795@gmail.com>
Co-authored-by: Pratyush Mishra <pratyushmishra@berkeley.edu>

Author: emberian

CHANGELOG.md

@@ -6,6 +6,7 @@
 - [\#971](https://github.com/arkworks-rs/algebra/pull/971) (`ark-ff`) Make serial_batch_inversion_and_mul public.
 - Consolidated logic into `bitreverse_permutation_in_place` and made it public.
 - Remove redundant type constraints from `Pairing::G1Prepared`.
+- (`ark-serialize`) Add serde-compatible wrapper types `CompressedChecked<T>`, `CompressedUnchecked<T>`, `UncompressedChecked<T>`, `UncompressedUnchecked<T>`.
 
 ### Breaking changes
 

Cargo.toml

@@ -169,6 +169,8 @@ rayon = "1"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
+serde-encoded-bytes = "0.2"
+serde_with = "3.12"
 sha2 = { version = "0.10", default-features = false }
 sha3 = { version = "0.10", default-features = false }
 blake2 = { version = "0.10", default-features = false }

serialize/Cargo.toml

@@ -25,11 +25,15 @@ arrayvec.workspace = true
 digest.workspace = true
 num-bigint.workspace = true
 rayon = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+serde-encoded-bytes = { workspace = true, optional = true, features = ["base64"] }
+serde_with = { workspace = true, optional = true, default-features = false }
 
 [dev-dependencies]
 sha2.workspace = true
 sha3.workspace = true
 blake2.workspace = true
+serde_json.workspace = true
 ark-test-curves = { workspace = true, default-features = false, features = [
     "bls12_381_curve",
 ] }
@@ -38,5 +42,7 @@ ark-test-curves = { workspace = true, default-features = false, features = [
 [features]
 default = []
 parallel = ["rayon"]
-std = ["ark-std/std"]
+std = ["ark-std/std", "serde_with?/std"]
 derive = ["ark-serialize-derive"]
+serde = ["dep:serde", "dep:serde-encoded-bytes", "dep:serde_with"]
+serde_with = ["serde", "dep:serde_with"]

serialize/README.md

@@ -126,3 +126,64 @@ impl Valid for MyStruct {
     }
 }
 ```
+
+### `serde`-compatibility
+
+Four wrapper types (`CompressedChecked<T>`, `UncompressedChecked<T>`, `CompressedUnchecked<T>`, `UncompressedUnchecked<T>`) exist with two features: first, a type-level configuration of the de/serialization modes, and support for the [`serde`](https://serde.rs) framework. The easiest way to use these is with the `from` and `into` annotations on a container type already implementing `Canonical*`:
+
+```rust,ignore
+use ark_serialize::{CanonicalSerialize, CanonicalDeserialize, CompressedChecked};
+use ark_test_curves::bls12_381::{G1Affine, G2Affine, Fr};
+use serde::{Serialize, Deserialize};
+
+#[derive(Clone, Debug, PartialEq, Eq, CanonicalSerialize, CanonicalDeserialize)]
+pub struct Proof(pub G1Affine);
+
+#[derive(Clone, Debug, PartialEq, Eq, CanonicalSerialize, CanonicalDeserialize)]
+#[derive(Serialize, Deserialize)]
+#[serde(from = "CompressedChecked<Self>", into = "CompressedChecked<Self>")]
+pub struct Signature {
+    /// Aggregated BLS signature σ' = H(m)^aSK.
+    pub agg_sig_prime: G2Affine,
+    /// The threshold for the signature.
+    pub threshold: Fr,
+    /// The SNARK proof π.
+    pub proof: Proof,
+}
+
+impl From<CompressedChecked<Signature>> for Signature {
+    fn from(sig: CompressedChecked<Signature>) -> Self {
+        sig.0
+    }
+}
+```
+
+This type can now be used with either serialization framework.
+
+When the container type isn't suitable for `#[serde(from/into)]`, `serde_with` conversions can be used instead of pushing the wrapper types into the field values. This prevents the conversion structures from polluting the real datastructure (eg having to add dummy constructors and strip them out of collections), minimizing the impact of adding serde support.
+
+If `serde_with` is not desired, the less powerful `vec_*` mods provide support just for the common case of sequences. Without this converter, a `CompressedChecked<Vec<T>>` gets serialized as a single blob, as opposed to one blob per element, which is probably more intuitive. The alternative, trying to store `Vec<CompressedCheck<T>>`, causes invasive API pollution.
+
+```rust,ignore
+use ark_serialize::CompressedChecked;
+use serde::Serialize;
+use ark_test_curves::bls12_381::{G1Affine, G2Affine, Fr};
+
+#[serde_with::serde_as]
+#[derive(Clone, Debug, Serialize)]
+pub struct GlobalData {
+    #[serde_as(as = "CompressedChecked<UniversalParams<Curve>>")]
+    pub params: UniversalParams<Curve>,
+    pub degree_max: usize,
+    /// Used for domain separation in lockstitch
+    pub domain: String,
+    #[serde_as(as = "Vec<CompressedChecked<DensePolynomial<F>>>")]
+    pub(crate) lagrange_polynomials: Vec<DensePolynomial<F>>,
+    #[serde(with = "ark_serialize::vec_compressed_checked")]
+    pub(crate) lagrange_coms_g1: Vec<G1Affine>,
+    #[serde(with = "ark_serialize::vec_compressed_checked")]
+    pub(crate) lagrange_coms_g2: Vec<G2Affine>,
+    #[serde(skip)]
+    pub(crate) lockstitch: lockstitch::Protocol,
+}
+```

serialize/src/impls.rs

@@ -980,3 +980,31 @@ where
             .collect()
     }
 }
+
+impl<T: CanonicalSerialize> CanonicalSerialize for &T {
+    fn serialize_with_mode<W: Write>(
+        &self,
+        writer: W,
+        compress: Compress,
+    ) -> Result<(), SerializationError> {
+        (*self).serialize_with_mode(writer, compress)
+    }
+
+    fn serialized_size(&self, compress: Compress) -> usize {
+        (*self).serialized_size(compress)
+    }
+}
+
+impl<T: CanonicalSerialize> CanonicalSerialize for &mut T {
+    fn serialize_with_mode<W: Write>(
+        &self,
+        writer: W,
+        compress: Compress,
+    ) -> Result<(), SerializationError> {
+        (**self).serialize_with_mode(writer, compress)
+    }
+
+    fn serialized_size(&self, compress: Compress) -> usize {
+        (**self).serialized_size(compress)
+    }
+}

serialize/src/lib.rs

@@ -12,10 +12,13 @@ mod error;
 mod flags;
 mod impls;
 
+mod serde;
+
 pub use ark_std::io::{Read, Write};
 
 pub use error::*;
 pub use flags::*;
+pub use serde::*;
 
 #[cfg(test)]
 mod test;