rm .instances() since it's not needed

examples/circom_full_flow.rs

@@ -89,7 +89,8 @@ fn main() {
     let mut nova = N::init(&nova_params, f_circuit.clone(), z_0).unwrap();
 
     // prepare the Decider prover & verifier params
-    let (decider_pp, decider_vp) = D::preprocess(&mut rng, nova_params, nova.clone()).unwrap();
+    let (decider_pp, decider_vp) =
+        D::preprocess(&mut rng, nova_params.clone(), nova.clone()).unwrap();
 
     // run n steps of the folding iteration
     for (i, external_inputs_at_step) in external_inputs.iter().enumerate() {

examples/external_inputs.rs

@@ -207,10 +207,8 @@ fn main() {
         folding_scheme.state()
     );
 
-    let (running_instance, incoming_instance, cyclefold_instance) = folding_scheme.instances();
-
     println!("Run the Nova's IVC verifier");
-    let ivc_proof = nova.ivc_proof();
+    let ivc_proof = folding_scheme.ivc_proof();
     N::verify(
         nova_params.1, // Nova's verifier params
         ivc_proof,

examples/multi_inputs.rs

@@ -154,10 +154,8 @@ fn main() {
         println!("Nova::prove_step {}: {:?}", i, start.elapsed());
     }
 
-    let (running_instance, incoming_instance, cyclefold_instance) = folding_scheme.instances();
-
     println!("Run the Nova's IVC verifier");
-    let ivc_proof = nova.ivc_proof();
+    let ivc_proof = folding_scheme.ivc_proof();
     N::verify(
         nova_params.1, // Nova's verifier params
         ivc_proof,

examples/noir_full_flow.rs

@@ -79,7 +79,8 @@ fn main() {
     let mut nova = N::init(&nova_params, f_circuit.clone(), z_0).unwrap();
 
     // prepare the Decider prover & verifier params
-    let (decider_pp, decider_vp) = D::preprocess(&mut rng, nova_params, nova.clone()).unwrap();
+    let (decider_pp, decider_vp) =
+        D::preprocess(&mut rng, nova_params.clone(), nova.clone()).unwrap();
 
     // run n steps of the folding iteration
     for i in 0..5 {

examples/noname_full_flow.rs

@@ -89,7 +89,8 @@ fn main() {
     let mut nova = N::init(&nova_params, f_circuit.clone(), z_0).unwrap();
 
     // prepare the Decider prover & verifier params
-    let (decider_pp, decider_vp) = D::preprocess(&mut rng, nova_params, nova.clone()).unwrap();
+    let (decider_pp, decider_vp) =
+        D::preprocess(&mut rng, nova_params.clone(), nova.clone()).unwrap();
 
     // run n steps of the folding iteration
     for (i, external_inputs_at_step) in external_inputs.iter().enumerate() {

examples/sha256.rs

@@ -138,10 +138,8 @@ fn main() {
         println!("Nova::prove_step {}: {:?}", i, start.elapsed());
     }
 
-    let (running_instance, incoming_instance, cyclefold_instance) = folding_scheme.instances();
-
     println!("Run the Nova's IVC verifier");
-    let ivc_proof = nova.ivc_proof();
+    let ivc_proof = folding_scheme.ivc_proof();
     N::verify(
         nova_params.1, // Nova's verifier params
         ivc_proof,

folding-schemes/src/folding/hypernova/mod.rs

@@ -991,20 +991,6 @@ where
         self.z_i.clone()
     }
 
-    fn instances(
-        &self,
-    ) -> (
-        Self::RunningInstance,
-        Self::IncomingInstance,
-        Self::CFInstance,
-    ) {
-        (
-            (self.U_i.clone(), self.W_i.clone()),
-            (self.u_i.clone(), self.w_i.clone()),
-            (self.cf_U_i.clone(), self.cf_W_i.clone()),
-        )
-    }
-
     fn ivc_proof(&self) -> Self::IVCProof {
         Self::IVCProof {
             i: self.i,
@@ -1168,18 +1154,6 @@ mod tests {
     >(
         poseidon_config: PoseidonConfig<Fr>,
         F_circuit: CubicFCircuit<Fr>,
-    ) -> (
-        HyperNova<Projective, GVar, Projective2, GVar2, CubicFCircuit<Fr>, CS1, CS2, 2, 3, H>,
-        (
-            ProverParams<Projective, Projective2, CS1, CS2, H>,
-            VerifierParams<Projective, Projective2, CS1, CS2, H>,
-        ),
-        (LCCCS<Projective>, Witness<Fr>),
-        (CCCS<Projective>, Witness<Fr>),
-        (
-            CycleFoldCommittedInstance<Projective2>,
-            CycleFoldWitness<Projective2>,
-        ),
     ) {
         let mut rng = ark_std::test_rng();
 
@@ -1239,14 +1213,5 @@ mod tests {
             ivc_proof,
         )
         .unwrap();
-
-        let (running_instance, incoming_instance, cyclefold_instance) = hypernova.instances();
-        (
-            hypernova,
-            hypernova_params,
-            running_instance,
-            incoming_instance,
-            cyclefold_instance,
-        )
     }
 }

folding-schemes/src/folding/mod.rs

@@ -25,8 +25,10 @@ pub mod tests {
     use crate::Error;
     use crate::FoldingScheme;
 
+    /// tests the IVC proofs and its serializers for the 3 implemented IVCs: Nova, HyperNova and
+    /// ProtoGalaxy.
     #[test]
-    fn test_serialize_ivc() {
+    fn test_serialize_ivc_nova_hypernova_protogalaxy() {
         let poseidon_config = poseidon_canonical_config::<Fr>();
         type FC = CubicFCircuit<Fr>;
         let f_circuit = FC::new(()).unwrap();

folding-schemes/src/folding/nova/mod.rs

@@ -344,15 +344,6 @@ where
     CS2: CommitmentScheme<C2, H>,
 {
     fn check(&self) -> Result<(), ark_serialize::SerializationError> {
-        self.poseidon_config.full_rounds.check()?;
-        self.poseidon_config.partial_rounds.check()?;
-        self.poseidon_config.alpha.check()?;
-        self.poseidon_config.ark.check()?;
-        self.poseidon_config.mds.check()?;
-        self.poseidon_config.rate.check()?;
-        self.poseidon_config.capacity.check()?;
-        self.r1cs.check()?;
-        self.cf_r1cs.check()?;
         self.cs_vp.check()?;
         self.cf_cs_vp.check()?;
         Ok(())
@@ -370,7 +361,6 @@ where
         mut writer: W,
         compress: ark_serialize::Compress,
     ) -> Result<(), ark_serialize::SerializationError> {
-        self.cs_vp.serialize_with_mode(&mut writer, compress)?;
         self.cs_vp.serialize_with_mode(&mut writer, compress)?;
         self.cf_cs_vp.serialize_with_mode(&mut writer, compress)
     }
@@ -411,13 +401,13 @@ where
         // to serialize them, saving significant space in the VerifierParams serialized size.
 
         // main circuit R1CS:
-        let f_circuit = FC::new(fcircuit_params).or(Err(SerializationError::InvalidData))?;
+        let f_circuit = FC::new(fcircuit_params).map_err(|_| SerializationError::InvalidData)?;
         let cs = ConstraintSystem::<C1::ScalarField>::new_ref();
         let augmented_F_circuit =
             AugmentedFCircuit::<C1, C2, GC2, FC>::empty(&poseidon_config, f_circuit.clone());
         augmented_F_circuit
             .generate_constraints(cs.clone())
-            .or(Err(SerializationError::InvalidData))?;
+            .map_err(|_| SerializationError::InvalidData)?;
         cs.finalize();
         let cs = cs.into_inner().ok_or(SerializationError::InvalidData)?;
         let r1cs = extract_r1cs::<C1::ScalarField>(&cs);
@@ -427,7 +417,7 @@ where
         let cf_circuit = NovaCycleFoldCircuit::<C1, GC1>::empty();
         cf_circuit
             .generate_constraints(cs2.clone())
-            .or(Err(SerializationError::InvalidData))?;
+            .map_err(|_| SerializationError::InvalidData)?;
         cs2.finalize();
         let cs2 = cs2.into_inner().ok_or(SerializationError::InvalidData)?;
         let cf_r1cs = extract_r1cs::<C1::BaseField>(&cs2);
@@ -933,20 +923,6 @@ where
         self.z_i.clone()
     }
 
-    fn instances(
-        &self,
-    ) -> (
-        Self::RunningInstance,
-        Self::IncomingInstance,
-        Self::CFInstance,
-    ) {
-        (
-            (self.U_i.clone(), self.W_i.clone()),
-            (self.u_i.clone(), self.w_i.clone()),
-            (self.cf_U_i.clone(), self.cf_W_i.clone()),
-        )
-    }
-
     fn ivc_proof(&self) -> Self::IVCProof {
         Self::IVCProof {
             i: self.i,

folding-schemes/src/folding/protogalaxy/mod.rs

@@ -917,19 +917,6 @@ where
     fn state(&self) -> Vec<C1::ScalarField> {
         self.z_i.clone()
     }
-    fn instances(
-        &self,
-    ) -> (
-        Self::RunningInstance,
-        Self::IncomingInstance,
-        Self::CFInstance,
-    ) {
-        (
-            (self.U_i.clone(), self.W_i.clone()),
-            (self.u_i.clone(), self.w_i.clone()),
-            (self.cf_U_i.clone(), self.cf_W_i.clone()),
-        )
-    }
 
     fn ivc_proof(&self) -> Self::IVCProof {
         Self::IVCProof {

folding-schemes/src/lib.rs

@@ -154,16 +154,6 @@ where
     /// returns the state at the current step
     fn state(&self) -> Vec<C1::ScalarField>;
 
-    /// returns the instances at the current step, in the following order:
-    /// (running_instance, incoming_instance, cyclefold_instance)
-    fn instances(
-        &self,
-    ) -> (
-        Self::RunningInstance,
-        Self::IncomingInstance,
-        Self::CFInstance,
-    );
-
     /// returns the last IVC state proof, which can be verified in the `verify` method
     fn ivc_proof(&self) -> Self::IVCProof;