Use the ZMPCS Evaluation Engine and the KZG Commitment Engine in tests.

Author: huitseeker

src/lib.rs

@@ -946,13 +946,10 @@ mod tests {
   use core::fmt::Write;
 
   use super::*;
-  #[allow(dead_code)]
-  type ZM<E> = provider::non_hiding_zeromorph::ZMEvaluation<E>;
+  type ZM<E> = provider::non_hiding_zeromorph::ZMPCS<E>;
   type EE<G> = provider::ipa_pc::EvaluationEngine<G>;
   type S<G, EE> = spartan::snark::RelaxedR1CSSNARK<G, EE>;
   type SPrime<G, EE> = spartan::ppsnark::RelaxedR1CSSNARK<G, EE>;
-  #[allow(dead_code)]
-  type SZM<G, E> = spartan::snark::RelaxedR1CSSNARK<G, ZM<E>>;
 
   use ::bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
   use core::marker::PhantomData;
@@ -1066,12 +1063,12 @@ mod tests {
     let trivial_circuit2_grumpkin = TrivialCircuit::<<grumpkin::Point as Group>::Scalar>::default();
     let cubic_circuit1_grumpkin = CubicCircuit::<<bn256::Point as Group>::Scalar>::default();
 
-    test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _, ZM<halo2curves::bn256::Bn256>, EE<_>>(
       &trivial_circuit1_grumpkin,
       &trivial_circuit2_grumpkin,
       "184d05f08dca260f010cb48c6cf8c5eb61dedfc270e5a18226eb622cf7da0203",
     );
-    test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _, ZM<halo2curves::bn256::Bn256>, EE<_>>(
       &cubic_circuit1_grumpkin,
       &trivial_circuit2_grumpkin,
       "2fb992932b2a642b4ce8f52646a7ef6a5a486682716cf969df50021107afff03",
@@ -1325,7 +1322,12 @@ mod tests {
     type G2 = pasta_curves::vesta::Point;
 
     test_ivc_nontrivial_with_compression_with::<G1, G2, EE<_>, EE<_>>();
-    test_ivc_nontrivial_with_compression_with::<bn256::Point, grumpkin::Point, EE<_>, EE<_>>();
+    test_ivc_nontrivial_with_compression_with::<
+      bn256::Point,
+      grumpkin::Point,
+      ZM<halo2curves::bn256::Bn256>,
+      EE<_>,
+    >();
     test_ivc_nontrivial_with_compression_with::<secp256k1::Point, secq256k1::Point, EE<_>, EE<_>>();
   }
 
@@ -1433,8 +1435,12 @@ mod tests {
     type G2 = pasta_curves::vesta::Point;
 
     test_ivc_nontrivial_with_spark_compression_with::<G1, G2, EE<_>, EE<_>>();
-    test_ivc_nontrivial_with_spark_compression_with::<bn256::Point, grumpkin::Point, EE<_>, EE<_>>(
-    );
+    test_ivc_nontrivial_with_spark_compression_with::<
+      bn256::Point,
+      grumpkin::Point,
+      ZM<halo2curves::bn256::Bn256>,
+      EE<_>,
+    >();
     test_ivc_nontrivial_with_spark_compression_with::<
       secp256k1::Point,
       secq256k1::Point,
@@ -1587,7 +1593,12 @@ mod tests {
     type G2 = pasta_curves::vesta::Point;
 
     test_ivc_nondet_with_compression_with::<G1, G2, EE<_>, EE<_>>();
-    test_ivc_nondet_with_compression_with::<bn256::Point, grumpkin::Point, EE<_>, EE<_>>();
+    test_ivc_nondet_with_compression_with::<
+      bn256::Point,
+      grumpkin::Point,
+      ZM<halo2curves::bn256::Bn256>,
+      EE<_>,
+    >();
     test_ivc_nondet_with_compression_with::<secp256k1::Point, secq256k1::Point, EE<_>, EE<_>>();
   }
 

src/provider/bn256_grumpkin.rs

@@ -27,6 +27,8 @@ use halo2curves::grumpkin::{
   G1Affine as GrumpkinAffine, G1Compressed as GrumpkinCompressed, G1 as GrumpkinPoint,
 };
 
+use super::kzg_commitment::KZGCommitmentEngine;
+
 /// Re-exports that give access to the standard aliases used in the code base, for bn256
 pub mod bn256 {
   pub use halo2curves::bn256::{
@@ -58,7 +60,8 @@ impl_traits!(
   Bn256Compressed,
   Bn256Point,
   Bn256Affine,
-  "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001"
+  "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001",
+  KZGCommitmentEngine<halo2curves::bn256::Bn256>
 );
 
 impl_traits!(

src/provider/kzg_commitment.rs

@@ -36,9 +36,11 @@ where
 
   fn setup(label: &'static [u8], n: usize) -> Self::CommitmentKey {
     // TODO: this is just for testing, replace by grabbing from a real setup for production
-    let label_bytes: [u8; 32] = label[..32].try_into().unwrap();
-    let rng = &mut StdRng::from_seed(label_bytes);
-    UVUniversalKZGParam::gen_srs_for_testing(rng, n)
+    let mut bytes = [0u8; 32];
+    let len = label.len().min(32);
+    bytes[..len].copy_from_slice(&label[..len]);
+    let rng = &mut StdRng::from_seed(bytes);
+    UVUniversalKZGParam::gen_srs_for_testing(rng, n.next_power_of_two())
   }
 
   fn commit(ck: &Self::CommitmentKey, v: &[<E::G1 as Group>::Scalar]) -> Self::Commitment {

src/provider/mod.rs

@@ -157,7 +157,24 @@ macro_rules! impl_traits {
     $name_compressed:ident,
     $name_curve:ident,
     $name_curve_affine:ident,
-    $order_str:literal
+    $order_str:expr
+  ) => {
+    impl_traits!(
+      $name,
+      $name_compressed,
+      $name_curve,
+      $name_curve_affine,
+      $order_str,
+      CommitmentEngine<Self>
+    );
+  };
+  (
+    $name:ident,
+    $name_compressed:ident,
+    $name_curve:ident,
+    $name_curve_affine:ident,
+    $order_str:literal,
+    $commitment_engine:ty
   ) => {
     impl Group for $name::Point {
       type Base = $name::Base;
@@ -167,7 +184,7 @@ macro_rules! impl_traits {
       type RO = PoseidonRO<Self::Base, Self::Scalar>;
       type ROCircuit = PoseidonROCircuit<Self::Base>;
       type TE = Keccak256Transcript<Self>;
-      type CE = CommitmentEngine<Self>;
+      type CE = $commitment_engine;
 
       fn vartime_multiscalar_mul(
         scalars: &[Self::Scalar],

src/provider/non_hiding_zeromorph.rs

@@ -4,24 +4,26 @@
 
 use crate::{
   errors::{NovaError, PCSError},
-  spartan::{math::Math, polys::multilinear::MultilinearPolynomial},
+  spartan::polys::multilinear::MultilinearPolynomial,
   traits::{commitment::Len, evaluation::EvaluationEngineTrait, Group, TranscriptEngineTrait},
-  Commitment, CommitmentKey,
+  Commitment,
 };
 use abomonation_derive::Abomonation;
 use ff::{BatchInvert, Field, PrimeField};
 use group::{Curve, Group as _};
 use pairing::{Engine, MillerLoopResult, MultiMillerLoop};
-use rand::thread_rng;
 use rayon::prelude::{
   IndexedParallelIterator, IntoParallelIterator, IntoParallelRefMutIterator, ParallelIterator,
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{borrow::Borrow, iter, marker::PhantomData};
 
-use super::non_hiding_kzg::{
-  UVKZGCommitment, UVKZGEvaluation, UVKZGPoly, UVKZGProof, UVKZGProverKey, UVKZGVerifierKey,
-  UVUniversalKZGParam, UVKZGPCS,
+use super::{
+  kzg_commitment::KZGCommitmentEngine,
+  non_hiding_kzg::{
+    UVKZGCommitment, UVKZGEvaluation, UVKZGPoly, UVKZGProof, UVKZGProverKey, UVKZGVerifierKey,
+    UVUniversalKZGParam, UVKZGPCS,
+  },
 };
 
 /// `ZMProverKey` is used to generate a proof
@@ -408,27 +410,22 @@ fn eval_and_quotient_scalars<F: Field>(y: F, x: F, z: F, u: &[F]) -> (F, Vec<F>)
 
 impl<E: MultiMillerLoop> EvaluationEngineTrait<E::G1> for ZMPCS<E>
 where
-  E::G1: Group<PreprocessedGroupElement = E::G1Affine, Scalar = E::Fr>,
+  E::G1: Group<PreprocessedGroupElement = E::G1Affine, Scalar = E::Fr, CE = KZGCommitmentEngine<E>>,
   E::G1Affine: Serialize + DeserializeOwned,
   E::G2Affine: Serialize + DeserializeOwned,
 {
   type ProverKey = ZMProverKey<E>;
-
   type VerifierKey = ZMVerifierKey<E>;
 
   type EvaluationArgument = ZMProof<E>;
 
-  fn setup(ck: &CommitmentKey<E::G1>) -> (Self::ProverKey, Self::VerifierKey) {
-    let max_vars = ck.length().log_2();
-    let mut rng = thread_rng();
-    let max_poly_size = 1 << (max_vars + 1);
-    let universal_setup = UVUniversalKZGParam::<E>::gen_srs_for_testing(&mut rng, max_poly_size);
-
-    trim(&universal_setup, max_poly_size)
+  fn setup(ck: &UVUniversalKZGParam<E>) -> (Self::ProverKey, Self::VerifierKey) {
+    // TODO: refine!!
+    trim(&ck, ck.length() - 1)
   }
 
   fn prove(
-    ck: &CommitmentKey<E::G1>,
+    ck: &UVUniversalKZGParam<E>,
     pk: &Self::ProverKey,
     transcript: &mut <E::G1 as Group>::TE,
     comm: &Commitment<E::G1>,

src/spartan/direct.rs

@@ -153,7 +153,7 @@ impl<G: Group, S: RelaxedR1CSSNARKTrait<G>, C: StepCircuit<G::Scalar>> DirectSNA
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::provider::{bn256_grumpkin::bn256, secp_secq::secp256k1};
+  use crate::provider::{bn256_grumpkin::bn256, non_hiding_zeromorph::ZMPCS, secp_secq::secp256k1};
   use ::bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
   use core::marker::PhantomData;
   use ff::PrimeField;
@@ -219,7 +219,7 @@ mod tests {
     test_direct_snark_with::<G, Spp>();
 
     type G2 = bn256::Point;
-    type EE2 = crate::provider::ipa_pc::EvaluationEngine<G2>;
+    type EE2 = ZMPCS<halo2curves::bn256::Bn256>;
     type S2 = crate::spartan::snark::RelaxedR1CSSNARK<G2, EE2>;
     type S2pp = crate::spartan::ppsnark::RelaxedR1CSSNARK<G2, EE2>;
     test_direct_snark_with::<G2, S2>();