zec
/
librustzcash
mirror of https://github.com/zcash/librustzcash.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

group: Renaming prior to trait refactor 

This will reduce the size of the subsequent refactor diff.
This commit is contained in:
Jack Grigg 2020-05-29 21:52:39 +12:00
parent df13cd7480
commit d52053d877
13 changed files with 94 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
bellman/src/domain.rs
View File

@ -12,7 +12,7 @@
//! [Groth16]: https://eprint.iacr.org/2016/260
use ff::PrimeField;
use group::CurveProjective;
use group::CofactorCurve;
use super::SynthesisError;
@ -196,23 +196,23 @@ pub trait Group<Scalar: PrimeField>: Sized + Copy + Clone + Send + Sync {
fn group_sub_assign(&mut self, other: &Self);
}
pub struct Point<G: CurveProjective>(pub G);
pub struct Point<G: CofactorCurve>(pub G);
impl<G: CurveProjective> PartialEq for Point<G> {
impl<G: CofactorCurve> PartialEq for Point<G> {
fn eq(&self, other: &Point<G>) -> bool {
self.0 == other.0
}
}
impl<G: CurveProjective> Copy for Point<G> {}
impl<G: CofactorCurve> Copy for Point<G> {}
impl<G: CurveProjective> Clone for Point<G> {
impl<G: CofactorCurve> Clone for Point<G> {
fn clone(&self) -> Point<G> {
*self
}
}
impl<G: CurveProjective> Group<G::Scalar> for Point<G> {
impl<G: CofactorCurve> Group<G::Scalar> for Point<G> {
fn group_zero() -> Self {
Point(G::identity())
}

2
bellman/src/groth16/generator.rs
View File

@ -3,7 +3,7 @@ use std::ops::{AddAssign, MulAssign};
use std::sync::Arc;
use ff::{Field, PrimeField};
use group::{CurveAffine, CurveProjective, Group, Wnaf};
use group::{CurveAffine, CofactorCurve, Group, Wnaf};
use pairing::Engine;
use super::{Parameters, VerifyingKey};

2
bellman/src/groth16/prover.rs
View File

@ -5,7 +5,7 @@ use std::sync::Arc;
use futures::Future;
use ff::{Field, PrimeField};
use group::{CurveAffine, CurveProjective};
use group::{CurveAffine, CofactorCurve};
use pairing::Engine;
use super::{ParameterSource, Proof};

8
bellman/src/groth16/tests/dummy_engine.rs
View File

@ -1,5 +1,5 @@
use ff::{Field, PrimeField};
use group::{CurveAffine, CurveProjective, Group, GroupEncoding, PrimeGroup, UncompressedEncoding};
use group::{CurveAffine, CofactorCurve, Group, GroupEncoding, PrimeGroup, UncompressedEncoding};
use pairing::{Engine, MillerLoopResult, MultiMillerLoop, PairingCurveAffine};
use rand_core::RngCore;
@ -393,7 +393,7 @@ impl Group for Fr {
impl PrimeGroup for Fr {}
impl CurveProjective for Fr {
impl CofactorCurve for Fr {
type Affine = Fr;
fn to_affine(&self) -> Fr {
@ -425,7 +425,7 @@ impl AsRef<[u8]> for FakePoint {
}
impl CurveAffine for Fr {
type Projective = Fr;
type Curve = Fr;
type Scalar = Fr;
fn identity() -> Self {
@ -440,7 +440,7 @@ impl CurveAffine for Fr {
Choice::from(if <Fr as Field>::is_zero(self) { 1 } else { 0 })
}
fn to_projective(&self) -> Self::Projective {
fn to_curve(&self) -> Self::Curve {
*self
}
}

4
bellman/src/groth16/verifier.rs
View File

@ -1,4 +1,4 @@
use group::{CurveAffine, CurveProjective};
use group::{CurveAffine, CofactorCurve};
use pairing::{MillerLoopResult, MultiMillerLoop};
use std::ops::{AddAssign, Neg};
@ -27,7 +27,7 @@ pub fn verify_proof<'a, E: MultiMillerLoop>(
return Err(SynthesisError::MalformedVerifyingKey);
}
let mut acc = pvk.ic[0].to_projective();
let mut acc = pvk.ic[0].to_curve();
for (i, b) in public_inputs.iter().zip(pvk.ic.iter().skip(1)) {
AddAssign::<&E::G1>::add_assign(&mut acc, &(*b * i));

22
bellman/src/multiexp.rs
View File

@ -2,7 +2,7 @@ use super::multicore::Worker;
use bit_vec::{self, BitVec};
use ff::{Endianness, Field, PrimeField};
use futures::Future;
use group::{CurveAffine, CurveProjective};
use group::{CofactorCurve, CurveAffine};
use std::io;
use std::iter;
use std::ops::AddAssign;
@ -25,17 +25,17 @@ pub trait Source<G: CurveAffine> {
fn skip(&mut self, amt: usize) -> Result<(), SynthesisError>;
}
pub trait AddAssignFromSource: CurveProjective {
pub trait AddAssignFromSource: CofactorCurve {
/// Parses the element from the source. Fails if the point is at infinity.
fn add_assign_from_source<S: Source<<Self as CurveProjective>::Affine>>(
fn add_assign_from_source<S: Source<<Self as CofactorCurve>::Affine>>(
&mut self,
source: &mut S,
) -> Result<(), SynthesisError> {
AddAssign::<&<Self as CurveProjective>::Affine>::add_assign(self, source.next()?);
AddAssign::<&<Self as CofactorCurve>::Affine>::add_assign(self, source.next()?);
Ok(())
}
}
impl<G> AddAssignFromSource for G where G: CurveProjective {}
impl<G> AddAssignFromSource for G where G: CofactorCurve {}
impl<G: CurveAffine> SourceBuilder<G> for (Arc<Vec<G>>, usize) {
type Source = (Arc<Vec<G>>, usize);
@ -162,8 +162,8 @@ fn multiexp_inner<Q, D, G, S>(
where
for<'a> &'a Q: QueryDensity,
D: Send + Sync + 'static + Clone + AsRef<Q>,
G: CurveProjective,
S: SourceBuilder<<G as CurveProjective>::Affine>,
G: CofactorCurve,
S: SourceBuilder<<G as CofactorCurve>::Affine>,
{
// Perform this region of the multiexp
let this = {
@ -274,8 +274,8 @@ pub fn multiexp<Q, D, G, S>(
where
for<'a> &'a Q: QueryDensity,
D: Send + Sync + 'static + Clone + AsRef<Q>,
G: CurveProjective,
S: SourceBuilder<<G as CurveProjective>::Affine>,
G: CofactorCurve,
S: SourceBuilder<<G as CofactorCurve>::Affine>,
{
let c = if exponents.len() < 32 {
3u32
@ -296,8 +296,8 @@ where
#[cfg(feature = "pairing")]
#[test]
fn test_with_bls12() {
fn naive_multiexp<G: CurveProjective>(
bases: Arc<Vec<<G as CurveProjective>::Affine>>,
fn naive_multiexp<G: CofactorCurve>(
bases: Arc<Vec<<G as CofactorCurve>::Affine>>,
exponents: Arc<Vec<G::Scalar>>,
) -> G {
assert_eq!(bases.len(), exponents.len());

18
group/src/lib.rs
View File

@ -88,12 +88,10 @@ pub trait PrimeGroup: Group {}
/// Projective representation of an elliptic curve point guaranteed to be
/// in the correct prime order subgroup.
pub trait CurveProjective:
Group
+ GroupOps<<Self as CurveProjective>::Affine>
+ GroupOpsOwned<<Self as CurveProjective>::Affine>
pub trait CofactorCurve:
Group + GroupOps<<Self as CofactorCurve>::Affine> + GroupOpsOwned<<Self as CofactorCurve>::Affine>
{
type Affine: CurveAffine<Projective = Self, Scalar = Self::Scalar>
type Affine: CurveAffine<Curve = Self, Scalar = Self::Scalar>
+ Mul<Self::Scalar, Output = Self>
+ for<'r> Mul<Self::Scalar, Output = Self>;
@ -134,11 +132,11 @@ pub trait CurveAffine:
+ 'static
+ GroupEncoding
+ Neg<Output = Self>
+ Mul<<Self as CurveAffine>::Scalar, Output = <Self as CurveAffine>::Projective>
+ for<'r> Mul<<Self as CurveAffine>::Scalar, Output = <Self as CurveAffine>::Projective>
+ Mul<<Self as CurveAffine>::Scalar, Output = <Self as CurveAffine>::Curve>
+ for<'r> Mul<<Self as CurveAffine>::Scalar, Output = <Self as CurveAffine>::Curve>
{
type Scalar: PrimeField;
type Projective: CurveProjective<Affine = Self, Scalar = Self::Scalar>;
type Curve: CofactorCurve<Affine = Self, Scalar = Self::Scalar>;
/// Returns the additive identity.
fn identity() -> Self;
@ -150,8 +148,8 @@ pub trait CurveAffine:
/// additive identity.
fn is_identity(&self) -> Choice;
/// Converts this element into its affine representation.
fn to_projective(&self) -> Self::Projective;
/// Converts this element into its efficient representation.
fn to_curve(&self) -> Self::Curve;
}
pub trait GroupEncoding: Sized {

36
group/src/tests/mod.rs
View File

@ -3,9 +3,9 @@ use rand::SeedableRng;
use rand_xorshift::XorShiftRng;
use std::ops::{Mul, Neg};
use crate::{CurveAffine, CurveProjective, GroupEncoding, UncompressedEncoding};
use crate::{CofactorCurve, CurveAffine, GroupEncoding, UncompressedEncoding};
pub fn curve_tests<G: CurveProjective>() {
pub fn curve_tests<G: CofactorCurve>() {
let mut rng = XorShiftRng::from_seed([
0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06, 0xbc,
0xe5,
@ -50,8 +50,8 @@ pub fn curve_tests<G: CurveProjective>() {
// Transformations
{
let a = G::random(&mut rng);
let b = a.to_affine().to_projective();
let c = a.to_affine().to_projective().to_affine().to_projective();
let b = a.to_affine().to_curve();
let c = a.to_affine().to_curve().to_affine().to_curve();
assert_eq!(a, b);
assert_eq!(b, c);
}
@ -65,7 +65,7 @@ pub fn curve_tests<G: CurveProjective>() {
random_compressed_encoding_tests::<G>();
}
fn random_wnaf_tests<G: CurveProjective>() {
fn random_wnaf_tests<G: CofactorCurve>() {
use crate::wnaf::*;
let mut rng = XorShiftRng::from_seed([
@ -184,7 +184,7 @@ fn random_wnaf_tests<G: CurveProjective>() {
}
}
fn random_negation_tests<G: CurveProjective>() {
fn random_negation_tests<G: CofactorCurve>() {
let mut rng = XorShiftRng::from_seed([
0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06, 0xbc,
0xe5,
@ -214,7 +214,7 @@ fn random_negation_tests<G: CurveProjective>() {
}
}
fn random_doubling_tests<G: CurveProjective>() {
fn random_doubling_tests<G: CofactorCurve>() {
let mut rng = XorShiftRng::from_seed([
0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06, 0xbc,
0xe5,
@ -242,7 +242,7 @@ fn random_doubling_tests<G: CurveProjective>() {
}
}
fn random_multiplication_tests<G: CurveProjective>() {
fn random_multiplication_tests<G: CofactorCurve>() {
let mut rng = XorShiftRng::from_seed([
0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06, 0xbc,
0xe5,
@ -277,7 +277,7 @@ fn random_multiplication_tests<G: CurveProjective>() {
}
}
fn random_addition_tests<G: CurveProjective>() {
fn random_addition_tests<G: CofactorCurve>() {
let mut rng = XorShiftRng::from_seed([
0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06, 0xbc,
0xe5,
@ -325,17 +325,17 @@ fn random_addition_tests<G: CurveProjective>() {
// Mixed addition
// (a + b) + c
tmp[3] = a_affine.to_projective();
tmp[3] = a_affine.to_curve();
tmp[3].add_assign(&b_affine);
tmp[3].add_assign(&c_affine);
// a + (b + c)
tmp[4] = b_affine.to_projective();
tmp[4] = b_affine.to_curve();
tmp[4].add_assign(&c_affine);
tmp[4].add_assign(&a_affine);
// (a + c) + b
tmp[5] = a_affine.to_projective();
tmp[5] = a_affine.to_curve();
tmp[5].add_assign(&c_affine);
tmp[5].add_assign(&b_affine);
@ -357,7 +357,7 @@ fn random_addition_tests<G: CurveProjective>() {
}
}
fn random_transformation_tests<G: CurveProjective>() {
fn random_transformation_tests<G: CofactorCurve>() {
let mut rng = XorShiftRng::from_seed([
0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06, 0xbc,
0xe5,
@ -366,7 +366,7 @@ fn random_transformation_tests<G: CurveProjective>() {
for _ in 0..1000 {
let g = G::random(&mut rng);
let g_affine = g.to_affine();
let g_projective = g_affine.to_projective();
let g_projective = g_affine.to_curve();
assert_eq!(g, g_projective);
}
@ -382,7 +382,7 @@ fn random_transformation_tests<G: CurveProjective>() {
}
for _ in 0..5 {
let s = between.sample(&mut rng);
v[s] = v[s].to_affine().to_projective();
v[s] = v[s].to_affine().to_curve();
}
let expected_v = v.iter().map(|v| v.to_affine()).collect::<Vec<_>>();
@ -394,7 +394,7 @@ fn random_transformation_tests<G: CurveProjective>() {
}
}
fn random_compressed_encoding_tests<G: CurveProjective>() {
fn random_compressed_encoding_tests<G: CofactorCurve>() {
let mut rng = XorShiftRng::from_seed([
0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06, 0xbc,
0xe5,
@ -420,9 +420,9 @@ fn random_compressed_encoding_tests<G: CurveProjective>() {
}
}
pub fn random_uncompressed_encoding_tests<G: CurveProjective>()
pub fn random_uncompressed_encoding_tests<G: CofactorCurve>()
where
G::Affine: UncompressedEncoding,
<G as CofactorCurve>::Affine: UncompressedEncoding,
{
let mut rng = XorShiftRng::from_seed([
0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06, 0xbc,

16
group/src/wnaf.rs
View File

@ -2,10 +2,10 @@ use byteorder::{ByteOrder, LittleEndian};
use ff::PrimeField;
use std::iter;
use super::{CurveProjective, Group};
use super::{CofactorCurve, Group};
/// Replaces the contents of `table` with a w-NAF window table for the given window size.
pub(crate) fn wnaf_table<G: CurveProjective>(table: &mut Vec<G>, mut base: G, window: usize) {
pub(crate) fn wnaf_table<G: CofactorCurve>(table: &mut Vec<G>, mut base: G, window: usize) {
table.truncate(0);
table.reserve(1 << (window - 1));
@ -78,7 +78,7 @@ pub(crate) fn wnaf_form<S: AsRef<[u8]>>(wnaf: &mut Vec<i64>, c: S, window: usize
///
/// This function must be provided a `table` and `wnaf` that were constructed with
/// the same window size; otherwise, it may panic or produce invalid results.
pub(crate) fn wnaf_exp<G: CurveProjective>(table: &[G], wnaf: &[i64]) -> G {
pub(crate) fn wnaf_exp<G: CofactorCurve>(table: &[G], wnaf: &[i64]) -> G {
let mut result = G::identity();
let mut found_one = false;
@ -110,7 +110,7 @@ pub struct Wnaf<W, B, S> {
window_size: W,
}
impl<G: CurveProjective> Wnaf<(), Vec<G>, Vec<i64>> {
impl<G: CofactorCurve> Wnaf<(), Vec<G>, Vec<i64>> {
/// Construct a new wNAF context without allocating.
pub fn new() -> Self {
Wnaf {
@ -157,7 +157,7 @@ impl<G: CurveProjective> Wnaf<(), Vec<G>, Vec<i64>> {
}
}
impl<'a, G: CurveProjective> Wnaf<usize, &'a [G], &'a mut Vec<i64>> {
impl<'a, G: CofactorCurve> Wnaf<usize, &'a [G], &'a mut Vec<i64>> {
/// Constructs new space for the scalar representation while borrowing
/// the computed window table, for sending the window table across threads.
pub fn shared(&self) -> Wnaf<usize, &'a [G], Vec<i64>> {
@ -169,7 +169,7 @@ impl<'a, G: CurveProjective> Wnaf<usize, &'a [G], &'a mut Vec<i64>> {
}
}
impl<'a, G: CurveProjective> Wnaf<usize, &'a mut Vec<G>, &'a [i64]> {
impl<'a, G: CofactorCurve> Wnaf<usize, &'a mut Vec<G>, &'a [i64]> {
/// Constructs new space for the window table while borrowing
/// the computed scalar representation, for sending the scalar representation
/// across threads.
@ -184,7 +184,7 @@ impl<'a, G: CurveProjective> Wnaf<usize, &'a mut Vec<G>, &'a [i64]> {
impl<B, S: AsRef<[i64]>> Wnaf<usize, B, S> {
/// Performs exponentiation given a base.
pub fn base<G: CurveProjective>(&mut self, base: G) -> G
pub fn base<G: CofactorCurve>(&mut self, base: G) -> G
where
B: AsMut<Vec<G>>,
{
@ -195,7 +195,7 @@ impl<B, S: AsRef<[i64]>> Wnaf<usize, B, S> {
impl<B, S: AsMut<Vec<i64>>> Wnaf<usize, B, S> {
/// Performs exponentiation given a scalar.
pub fn scalar<G: CurveProjective>(&mut self, scalar: &<G as Group>::Scalar) -> G
pub fn scalar<G: CofactorCurve>(&mut self, scalar: &<G as Group>::Scalar) -> G
where
B: AsRef<[G]>,
{

56
pairing/src/bls12_381/ec.rs
View File

@ -199,7 +199,7 @@ macro_rules! curve_impl {
impl CurveAffine for $affine {
type Scalar = $scalarfield;
type Projective = $projective;
type Curve = $projective;
fn identity() -> Self {
$affine {
@ -217,7 +217,7 @@ macro_rules! curve_impl {
Choice::from(if self.infinity { 1 } else { 0 })
}
fn to_projective(&self) -> $projective {
fn to_curve(&self) -> $projective {
(*self).into()
}
}
@ -466,30 +466,28 @@ macro_rules! curve_impl {
}
}
impl<'r> ::std::ops::Add<&'r <$projective as CurveProjective>::Affine> for $projective {
impl<'r> ::std::ops::Add<&'r $affine> for $projective {
type Output = Self;
#[inline]
fn add(self, other: &<$projective as CurveProjective>::Affine) -> Self {
fn add(self, other: &$affine) -> Self {
let mut ret = self;
ret.add_assign(other);
ret
}
}
impl ::std::ops::Add<<$projective as CurveProjective>::Affine> for $projective {
impl ::std::ops::Add<$affine> for $projective {
type Output = Self;
#[inline]
fn add(self, other: <$projective as CurveProjective>::Affine) -> Self {
fn add(self, other: $affine) -> Self {
self + &other
}
}
impl<'r> ::std::ops::AddAssign<&'r <$projective as CurveProjective>::Affine>
for $projective
{
fn add_assign(&mut self, other: &<$projective as CurveProjective>::Affine) {
impl<'r> ::std::ops::AddAssign<&'r $affine> for $projective {
fn add_assign(&mut self, other: &$affine) {
if other.is_identity().into() {
return;
}
@ -567,44 +565,42 @@ macro_rules! curve_impl {
}
}
impl ::std::ops::AddAssign<<$projective as CurveProjective>::Affine> for $projective {
impl ::std::ops::AddAssign<$affine> for $projective {
#[inline]
fn add_assign(&mut self, other: <$projective as CurveProjective>::Affine) {
fn add_assign(&mut self, other: $affine) {
self.add_assign(&other);
}
}
impl<'r> ::std::ops::Sub<&'r <$projective as CurveProjective>::Affine> for $projective {
impl<'r> ::std::ops::Sub<&'r $affine> for $projective {
type Output = Self;
#[inline]
fn sub(self, other: &<$projective as CurveProjective>::Affine) -> Self {
fn sub(self, other: &$affine) -> Self {
let mut ret = self;
ret.sub_assign(other);
ret
}
}
impl ::std::ops::Sub<<$projective as CurveProjective>::Affine> for $projective {
impl ::std::ops::Sub<$affine> for $projective {
type Output = Self;
#[inline]
fn sub(self, other: <$projective as CurveProjective>::Affine) -> Self {
fn sub(self, other: $affine) -> Self {
self - &other
}
}
impl<'r> ::std::ops::SubAssign<&'r <$projective as CurveProjective>::Affine>
for $projective
{
fn sub_assign(&mut self, other: &<$projective as CurveProjective>::Affine) {
impl<'r> ::std::ops::SubAssign<&'r $affine> for $projective {
fn sub_assign(&mut self, other: &$affine) {
self.add_assign(&other.neg());
}
}
impl ::std::ops::SubAssign<<$projective as CurveProjective>::Affine> for $projective {
impl ::std::ops::SubAssign<$affine> for $projective {
#[inline]
fn sub_assign(&mut self, other: <$projective as CurveProjective>::Affine) {
fn sub_assign(&mut self, other: $affine) {
self.sub_assign(&other);
}
}
@ -746,7 +742,7 @@ macro_rules! curve_impl {
impl PrimeGroup for $projective {}
impl CurveProjective for $projective {
impl CofactorCurve for $projective {
type Affine = $affine;
fn batch_normalize(p: &[Self], q: &mut [$affine]) {
@ -908,7 +904,7 @@ pub mod g1 {
use crate::{Engine, PairingCurveAffine};
use ff::{BitIterator, Field, PrimeField};
use group::{
CurveAffine, CurveProjective, Group, GroupEncoding, PrimeGroup, UncompressedEncoding,
CofactorCurve, CurveAffine, Group, GroupEncoding, PrimeGroup, UncompressedEncoding,
};
use rand_core::RngCore;
use std::fmt;
@ -1462,15 +1458,15 @@ pub mod g1 {
assert!(b.is_on_curve() && b.is_in_correct_subgroup_assuming_on_curve());
assert!(c.is_on_curve() && c.is_in_correct_subgroup_assuming_on_curve());
let mut tmp1 = a.to_projective();
tmp1.add_assign(&b.to_projective());
let mut tmp1 = a.to_curve();
tmp1.add_assign(&b.to_curve());
assert_eq!(tmp1.to_affine(), c);
assert_eq!(tmp1, c.to_projective());
assert_eq!(tmp1, c.to_curve());
let mut tmp2 = a.to_projective();
let mut tmp2 = a.to_curve();
tmp2.add_assign(&b);
assert_eq!(tmp2.to_affine(), c);
assert_eq!(tmp2, c.to_projective());
assert_eq!(tmp2, c.to_curve());
}
#[test]
@ -1487,7 +1483,7 @@ pub mod g2 {
use crate::{Engine, PairingCurveAffine};
use ff::{BitIterator, Field, PrimeField};
use group::{
CurveAffine, CurveProjective, Group, GroupEncoding, PrimeGroup, UncompressedEncoding,
CofactorCurve, CurveAffine, Group, GroupEncoding, PrimeGroup, UncompressedEncoding,
};
use rand_core::RngCore;
use std::fmt;

6
pairing/src/bls12_381/tests/mod.rs
View File

@ -1,5 +1,5 @@
use ff::PrimeField;
use group::{CurveAffine, CurveProjective, GroupEncoding, UncompressedEncoding};
use group::{CofactorCurve, CurveAffine, GroupEncoding, UncompressedEncoding};
use super::*;
use crate::*;
@ -55,7 +55,7 @@ fn test_pairing_result_against_relic() {
});
}
fn uncompressed_test_vectors<G: CurveProjective>(expected: &[u8])
fn uncompressed_test_vectors<G: CofactorCurve>(expected: &[u8])
where
G::Affine: UncompressedEncoding,
{
@ -85,7 +85,7 @@ where
assert_eq!(&v[..], expected);
}
fn compressed_test_vectors<G: CurveProjective>(expected: &[u8]) {
fn compressed_test_vectors<G: CofactorCurve>(expected: &[u8]) {
let mut e = G::identity();
let encoded_len = <G::Affine as GroupEncoding>::Repr::default().as_ref().len();

10
pairing/src/lib.rs
View File

@ -23,7 +23,7 @@ pub mod bls12_381;
use core::ops::Mul;
use ff::{Field, PrimeField};
use group::{
CurveAffine, CurveProjective, GroupOps, GroupOpsOwned, ScalarMul, ScalarMulOwned,
CofactorCurve, CurveAffine, GroupOps, GroupOpsOwned, ScalarMul, ScalarMulOwned,
UncompressedEncoding,
};
@ -35,7 +35,7 @@ pub trait Engine: Sized + 'static + Clone {
type Fr: PrimeField;
/// The projective representation of an element in G1.
type G1: CurveProjective<Scalar = Self::Fr, Affine = Self::G1Affine>
type G1: CofactorCurve<Scalar = Self::Fr, Affine = Self::G1Affine>
+ From<Self::G1Affine>
+ GroupOps<Self::G1Affine>
+ GroupOpsOwned<Self::G1Affine>
@ -45,7 +45,7 @@ pub trait Engine: Sized + 'static + Clone {
/// The affine representation of an element in G1.
type G1Affine: PairingCurveAffine<
Scalar = Self::Fr,
Projective = Self::G1,
Curve = Self::G1,
Pair = Self::G2Affine,
PairingResult = Self::Gt,
> + From<Self::G1>
@ -53,7 +53,7 @@ pub trait Engine: Sized + 'static + Clone {
+ for<'a> Mul<&'a Self::Fr, Output = Self::G1>;
/// The projective representation of an element in G2.
type G2: CurveProjective<Scalar = Self::Fr, Affine = Self::G2Affine>
type G2: CofactorCurve<Scalar = Self::Fr, Affine = Self::G2Affine>
+ From<Self::G2Affine>
+ GroupOps<Self::G2Affine>
+ GroupOpsOwned<Self::G2Affine>
@ -63,7 +63,7 @@ pub trait Engine: Sized + 'static + Clone {
/// The affine representation of an element in G2.
type G2Affine: PairingCurveAffine<
Scalar = Self::Fr,
Projective = Self::G2,
Curve = Self::G2,
Pair = Self::G1Affine,
PairingResult = Self::Gt,
> + From<Self::G2>

2
pairing/src/tests/engine.rs
View File

@ -1,5 +1,5 @@
use ff::{Endianness, Field, PrimeField};
use group::{CurveAffine, CurveProjective, Group};
use group::{CofactorCurve, CurveAffine, Group};
use rand_core::SeedableRng;
use rand_xorshift::XorShiftRng;
use std::ops::MulAssign;