diff --git a/tfhe-zk-pok/Cargo.toml b/tfhe-zk-pok/Cargo.toml
index dd53f6c260..c816f08b97 100644
--- a/tfhe-zk-pok/Cargo.toml
+++ b/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"
diff --git a/tfhe-zk-pok/src/backward_compatibility/mod.rs b/tfhe-zk-pok/src/backward_compatibility/mod.rs
new file mode 100644
index 0000000000..f9ffd2bdc7
--- /dev/null
+++ b/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>),
+}
diff --git a/tfhe-zk-pok/src/curve_api.rs b/tfhe-zk-pok/src/curve_api.rs
index ca83cd887d..13ab8f9a99 100644
--- a/tfhe-zk-pok/src/curve_api.rs
+++ b/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 {
diff --git a/tfhe-zk-pok/src/curve_api/bls12_381.rs b/tfhe-zk-pok/src/curve_api/bls12_381.rs
index bb14fe9de9..a28465e2e7 100644
--- a/tfhe-zk-pok/src/curve_api/bls12_381.rs
+++ b/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,
diff --git a/tfhe-zk-pok/src/curve_api/bls12_446.rs b/tfhe-zk-pok/src/curve_api/bls12_446.rs
index 7119c4c252..e4ed7850a7 100644
--- a/tfhe-zk-pok/src/curve_api/bls12_446.rs
+++ b/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,
diff --git a/tfhe-zk-pok/src/lib.rs b/tfhe-zk-pok/src/lib.rs
index 87a41c80e0..5d4d44f430 100644
--- a/tfhe-zk-pok/src/lib.rs
+++ b/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;
diff --git a/tfhe-zk-pok/src/proofs/pke_v2.rs b/tfhe-zk-pok/src/proofs/pke_v2.rs
index 0c079e3caf..a7347dccd1 100644
--- a/tfhe-zk-pok/src/proofs/pke_v2.rs
+++ b/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,
diff --git a/tfhe-zk-pok/src/serialization.rs b/tfhe-zk-pok/src/serialization.rs
index 54f612bff4..60a05f8219 100644
--- a/tfhe-zk-pok/src/serialization.rs
+++ b/tfhe-zk-pok/src/serialization.rs
@@ -6,28 +6,17 @@ use ark_ec::short_weierstrass::{Affine, SWCurveConfig};
 use ark_ec::AffineRepr;
 use ark_ff::{BigInt, Field, Fp, Fp2, Fp6, Fp6Config, FpConfig, QuadExtConfig, QuadExtField};
 use serde::{Deserialize, Serialize};
+use tfhe_versionable::Versionize;
 
-#[derive(Debug)]
-pub struct InvalidSerializedFpError {
-    expected_len: usize,
-    found_len: usize,
-}
-
-impl Display for InvalidSerializedFpError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Invalid serialized FP: found array of size {}, expected {}",
-            self.found_len, self.expected_len
-        )
-    }
-}
-
-impl Error for InvalidSerializedFpError {}
+use crate::backward_compatibility::{
+    SerializableAffineVersions, SerializableCubicExtFieldVersions, SerializableFpVersions,
+    SerializableQuadExtFieldVersions,
+};
 
 /// Serialization equivalent of the [`Fp`] struct, where the bigint is split into
 /// multiple u64.
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Versionize)]
+#[versionize(SerializableFpVersions)]
 pub struct SerializableFp {
     val: Vec<u64>, // Use a Vec<u64> since serde does not support fixed size arrays
 }
@@ -55,6 +44,24 @@ impl<P: FpConfig<N>, const N: usize> TryFrom<SerializableFp> for Fp<P, N> {
     }
 }
 
+#[derive(Debug)]
+pub struct InvalidSerializedFpError {
+    expected_len: usize,
+    found_len: usize,
+}
+
+impl Display for InvalidSerializedFpError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Invalid serialized FP: found array of size {}, expected {}",
+            self.found_len, self.expected_len
+        )
+    }
+}
+
+impl Error for InvalidSerializedFpError {}
+
 #[derive(Debug)]
 pub enum InvalidSerializedAffineError {
     InvalidFp(InvalidSerializedFpError),
@@ -94,8 +101,9 @@ impl From<InvalidSerializedFpError> for InvalidSerializedAffineError {
 
 /// Serialization equivalent to the [`Affine`], which support an optional compression mode
 /// where only the `x` coordinate is stored, and the `y` is computed on load.
-#[derive(Serialize, Deserialize)]
-pub(crate) enum SerializableAffine<F> {
+#[derive(Serialize, Deserialize, Versionize)]
+#[versionize(SerializableAffineVersions)]
+pub enum SerializableAffine<F> {
     Infinity,
     Compressed { x: F, take_largest_y: bool },
     Uncompressed { x: F, y: F },
@@ -151,36 +159,17 @@ where
     }
 }
 
-/// Serialization equivalent of the [`Fp`] struct, where the bigint is split into
-/// multiple u64.
-#[derive(Serialize, Deserialize)]
-pub(crate) struct SerializableFp {
-    val: Vec<u64>, // Use a Vec<u64> since serde does not support fixed size arrays
-}
-
-impl<P: FpConfig<N>, const N: usize> From<Fp<P, N>> for SerializableFp {
-    fn from(value: Fp<P, N>) -> Self {
-        Self {
-            val: value.0 .0.to_vec(),
-        }
-    }
-}
-
-impl<P: FpConfig<N>, const N: usize> TryFrom<SerializableFp> for Fp<P, N> {
-    type Error = Vec<u64>; // TODO
-
-    fn try_from(value: SerializableFp) -> Result<Self, Self::Error> {
-        Ok(Fp(BigInt(value.val.try_into()?), PhantomData))
-    }
-}
+pub(crate) type SerializableG1Affine = SerializableAffine<SerializableFp>;
 
-#[derive(Serialize, Deserialize)]
-pub(crate) struct SerializableQuadExtField<F> {
+#[derive(Serialize, Deserialize, Versionize)]
+#[versionize(SerializableQuadExtFieldVersions)]
+pub struct SerializableQuadExtField<F> {
     c0: F,
     c1: F,
 }
 
 pub(crate) type SerializableFp2 = SerializableQuadExtField<SerializableFp>;
+pub type SerializableG2Affine = SerializableAffine<SerializableFp2>;
 
 impl<F, P: QuadExtConfig> From<QuadExtField<P>> for SerializableQuadExtField<F>
 where
@@ -208,14 +197,15 @@ where
     }
 }
 
-#[derive(Serialize, Deserialize)]
-pub(crate) struct SerializableCubicExtField<F> {
+#[derive(Serialize, Deserialize, Versionize)]
+#[versionize(SerializableCubicExtFieldVersions)]
+pub struct SerializableCubicExtField<F> {
     c0: F,
     c1: F,
     c2: F,
 }
 
-type SerializableFp6 = SerializableCubicExtField<SerializableFp2>;
+pub(crate) type SerializableFp6 = SerializableCubicExtField<SerializableFp2>;
 
 impl<F, P6: Fp6Config> From<Fp6<P6>> for SerializableCubicExtField<F>
 where
diff --git a/tfhe/src/high_level_api/backward_compatibility/compact_list.rs b/tfhe/src/high_level_api/backward_compatibility/compact_list.rs
index b6f3bdf4f4..cc38b5a16a 100644
--- a/tfhe/src/high_level_api/backward_compatibility/compact_list.rs
+++ b/tfhe/src/high_level_api/backward_compatibility/compact_list.rs
@@ -17,8 +17,17 @@ impl Upgrade<CompactCiphertextList> for CompactCiphertextListV0 {
     }
 }
 
+#[cfg(feature = "zk-pok")]
+use crate::ProvenCompactCiphertextList;
+
 #[derive(VersionsDispatch)]
 pub enum CompactCiphertextListVersions {
     V0(CompactCiphertextListV0),
     V1(CompactCiphertextList),
 }
+
+#[cfg(feature = "zk-pok")]
+#[derive(VersionsDispatch)]
+pub enum ProvenCompactCiphertextListVersions {
+    V0(ProvenCompactCiphertextList),
+}
diff --git a/tfhe/src/high_level_api/compact_list.rs b/tfhe/src/high_level_api/compact_list.rs
index b6bb37a72e..cde071dcd2 100644
--- a/tfhe/src/high_level_api/compact_list.rs
+++ b/tfhe/src/high_level_api/compact_list.rs
@@ -1,6 +1,8 @@
 use tfhe_versionable::Versionize;
 
 use crate::backward_compatibility::compact_list::CompactCiphertextListVersions;
+#[cfg(feature = "zk-pok")]
+use crate::backward_compatibility::compact_list::ProvenCompactCiphertextListVersions;
 use crate::conformance::ParameterSetConformant;
 use crate::core_crypto::commons::math::random::{Deserialize, Serialize};
 use crate::core_crypto::prelude::Numeric;
@@ -191,7 +193,8 @@ impl ParameterSetConformant for CompactCiphertextList {
 mod zk {
     use super::*;
 
-    #[derive(Clone, Serialize, Deserialize)]
+    #[derive(Clone, Serialize, Deserialize, Versionize)]
+    #[versionize(ProvenCompactCiphertextListVersions)]
     pub struct ProvenCompactCiphertextList {
         pub(crate) inner: crate::integer::ciphertext::ProvenCompactCiphertextList,
         pub(crate) tag: Tag,
diff --git a/tfhe/src/integer/backward_compatibility/ciphertext/mod.rs b/tfhe/src/integer/backward_compatibility/ciphertext/mod.rs
index f268099091..1a2459e83a 100644
--- a/tfhe/src/integer/backward_compatibility/ciphertext/mod.rs
+++ b/tfhe/src/integer/backward_compatibility/ciphertext/mod.rs
@@ -9,6 +9,8 @@ use crate::integer::ciphertext::{
     CompressedModulusSwitchedSignedRadixCiphertext, DataKind,
 };
 use crate::integer::BooleanBlock;
+#[cfg(feature = "zk-pok")]
+use crate::integer::ProvenCompactCiphertextList;
 use crate::shortint::ciphertext::CompressedModulusSwitchedCiphertext;
 
 #[derive(VersionsDispatch)]
@@ -53,6 +55,12 @@ pub enum CompactCiphertextListVersions {
     V1(CompactCiphertextList),
 }
 
+#[cfg(feature = "zk-pok")]
+#[derive(VersionsDispatch)]
+pub enum ProvenCompactCiphertextListVersions {
+    V0(ProvenCompactCiphertextList),
+}
+
 #[derive(VersionsDispatch)]
 pub enum DataKindVersions {
     V0(DataKind),
diff --git a/tfhe/src/integer/ciphertext/compact_list.rs b/tfhe/src/integer/ciphertext/compact_list.rs
index 7c153338ac..ffa1364a91 100644
--- a/tfhe/src/integer/ciphertext/compact_list.rs
+++ b/tfhe/src/integer/ciphertext/compact_list.rs
@@ -2,6 +2,8 @@ use super::{DataKind, Expandable};
 use crate::conformance::{ListSizeConstraint, ParameterSetConformant};
 use crate::core_crypto::prelude::Numeric;
 use crate::integer::backward_compatibility::ciphertext::CompactCiphertextListVersions;
+#[cfg(feature = "zk-pok")]
+use crate::integer::backward_compatibility::ciphertext::ProvenCompactCiphertextListVersions;
 use crate::integer::block_decomposition::DecomposableInto;
 use crate::integer::encryption::{create_clear_radix_block_iterator, KnowsMessageModulus};
 use crate::integer::parameters::CompactCiphertextListConformanceParams;
@@ -550,7 +552,8 @@ impl CompactCiphertextList {
 }
 
 #[cfg(feature = "zk-pok")]
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize, Versionize)]
+#[versionize(ProvenCompactCiphertextListVersions)]
 pub struct ProvenCompactCiphertextList {
     pub(crate) ct_list: crate::shortint::ciphertext::ProvenCompactCiphertextList,
     // Integers stored can have a heterogeneous number of blocks and signedness
diff --git a/tfhe/src/shortint/backward_compatibility/ciphertext/mod.rs b/tfhe/src/shortint/backward_compatibility/ciphertext/mod.rs
index 947e33cfb4..93d416c760 100644
--- a/tfhe/src/shortint/backward_compatibility/ciphertext/mod.rs
+++ b/tfhe/src/shortint/backward_compatibility/ciphertext/mod.rs
@@ -64,6 +64,12 @@ pub enum CompactCiphertextListVersions {
     V1(CompactCiphertextList),
 }
 
+#[cfg(feature = "zk-pok")]
+#[derive(VersionsDispatch)]
+pub enum ProvenCompactCiphertextListVersions {
+    V0(ProvenCompactCiphertextList),
+}
+
 #[derive(VersionsDispatch)]
 pub enum CompressedCiphertextVersions {
     V0(CompressedCiphertext),
diff --git a/tfhe/src/shortint/ciphertext/zk.rs b/tfhe/src/shortint/ciphertext/zk.rs
index 9227cbce86..efd4f77a2b 100644
--- a/tfhe/src/shortint/ciphertext/zk.rs
+++ b/tfhe/src/shortint/ciphertext/zk.rs
@@ -1,4 +1,5 @@
 use crate::core_crypto::algorithms::verify_lwe_compact_ciphertext_list;
+use crate::shortint::backward_compatibility::ciphertext::ProvenCompactCiphertextListVersions;
 use crate::shortint::ciphertext::CompactCiphertextList;
 use crate::shortint::parameters::{
     CompactPublicKeyEncryptionParameters, ShortintCompactCiphertextListCastingMode,
@@ -7,6 +8,7 @@ use crate::shortint::{Ciphertext, CompactPublicKey, MessageModulus};
 use crate::zk::{CompactPkeCrs, CompactPkeProof, CompactPkePublicParams, ZkVerificationOutCome};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
+use tfhe_versionable::Versionize;
 
 impl CompactPkeCrs {
     /// Construct the CRS that corresponds to the given parameters
@@ -43,7 +45,8 @@ impl CompactPkeCrs {
 /// A List of CompactCiphertext with their zero-knowledge proofs
 ///
 /// The proofs can only be generated during the encryption with a [CompactPublicKey]
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize, Versionize)]
+#[versionize(ProvenCompactCiphertextListVersions)]
 pub struct ProvenCompactCiphertextList {
     pub(crate) proved_lists: Vec<(CompactCiphertextList, CompactPkeProof)>,
 }
diff --git a/tfhe/src/zk.rs b/tfhe/src/zk.rs
index 1c0f30e92f..3aa28b0ad3 100644
--- a/tfhe/src/zk.rs
+++ b/tfhe/src/zk.rs
@@ -9,8 +9,8 @@ use tfhe_zk_pok::proofs::pke_v2::crs_gen;
 pub use tfhe_zk_pok::proofs::ComputeLoad as ZkComputeLoad;
 pub use tfhe_zk_pok::{CanonicalDeserialize, CanonicalSerialize, Compress, Validate};
 type Curve = tfhe_zk_pok::curve_api::Bls12_446;
-pub type CompactPkeProof = tfhe_zk_pok::proofs::pke::Proof<Curve>;
-pub type CompactPkePublicParams = tfhe_zk_pok::proofs::pke::PublicParams<Curve>;
+pub type CompactPkeProof = tfhe_zk_pok::proofs::pke_v2::Proof<Curve>;
+pub type CompactPkePublicParams = tfhe_zk_pok::proofs::pke_v2::PublicParams<Curve>;
 
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub enum ZkVerificationOutCome {