Qortal/pirate-librustzcash
3
0
Fork 0
mirror of https://github.com/Qortal/pirate-librustzcash.git synced 2025-02-12 10:05:47 +00:00
Code Issues Projects Releases Wiki Activity

Use ff:ScalarEngine instead of pairing::Engine in bellman core

Browse Source
This commit is contained in:
Jack Grigg 2018-07-06 21:37:18 +01:00
parent 3e8f2f8202
commit 276e09f1fb
No known key found for this signature in database
GPG Key ID: 1B8D649257DB0829
2 changed files with 31 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/domain.rs
View File

@ -12,7 +12,6 @@
use ff::{Field, PrimeField, ScalarEngine}; use ff::{Field, PrimeField, ScalarEngine};
use group::CurveProjective; use group::CurveProjective;
use pairing::Engine;
use super::{ use super::{
SynthesisError SynthesisError
@ -20,7 +19,7 @@ use super::{
use super::multicore::Worker; use super::multicore::Worker;
pub struct EvaluationDomain<E: Engine, G: Group<E>> { pub struct EvaluationDomain<E: ScalarEngine, G: Group<E>> {
coeffs: Vec<G>, coeffs: Vec<G>,
exp: u32, exp: u32,
omega: E::Fr, omega: E::Fr,
@ -29,7 +28,7 @@ pub struct EvaluationDomain<E: Engine, G: Group<E>> {
minv: E::Fr minv: E::Fr
} }
impl<E: Engine, G: Group<E>> EvaluationDomain<E, G> { impl<E: ScalarEngine, G: Group<E>> EvaluationDomain<E, G> {
pub fn as_ref(&self) -> &[G] { pub fn as_ref(&self) -> &[G] {
&self.coeffs &self.coeffs
} }
@ -224,23 +223,23 @@ impl<G: CurveProjective> Group<G::Engine> for Point<G> {
} }
} }
pub struct Scalar<E: Engine>(pub E::Fr); pub struct Scalar<E: ScalarEngine>(pub E::Fr);
impl<E: Engine> PartialEq for Scalar<E> { impl<E: ScalarEngine> PartialEq for Scalar<E> {
fn eq(&self, other: &Scalar<E>) -> bool { fn eq(&self, other: &Scalar<E>) -> bool {
self.0 == other.0 self.0 == other.0
} }
} }
impl<E: Engine> Copy for Scalar<E> { } impl<E: ScalarEngine> Copy for Scalar<E> { }
impl<E: Engine> Clone for Scalar<E> { impl<E: ScalarEngine> Clone for Scalar<E> {
fn clone(&self) -> Scalar<E> { fn clone(&self) -> Scalar<E> {
*self *self
} }
} }
impl<E: Engine> Group<E> for Scalar<E> { impl<E: ScalarEngine> Group<E> for Scalar<E> {
fn group_zero() -> Self { fn group_zero() -> Self {
Scalar(E::Fr::zero()) Scalar(E::Fr::zero())
} }
@ -255,7 +254,7 @@ impl<E: Engine> Group<E> for Scalar<E> {
} }
} }
fn best_fft<E: Engine, T: Group<E>>(a: &mut [T], worker: &Worker, omega: &E::Fr, log_n: u32) fn best_fft<E: ScalarEngine, T: Group<E>>(a: &mut [T], worker: &Worker, omega: &E::Fr, log_n: u32)
{ {
let log_cpus = worker.log_num_cpus(); let log_cpus = worker.log_num_cpus();
@ -266,7 +265,7 @@ fn best_fft<E: Engine, T: Group<E>>(a: &mut [T], worker: &Worker, omega: &E::Fr,
} }
} }
fn serial_fft<E: Engine, T: Group<E>>(a: &mut [T], omega: &E::Fr, log_n: u32) fn serial_fft<E: ScalarEngine, T: Group<E>>(a: &mut [T], omega: &E::Fr, log_n: u32)
{ {
fn bitreverse(mut n: u32, l: u32) -> u32 { fn bitreverse(mut n: u32, l: u32) -> u32 {
let mut r = 0; let mut r = 0;
@ -311,7 +310,7 @@ fn serial_fft<E: Engine, T: Group<E>>(a: &mut [T], omega: &E::Fr, log_n: u32)
} }
} }
fn parallel_fft<E: Engine, T: Group<E>>( fn parallel_fft<E: ScalarEngine, T: Group<E>>(
a: &mut [T], a: &mut [T],
worker: &Worker, worker: &Worker,
omega: &E::Fr, omega: &E::Fr,
@ -377,7 +376,7 @@ fn polynomial_arith() {
use pairing::bls12_381::Bls12; use pairing::bls12_381::Bls12;
use rand::{self, Rand}; use rand::{self, Rand};
fn test_mul<E: Engine, R: rand::Rng>(rng: &mut R) fn test_mul<E: ScalarEngine, R: rand::Rng>(rng: &mut R)
{ {
let worker = Worker::new(); let worker = Worker::new();
@ -424,7 +423,7 @@ fn fft_composition() {
use pairing::bls12_381::Bls12; use pairing::bls12_381::Bls12;
use rand; use rand;
fn test_comp<E: Engine, R: rand::Rng>(rng: &mut R) fn test_comp<E: ScalarEngine, R: rand::Rng>(rng: &mut R)
{ {
let worker = Worker::new(); let worker = Worker::new();
@ -463,7 +462,7 @@ fn parallel_fft_consistency() {
use rand::{self, Rand}; use rand::{self, Rand};
use std::cmp::min; use std::cmp::min;
fn test_consistency<E: Engine, R: rand::Rng>(rng: &mut R) fn test_consistency<E: ScalarEngine, R: rand::Rng>(rng: &mut R)
{ {
let worker = Worker::new(); let worker = Worker::new();

37
src/lib.rs
View File

@ -14,8 +14,7 @@ mod multiexp;
pub mod domain; pub mod domain;
pub mod groth16; pub mod groth16;
use ff::Field; use ff::{Field, ScalarEngine};
use pairing::Engine;
use std::ops::{Add, Sub}; use std::ops::{Add, Sub};
use std::fmt; use std::fmt;
@ -27,7 +26,7 @@ use std::marker::PhantomData;
/// rank-1 quadratic constraint systems. The `Circuit` trait represents a /// rank-1 quadratic constraint systems. The `Circuit` trait represents a
/// circuit that can be synthesized. The `synthesize` method is called during /// circuit that can be synthesized. The `synthesize` method is called during
/// CRS generation and during proving. /// CRS generation and during proving.
pub trait Circuit<E: Engine> { pub trait Circuit<E: ScalarEngine> {
/// Synthesize the circuit into a rank-1 quadratic constraint system /// Synthesize the circuit into a rank-1 quadratic constraint system
fn synthesize<CS: ConstraintSystem<E>>( fn synthesize<CS: ConstraintSystem<E>>(
self, self,
@ -64,21 +63,21 @@ pub enum Index {
/// This represents a linear combination of some variables, with coefficients /// This represents a linear combination of some variables, with coefficients
/// in the scalar field of a pairing-friendly elliptic curve group. /// in the scalar field of a pairing-friendly elliptic curve group.
#[derive(Clone)] #[derive(Clone)]
pub struct LinearCombination<E: Engine>(Vec<(Variable, E::Fr)>); pub struct LinearCombination<E: ScalarEngine>(Vec<(Variable, E::Fr)>);
impl<E: Engine> AsRef<[(Variable, E::Fr)]> for LinearCombination<E> { impl<E: ScalarEngine> AsRef<[(Variable, E::Fr)]> for LinearCombination<E> {
fn as_ref(&self) -> &[(Variable, E::Fr)] { fn as_ref(&self) -> &[(Variable, E::Fr)] {
&self.0 &self.0
} }
} }
impl<E: Engine> LinearCombination<E> { impl<E: ScalarEngine> LinearCombination<E> {
pub fn zero() -> LinearCombination<E> { pub fn zero() -> LinearCombination<E> {
LinearCombination(vec![]) LinearCombination(vec![])
} }
} }
impl<E: Engine> Add<(E::Fr, Variable)> for LinearCombination<E> { impl<E: ScalarEngine> Add<(E::Fr, Variable)> for LinearCombination<E> {
type Output = LinearCombination<E>; type Output = LinearCombination<E>;
fn add(mut self, (coeff, var): (E::Fr, Variable)) -> LinearCombination<E> { fn add(mut self, (coeff, var): (E::Fr, Variable)) -> LinearCombination<E> {
@ -88,7 +87,7 @@ impl<E: Engine> Add<(E::Fr, Variable)> for LinearCombination<E> {
} }
} }
impl<E: Engine> Sub<(E::Fr, Variable)> for LinearCombination<E> { impl<E: ScalarEngine> Sub<(E::Fr, Variable)> for LinearCombination<E> {
type Output = LinearCombination<E>; type Output = LinearCombination<E>;
fn sub(self, (mut coeff, var): (E::Fr, Variable)) -> LinearCombination<E> { fn sub(self, (mut coeff, var): (E::Fr, Variable)) -> LinearCombination<E> {
@ -98,7 +97,7 @@ impl<E: Engine> Sub<(E::Fr, Variable)> for LinearCombination<E> {
} }
} }
impl<E: Engine> Add<Variable> for LinearCombination<E> { impl<E: ScalarEngine> Add<Variable> for LinearCombination<E> {
type Output = LinearCombination<E>; type Output = LinearCombination<E>;
fn add(self, other: Variable) -> LinearCombination<E> { fn add(self, other: Variable) -> LinearCombination<E> {
@ -106,7 +105,7 @@ impl<E: Engine> Add<Variable> for LinearCombination<E> {
} }
} }
impl<E: Engine> Sub<Variable> for LinearCombination<E> { impl<E: ScalarEngine> Sub<Variable> for LinearCombination<E> {
type Output = LinearCombination<E>; type Output = LinearCombination<E>;
fn sub(self, other: Variable) -> LinearCombination<E> { fn sub(self, other: Variable) -> LinearCombination<E> {
@ -114,7 +113,7 @@ impl<E: Engine> Sub<Variable> for LinearCombination<E> {
} }
} }
impl<'a, E: Engine> Add<&'a LinearCombination<E>> for LinearCombination<E> { impl<'a, E: ScalarEngine> Add<&'a LinearCombination<E>> for LinearCombination<E> {
type Output = LinearCombination<E>; type Output = LinearCombination<E>;
fn add(mut self, other: &'a LinearCombination<E>) -> LinearCombination<E> { fn add(mut self, other: &'a LinearCombination<E>) -> LinearCombination<E> {
@ -126,7 +125,7 @@ impl<'a, E: Engine> Add<&'a LinearCombination<E>> for LinearCombination<E> {
} }
} }
impl<'a, E: Engine> Sub<&'a LinearCombination<E>> for LinearCombination<E> { impl<'a, E: ScalarEngine> Sub<&'a LinearCombination<E>> for LinearCombination<E> {
type Output = LinearCombination<E>; type Output = LinearCombination<E>;
fn sub(mut self, other: &'a LinearCombination<E>) -> LinearCombination<E> { fn sub(mut self, other: &'a LinearCombination<E>) -> LinearCombination<E> {
@ -138,7 +137,7 @@ impl<'a, E: Engine> Sub<&'a LinearCombination<E>> for LinearCombination<E> {
} }
} }
impl<'a, E: Engine> Add<(E::Fr, &'a LinearCombination<E>)> for LinearCombination<E> { impl<'a, E: ScalarEngine> Add<(E::Fr, &'a LinearCombination<E>)> for LinearCombination<E> {
type Output = LinearCombination<E>; type Output = LinearCombination<E>;
fn add(mut self, (coeff, other): (E::Fr, &'a LinearCombination<E>)) -> LinearCombination<E> { fn add(mut self, (coeff, other): (E::Fr, &'a LinearCombination<E>)) -> LinearCombination<E> {
@ -152,7 +151,7 @@ impl<'a, E: Engine> Add<(E::Fr, &'a LinearCombination<E>)> for LinearCombination
} }
} }
impl<'a, E: Engine> Sub<(E::Fr, &'a LinearCombination<E>)> for LinearCombination<E> { impl<'a, E: ScalarEngine> Sub<(E::Fr, &'a LinearCombination<E>)> for LinearCombination<E> {
type Output = LinearCombination<E>; type Output = LinearCombination<E>;
fn sub(mut self, (coeff, other): (E::Fr, &'a LinearCombination<E>)) -> LinearCombination<E> { fn sub(mut self, (coeff, other): (E::Fr, &'a LinearCombination<E>)) -> LinearCombination<E> {
@ -222,7 +221,7 @@ impl fmt::Display for SynthesisError {
/// Represents a constraint system which can have new variables /// Represents a constraint system which can have new variables
/// allocated and constrains between them formed. /// allocated and constrains between them formed.
pub trait ConstraintSystem<E: Engine>: Sized { pub trait ConstraintSystem<E: ScalarEngine>: Sized {
/// Represents the type of the "root" of this constraint system /// Represents the type of the "root" of this constraint system
/// so that nested namespaces can minimize indirection. /// so that nested namespaces can minimize indirection.
type Root: ConstraintSystem<E>; type Root: ConstraintSystem<E>;
@ -294,9 +293,9 @@ pub trait ConstraintSystem<E: Engine>: Sized {
/// This is a "namespaced" constraint system which borrows a constraint system (pushing /// This is a "namespaced" constraint system which borrows a constraint system (pushing
/// a namespace context) and, when dropped, pops out of the namespace context. /// a namespace context) and, when dropped, pops out of the namespace context.
pub struct Namespace<'a, E: Engine, CS: ConstraintSystem<E> + 'a>(&'a mut CS, PhantomData<E>); pub struct Namespace<'a, E: ScalarEngine, CS: ConstraintSystem<E> + 'a>(&'a mut CS, PhantomData<E>);
impl<'cs, E: Engine, CS: ConstraintSystem<E>> ConstraintSystem<E> for Namespace<'cs, E, CS> { impl<'cs, E: ScalarEngine, CS: ConstraintSystem<E>> ConstraintSystem<E> for Namespace<'cs, E, CS> {
type Root = CS::Root; type Root = CS::Root;
fn one() -> Variable { fn one() -> Variable {
@ -359,7 +358,7 @@ impl<'cs, E: Engine, CS: ConstraintSystem<E>> ConstraintSystem<E> for Namespace<
} }
} }
impl<'a, E: Engine, CS: ConstraintSystem<E>> Drop for Namespace<'a, E, CS> { impl<'a, E: ScalarEngine, CS: ConstraintSystem<E>> Drop for Namespace<'a, E, CS> {
fn drop(&mut self) { fn drop(&mut self) {
self.get_root().pop_namespace() self.get_root().pop_namespace()
} }
@ -367,7 +366,7 @@ impl<'a, E: Engine, CS: ConstraintSystem<E>> Drop for Namespace<'a, E, CS> {
/// Convenience implementation of ConstraintSystem<E> for mutable references to /// Convenience implementation of ConstraintSystem<E> for mutable references to
/// constraint systems. /// constraint systems.
impl<'cs, E: Engine, CS: ConstraintSystem<E>> ConstraintSystem<E> for &'cs mut CS { impl<'cs, E: ScalarEngine, CS: ConstraintSystem<E>> ConstraintSystem<E> for &'cs mut CS {
type Root = CS::Root; type Root = CS::Root;
fn one() -> Variable { fn one() -> Variable {