ff: Remove ScalarEngine

bellman/src/groth16/tests/dummy_engine.rs

@@ -1,4 +1,4 @@
-use ff::{Field, PrimeField, ScalarEngine};
+use ff::{Field, PrimeField};
 use group::{CurveAffine, CurveProjective, Group, PrimeGroup};
 use pairing::{Engine, PairingCurveAffine};
 
@@ -324,11 +324,8 @@ impl PrimeField for Fr {
 #[derive(Clone)]
 pub struct DummyEngine;
 
-impl ScalarEngine for DummyEngine {
-    type Fr = Fr;
-}
-
 impl Engine for DummyEngine {
+    type Fr = Fr;
     type G1 = Fr;
     type G1Affine = Fr;
     type G2 = Fr;

bellman/src/multiexp.rs

@@ -293,9 +293,6 @@ where
     multiexp_inner(pool, bases, density_map, exponents, 0, c, true)
 }
 
-#[cfg(all(test, feature = "pairing"))]
-use ff::ScalarEngine;
-
 #[cfg(feature = "pairing")]
 #[test]
 fn test_with_bls12() {
@@ -315,17 +312,16 @@ fn test_with_bls12() {
     }
 
     use group::Group;
-    use pairing::{bls12_381::Bls12, Engine};
+    use pairing::{
+        bls12_381::{Bls12, Fr},
+        Engine,
+    };
     use rand;
 
     const SAMPLES: usize = 1 << 14;
 
     let rng = &mut rand::thread_rng();
-    let v = Arc::new(
-        (0..SAMPLES)
-            .map(|_| <Bls12 as ScalarEngine>::Fr::random(rng))
-            .collect::<Vec<_>>(),
-    );
+    let v = Arc::new((0..SAMPLES).map(|_| Fr::random(rng)).collect::<Vec<_>>());
     let g = Arc::new(
         (0..SAMPLES)
             .map(|_| <Bls12 as Engine>::G1::random(rng).to_affine())

bellman/tests/mimc.rs

@@ -8,7 +8,7 @@ use std::time::{Duration, Instant};
 use ff::{Field, PrimeField};
 
 // We're going to use the BLS12-381 pairing-friendly elliptic curve.
-use pairing::bls12_381::Bls12;
+use pairing::bls12_381::{Bls12, Fr};
 
 // We'll use these interfaces to construct our circuit.
 use bellman::{Circuit, ConstraintSystem, SynthesisError};
@@ -145,15 +145,13 @@ impl<'a, Scalar: PrimeField> Circuit<Scalar> for MiMCDemo<'a, Scalar> {
 
 #[test]
 fn test_mimc() {
-    use ff::ScalarEngine;
-
     // This may not be cryptographically safe, use
     // `OsRng` (for example) in production software.
     let rng = &mut thread_rng();
 
     // Generate the MiMC round constants
     let constants = (0..MIMC_ROUNDS)
-        .map(|_| <Bls12 as ScalarEngine>::Fr::random(rng))
+        .map(|_| Fr::random(rng))
         .collect::<Vec<_>>();
 
     println!("Creating parameters...");
@@ -185,8 +183,8 @@ fn test_mimc() {
 
     for _ in 0..SAMPLES {
         // Generate a random preimage and compute the image
-        let xl = <Bls12 as ScalarEngine>::Fr::random(rng);
-        let xr = <Bls12 as ScalarEngine>::Fr::random(rng);
+        let xl = Fr::random(rng);
+        let xr = Fr::random(rng);
         let image = mimc(xl, xr, &constants);
 
         proof_vec.truncate(0);

ff/src/lib.rs

@@ -213,14 +213,6 @@ pub trait PrimeField: Field + From<u64> {
     fn root_of_unity() -> Self;
 }
 
-/// An "engine" is a collection of types (fields, elliptic curve groups, etc.)
-/// with well-defined relationships. Specific relationships (for example, a
-/// pairing-friendly curve) can be defined in a subtrait.
-pub trait ScalarEngine: Sized + 'static + Clone {
-    /// This is the scalar field of the engine's groups.
-    type Fr: PrimeField;
-}
-
 #[derive(Debug)]
 pub struct BitIterator<T, E: AsRef<[T]>> {
     t: E,

group/src/lib.rs

@@ -35,10 +35,6 @@ impl<T, Rhs, Output> ScalarMul<Rhs, Output> for T where T: Mul<Rhs, Output = Out
 {}
 
 /// A helper trait for references implementing group scalar multiplication.
-///
-/// This trait, in combination with `ScalarMul`, is necessary to address type constraint
-/// issues in `pairing::Engine` (specifically, to ensure that [`ff::ScalarEngine::Fr`] is
-/// correctly constrained to implement these traits required by [`Group::Scalar`]).
 pub trait ScalarMulOwned<Rhs, Output = Self>: for<'r> ScalarMul<&'r Rhs, Output> {}
 impl<T, Rhs, Output> ScalarMulOwned<Rhs, Output> for T where T: for<'r> ScalarMul<&'r Rhs, Output> {}
 

pairing/src/bls12_381/mod.rs

@@ -23,7 +23,7 @@ pub use self::fr::{Fr, FrRepr};
 
 use super::{Engine, PairingCurveAffine};
 
-use ff::{BitIterator, Field, ScalarEngine};
+use ff::{BitIterator, Field};
 use group::CurveAffine;
 use std::ops::{AddAssign, MulAssign, Neg, SubAssign};
 use subtle::CtOption;
@@ -35,11 +35,8 @@ const BLS_X_IS_NEGATIVE: bool = true;
 #[derive(Clone, Debug)]
 pub struct Bls12;
 
-impl ScalarEngine for Bls12 {
-    type Fr = Fr;
-}
-
 impl Engine for Bls12 {
+    type Fr = Fr;
     type G1 = G1;
     type G1Affine = G1Affine;
     type G2 = G2;

pairing/src/lib.rs

@@ -21,14 +21,17 @@ pub mod tests;
 pub mod bls12_381;
 
 use core::ops::Mul;
-use ff::{Field, PrimeField, ScalarEngine};
+use ff::{Field, PrimeField};
 use group::{CurveAffine, CurveProjective, GroupOps, GroupOpsOwned, ScalarMul, ScalarMulOwned};
 use subtle::CtOption;
 
 /// An "engine" is a collection of types (fields, elliptic curve groups, etc.)
 /// with well-defined relationships. In particular, the G1/G2 curve groups are
 /// of prime order `r`, and are equipped with a bilinear pairing function.
-pub trait Engine: ScalarEngine {
+pub trait Engine: Sized + 'static + Clone {
+    /// This is the scalar field of the engine's groups.
+    type Fr: PrimeField;
+
     /// The projective representation of an element in G1.
     type G1: CurveProjective<Base = Self::Fq, Scalar = Self::Fr, Affine = Self::G1Affine>
         + From<Self::G1Affine>