use general evaluation domain

ferveo/benches/benchmarks/eval_domain.rs

@@ -21,7 +21,7 @@ pub fn bench_eval_domain(c: &mut Criterion) {
     for shares_num in NUM_SHARES_CASES {
         let eval_radix2_eval_domain = {
             let domain =
-                ark_poly::MixedRadixEvaluationDomain::new(shares_num).unwrap();
+                ark_poly::GeneralEvaluationDomain::new(shares_num).unwrap();
             let phi = SecretPolynomial::<ark_bls12_381::Bls12_381>::new(
                 &s, shares_num, rng,
             );
@@ -33,7 +33,7 @@ pub fn bench_eval_domain(c: &mut Criterion) {
 
         let eval_mixed_eval_domain = {
             let domain =
-                ark_poly::MixedRadixEvaluationDomain::new(shares_num).unwrap();
+                ark_poly::GeneralEvaluationDomain::new(shares_num).unwrap();
             let phi = SecretPolynomial::<ark_bls12_381::Bls12_381>::new(
                 &s, shares_num, rng,
             );

ferveo/src/api.rs

@@ -1,6 +1,6 @@
 use std::io;
 
-use ark_poly::{EvaluationDomain, MixedRadixEvaluationDomain};
+use ark_poly::{EvaluationDomain, GeneralEvaluationDomain};
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_std::UniformRand;
 use bincode;
@@ -204,7 +204,7 @@ impl AggregatedTranscript {
         messages: &[ValidatorMessage],
     ) -> Result<bool> {
         let pvss_params = PubliclyVerifiableParams::<E>::default();
-        let domain = MixedRadixEvaluationDomain::<Fr>::new(shares_num as usize)
+        let domain = GeneralEvaluationDomain::<Fr>::new(shares_num as usize)
             .expect("Unable to construct an evaluation domain");
 
         let is_valid_optimistic = self.0.verify_optimistic();

ferveo/src/dkg.rs

@@ -59,7 +59,7 @@ pub struct PubliclyVerifiableDkg<E: Pairing> {
     pub pvss_params: PubliclyVerifiableParams<E>,
     pub validators: ValidatorsMap<E>,
     pub vss: PVSSMap<E>,
-    pub domain: ark_poly::MixedRadixEvaluationDomain<E::ScalarField>,
+    pub domain: ark_poly::GeneralEvaluationDomain<E::ScalarField>,
     pub me: DkgValidator<E>,
     pub state: DkgState<E>,
 }
@@ -76,11 +76,10 @@ impl<E: Pairing> PubliclyVerifiableDkg<E> {
         dkg_params: &DkgParams,
         me: &Validator<E>,
     ) -> Result<Self> {
-        let domain =
-            ark_poly::MixedRadixEvaluationDomain::<E::ScalarField>::new(
-                dkg_params.shares_num as usize,
-            )
-            .expect("unable to construct domain");
+        let domain = ark_poly::GeneralEvaluationDomain::<E::ScalarField>::new(
+            dkg_params.shares_num as usize,
+        )
+        .expect("unable to construct domain");
 
         // Sort the validators to verify a global ordering
         if !is_sorted(validators) {

ferveo/src/pvss.rs

@@ -224,7 +224,7 @@ pub fn do_verify_full<E: Pairing>(
     pvss_encrypted_shares: &[E::G2Affine],
     pvss_params: &PubliclyVerifiableParams<E>,
     validators: &[Validator<E>],
-    domain: &ark_poly::MixedRadixEvaluationDomain<E::ScalarField>,
+    domain: &ark_poly::GeneralEvaluationDomain<E::ScalarField>,
 ) -> bool {
     let mut commitment = batch_to_projective_g1::<E>(pvss_coefficients);
     domain.fft_in_place(&mut commitment);
@@ -256,7 +256,7 @@ pub fn do_verify_aggregation<E: Pairing>(
     pvss_agg_encrypted_shares: &[E::G2Affine],
     pvss_params: &PubliclyVerifiableParams<E>,
     validators: &[Validator<E>],
-    domain: &ark_poly::MixedRadixEvaluationDomain<E::ScalarField>,
+    domain: &ark_poly::GeneralEvaluationDomain<E::ScalarField>,
     vss: &PVSSMap<E>,
 ) -> Result<bool> {
     let is_valid = do_verify_full(

subproductdomain/src/lib.rs

@@ -9,7 +9,7 @@ use ark_ec::{
 use ark_ff::{FftField, Field, Zero};
 use ark_poly::{
     univariate::DensePolynomial, DenseUVPolynomial, EvaluationDomain,
-    MixedRadixEvaluationDomain, Polynomial,
+    GeneralEvaluationDomain, Polynomial,
 };
 
 /// Compute a fast multiexp of many scalars times the same base
@@ -342,7 +342,7 @@ pub fn toeplitz_mul<E: Pairing, const NORMALIZE: bool>(
     let m = polynomial.coeffs.len() - 1;
     let size = ark_std::cmp::max(size, m);
 
-    let domain = MixedRadixEvaluationDomain::<E::ScalarField>::new(2 * size)
+    let domain = GeneralEvaluationDomain::<E::ScalarField>::new(2 * size)
         .ok_or_else(|| {
             anyhow::anyhow!("toeplitz multiplication on too large a domain")
         })?;

tpke/src/combine.rs

@@ -161,14 +161,13 @@ mod tests {
         use ark_poly::EvaluationDomain;
         use ark_std::One;
         let fft_domain =
-            ark_poly::MixedRadixEvaluationDomain::<ScalarField>::new(500)
-                .unwrap();
+            ark_poly::GeneralEvaluationDomain::<ScalarField>::new(500).unwrap();
 
         let mut domain = Vec::with_capacity(500);
         let mut point = ScalarField::one();
         for _ in 0..500 {
             domain.push(point);
-            point *= fft_domain.group_gen;
+            point *= fft_domain.group_gen();
         }
 
         let mut lagrange_n_0 = domain.iter().product::<ScalarField>();

tpke/src/lib.rs

@@ -94,7 +94,7 @@ pub mod test_common {
             DensePolynomial::<E::ScalarField>::rand(threshold - 1, rng);
         // Domain, or omega Ω
         let fft_domain =
-            ark_poly::MixedRadixEvaluationDomain::<E::ScalarField>::new(
+            ark_poly::GeneralEvaluationDomain::<E::ScalarField>::new(
                 shares_num,
             )
             .unwrap();
@@ -123,9 +123,9 @@ pub mod test_common {
 
         for _ in 0..shares_num {
             domain_points.push(point); // 1, t, t^2, t^3, ...; where t is a scalar generator fft_domain.group_gen
-            point *= fft_domain.group_gen;
+            point *= fft_domain.group_gen();
             domain_points_inv.push(point_inv);
-            point_inv *= fft_domain.group_gen_inv;
+            point_inv *= fft_domain.group_gen_inv();
         }
 
         let mut private_contexts = vec![];
@@ -195,7 +195,7 @@ pub mod test_common {
             DensePolynomial::<E::ScalarField>::rand(threshold - 1, rng);
         // Domain, or omega Ω
         let fft_domain =
-            ark_poly::MixedRadixEvaluationDomain::<E::ScalarField>::new(
+            ark_poly::GeneralEvaluationDomain::<E::ScalarField>::new(
                 shares_num,
             )
             .unwrap();