1use ark_crypto_primitives::sponge::{poseidon::PoseidonConfig, Absorb};
  2use ark_ec::{CurveGroup, Group};
  3use ark_ff::PrimeField;
  4use ark_r1cs_std::{
  5    groups::{CurveVar, GroupOpsBounds},
  6    ToConstraintFieldGadget,
  7};
  8use ark_relations::r1cs::ConstraintSynthesizer;
  9use ark_relations::r1cs::ConstraintSystem;
 10use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, SerializationError, Write};
 11use std::marker::PhantomData;
 12
 13use super::{circuits::AugmentedFCircuit, Nova, ProverParams};
 14use super::{CommittedInstance, Witness};
 15use crate::folding::{
 16    circuits::{cyclefold::CycleFoldCircuit, CF2},
 17    nova::NOVA_CF_N_POINTS,
 18};
 19use crate::{
 20    arith::r1cs::extract_r1cs, commitment::CommitmentScheme, folding::circuits::CF1,
 21    frontend::FCircuit,
 22};
 23
 24impl<C1, GC1, C2, GC2, FC, CS1, CS2> CanonicalSerialize for Nova<C1, GC1, C2, GC2, FC, CS1, CS2>
 25where
 26    C1: CurveGroup,
 27    C2: CurveGroup,
 28    FC: FCircuit<C1::ScalarField>,
 29    CS1: CommitmentScheme<C1>,
 30    CS2: CommitmentScheme<C2>,
 31    <C1 as CurveGroup>::BaseField: PrimeField,
 32    <C2 as CurveGroup>::BaseField: PrimeField,
 33    <C1 as Group>::ScalarField: Absorb,
 34    <C2 as Group>::ScalarField: Absorb,
 35    C1: CurveGroup<BaseField = C2::ScalarField, ScalarField = C2::BaseField>,
 36    for<'a> &'a GC1: GroupOpsBounds<'a, C1, GC1>,
 37    for<'a> &'a GC2: GroupOpsBounds<'a, C2, GC2>,
 38    GC1: CurveVar<C1, <C2 as Group>::ScalarField>,
 39    GC1: ToConstraintFieldGadget<<C2 as Group>::ScalarField>,
 40    GC2: CurveVar<C2, <C2 as CurveGroup>::BaseField>,
 41{
 42    fn serialize_with_mode<W: Write>(
 43        &self,
 44        mut writer: W,
 45        compress: ark_serialize::Compress,
 46    ) -> Result<(), ark_serialize::SerializationError> {
 47        self.pp_hash.serialize_with_mode(&mut writer, compress)?;
 48        self.i.serialize_with_mode(&mut writer, compress)?;
 49        self.z_0.serialize_with_mode(&mut writer, compress)?;
 50        self.z_i.serialize_with_mode(&mut writer, compress)?;
 51        self.w_i.serialize_with_mode(&mut writer, compress)?;
 52        self.u_i.serialize_with_mode(&mut writer, compress)?;
 53        self.W_i.serialize_with_mode(&mut writer, compress)?;
 54        self.U_i.serialize_with_mode(&mut writer, compress)?;
 55        self.cf_W_i.serialize_with_mode(&mut writer, compress)?;
 56        self.cf_U_i.serialize_with_mode(&mut writer, compress)
 57    }
 58
 59    fn serialized_size(&self, compress: ark_serialize::Compress) -> usize {
 60        self.pp_hash.serialized_size(compress)
 61            + self.i.serialized_size(compress)
 62            + self.z_0.serialized_size(compress)
 63            + self.z_i.serialized_size(compress)
 64            + self.w_i.serialized_size(compress)
 65            + self.u_i.serialized_size(compress)
 66            + self.W_i.serialized_size(compress)
 67            + self.U_i.serialized_size(compress)
 68            + self.cf_W_i.serialized_size(compress)
 69            + self.cf_U_i.serialized_size(compress)
 70    }
 71
 72    fn serialize_compressed<W: Write>(
 73        &self,
 74        writer: W,
 75    ) -> Result<(), ark_serialize::SerializationError> {
 76        self.serialize_with_mode(writer, ark_serialize::Compress::Yes)
 77    }
 78
 79    fn compressed_size(&self) -> usize {
 80        self.serialized_size(ark_serialize::Compress::Yes)
 81    }
 82
 83    fn serialize_uncompressed<W: Write>(
 84        &self,
 85        writer: W,
 86    ) -> Result<(), ark_serialize::SerializationError> {
 87        self.serialize_with_mode(writer, ark_serialize::Compress::No)
 88    }
 89
 90    fn uncompressed_size(&self) -> usize {
 91        self.serialized_size(ark_serialize::Compress::No)
 92    }
 93}
 94
 95// Note that we can't derive or implement `CanonicalDeserialize` directly.
 96// This is because `CurveVar` notably does not implement the `Sync` trait.
 97impl<C1, GC1, C2, GC2, FC, CS1, CS2> Nova<C1, GC1, C2, GC2, FC, CS1, CS2>
 98where
 99    C1: CurveGroup,
100    C2: CurveGroup,
101    FC: FCircuit<CF1<C1>, Params = ()>,
102    CS1: CommitmentScheme<C1>,
103    CS2: CommitmentScheme<C2>,
104    <C1 as CurveGroup>::BaseField: PrimeField,
105    <C2 as CurveGroup>::BaseField: PrimeField,
106    <C1 as Group>::ScalarField: Absorb,
107    <C2 as Group>::ScalarField: Absorb,
108    C1: CurveGroup<BaseField = C2::ScalarField, ScalarField = C2::BaseField>,
109    for<'a> &'a GC1: GroupOpsBounds<'a, C1, GC1>,
110    for<'a> &'a GC2: GroupOpsBounds<'a, C2, GC2>,
111    GC1: CurveVar<C1, <C2 as Group>::ScalarField>,
112    GC1: ToConstraintFieldGadget<<C2 as Group>::ScalarField>,
113    GC2: CurveVar<C2, CF2<C2>>,
114    GC2: ToConstraintFieldGadget<<C2 as CurveGroup>::BaseField>,
115{
116    pub fn deserialize_nova<R: std::io::prelude::Read>(
117        mut reader: R,
118        compress: ark_serialize::Compress,
119        validate: ark_serialize::Validate,
120        prover_params: ProverParams<C1, C2, CS1, CS2>,
121        poseidon_config: PoseidonConfig<C1::ScalarField>,
122    ) -> Result<Self, ark_serialize::SerializationError> {
123        let pp_hash = C1::ScalarField::deserialize_with_mode(&mut reader, compress, validate)?;
124        let i = C1::ScalarField::deserialize_with_mode(&mut reader, compress, validate)?;
125        let z_0 = Vec::<C1::ScalarField>::deserialize_with_mode(&mut reader, compress, validate)?;
126        let z_i = Vec::<C1::ScalarField>::deserialize_with_mode(&mut reader, compress, validate)?;
127        let w_i = Witness::<C1>::deserialize_with_mode(&mut reader, compress, validate)?;
128        let u_i = CommittedInstance::<C1>::deserialize_with_mode(&mut reader, compress, validate)?;
129        let W_i = Witness::<C1>::deserialize_with_mode(&mut reader, compress, validate)?;
130        let U_i = CommittedInstance::<C1>::deserialize_with_mode(&mut reader, compress, validate)?;
131        let cf_W_i = Witness::<C2>::deserialize_with_mode(&mut reader, compress, validate)?;
132        let cf_U_i =
133            CommittedInstance::<C2>::deserialize_with_mode(&mut reader, compress, validate)?;
134
135        let f_circuit = FC::new(()).unwrap();
136        let cs = ConstraintSystem::<C1::ScalarField>::new_ref();
137        let cs2 = ConstraintSystem::<C1::BaseField>::new_ref();
138        let augmented_F_circuit =
139            AugmentedFCircuit::<C1, C2, GC2, FC>::empty(&poseidon_config, f_circuit.clone());
140        let cf_circuit = CycleFoldCircuit::<C1, GC1>::empty(NOVA_CF_N_POINTS);
141
142        augmented_F_circuit
143            .generate_constraints(cs.clone())
144            .map_err(|_| SerializationError::InvalidData)?;
145        cs.finalize();
146        let cs = cs.into_inner().ok_or(SerializationError::InvalidData)?;
147        let r1cs = extract_r1cs::<C1::ScalarField>(&cs);
148
149        cf_circuit
150            .generate_constraints(cs2.clone())
151            .map_err(|_| SerializationError::InvalidData)?;
152        cs2.finalize();
153        let cs2 = cs2.into_inner().ok_or(SerializationError::InvalidData)?;
154        let cf_r1cs = extract_r1cs::<C1::BaseField>(&cs2);
155
156        Ok(Nova {
157            _gc1: PhantomData,
158            _c2: PhantomData,
159            _gc2: PhantomData,
160            r1cs,
161            cf_r1cs,
162            poseidon_config,
163            cs_pp: prover_params.cs_pp,
164            cf_cs_pp: prover_params.cf_cs_pp,
165            F: f_circuit,
166            pp_hash,
167            i,
168            z_0,
169            z_i,
170            w_i,
171            u_i,
172            W_i,
173            U_i,
174            cf_W_i,
175            cf_U_i,
176        })
177    }
178}
179
180#[cfg(test)]
181pub mod tests {
182    use ark_bn254::{constraints::GVar, Bn254, Fr, G1Projective as Projective};
183    use ark_grumpkin::{constraints::GVar as GVar2, Projective as Projective2};
184    use ark_serialize::{CanonicalSerialize, Compress, Validate};
185    use std::{fs, io::Write};
186
187    use crate::{
188        commitment::{kzg::KZG, pedersen::Pedersen},
189        folding::nova::{Nova, PreprocessorParam},
190        frontend::{tests::CubicFCircuit, FCircuit},
191        transcript::poseidon::poseidon_canonical_config,
192        FoldingScheme,
193    };
194
195    #[test]
196    fn test_serde_nova() {
197        let mut rng = ark_std::test_rng();
198        let poseidon_config = poseidon_canonical_config::<Fr>();
199        let F_circuit = CubicFCircuit::<Fr>::new(()).unwrap();
200
201        // Initialize nova and make multiple `prove_step()`
202        type N = Nova<
203            Projective,
204            GVar,
205            Projective2,
206            GVar2,
207            CubicFCircuit<Fr>,
208            KZG<'static, Bn254>,
209            Pedersen<Projective2>,
210        >;
211        let prep_param = PreprocessorParam::new(poseidon_config.clone(), F_circuit);
212        let nova_params = N::preprocess(&mut rng, &prep_param).unwrap();
213
214        let z_0 = vec![Fr::from(3_u32)];
215        let mut nova = N::init(&nova_params, F_circuit, z_0.clone()).unwrap();
216
217        let num_steps: usize = 3;
218        for _ in 0..num_steps {
219            nova.prove_step(&mut rng, vec![], None).unwrap();
220        }
221
222        let mut writer = vec![];
223        assert!(nova
224            .serialize_with_mode(&mut writer, ark_serialize::Compress::No)
225            .is_ok());
226
227        let mut file = fs::OpenOptions::new()
228            .create(true)
229            .write(true)
230            .open("./nova.serde")
231            .unwrap();
232
233        file.write_all(&writer).unwrap();
234
235        let bytes = fs::read("./nova.serde").unwrap();
236
237        let mut deserialized_nova = Nova::<
238            Projective,
239            GVar,
240            Projective2,
241            GVar2,
242            CubicFCircuit<Fr>,
243            KZG<Bn254>,
244            Pedersen<Projective2>,
245        >::deserialize_nova(
246            bytes.as_slice(),
247            Compress::No,
248            Validate::No,
249            nova_params.0, // Nova's prover params
250            poseidon_config,
251        )
252        .unwrap();
253
254        assert_eq!(nova.i, deserialized_nova.i);
255
256        let num_steps: usize = 3;
257        for _ in 0..num_steps {
258            deserialized_nova
259                .prove_step(&mut rng, vec![], None)
260                .unwrap();
261            nova.prove_step(&mut rng, vec![], None).unwrap();
262        }
263
264        assert_eq!(deserialized_nova.w_i, nova.w_i);
265    }
266}