simplify field trait, remove redundant modulus, add tests, implement ark for all curves

zokrates_field/src/bls12_377.rs

@@ -1,9 +1,5 @@
 use ark_bls12_377::Bls12_377;
 
-prime_field!(
-    b"8444461749428370424248824938781546531375899335154063827935233455917409239041",
-    "bls12_377",
-    Bls12_377
-);
+prime_field!("bls12_377", Bls12_377);
 
-ark_extensions!(ark_bls12_377::Bls12_377);
+ark_extensions!(Bls12_377);

zokrates_field/src/bls12_381.rs

@@ -1,10 +1,8 @@
 use ark_bls12_381::Bls12_381;
 
-prime_field!(
-    b"52435875175126190479447740508185965837690552500527637822603658699938581184513",
-    "bls12_381",
-    Bls12_381
-);
+prime_field!("bls12_381", Bls12_381);
+
+ark_extensions!(Bls12_381);
 
 #[cfg(feature = "bellman")]
 use bellman_ce::pairing::bls12_381::{Bls12, Fq2};

zokrates_field/src/bn128.rs

@@ -1,10 +1,6 @@
 use ark_bn254::Bn254;
 
-prime_field!(
-    b"21888242871839275222246405745257275088548364400416034343698204186575808495617",
-    "bn128",
-    Bn254
-);
+prime_field!("bn128", Bn254);
 
 ark_extensions!(Bn254);
 
@@ -201,6 +197,11 @@ mod tests {
             );
         }
 
+        #[test]
+        fn required_bits() {
+            assert_eq!(FieldPrime::get_required_bits(), 254);
+        }
+
         #[test]
         fn bits() {
             assert_eq!(FieldPrime::from(0).bits(), 1);
@@ -256,7 +257,6 @@ mod tests {
         #[test]
         fn serde_json_ser_deser() {
             let serialized = serde_json::to_string(&FieldPrime::from("11")).unwrap();
-            println!("{}", serialized);
             let deserialized = serde_json::from_str(&serialized).unwrap();
             assert_eq!(FieldPrime::from("11"), deserialized);
         }
@@ -264,9 +264,7 @@ mod tests {
         #[test]
         fn bytes_ser_deser() {
             let fp = FieldPrime::from("101");
-            println!("{}", fp);
             let bv = fp.to_byte_vector();
-            println!("{:#?}", bv);
             assert_eq!(fp, FieldPrime::from_byte_vector(bv));
         }
 
@@ -301,25 +299,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn bigint_assertions() {
-        use num_integer::Integer;
-        let x = BigInt::parse_bytes(b"65", 10).unwrap();
-        assert_eq!(&x + &x, BigInt::parse_bytes(b"130", 10).unwrap());
-        assert_eq!(
-            "1".parse::<BigInt>().unwrap(),
-            "3".parse::<BigInt>()
-                .unwrap()
-                .div_floor(&"2".parse::<BigInt>().unwrap())
-        );
-        assert_eq!(
-            "-2".parse::<BigInt>().unwrap(),
-            "-3".parse::<BigInt>()
-                .unwrap()
-                .div_floor(&"2".parse::<BigInt>().unwrap())
-        );
-    }
-
     #[cfg(feature = "bellman")]
     mod bellman {
         use super::*;

zokrates_field/src/bw6_761.rs

@@ -1,9 +1,5 @@
 use ark_bw6_761::BW6_761;
 
-prime_field!(
-    b"258664426012969094010652733694893533536393512754914660539884262666720468348340822774968888139573360124440321458177",
-    "bw6_761",
-    BW6_761
-);
+prime_field!("bw6_761", BW6_761);
 
 ark_extensions!(BW6_761);

zokrates_field/src/lib.rs

@@ -149,11 +149,10 @@ pub trait Field:
 #[macro_use]
 mod prime_field {
     macro_rules! prime_field {
-        ($modulus:expr, $name:expr, $v:ty) => {
+        ($name:expr, $v:ty) => {
             use crate::{Field, FieldParseError, Pow};
             use ark_ff::{Field as ArkField, PrimeField};
-            use lazy_static::lazy_static;
-            use num_bigint::{BigInt, BigUint};
+            use num_bigint::BigUint;
             use num_traits::{CheckedDiv, One, Zero};
             use serde::de::{self, Visitor};
             use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -163,10 +162,6 @@ mod prime_field {
             use std::fmt::{Debug, Display};
             use std::ops::{Add, Div, Mul, Sub};
 
-            lazy_static! {
-                static ref P: BigInt = BigInt::parse_bytes($modulus, 10).unwrap();
-            }
-
             type Fr = <$v as ark_ec::PairingEngine>::Fr;
 
             #[derive(PartialEq, PartialOrd, Clone, Eq, Ord, Hash)]
@@ -233,7 +228,8 @@ mod prime_field {
                     }
                 }
                 fn get_required_bits() -> usize {
-                    (*P).bits()
+                    use ark_ff::FpParameters;
+                    <Fr as PrimeField>::Params::MODULUS_BITS as usize
                 }
                 fn try_from_dec_str(s: &str) -> Result<Self, FieldParseError> {
                     use std::str::FromStr;
@@ -259,8 +255,10 @@ mod prime_field {
                 }
                 fn id() -> [u8; 4] {
                     let mut res = [0u8; 4];
+                    use ark_ff::BigInteger;
+                    use ark_ff::FpParameters;
                     use sha2::{Digest, Sha256};
-                    let hash = Sha256::digest(&P.to_bytes_le().1);
+                    let hash = Sha256::digest(&<Fr as PrimeField>::Params::MODULUS.to_bytes_le());
                     for i in 0..4 {
                         res[i] = hash[i];
                     }