Fix with latest arkworks version. (#95)

Co-authored-by: Pratyush Mishra <[email protected]>

Author: mmaker

Cargo.toml

@@ -58,7 +58,6 @@ ark-std = { git = "https://github.com/arkworks-rs/std" }
 ark-ec = { git = "https://github.com/arkworks-rs/algebra" }
 ark-ff = { git = "https://github.com/arkworks-rs/algebra" }
 ark-poly = { git = "https://github.com/arkworks-rs/algebra" }
-ark-serialize = { git = "https://github.com/arkworks-rs/algebra" }
 ark-test-curves = { git = "https://github.com/arkworks-rs/algebra" }
 ark-bls12-381 = { git = "https://github.com/arkworks-rs/curves" }
 ark-bls12-377 = { git = "https://github.com/arkworks-rs/curves" }

benches/bench.rs

@@ -1,6 +1,9 @@
 use ark_ff::PrimeField;
-use ark_r1cs_std::fields::nonnative::NonNativeFieldVar;
-use ark_r1cs_std::{alloc::AllocVar, eq::EqGadget, fields::FieldVar};
+use ark_r1cs_std::{
+    alloc::AllocVar,
+    eq::EqGadget,
+    fields::{nonnative::NonNativeFieldVar, FieldVar},
+};
 use ark_relations::{
     ns,
     r1cs::{ConstraintSystem, ConstraintSystemRef, OptimizationGoal},

src/bits/boolean.rs

@@ -608,7 +608,8 @@ impl<F: Field> Boolean<F> {
         }
     }
 
-    /// Convert a little-endian bitwise representation of a field element to `FpVar<F>`
+    /// Convert a little-endian bitwise representation of a field element to
+    /// `FpVar<F>`
     #[tracing::instrument(target = "r1cs", skip(bits))]
     pub fn le_bits_to_fp_var(bits: &[Self]) -> Result<FpVar<F>, SynthesisError>
     where
@@ -761,7 +762,6 @@ impl<F: Field> Boolean<F> {
     /// # Ok(())
     /// # }
     /// ```
-    ///
     #[tracing::instrument(target = "r1cs", skip(first, second))]
     pub fn select<T: CondSelectGadget<F>>(
         &self,

src/bits/uint.rs

@@ -7,8 +7,7 @@ macro_rules! make_uint {
         #[doc = " type."]
         pub mod $mod_name {
             use ark_ff::{Field, One, PrimeField, Zero};
-            use core::borrow::Borrow;
-            use core::convert::TryFrom;
+            use core::{borrow::Borrow, convert::TryFrom};
             use num_bigint::BigUint;
             use num_traits::cast::ToPrimitive;
 
@@ -87,7 +86,6 @@ macro_rules! make_uint {
                 /// Construct `Self` from a slice of `Boolean`s.
                 ///
                 /// # Panics
-                ///
                 #[doc = "This method panics if `bits.len() != "]
                 #[doc = $num_bits_doc]
                 #[doc = "`."]
@@ -142,8 +140,8 @@ macro_rules! make_uint {
 
                 /// Outputs `self ^ other`.
                 ///
-                /// If at least one of `self` and `other` are constants, then this method
-                /// *does not* create any constraints or variables.
+                /// If at least one of `self` and `other` are constants, then this
+                /// method *does not* create any constraints or variables.
                 #[tracing::instrument(target = "r1cs", skip(self, other))]
                 pub fn xor(&self, other: &Self) -> Result<Self, SynthesisError> {
                     let mut result = self.clone();
@@ -225,7 +223,8 @@ macro_rules! make_uint {
                                 Boolean::Not(ref bit) => {
                                     all_constants = false;
 
-                                    // Add coeff * (1 - bit_gadget) = coeff * ONE - coeff * bit_gadget
+                                    // Add coeff * (1 - bit_gadget) = coeff * ONE - coeff *
+                                    // bit_gadget
                                     lc = lc + (coeff, Variable::One) - (coeff, bit.variable());
                                 },
                                 Boolean::Constant(bit) => {

src/bits/uint8.rs

@@ -2,8 +2,11 @@ use ark_ff::{Field, PrimeField, ToConstraintField};
 
 use ark_relations::r1cs::{ConstraintSystemRef, Namespace, SynthesisError};
 
-use crate::fields::fp::{AllocatedFp, FpVar};
-use crate::{prelude::*, Assignment, ToConstraintFieldGadget, Vec};
+use crate::{
+    fields::fp::{AllocatedFp, FpVar},
+    prelude::*,
+    Assignment, ToConstraintFieldGadget, Vec,
+};
 use core::{borrow::Borrow, convert::TryFrom};
 
 /// Represents an interpretation of 8 `Boolean` objects as an
@@ -335,9 +338,9 @@ impl<ConstraintF: Field> AllocVar<u8, ConstraintF> for UInt8<ConstraintF> {
     }
 }
 
-/// Parses the `Vec<UInt8<ConstraintF>>` in fixed-sized `ConstraintF::MODULUS_BIT_SIZE - 1` chunks and
-/// converts each chunk, which is assumed to be little-endian, to its `FpVar<ConstraintF>`
-/// representation.
+/// Parses the `Vec<UInt8<ConstraintF>>` in fixed-sized
+/// `ConstraintF::MODULUS_BIT_SIZE - 1` chunks and converts each chunk, which is
+/// assumed to be little-endian, to its `FpVar<ConstraintF>` representation.
 /// This is the gadget counterpart to the `[u8]` implementation of
 /// [ToConstraintField](ark_ff::ToConstraintField).
 impl<ConstraintF: PrimeField> ToConstraintFieldGadget<ConstraintF> for [UInt8<ConstraintF>] {
@@ -360,13 +363,17 @@ impl<ConstraintF: PrimeField> ToConstraintFieldGadget<ConstraintF> for Vec<UInt8
 #[cfg(test)]
 mod test {
     use super::UInt8;
-    use crate::fields::fp::FpVar;
-    use crate::prelude::AllocationMode::{Constant, Input, Witness};
-    use crate::{prelude::*, ToConstraintFieldGadget, Vec};
+    use crate::{
+        fields::fp::FpVar,
+        prelude::{
+            AllocationMode::{Constant, Input, Witness},
+            *,
+        },
+        ToConstraintFieldGadget, Vec,
+    };
     use ark_ff::{PrimeField, ToConstraintField};
     use ark_relations::r1cs::{ConstraintSystem, SynthesisError};
-    use ark_std::rand::distributions::Uniform;
-    use ark_std::rand::Rng;
+    use ark_std::rand::{distributions::Uniform, Rng};
     use ark_test_curves::bls12_381::Fr;
 
     #[test]

src/fields/fp/cmp.rs

@@ -153,8 +153,7 @@ impl<F: PrimeField> FpVar<F> {
 
 #[cfg(test)]
 mod test {
-    use ark_std::cmp::Ordering;
-    use ark_std::rand::Rng;
+    use ark_std::{cmp::Ordering, rand::Rng};
 
     use crate::{alloc::AllocVar, fields::fp::FpVar};
     use ark_ff::{PrimeField, UniformRand};

src/fields/fp/mod.rs

@@ -127,7 +127,8 @@ impl<F: PrimeField> AllocatedFp<F> {
 
     /// Add many allocated Fp elements together.
     ///
-    /// This does not create any constraints and only creates one linear combination.
+    /// This does not create any constraints and only creates one linear
+    /// combination.
     pub fn addmany<'a, I: Iterator<Item = &'a Self>>(iter: I) -> Self {
         let mut cs = ConstraintSystemRef::None;
         let mut has_value = true;
@@ -918,15 +919,19 @@ impl<F: PrimeField> ToBytesGadget<F> for FpVar<F> {
     #[tracing::instrument(target = "r1cs")]
     fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
         match self {
-            Self::Constant(c) => Ok(UInt8::constant_vec(&ark_ff::to_bytes![c].unwrap())),
+            Self::Constant(c) => Ok(UInt8::constant_vec(
+                c.into_bigint().to_bytes_be().as_slice(),
+            )),
             Self::Var(v) => v.to_bytes(),
         }
     }
 
     #[tracing::instrument(target = "r1cs")]
     fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
         match self {
-            Self::Constant(c) => Ok(UInt8::constant_vec(&ark_ff::to_bytes![c].unwrap())),
+            Self::Constant(c) => Ok(UInt8::constant_vec(
+                c.into_bigint().to_bytes_be().as_slice(),
+            )),
             Self::Var(v) => v.to_non_unique_bytes(),
         }
     }
@@ -1060,10 +1065,12 @@ impl<'a, F: PrimeField> Sum<&'a FpVar<F>> for FpVar<F> {
 
 #[cfg(test)]
 mod test {
-    use crate::alloc::{AllocVar, AllocationMode};
-    use crate::eq::EqGadget;
-    use crate::fields::fp::FpVar;
-    use crate::R1CSVar;
+    use crate::{
+        alloc::{AllocVar, AllocationMode},
+        eq::EqGadget,
+        fields::fp::FpVar,
+        R1CSVar,
+    };
     use ark_relations::r1cs::ConstraintSystem;
     use ark_std::{UniformRand, Zero};
     use ark_test_curves::bls12_381::Fr;

src/fields/fp12.rs

@@ -1,7 +1,9 @@
 use crate::fields::{fp2::Fp2Var, fp6_3over2::Fp6Var, quadratic_extension::*, FieldVar};
-use ark_ff::fields::{fp12_2over3over2::*, Field};
-use ark_ff::fp6_3over2::Fp6Config;
-use ark_ff::QuadExtConfig;
+use ark_ff::{
+    fields::{fp12_2over3over2::*, Field},
+    fp6_3over2::Fp6Config,
+    QuadExtConfig,
+};
 use ark_relations::r1cs::SynthesisError;
 
 /// A degree-12 extension field constructed as the tower of a

src/fields/fp3.rs

@@ -1,6 +1,8 @@
 use crate::fields::{cubic_extension::*, fp::FpVar};
-use ark_ff::fields::{CubicExtConfig, Fp3ConfigWrapper};
-use ark_ff::Fp3Config;
+use ark_ff::{
+    fields::{CubicExtConfig, Fp3ConfigWrapper},
+    Fp3Config,
+};
 
 /// A cubic extension field constructed over a prime field.
 /// This is the R1CS equivalent of `ark_ff::Fp3<P>`.

src/fields/fp4.rs

@@ -1,6 +1,8 @@
 use crate::fields::{fp2::Fp2Var, quadratic_extension::*};
-use ark_ff::fields::{Fp4ConfigWrapper, QuadExtConfig};
-use ark_ff::Fp4Config;
+use ark_ff::{
+    fields::{Fp4ConfigWrapper, QuadExtConfig},
+    Fp4Config,
+};
 
 /// A quartic extension field constructed as the tower of a
 /// quadratic extension over a quadratic extension field.