feat(zk): Versionize ProvenCompactCiphertextList

tfhe-zk-pok/Cargo.toml

@@ -23,6 +23,7 @@ sha3 = "0.10.8"
 serde = { version = "~1.0", features = ["derive"] }
 zeroize = "1.7.0"
 num-bigint = "0.4.5"
+tfhe-versionable = { version = "0.2.2", path = "../utils/tfhe-versionable" }
 
 [dev-dependencies]
 serde_json = "~1.0"

tfhe-zk-pok/src/backward_compatibility/mod.rs

@@ -0,0 +1,41 @@
+use tfhe_versionable::{Unversionize, Versionize, VersionsDispatch};
+
+use crate::curve_api::Curve;
+use crate::proofs::pke_v2::Proof;
+use crate::serialization::{
+    SerializableAffine, SerializableCubicExtField, SerializableFp, SerializableFp2,
+    SerializableFp6, SerializableQuadExtField,
+};
+
+#[derive(VersionsDispatch)]
+pub enum SerializableAffineVersions<F> {
+    V0(SerializableAffine<F>),
+}
+
+#[derive(VersionsDispatch)]
+pub enum SerializableFpVersions {
+    V0(SerializableFp),
+}
+
+#[derive(VersionsDispatch)]
+pub enum SerializableQuadExtFieldVersions<F> {
+    V0(SerializableQuadExtField<F>),
+}
+
+#[derive(VersionsDispatch)]
+pub enum SerializableCubicExtFieldVersions<F> {
+    V0(SerializableCubicExtField<F>),
+}
+
+pub type SerializableG1AffineVersions = SerializableAffineVersions<SerializableFp>;
+pub type SerializableG2AffineVersions = SerializableAffineVersions<SerializableFp2>;
+pub type SerializableFp12Versions = SerializableQuadExtFieldVersions<SerializableFp6>;
+
+#[derive(VersionsDispatch)]
+pub enum ProofVersions<G: Curve>
+where
+    G::G1: Versionize + Unversionize,
+    G::G2: Versionize + Unversionize,
+{
+    V0(Proof<G>),
+}

tfhe-zk-pok/src/curve_api.rs

@@ -7,6 +7,7 @@ use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use core::fmt;
 use core::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
 use serde::{Deserialize, Serialize};
+use tfhe_versionable::NotVersioned;
 
 use crate::serialization::{SerializableAffine, SerializableFp, SerializableFp12, SerializableFp2};
 
@@ -412,9 +413,11 @@ impl PairingGroupOps<bls12_446::Zp, bls12_446::G1, bls12_446::G2> for bls12_446:
     }
 }
 
-#[derive(Debug, Copy, Clone, serde::Serialize, serde::Deserialize)]
+// These are just ZSTs that are not actually produced and are only used for their
+// associated types. So it's ok to derive "NotVersioned" for them.
+#[derive(Debug, Copy, Clone, serde::Serialize, serde::Deserialize, NotVersioned)]
 pub struct Bls12_381;
-#[derive(Debug, Copy, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Copy, Clone, serde::Serialize, serde::Deserialize, NotVersioned)]
 pub struct Bls12_446;
 
 impl Curve for Bls12_381 {

tfhe-zk-pok/src/curve_api/bls12_381.rs

@@ -34,6 +34,9 @@ fn bigint_to_le_bytes(x: [u64; 6]) -> [u8; 6 * 8] {
 }
 
 mod g1 {
+    use tfhe_versionable::Versionize;
+
+    use crate::backward_compatibility::SerializableG1AffineVersions;
     use crate::serialization::{InvalidSerializedAffineError, SerializableG1Affine};
 
     use super::*;
@@ -49,10 +52,13 @@ mod g1 {
         Hash,
         CanonicalSerialize,
         CanonicalDeserialize,
+        Versionize,
     )]
-    #[serde(
-        try_from = "SerializableAffine<SerializableFp>",
-        into = "SerializableAffine<SerializableFp>"
+    #[serde(try_from = "SerializableG1Affine", into = "SerializableG1Affine")]
+    #[versionize(
+        SerializableG1AffineVersions,
+        try_from = "SerializableG1Affine",
+        into = "SerializableG1Affine"
     )]
     #[repr(transparent)]
     pub struct G1Affine {
@@ -100,10 +106,13 @@ mod g1 {
         Hash,
         CanonicalSerialize,
         CanonicalDeserialize,
+        Versionize,
     )]
-    #[serde(
-        try_from = "SerializableAffine<SerializableFp>",
-        into = "SerializableAffine<SerializableFp>"
+    #[serde(try_from = "SerializableG1Affine", into = "SerializableG1Affine")]
+    #[versionize(
+        SerializableG1AffineVersions,
+        try_from = "SerializableG1Affine",
+        into = "SerializableG1Affine"
     )]
     #[repr(transparent)]
     pub struct G1 {
@@ -250,6 +259,9 @@ mod g1 {
 }
 
 mod g2 {
+    use tfhe_versionable::Versionize;
+
+    use crate::backward_compatibility::SerializableG2AffineVersions;
     use crate::serialization::{InvalidSerializedAffineError, SerializableG2Affine};
 
     use super::*;
@@ -265,10 +277,13 @@ mod g2 {
         Hash,
         CanonicalSerialize,
         CanonicalDeserialize,
+        Versionize,
     )]
-    #[serde(
-        try_from = "SerializableAffine<SerializableFp2>",
-        into = "SerializableAffine<SerializableFp2>"
+    #[serde(try_from = "SerializableG2Affine", into = "SerializableG2Affine")]
+    #[versionize(
+        SerializableG2AffineVersions,
+        try_from = "SerializableG2Affine",
+        into = "SerializableG2Affine"
     )]
     #[repr(transparent)]
     pub struct G2Affine {
@@ -316,10 +331,13 @@ mod g2 {
         Hash,
         CanonicalSerialize,
         CanonicalDeserialize,
+        Versionize,
     )]
-    #[serde(
-        try_from = "SerializableAffine<SerializableFp2>",
-        into = "SerializableAffine<SerializableFp2>"
+    #[serde(try_from = "SerializableG2Affine", into = "SerializableG2Affine")]
+    #[versionize(
+        SerializableG2AffineVersions,
+        try_from = "SerializableG2Affine",
+        into = "SerializableG2Affine"
     )]
     #[repr(transparent)]
     pub struct G2 {
@@ -513,13 +531,20 @@ mod g2 {
 }
 
 mod gt {
+    use crate::backward_compatibility::SerializableFp12Versions;
     use crate::serialization::InvalidSerializedFpError;
 
     use super::*;
     use ark_ec::pairing::Pairing;
+    use tfhe_versionable::Versionize;
 
-    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
+    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Versionize, Hash)]
     #[serde(try_from = "SerializableFp12", into = "SerializableFp12")]
+    #[versionize(
+        SerializableFp12Versions,
+        try_from = "SerializableFp12",
+        into = "SerializableFp12"
+    )]
     #[repr(transparent)]
     pub struct Gt {
         inner: ark_ec::pairing::PairingOutput<ark_bls12_381::Bls12_381>,
@@ -664,10 +689,12 @@ mod gt {
 }
 
 mod zp {
+    use crate::backward_compatibility::SerializableFpVersions;
     use crate::serialization::InvalidSerializedFpError;
 
     use super::*;
     use ark_ff::Fp;
+    use tfhe_versionable::Versionize;
     use zeroize::Zeroize;
 
     fn redc(n: [u64; 4], nprime: u64, mut t: [u64; 6]) -> [u64; 4] {
@@ -704,8 +731,13 @@ mod zp {
         t
     }
 
-    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Hash, Zeroize)]
+    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Versionize, Hash, Zeroize)]
     #[serde(try_from = "SerializableFp", into = "SerializableFp")]
+    #[versionize(
+        SerializableFpVersions,
+        try_from = "SerializableFp",
+        into = "SerializableFp"
+    )]
     #[repr(transparent)]
     pub struct Zp {
         pub(crate) inner: ark_bls12_381::Fr,

tfhe-zk-pok/src/curve_api/bls12_446.rs

@@ -34,6 +34,9 @@ fn bigint_to_le_bytes(x: [u64; 7]) -> [u8; 7 * 8] {
 }
 
 mod g1 {
+    use tfhe_versionable::Versionize;
+
+    use crate::backward_compatibility::SerializableG1AffineVersions;
     use crate::serialization::{InvalidSerializedAffineError, SerializableG1Affine};
 
     use super::*;
@@ -49,10 +52,13 @@ mod g1 {
         Hash,
         CanonicalDeserialize,
         CanonicalSerialize,
+        Versionize,
     )]
-    #[serde(
-        try_from = "SerializableAffine<SerializableFp>",
-        into = "SerializableAffine<SerializableFp>"
+    #[serde(try_from = "SerializableG1Affine", into = "SerializableG1Affine")]
+    #[versionize(
+        SerializableG1AffineVersions,
+        try_from = "SerializableG1Affine",
+        into = "SerializableG1Affine"
     )]
     #[repr(transparent)]
     pub struct G1Affine {
@@ -101,10 +107,13 @@ mod g1 {
         Hash,
         CanonicalSerialize,
         CanonicalDeserialize,
+        Versionize,
     )]
-    #[serde(
-        try_from = "SerializableAffine<SerializableFp>",
-        into = "SerializableAffine<SerializableFp>"
+    #[serde(try_from = "SerializableG1Affine", into = "SerializableG1Affine")]
+    #[versionize(
+        SerializableG1AffineVersions,
+        try_from = "SerializableG1Affine",
+        into = "SerializableG1Affine"
     )]
     #[repr(transparent)]
     pub struct G1 {
@@ -251,6 +260,10 @@ mod g1 {
 }
 
 mod g2 {
+    use tfhe_versionable::Versionize;
+
+    use crate::backward_compatibility::SerializableG2AffineVersions;
+
     use super::*;
     use crate::serialization::{InvalidSerializedAffineError, SerializableG2Affine};
 
@@ -265,10 +278,13 @@ mod g2 {
         Hash,
         CanonicalSerialize,
         CanonicalDeserialize,
+        Versionize,
     )]
-    #[serde(
-        try_from = "SerializableAffine<SerializableFp2>",
-        into = "SerializableAffine<SerializableFp2>"
+    #[serde(try_from = "SerializableG2Affine", into = "SerializableG2Affine")]
+    #[versionize(
+        SerializableG2AffineVersions,
+        try_from = "SerializableG2Affine",
+        into = "SerializableG2Affine"
     )]
     #[repr(transparent)]
     pub struct G2Affine {
@@ -407,10 +423,13 @@ mod g2 {
         Hash,
         CanonicalSerialize,
         CanonicalDeserialize,
+        Versionize,
     )]
-    #[serde(
-        try_from = "SerializableAffine<SerializableFp2>",
-        into = "SerializableAffine<SerializableFp2>"
+    #[serde(try_from = "SerializableG2Affine", into = "SerializableG2Affine")]
+    #[versionize(
+        SerializableG2AffineVersions,
+        try_from = "SerializableG2Affine",
+        into = "SerializableG2Affine"
     )]
     #[repr(transparent)]
     pub struct G2 {
@@ -603,12 +622,14 @@ mod g2 {
 }
 
 mod gt {
+    use crate::backward_compatibility::SerializableFp12Versions;
     use crate::curve_446::{Fq, Fq12, Fq2};
     use crate::serialization::InvalidSerializedAffineError;
 
     use super::*;
     use ark_ec::pairing::{MillerLoopOutput, Pairing};
     use ark_ff::{CubicExtField, QuadExtField};
+    use tfhe_versionable::Versionize;
 
     type Bls = crate::curve_446::Bls12_446;
 
@@ -778,8 +799,13 @@ mod gt {
         }
     }
 
-    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
+    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Versionize, Hash)]
     #[serde(try_from = "SerializableFp12", into = "SerializableFp12")]
+    #[versionize(
+        SerializableFp12Versions,
+        try_from = "SerializableFp12",
+        into = "SerializableFp12"
+    )]
     #[repr(transparent)]
     pub struct Gt {
         pub(crate) inner: ark_ec::pairing::PairingOutput<crate::curve_446::Bls12_446>,
@@ -922,9 +948,12 @@ mod gt {
 }
 
 mod zp {
+    use crate::backward_compatibility::SerializableFpVersions;
+
     use super::*;
     use crate::serialization::InvalidSerializedFpError;
     use ark_ff::Fp;
+    use tfhe_versionable::Versionize;
     use zeroize::Zeroize;
 
     fn redc(n: [u64; 5], nprime: u64, mut t: [u64; 7]) -> [u64; 5] {
@@ -961,8 +990,13 @@ mod zp {
         t
     }
 
-    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Hash, Zeroize)]
+    #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Versionize, Hash, Zeroize)]
     #[serde(try_from = "SerializableFp", into = "SerializableFp")]
+    #[versionize(
+        SerializableFpVersions,
+        try_from = "SerializableFp",
+        into = "SerializableFp"
+    )]
     #[repr(transparent)]
     pub struct Zp {
         pub inner: crate::curve_446::Fr,

tfhe-zk-pok/src/lib.rs

@@ -5,4 +5,5 @@ pub mod curve_api;
 pub mod proofs;
 pub mod serialization;
 
+pub mod backward_compatibility;
 mod four_squares;

tfhe-zk-pok/src/proofs/pke_v2.rs

@@ -2,9 +2,11 @@
 #![allow(non_snake_case)]
 
 use super::*;
+use crate::backward_compatibility::ProofVersions;
 use crate::four_squares::*;
 use core::marker::PhantomData;
 use rayon::prelude::*;
+use tfhe_versionable::{Unversionize, Versionize};
 
 fn bit_iter(x: u64, nbits: u32) -> impl Iterator<Item = bool> {
     (0..nbits).map(move |idx| ((x >> idx) & 1) != 0)
@@ -88,11 +90,15 @@ impl<G: Curve> PublicParams<G> {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Versionize)]
 #[serde(bound(
     deserialize = "G: Curve, G::G1: serde::Deserialize<'de>, G::G2: serde::Deserialize<'de>",
     serialize = "G: Curve, G::G1: serde::Serialize, G::G2: serde::Serialize"
 ))]
+#[versionize(
+    ProofVersions,
+    bound = "G::G1: Versionize + Unversionize, G::G2: Versionize + Unversionize"
+)]
 pub struct Proof<G: Curve> {
     C_hat_e: G::G2,
     C_e: G::G1,