From bc427597a4fceed9c3f7572241a1ec377c18f1bd Mon Sep 17 00:00:00 2001 From: schaeff Date: Thu, 2 Dec 2021 18:29:56 +0100 Subject: [PATCH 1/9] use arkff in zokrates_field --- Cargo.lock | 13 ++ zokrates_core/src/ir/expression.rs | 4 +- zokrates_field/Cargo.toml | 4 +- zokrates_field/src/bls12_377.rs | 5 +- zokrates_field/src/bls12_381.rs | 5 +- zokrates_field/src/bn128.rs | 199 +++++++----------- zokrates_field/src/bw6_761.rs | 7 +- zokrates_field/src/lib.rs | 310 +++++++++++++++-------------- 8 files changed, 270 insertions(+), 277 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 41db65de..b56a8b3a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -67,6 +67,17 @@ dependencies = [ "ark-std", ] +[[package]] +name = "ark-bls12-381" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70e1c2ad76c4f725520440b981df3ce2d635f2baa1122750c757c0cf0f3d4b74" +dependencies = [ + "ark-ec", + "ark-ff", + "ark-std", +] + [[package]] name = "ark-bn254" version = "0.2.0" @@ -2483,10 +2494,12 @@ name = "zokrates_field" version = "0.4.0" dependencies = [ "ark-bls12-377", + "ark-bls12-381", "ark-bn254", "ark-bw6-761", "ark-ec", "ark-ff", + "ark-serialize", "bellman_ce", "bincode", "lazy_static", diff --git a/zokrates_core/src/ir/expression.rs b/zokrates_core/src/ir/expression.rs index 57ec2753..77069a4d 100644 --- a/zokrates_core/src/ir/expression.rs +++ b/zokrates_core/src/ir/expression.rs @@ -259,10 +259,8 @@ impl Mul<&T> for LinComb { impl Div<&T> for LinComb { type Output = LinComb; - // Clippy warns about multiplication in a method named div. It's okay, here, since we multiply with the inverse. - #[allow(clippy::suspicious_arithmetic_impl)] fn div(self, scalar: &T) -> LinComb { - self * &scalar.inverse_mul().unwrap() + self * &T::one().div(scalar) } } diff --git a/zokrates_field/Cargo.toml b/zokrates_field/Cargo.toml index cea2f9ec..7c26729b 100644 --- a/zokrates_field/Cargo.toml +++ b/zokrates_field/Cargo.toml @@ -6,7 +6,7 @@ edition = "2018" [features] default = ["ark", "bellman"] -ark = ["ark-ff", "ark-ec", "ark-bn254", "ark-bls12-377", "ark-bw6-761"] +ark = ["ark-ff", "ark-ec", "ark-bn254", "ark-bls12-381", "ark-bls12-377", "ark-bw6-761", "ark-serialize"] bellman = ["bellman_ce"] [dependencies] @@ -27,7 +27,9 @@ ark-ff = { version = "^0.2.0", default-features = false, optional = true } ark-ec = { version = "^0.2.0", default-features = false, optional = true } ark-bn254 = { version = "^0.2.0", features = ["curve"], default-features = false, optional = true } ark-bls12-377 = { version = "^0.2.0", features = ["curve"], default-features = false, optional = true } +ark-bls12-381 = { version = "^0.2.0", features = ["curve"], default-features = false, optional = true } ark-bw6-761 = { version = "^0.2.0", default-features = false, optional = true } +ark-serialize = { version = "^0.2.0", default-features = false, optional = true } [dev-dependencies] rand = "0.4" diff --git a/zokrates_field/src/bls12_377.rs b/zokrates_field/src/bls12_377.rs index 08045dcb..54e4f4f1 100644 --- a/zokrates_field/src/bls12_377.rs +++ b/zokrates_field/src/bls12_377.rs @@ -1,6 +1,9 @@ +use ark_bls12_377::Bls12_377; + prime_field!( b"8444461749428370424248824938781546531375899335154063827935233455917409239041", - "bls12_377" + "bls12_377", + Bls12_377 ); #[cfg(feature = "ark")] diff --git a/zokrates_field/src/bls12_381.rs b/zokrates_field/src/bls12_381.rs index 25f4e827..e76dbc0b 100644 --- a/zokrates_field/src/bls12_381.rs +++ b/zokrates_field/src/bls12_381.rs @@ -1,6 +1,9 @@ +use ark_bls12_381::Bls12_381; + prime_field!( b"52435875175126190479447740508185965837690552500527637822603658699938581184513", - "bls12_381" + "bls12_381", + Bls12_381 ); #[cfg(feature = "bellman")] diff --git a/zokrates_field/src/bn128.rs b/zokrates_field/src/bn128.rs index b7bf2ea2..54c08a7a 100644 --- a/zokrates_field/src/bn128.rs +++ b/zokrates_field/src/bn128.rs @@ -1,6 +1,9 @@ +use ark_bn254::Bn254; + prime_field!( b"21888242871839275222246405745257275088548364400416034343698204186575808495617", - "bn128" + "bn128", + Bn254 ); #[cfg(feature = "bellman")] @@ -8,9 +11,6 @@ use bellman_ce::pairing::bn256::{Bn256, Fq2}; #[cfg(feature = "bellman")] bellman_extensions!(Bn256, Fq2); -#[cfg(feature = "ark")] -use ark_bn254::Bn254; -#[cfg(feature = "ark")] ark_extensions!(Bn254); #[cfg(test)] @@ -37,157 +37,155 @@ mod tests { ); } - #[test] - fn positive_number() { - assert_eq!( - "1234245612".parse::().unwrap(), - FieldPrime::from("1234245612").value - ); - } + // #[test] + // fn positive_number() { + // assert_eq!( + // "1234245612".parse::().unwrap(), + // FieldPrime::from("1234245612").value + // ); + // } - #[test] - fn negative_number() { - assert_eq!( - P.checked_sub(&"12".parse::().unwrap()).unwrap(), - FieldPrime::from("-12").value - ); - } + // #[test] + // fn negative_number() { + // assert_eq!( + // P.checked_sub(&"12".parse::().unwrap()).unwrap(), + // FieldPrime::from("-12").value + // ); + // } #[test] fn addition() { assert_eq!( - "65484493".parse::().unwrap(), - (FieldPrime::from("65416358") + FieldPrime::from("68135")).value + FieldPrime::from("65484493"), + FieldPrime::from("65416358") + FieldPrime::from("68135") ); assert_eq!( - "65484493".parse::().unwrap(), - (FieldPrime::from("65416358") + &FieldPrime::from("68135")).value + FieldPrime::from("65484493"), + FieldPrime::from("65416358") + &FieldPrime::from("68135") ); } #[test] fn addition_negative_small() { assert_eq!( - "3".parse::().unwrap(), - (FieldPrime::from("5") + FieldPrime::from("-2")).value + FieldPrime::from("3"), + FieldPrime::from("5") + FieldPrime::from(-2) ); assert_eq!( - "3".parse::().unwrap(), - (FieldPrime::from("5") + &FieldPrime::from("-2")).value + FieldPrime::from("3"), + FieldPrime::from("5") + &FieldPrime::from(-2) ); } #[test] fn addition_negative() { assert_eq!( - "65348223".parse::().unwrap(), - (FieldPrime::from("65416358") + FieldPrime::from("-68135")).value + FieldPrime::from("65348223"), + FieldPrime::from("65416358") + FieldPrime::from(-68135) ); assert_eq!( - "65348223".parse::().unwrap(), - (FieldPrime::from("65416358") + &FieldPrime::from("-68135")).value + FieldPrime::from("65348223"), + FieldPrime::from("65416358") + &FieldPrime::from(-68135) ); } #[test] fn subtraction() { assert_eq!( - "65348223".parse::().unwrap(), - (FieldPrime::from("65416358") - FieldPrime::from("68135")).value + FieldPrime::from("65348223"), + FieldPrime::from("65416358") - FieldPrime::from("68135") ); assert_eq!( - "65348223".parse::().unwrap(), - (FieldPrime::from("65416358") - &FieldPrime::from("68135")).value + FieldPrime::from("65348223"), + FieldPrime::from("65416358") - &FieldPrime::from("68135") ); } #[test] fn subtraction_negative() { assert_eq!( - "65484493".parse::().unwrap(), - (FieldPrime::from("65416358") - FieldPrime::from("-68135")).value + FieldPrime::from("65484493"), + FieldPrime::from("65416358") - FieldPrime::from(-68135) ); assert_eq!( - "65484493".parse::().unwrap(), - (FieldPrime::from("65416358") - &FieldPrime::from("-68135")).value + FieldPrime::from("65484493"), + FieldPrime::from("65416358") - &FieldPrime::from(-68135) ); } #[test] fn subtraction_overflow() { assert_eq!( - "21888242871839275222246405745257275088548364400416034343698204186575743147394" - .parse::() - .unwrap(), - (FieldPrime::from("68135") - FieldPrime::from("65416358")).value + FieldPrime::from( + "21888242871839275222246405745257275088548364400416034343698204186575743147394" + ), + FieldPrime::from("68135") - FieldPrime::from("65416358") ); assert_eq!( - "21888242871839275222246405745257275088548364400416034343698204186575743147394" - .parse::() - .unwrap(), - (FieldPrime::from("68135") - &FieldPrime::from("65416358")).value + FieldPrime::from( + "21888242871839275222246405745257275088548364400416034343698204186575743147394" + ), + FieldPrime::from("68135") - &FieldPrime::from("65416358") ); } #[test] fn multiplication() { assert_eq!( - "13472".parse::().unwrap(), - (FieldPrime::from("32") * FieldPrime::from("421")).value + FieldPrime::from("13472"), + FieldPrime::from("32") * FieldPrime::from("421") ); assert_eq!( - "13472".parse::().unwrap(), - (FieldPrime::from("32") * &FieldPrime::from("421")).value + FieldPrime::from("13472"), + FieldPrime::from("32") * &FieldPrime::from("421") ); } #[test] fn multiplication_negative() { assert_eq!( - "21888242871839275222246405745257275088548364400416034343698204186575808014369" - .parse::() - .unwrap(), - (FieldPrime::from("54") * FieldPrime::from("-8912")).value + FieldPrime::from( + "21888242871839275222246405745257275088548364400416034343698204186575808014369" + ), + FieldPrime::from("54") * FieldPrime::from(-8912) ); assert_eq!( - "21888242871839275222246405745257275088548364400416034343698204186575808014369" - .parse::() - .unwrap(), - (FieldPrime::from("54") * &FieldPrime::from("-8912")).value + FieldPrime::from( + "21888242871839275222246405745257275088548364400416034343698204186575808014369" + ), + FieldPrime::from("54") * &FieldPrime::from(-8912) ); } #[test] fn multiplication_two_negative() { assert_eq!( - "648".parse::().unwrap(), - (FieldPrime::from("-54") * FieldPrime::from("-12")).value + FieldPrime::from("648"), + FieldPrime::from(-54) * FieldPrime::from(-12) ); assert_eq!( - "648".parse::().unwrap(), - (FieldPrime::from("-54") * &FieldPrime::from("-12")).value + FieldPrime::from("648"), + FieldPrime::from(-54) * &FieldPrime::from(-12) ); } #[test] fn multiplication_overflow() { assert_eq!( - "6042471409729479866150380306128222617399890671095126975526159292198160466142" - .parse::() - .unwrap(), - (FieldPrime::from( + FieldPrime::from( + "6042471409729479866150380306128222617399890671095126975526159292198160466142" + ), + FieldPrime::from( "21888242871839225222246405785257275088694311157297823662689037894645225727" - ) * FieldPrime::from("218882428715392752222464057432572755886923")) - .value + ) * FieldPrime::from("218882428715392752222464057432572755886923") ); assert_eq!( - "6042471409729479866150380306128222617399890671095126975526159292198160466142" - .parse::() - .unwrap(), - (FieldPrime::from( + FieldPrime::from( + "6042471409729479866150380306128222617399890671095126975526159292198160466142" + ), + FieldPrime::from( "21888242871839225222246405785257275088694311157297823662689037894645225727" - ) * &FieldPrime::from("218882428715392752222464057432572755886923")) - .value + ) * &FieldPrime::from("218882428715392752222464057432572755886923") ); } @@ -218,8 +216,8 @@ mod tests { #[test] fn pow_usize() { assert_eq!( - "614787626176508399616".parse::().unwrap(), - (FieldPrime::from("54").pow(12)).value + FieldPrime::from("614787626176508399616"), + FieldPrime::from("54").pow(12) ); } @@ -233,6 +231,7 @@ 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); } @@ -293,54 +292,6 @@ mod tests { ); } - #[test] - fn test_extended_euclid() { - assert_eq!( - ( - ToBigInt::to_bigint(&1).unwrap(), - ToBigInt::to_bigint(&-9).unwrap(), - ToBigInt::to_bigint(&47).unwrap() - ), - extended_euclid( - &ToBigInt::to_bigint(&120).unwrap(), - &ToBigInt::to_bigint(&23).unwrap() - ) - ); - assert_eq!( - ( - ToBigInt::to_bigint(&2).unwrap(), - ToBigInt::to_bigint(&2).unwrap(), - ToBigInt::to_bigint(&-11).unwrap() - ), - extended_euclid( - &ToBigInt::to_bigint(&122).unwrap(), - &ToBigInt::to_bigint(&22).unwrap() - ) - ); - assert_eq!( - ( - ToBigInt::to_bigint(&2).unwrap(), - ToBigInt::to_bigint(&-9).unwrap(), - ToBigInt::to_bigint(&47).unwrap() - ), - extended_euclid( - &ToBigInt::to_bigint(&240).unwrap(), - &ToBigInt::to_bigint(&46).unwrap() - ) - ); - let (b, s, _) = extended_euclid(&ToBigInt::to_bigint(&253).unwrap(), &*P); - assert_eq!(b, BigInt::one()); - let s_field = FieldPrime { - value: &s - s.div_floor(&*P) * &*P, - }; - assert_eq!( - FieldPrime::from( - "12717674712096337777352654721552646000065650461901806515903699665717959876900" - ), - s_field - ); - } - #[cfg(feature = "bellman")] mod bellman { use super::*; diff --git a/zokrates_field/src/bw6_761.rs b/zokrates_field/src/bw6_761.rs index ef050191..122ae912 100644 --- a/zokrates_field/src/bw6_761.rs +++ b/zokrates_field/src/bw6_761.rs @@ -1,9 +1,10 @@ +use ark_bw6_761::BW6_761; + prime_field!( b"258664426012969094010652733694893533536393512754914660539884262666720468348340822774968888139573360124440321458177", - "bw6_761" + "bw6_761", + BW6_761 ); -#[cfg(feature = "ark")] -use ark_bw6_761::BW6_761; #[cfg(feature = "ark")] ark_extensions!(BW6_761); diff --git a/zokrates_field/src/lib.rs b/zokrates_field/src/lib.rs index 030841a9..3bdd40eb 100644 --- a/zokrates_field/src/lib.rs +++ b/zokrates_field/src/lib.rs @@ -93,7 +93,7 @@ pub trait Field: /// Returns this `Field`'s contents as decimal string fn to_dec_string(&self) -> String; /// Returns the multiplicative inverse, i.e.: self * self.inverse_mul() = Self::one() - fn inverse_mul(&self) -> Option; + //fn inverse_mul(&self) -> Option; /// Returns the smallest value that can be represented by this field type. fn min_value() -> Self; /// Returns the largest value that can be represented by this field type. @@ -153,13 +153,14 @@ pub trait Field: #[macro_use] mod prime_field { macro_rules! prime_field { - ($modulus:expr, $name:expr) => { + ($modulus:expr, $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, Sign, ToBigInt}; - use num_integer::Integer; + use num_bigint::{BigInt, BigUint}; use num_traits::{CheckedDiv, One, Zero}; - use serde_derive::{Deserialize, Serialize}; + use serde::de::{self, Visitor}; + use serde::{Deserialize, Deserializer, Serialize, Serializer}; use std::convert::From; use std::convert::TryFrom; use std::fmt; @@ -170,86 +171,90 @@ mod prime_field { static ref P: BigInt = BigInt::parse_bytes($modulus, 10).unwrap(); } - #[derive(PartialEq, PartialOrd, Clone, Eq, Ord, Hash, Serialize, Deserialize)] + type Fr = <$v as ark_ec::PairingEngine>::Fr; + + #[derive(PartialEq, PartialOrd, Clone, Eq, Ord, Hash)] pub struct FieldPrime { - value: BigInt, + v: Fr, } impl Field for FieldPrime { fn bits(&self) -> u32 { - self.value.bits() as u32 + use ark_ff::BigInteger; + let bits = self.v.into_repr().to_bits_be(); + let mut size = bits.len(); + for bit in bits { + if !bit { + size -= 1; + } else { + break; + } + } + size as u32 } fn to_biguint(&self) -> BigUint { - self.value.to_biguint().unwrap() + use ark_ff::BigInteger; + BigUint::from_bytes_le(&self.v.into_repr().to_bytes_le()) } fn to_byte_vector(&self) -> Vec { - match self.value.to_biguint() { - Option::Some(val) => val.to_bytes_le(), - Option::None => panic!("Should never happen."), - } + use ark_ff::BigInteger; + self.v.into_repr().to_bytes_be() } fn from_byte_vector(bytes: Vec) -> Self { - let uval = BigUint::from_bytes_le(bytes.as_slice()); + use ark_ff::FromBytes; + FieldPrime { - value: BigInt::from_biguint(Sign::Plus, uval), + v: Fr::from(::BigInt::read(&bytes[..]).unwrap()), } } fn to_dec_string(&self) -> String { - self.value.to_str_radix(10) + self.to_string() } - fn inverse_mul(&self) -> Option { - let (b, s, _) = extended_euclid(&self.value, &*P); - if b == BigInt::one() { - Some(FieldPrime { - value: &s - s.div_floor(&*P) * &*P, - }) - } else { - None - } - } fn min_value() -> FieldPrime { - FieldPrime { - value: ToBigInt::to_bigint(&0).unwrap(), - } + FieldPrime { v: Fr::from(0u32) } } fn max_value() -> FieldPrime { FieldPrime { - value: &*P - ToBigInt::to_bigint(&1).unwrap(), + v: Fr::from(0u32) - Fr::from(1u32), } } fn max_unique_value() -> FieldPrime { - use num_traits::Pow; - FieldPrime { - value: BigInt::from(2u32).pow(Self::get_required_bits() - 1) - 1, + v: Fr::from(2u32).pow([Self::get_required_bits() as u64 - 1]) + - Fr::from(1u32), } } fn get_required_bits() -> usize { (*P).bits() } fn try_from_dec_str(s: &str) -> Result { - Self::try_from_str(s, 10) - } - fn try_from_str(s: &str, radix: u32) -> Result { - let x = BigInt::parse_bytes(s.as_bytes(), radix).ok_or(FieldParseError)?; + use std::str::FromStr; + Ok(FieldPrime { - value: &x - x.div_floor(&*P) * &*P, + v: Fr::from_str(s).map_err(|_| FieldParseError)?, }) } + fn try_from_str(_: &str, _: u32) -> Result { + unimplemented!("try from str") + // let x = BigInt::parse_bytes(s.as_bytes(), radix).ok_or(FieldParseError)?; + // Ok(FieldPrime { + // value: &x - x.div_floor(&*P) * &*P, + // v: field_new!() + // }) + } fn to_compact_dec_string(&self) -> String { - // values up to (p-1)/2 included are represented as positive, values between (p+1)/2 and p-1 as represented as negative by subtracting p - if self.value <= FieldPrime::max_value().value / 2 { - format!("{}", self.value.to_str_radix(10)) + //values up to (p-1)/2 included are represented as positive, values between (p+1)/2 and p-1 as represented as negative by subtracting p + if self.v.into_repr() <= Fr::modulus_minus_one_div_two() { + format!("{}", self.to_string()) } else { format!( - "({})", - (&self.value - (FieldPrime::max_value().value + BigInt::one())) - .to_str_radix(10) + "(-{})", + (FieldPrime::max_value() - self + FieldPrime::one()).to_string() ) } } @@ -270,57 +275,53 @@ mod prime_field { impl Default for FieldPrime { fn default() -> Self { - FieldPrime { - value: BigInt::default(), - } + FieldPrime { v: Fr::from(0u32) } } } impl Display for FieldPrime { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.value.to_str_radix(10)) + write!(f, "{}", self.to_biguint()) } } impl Debug for FieldPrime { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.value.to_str_radix(10)) + write!(f, "{}", self.to_biguint()) } } impl From for FieldPrime { fn from(num: i32) -> Self { - let x = ToBigInt::to_bigint(&num).unwrap(); - FieldPrime { - value: &x - x.div_floor(&*P) * &*P, + if num < 0 { + FieldPrime { + v: Fr::zero() - Fr::from((-num) as u32), + } + } else { + FieldPrime { + v: Fr::from(num as u32), + } } } } impl From for FieldPrime { fn from(num: u32) -> Self { - let x = ToBigInt::to_bigint(&num).unwrap(); - FieldPrime { - value: &x - x.div_floor(&*P) * &*P, - } + FieldPrime { v: Fr::from(num) } } } impl From for FieldPrime { fn from(num: usize) -> Self { - let x = ToBigInt::to_bigint(&num).unwrap(); FieldPrime { - value: &x - x.div_floor(&*P) * &*P, + v: Fr::from(num as u128), } } } impl From for FieldPrime { fn from(num: u128) -> Self { - let x = ToBigInt::to_bigint(&num).unwrap(); - FieldPrime { - value: &x - x.div_floor(&*P) * &*P, - } + FieldPrime { v: Fr::from(num) } } } @@ -330,8 +331,10 @@ mod prime_field { fn try_from(value: BigUint) -> Result { match value <= Self::max_value().to_biguint() { true => { - let x = ToBigInt::to_bigint(&value).unwrap(); - Ok(FieldPrime { value: x }) + use std::str::FromStr; + Ok(FieldPrime { + v: Fr::from_str(&value.to_string()).unwrap(), + }) } false => Err(()), } @@ -340,20 +343,16 @@ mod prime_field { impl Zero for FieldPrime { fn zero() -> FieldPrime { - FieldPrime { - value: ToBigInt::to_bigint(&0).unwrap(), - } + FieldPrime { v: Fr::zero() } } fn is_zero(&self) -> bool { - self.value == ToBigInt::to_bigint(&0).unwrap() + self.v.is_zero() } } impl One for FieldPrime { fn one() -> FieldPrime { - FieldPrime { - value: ToBigInt::to_bigint(&1).unwrap(), - } + FieldPrime { v: Fr::one() } } } @@ -361,16 +360,8 @@ mod prime_field { type Output = FieldPrime; fn add(self, other: FieldPrime) -> FieldPrime { - if self.value == BigInt::zero() { - return other; - } - - if other.value == BigInt::zero() { - return self; - } - FieldPrime { - value: (self.value + other.value) % &*P, + v: self.v + other.v, } } } @@ -379,16 +370,8 @@ mod prime_field { type Output = FieldPrime; fn add(self, other: &FieldPrime) -> FieldPrime { - if self.value == BigInt::zero() { - return other.clone(); - } - - if other.value == BigInt::zero() { - return self; - } - FieldPrime { - value: (self.value + &other.value) % &*P, + v: self.v + other.v, } } } @@ -397,9 +380,8 @@ mod prime_field { type Output = FieldPrime; fn sub(self, other: FieldPrime) -> FieldPrime { - let x = self.value - other.value; FieldPrime { - value: &x - x.div_floor(&*P) * &*P, + v: self.v - other.v, } } } @@ -408,9 +390,8 @@ mod prime_field { type Output = FieldPrime; fn sub(self, other: &FieldPrime) -> FieldPrime { - let x = self.value - &other.value; FieldPrime { - value: &x - x.div_floor(&*P) * &*P, + v: self.v - other.v, } } } @@ -419,16 +400,8 @@ mod prime_field { type Output = FieldPrime; fn mul(self, other: FieldPrime) -> FieldPrime { - if self.value == BigInt::one() { - return other; - } - - if other.value == BigInt::one() { - return self; - } - FieldPrime { - value: (self.value * other.value) % &*P, + v: self.v * other.v, } } } @@ -437,23 +410,21 @@ mod prime_field { type Output = FieldPrime; fn mul(self, other: &FieldPrime) -> FieldPrime { - if self.value == BigInt::one() { - return other.clone(); - } - - if other.value == BigInt::one() { - return self; - } - FieldPrime { - value: (self.value * &other.value) % &*P, + v: self.v * other.v, } } } impl CheckedDiv for FieldPrime { fn checked_div(&self, other: &FieldPrime) -> Option { - other.inverse_mul().map(|inv| inv * self) + if other.v == Fr::zero() { + None + } else { + Some(FieldPrime { + v: self.v / other.v, + }) + } } } @@ -477,11 +448,9 @@ mod prime_field { type Output = FieldPrime; fn pow(self, exp: usize) -> FieldPrime { - let mut res = FieldPrime::from(1); - for _ in 0..exp { - res = res * &self; + FieldPrime { + v: self.v.pow(&[exp as u64]), } - res } } @@ -492,12 +461,21 @@ mod prime_field { assert!(self <= &bound); assert!(other <= &bound); - let big_res = &self.value + &other.value; + let mut big_res = self.v.into_repr(); - if big_res > bound.value { + use ark_ff::BigInteger; + let carry = big_res.add_nocarry(&other.v.into_repr()); + + if carry { + return None; + } + + if big_res > bound.v.into_repr() { None } else { - Some(FieldPrime { value: big_res }) + Some(FieldPrime { + v: Fr::from(big_res), + }) } } } @@ -509,40 +487,84 @@ mod prime_field { assert!(self <= &bound); assert!(other <= &bound); - let big_res = &self.value * &other.value; + let left = self.to_biguint(); + let right = other.to_biguint(); + + let big_res = left * right; // we only go up to 2**(bitwidth - 1) because after that we lose uniqueness of bit decomposition - if big_res > bound.value { + if big_res > bound.to_biguint() { None } else { - Some(FieldPrime { value: big_res }) + Some(self.clone() * other) } } } - /// Calculates the gcd using an iterative implementation of the extended euclidian algorithm. - /// Returning `(d, s, t)` so that `d = s * a + t * b` - /// - /// # Arguments - /// * `a` - First number as `BigInt` - /// * `b` - Second number as `BigInt` - fn extended_euclid(a: &BigInt, b: &BigInt) -> (BigInt, BigInt, BigInt) { - let (mut s, mut old_s) = (BigInt::zero(), BigInt::one()); - let (mut t, mut old_t) = (BigInt::one(), BigInt::zero()); - let (mut r, mut old_r) = (b.clone(), a.clone()); - while !&r.is_zero() { - let quotient = &old_r / &r; - let tmp_r = old_r.clone(); - old_r = r.clone(); - r = &tmp_r - "ient * &r; - let tmp_s = old_s.clone(); - old_s = s.clone(); - s = &tmp_s - "ient * &s; - let tmp_t = old_t.clone(); - old_t = t.clone(); - t = &tmp_t - "ient * &t; + impl Serialize for FieldPrime { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + use ark_serialize::CanonicalSerialize; + use serde::ser::Error; + let mut data: Vec = vec![]; + self.v + .serialize(&mut data) + .map_err(|e| S::Error::custom(e.to_string()))?; + serializer.serialize_bytes(&data) + } + } + + struct FieldVisitor; + + use serde::de::SeqAccess; + + impl<'de> Visitor<'de> for FieldVisitor { + type Value = FieldPrime; + + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.write_str("an ark field element") + } + + fn visit_bytes(self, value: &[u8]) -> Result + where + E: de::Error, + { + use ark_serialize::CanonicalDeserialize; + let value: Fr = Fr::deserialize(value).map_err(|e| E::custom(e.to_string()))?; + + Ok(FieldPrime { v: value }) + } + + fn visit_byte_buf(self, value: Vec) -> Result + where + E: de::Error, + { + self.visit_bytes(&value[..]) + } + + fn visit_seq(self, value: A) -> Result + where + A: SeqAccess<'de>, + { + let mut value = value; + let mut elements = vec![]; + while let Some(v) = value.next_element()? { + elements.push(v); + } + + self.visit_bytes(&elements[..]) + } + } + + impl<'de> Deserialize<'de> for FieldPrime { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + deserializer.deserialize_bytes(FieldVisitor) } - return (old_r, old_s, old_t); } }; } From 1f391e9f119f10140d35e5b7a5ea1ee4c560f66e Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 3 Dec 2021 12:03:43 +0100 Subject: [PATCH 2/9] add tests, clean --- zokrates_core/src/ir/expression.rs | 4 ++- zokrates_field/src/bn128.rs | 28 +++++++++++++++++++++ zokrates_field/src/lib.rs | 40 ++++++++++++++---------------- 3 files changed, 50 insertions(+), 22 deletions(-) diff --git a/zokrates_core/src/ir/expression.rs b/zokrates_core/src/ir/expression.rs index 77069a4d..57ec2753 100644 --- a/zokrates_core/src/ir/expression.rs +++ b/zokrates_core/src/ir/expression.rs @@ -259,8 +259,10 @@ impl Mul<&T> for LinComb { impl Div<&T> for LinComb { type Output = LinComb; + // Clippy warns about multiplication in a method named div. It's okay, here, since we multiply with the inverse. + #[allow(clippy::suspicious_arithmetic_impl)] fn div(self, scalar: &T) -> LinComb { - self * &T::one().div(scalar) + self * &scalar.inverse_mul().unwrap() } } diff --git a/zokrates_field/src/bn128.rs b/zokrates_field/src/bn128.rs index 54c08a7a..468424f5 100644 --- a/zokrates_field/src/bn128.rs +++ b/zokrates_field/src/bn128.rs @@ -201,6 +201,31 @@ mod tests { ); } + #[test] + fn bits() { + assert_eq!(FieldPrime::from(0).bits(), 1); + assert_eq!(FieldPrime::from(1).bits(), 1); + assert_eq!(FieldPrime::from(2).bits(), 2); + assert_eq!(FieldPrime::from(3).bits(), 2); + assert_eq!(FieldPrime::from(4).bits(), 3); + } + + #[test] + fn to_biguint() { + assert_eq!( + FieldPrime::try_from(FieldPrime::from(2).to_biguint()), + Ok(FieldPrime::from(2)) + ); + assert_eq!( + FieldPrime::try_from(FieldPrime::from(0).to_biguint()), + Ok(FieldPrime::from(0)) + ); + assert_eq!( + FieldPrime::try_from(FieldPrime::max_value().to_biguint()), + Ok(FieldPrime::max_value()) + ); + } + #[test] fn division_negative() { let res = FieldPrime::from(-54) / FieldPrime::from(12); @@ -239,7 +264,9 @@ 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)); } @@ -276,6 +303,7 @@ 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!( diff --git a/zokrates_field/src/lib.rs b/zokrates_field/src/lib.rs index 3bdd40eb..90d3a8d6 100644 --- a/zokrates_field/src/lib.rs +++ b/zokrates_field/src/lib.rs @@ -93,7 +93,7 @@ pub trait Field: /// Returns this `Field`'s contents as decimal string fn to_dec_string(&self) -> String; /// Returns the multiplicative inverse, i.e.: self * self.inverse_mul() = Self::one() - //fn inverse_mul(&self) -> Option; + fn inverse_mul(&self) -> Option; /// Returns the smallest value that can be represented by this field type. fn min_value() -> Self; /// Returns the largest value that can be represented by this field type. @@ -190,7 +190,7 @@ mod prime_field { break; } } - size as u32 + std::cmp::max(size as u32, 1) } fn to_biguint(&self) -> BigUint { @@ -200,7 +200,7 @@ mod prime_field { fn to_byte_vector(&self) -> Vec { use ark_ff::BigInteger; - self.v.into_repr().to_bytes_be() + self.v.into_repr().to_bytes_le() } fn from_byte_vector(bytes: Vec) -> Self { @@ -215,6 +215,13 @@ mod prime_field { self.to_string() } + fn inverse_mul(&self) -> Option { + use ark_ff::Field; + Some(FieldPrime { + v: self.v.inverse()?, + }) + } + fn min_value() -> FieldPrime { FieldPrime { v: Fr::from(0u32) } } @@ -239,13 +246,9 @@ mod prime_field { v: Fr::from_str(s).map_err(|_| FieldParseError)?, }) } - fn try_from_str(_: &str, _: u32) -> Result { - unimplemented!("try from str") - // let x = BigInt::parse_bytes(s.as_bytes(), radix).ok_or(FieldParseError)?; - // Ok(FieldPrime { - // value: &x - x.div_floor(&*P) * &*P, - // v: field_new!() - // }) + fn try_from_str(s: &str, radix: u32) -> Result { + let x = BigUint::parse_bytes(s.as_bytes(), radix).ok_or(FieldParseError)?; + FieldPrime::try_from(x).map_err(|_| FieldParseError) } fn to_compact_dec_string(&self) -> String { //values up to (p-1)/2 included are represented as positive, values between (p+1)/2 and p-1 as represented as negative by subtracting p @@ -461,21 +464,16 @@ mod prime_field { assert!(self <= &bound); assert!(other <= &bound); - let mut big_res = self.v.into_repr(); + let left = self.to_biguint(); + let right = other.to_biguint(); - use ark_ff::BigInteger; - let carry = big_res.add_nocarry(&other.v.into_repr()); + let big_res = left + right; - if carry { - return None; - } - - if big_res > bound.v.into_repr() { + // we only go up to 2**(bitwidth - 1) because after that we lose uniqueness of bit decomposition + if big_res > bound.to_biguint() { None } else { - Some(FieldPrime { - v: Fr::from(big_res), - }) + Some(self.clone() * other) } } } From 7a552ea4d2f0129fceb8091c66c11c895517e612 Mon Sep 17 00:00:00 2001 From: schaeff Date: Mon, 6 Dec 2021 15:11:00 +0100 Subject: [PATCH 3/9] fix features, fix checked mul --- zokrates_field/Cargo.toml | 14 +++++++------- zokrates_field/src/lib.rs | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/zokrates_field/Cargo.toml b/zokrates_field/Cargo.toml index 7c26729b..63c21c05 100644 --- a/zokrates_field/Cargo.toml +++ b/zokrates_field/Cargo.toml @@ -6,7 +6,7 @@ edition = "2018" [features] default = ["ark", "bellman"] -ark = ["ark-ff", "ark-ec", "ark-bn254", "ark-bls12-381", "ark-bls12-377", "ark-bw6-761", "ark-serialize"] +ark = ["ark-ec"] bellman = ["bellman_ce"] [dependencies] @@ -18,18 +18,18 @@ serde_json = "1.0" sha2 = "0.8.0" num-traits = { version = "0.2", default-features = false } num-integer = { version = "0.1", default-features = false } +ark-ff = { version = "^0.2.0", default-features = false } +ark-bn254 = { version = "^0.2.0", features = ["curve"], default-features = false } +ark-bls12-377 = { version = "^0.2.0", features = ["curve"], default-features = false } +ark-bls12-381 = { version = "^0.2.0", features = ["curve"], default-features = false } +ark-bw6-761 = { version = "^0.2.0", default-features = false } +ark-serialize = { version = "^0.2.0", default-features = false } # bellman bellman_ce = { version = "^0.3", default-features = false, optional = true } # ark -ark-ff = { version = "^0.2.0", default-features = false, optional = true } ark-ec = { version = "^0.2.0", default-features = false, optional = true } -ark-bn254 = { version = "^0.2.0", features = ["curve"], default-features = false, optional = true } -ark-bls12-377 = { version = "^0.2.0", features = ["curve"], default-features = false, optional = true } -ark-bls12-381 = { version = "^0.2.0", features = ["curve"], default-features = false, optional = true } -ark-bw6-761 = { version = "^0.2.0", default-features = false, optional = true } -ark-serialize = { version = "^0.2.0", default-features = false, optional = true } [dev-dependencies] rand = "0.4" diff --git a/zokrates_field/src/lib.rs b/zokrates_field/src/lib.rs index 90d3a8d6..b66d7ffb 100644 --- a/zokrates_field/src/lib.rs +++ b/zokrates_field/src/lib.rs @@ -473,7 +473,7 @@ mod prime_field { if big_res > bound.to_biguint() { None } else { - Some(self.clone() * other) + Some(self.clone() + other) } } } From 2dbb4b7a9c71dab5068d9fc61e0a0b9a2b5d6673 Mon Sep 17 00:00:00 2001 From: schaeff Date: Mon, 6 Dec 2021 15:35:48 +0100 Subject: [PATCH 4/9] update lock in zjs --- zokrates_js/Cargo.lock | 39 ++++++++++++++++++++++++++++++++++----- zokrates_js/Cargo.toml | 2 +- 2 files changed, 35 insertions(+), 6 deletions(-) diff --git a/zokrates_js/Cargo.lock b/zokrates_js/Cargo.lock index adbe48e4..5a8e6312 100644 --- a/zokrates_js/Cargo.lock +++ b/zokrates_js/Cargo.lock @@ -49,6 +49,28 @@ dependencies = [ "ark-std", ] +[[package]] +name = "ark-bls12-381" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70e1c2ad76c4f725520440b981df3ce2d635f2baa1122750c757c0cf0f3d4b74" +dependencies = [ + "ark-ec", + "ark-ff", + "ark-std", +] + +[[package]] +name = "ark-bn254" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ead066869de5e8cb2938123204d1572f09496b629e146a6f80fa8ec508446ba" +dependencies = [ + "ark-ec", + "ark-ff", + "ark-std", +] + [[package]] name = "ark-bw6-761" version = "0.2.0" @@ -1555,7 +1577,7 @@ version = "0.1.0" [[package]] name = "zokrates_core" -version = "0.6.7" +version = "0.6.8" dependencies = [ "bellman_ce", "bincode", @@ -1584,7 +1606,7 @@ dependencies = [ [[package]] name = "zokrates_embed" -version = "0.1.4" +version = "0.1.5" dependencies = [ "ark-bls12-377", "ark-bw6-761", @@ -1604,6 +1626,13 @@ dependencies = [ name = "zokrates_field" version = "0.4.0" dependencies = [ + "ark-bls12-377", + "ark-bls12-381", + "ark-bn254", + "ark-bw6-761", + "ark-ec", + "ark-ff", + "ark-serialize", "bellman_ce", "bincode", "lazy_static", @@ -1618,7 +1647,7 @@ dependencies = [ [[package]] name = "zokrates_js" -version = "1.0.36" +version = "1.0.37" dependencies = [ "console_error_panic_hook", "js-sys", @@ -1633,7 +1662,7 @@ dependencies = [ [[package]] name = "zokrates_parser" -version = "0.2.4" +version = "0.2.5" dependencies = [ "pest", "pest_derive", @@ -1641,7 +1670,7 @@ dependencies = [ [[package]] name = "zokrates_pest_ast" -version = "0.2.3" +version = "0.2.4" dependencies = [ "from-pest", "lazy_static", diff --git a/zokrates_js/Cargo.toml b/zokrates_js/Cargo.toml index 0b29f4a2..7d0a9541 100644 --- a/zokrates_js/Cargo.toml +++ b/zokrates_js/Cargo.toml @@ -14,6 +14,6 @@ serde_json = "1.0" wasm-bindgen = { version = "0.2.46", features = ["serde-serialize"] } zokrates_core = { path = "../zokrates_core", features = ["wasm", "bellman"], default-features = false } zokrates_common = { path = "../zokrates_common" } -zokrates_field = { path = "../zokrates_field", default-features = false, features = ["bellman"] } +zokrates_field = { path = "../zokrates_field", features = ["bellman"] } zokrates_abi = { path = "../zokrates_abi" } console_error_panic_hook = "0.1.6" \ No newline at end of file From 53876eb2154b4bbef33aa6784ce08ab3bface70e Mon Sep 17 00:00:00 2001 From: schaeff Date: Mon, 6 Dec 2021 15:37:55 +0100 Subject: [PATCH 5/9] changelog --- changelogs/unreleased/1061-schaeff | 1 + 1 file changed, 1 insertion(+) create mode 100644 changelogs/unreleased/1061-schaeff diff --git a/changelogs/unreleased/1061-schaeff b/changelogs/unreleased/1061-schaeff new file mode 100644 index 00000000..34578f62 --- /dev/null +++ b/changelogs/unreleased/1061-schaeff @@ -0,0 +1 @@ +Use ark-ff under the hood for optimized field operations \ No newline at end of file From 9e4050f09135182ed94e01829a4fd13ba14cbf53 Mon Sep 17 00:00:00 2001 From: schaeff Date: Mon, 6 Dec 2021 17:46:05 +0100 Subject: [PATCH 6/9] remove ark feature, fix errors --- zokrates_core/Cargo.toml | 2 +- zokrates_field/Cargo.toml | 15 +++++++-------- zokrates_field/src/bls12_377.rs | 1 - zokrates_field/src/bn128.rs | 4 ++-- zokrates_field/src/bw6_761.rs | 1 - zokrates_field/src/lib.rs | 16 +++------------- 6 files changed, 13 insertions(+), 26 deletions(-) diff --git a/zokrates_core/Cargo.toml b/zokrates_core/Cargo.toml index d78d1ecd..fd0b2a8f 100644 --- a/zokrates_core/Cargo.toml +++ b/zokrates_core/Cargo.toml @@ -13,7 +13,7 @@ libsnark = ["cc", "cmake", "git2"] bellman = ["bellman_ce", "pairing_ce", "ff_ce", "zokrates_field/bellman"] wasm = ["bellman_ce/nolog", "bellman_ce/wasm"] multicore = ["bellman_ce/multicore"] -ark = ["ark-ff", "ark-ec", "ark-bn254", "ark-bls12-377", "ark-bw6-761", "ark-gm17", "ark-serialize", "ark-relations", "ark-marlin", "ark-poly", "ark-poly-commit", "zokrates_field/ark", "sha2"] +ark = ["ark-ff", "ark-ec", "ark-bn254", "ark-bls12-377", "ark-bw6-761", "ark-gm17", "ark-serialize", "ark-relations", "ark-marlin", "ark-poly", "ark-poly-commit", "sha2"] [dependencies] log = "0.4" diff --git a/zokrates_field/Cargo.toml b/zokrates_field/Cargo.toml index 63c21c05..71435ff0 100644 --- a/zokrates_field/Cargo.toml +++ b/zokrates_field/Cargo.toml @@ -5,8 +5,7 @@ authors = ["Thibaut Schaeffer ", "Guillaume Ballet ::Fqe; } -#[cfg(feature = "ark")] pub trait ArkFieldExtensions { /// An associated type to be able to operate with ark ff traits - type ArkEngine: PairingEngine; + type ArkEngine: ark_ec::PairingEngine; fn from_ark(e: ::Fr) -> Self; fn into_ark(self) -> ::Fr; @@ -602,7 +598,6 @@ mod prime_field { }; } - #[cfg(feature = "ark")] macro_rules! ark_extensions { ($ark_type:ty) => { use crate::ArkFieldExtensions; @@ -611,16 +606,11 @@ mod prime_field { type ArkEngine = $ark_type; fn from_ark(e: ::Fr) -> Self { - use ark_ff::{BigInteger, PrimeField}; - let mut res: Vec = vec![]; - e.into_repr().write_le(&mut res).unwrap(); - Self::from_byte_vector(res) + Self { v: e } } fn into_ark(self) -> ::Fr { - use core::str::FromStr; - let s = self.to_dec_string(); - ::Fr::from_str(&s).unwrap() + self.v } } }; From 6e0fb3cb0bb419a58f73b4725267c05821dbfe42 Mon Sep 17 00:00:00 2001 From: schaeff Date: Mon, 6 Dec 2021 19:54:11 +0100 Subject: [PATCH 7/9] fix test --- .../tests/tests/hashes/mimcSponge/mimcFeistel.json | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcFeistel.json b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcFeistel.json index 6c6f7c65..a362cf0f 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcFeistel.json +++ b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcFeistel.json @@ -24,18 +24,6 @@ ] } } - }, - { - "input": { - "values": ["21888242871839275222246405745257275088548364400416034343698204186575808495617", "0", "0"] - }, - "output": { - "Ok": { - "values": [ - "14543742788565021628577424853847564376151732847602780516906950225481254681152", "21165881269406212375659499083070944693027168220143204011932538650149052385959" - ] - } - } } ] } From eef0cd95ae37c5b0f4ec4d41a3bdff84950905c3 Mon Sep 17 00:00:00 2001 From: schaeff Date: Tue, 7 Dec 2021 12:03:01 +0100 Subject: [PATCH 8/9] simplify field trait, remove redundant modulus, add tests, implement ark for all curves --- zokrates_field/src/bls12_377.rs | 8 ++------ zokrates_field/src/bls12_381.rs | 8 +++----- zokrates_field/src/bn128.rs | 33 ++++++--------------------------- zokrates_field/src/bw6_761.rs | 6 +----- zokrates_field/src/lib.rs | 16 +++++++--------- 5 files changed, 19 insertions(+), 52 deletions(-) diff --git a/zokrates_field/src/bls12_377.rs b/zokrates_field/src/bls12_377.rs index ac5291ed..66e297dc 100644 --- a/zokrates_field/src/bls12_377.rs +++ b/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); diff --git a/zokrates_field/src/bls12_381.rs b/zokrates_field/src/bls12_381.rs index e76dbc0b..81275843 100644 --- a/zokrates_field/src/bls12_381.rs +++ b/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}; diff --git a/zokrates_field/src/bn128.rs b/zokrates_field/src/bn128.rs index ca025e6b..1af60009 100644 --- a/zokrates_field/src/bn128.rs +++ b/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::().unwrap(), - "3".parse::() - .unwrap() - .div_floor(&"2".parse::().unwrap()) - ); - assert_eq!( - "-2".parse::().unwrap(), - "-3".parse::() - .unwrap() - .div_floor(&"2".parse::().unwrap()) - ); - } - #[cfg(feature = "bellman")] mod bellman { use super::*; diff --git a/zokrates_field/src/bw6_761.rs b/zokrates_field/src/bw6_761.rs index c754e8cc..82a90600 100644 --- a/zokrates_field/src/bw6_761.rs +++ b/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); diff --git a/zokrates_field/src/lib.rs b/zokrates_field/src/lib.rs index fe0fd7c6..dd421a5c 100644 --- a/zokrates_field/src/lib.rs +++ b/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; + ::Params::MODULUS_BITS as usize } fn try_from_dec_str(s: &str) -> Result { 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(&::Params::MODULUS.to_bytes_le()); for i in 0..4 { res[i] = hash[i]; } From 4c8ff7d0f618f787b0b9ae7df44b13783f902e9a Mon Sep 17 00:00:00 2001 From: schaeff Date: Tue, 7 Dec 2021 12:14:23 +0100 Subject: [PATCH 9/9] clean --- zokrates_field/src/bn128.rs | 16 ---------------- zokrates_field/src/lib.rs | 13 +++++-------- 2 files changed, 5 insertions(+), 24 deletions(-) diff --git a/zokrates_field/src/bn128.rs b/zokrates_field/src/bn128.rs index 1af60009..ddb5c4ea 100644 --- a/zokrates_field/src/bn128.rs +++ b/zokrates_field/src/bn128.rs @@ -33,22 +33,6 @@ mod tests { ); } - // #[test] - // fn positive_number() { - // assert_eq!( - // "1234245612".parse::().unwrap(), - // FieldPrime::from("1234245612").value - // ); - // } - - // #[test] - // fn negative_number() { - // assert_eq!( - // P.checked_sub(&"12".parse::().unwrap()).unwrap(), - // FieldPrime::from("-12").value - // ); - // } - #[test] fn addition() { assert_eq!( diff --git a/zokrates_field/src/lib.rs b/zokrates_field/src/lib.rs index dd421a5c..0240c7c5 100644 --- a/zokrates_field/src/lib.rs +++ b/zokrates_field/src/lib.rs @@ -214,17 +214,14 @@ mod prime_field { } fn min_value() -> FieldPrime { - FieldPrime { v: Fr::from(0u32) } + FieldPrime { v: Fr::zero() } } fn max_value() -> FieldPrime { - FieldPrime { - v: Fr::from(0u32) - Fr::from(1u32), - } + FieldPrime { v: -Fr::one() } } fn max_unique_value() -> FieldPrime { FieldPrime { - v: Fr::from(2u32).pow([Self::get_required_bits() as u64 - 1]) - - Fr::from(1u32), + v: Fr::from(2u32).pow([Self::get_required_bits() as u64 - 1]) - Fr::one(), } } fn get_required_bits() -> usize { @@ -272,7 +269,7 @@ mod prime_field { impl Default for FieldPrime { fn default() -> Self { - FieldPrime { v: Fr::from(0u32) } + FieldPrime { v: Fr::zero() } } } @@ -292,7 +289,7 @@ mod prime_field { fn from(num: i32) -> Self { if num < 0 { FieldPrime { - v: Fr::zero() - Fr::from((-num) as u32), + v: -Fr::from((-num) as u32), } } else { FieldPrime {