dusk-jubjub and bls12_381 bump w/ API rename (#322)

* dusk-jubjub and bls12_381 bump w/ API rename

Author: vlopes11

CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.4] - 02-11-20
+### Changed
+- dusk-jubjub update to `v0.5.0` with API renaming
+- dusk-bls12_381 update to `v0.3.0` with API renaming
+
 ## [0.3.3] - 02-11-20
 ### Added
 - `canon` feature to manage `Canon` derivations usage in ecc libs.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dusk-plonk"
-version = "0.3.3"
+version = "0.3.4"
 authors = ["Kevaundray Wedderburn <[email protected]>",
            "Luke Pearson <[email protected]>", 
            "CPerezz <[email protected]>"] 
@@ -25,12 +25,12 @@ merlin = "2.0.0"
 rand = "0.7.2"
 rand_core = { version = "0.5", default-features = false }
 # Built by default with "std", "alloc", "pairing", "groups" and "endo" features.
-dusk-bls12_381 = "0.2.0"
+dusk-bls12_381 = "0.3.0"
 itertools = "0.9.0"
 rand_chacha = "0.2"
 rayon = "1.3.0"
 anyhow = "1.0.32"
-dusk-jubjub = "0.4.0"
+dusk-jubjub = "0.5.0"
 thiserror = "1.0"
 serde = "1.0"
 

pk_testcirc

@@ -57,10 +57,10 @@ bit_iterator!(u8, BitIterator8);
 #[cfg(test)]
 mod test {
     use super::*;
-    use dusk_bls12_381::Scalar;
+    use dusk_bls12_381::BlsScalar;
     #[test]
     fn test_bit_iterator8() {
-        let mut a = BitIterator8::new(Scalar::one().to_bytes());
+        let mut a = BitIterator8::new(BlsScalar::one().to_bytes());
         let expected = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001";
         for e in expected.chars() {
             assert!(a.next().unwrap() == (e == '1'));

src/bit_iterator.rs

@@ -10,8 +10,8 @@ use crate::commitment_scheme::kzg10::PublicParameters;
 use crate::constraint_system::StandardComposer;
 use crate::proof_system::{Proof, ProverKey, VerifierKey};
 use anyhow::Result;
-use dusk_bls12_381::Scalar as BlsScalar;
-use dusk_jubjub::{AffinePoint as JubJubAffine, Scalar as JubJubScalar};
+use dusk_bls12_381::BlsScalar;
+use dusk_jubjub::{JubJubAffine, JubJubScalar};
 use thiserror::Error;
 
 /// Public Input

src/circuit_builder.rs

@@ -11,7 +11,7 @@ use super::{errors::KZG10Errors, AggregateProof, Commitment, Proof};
 use crate::{fft::Polynomial, transcript::TranscriptProtocol, util};
 use anyhow::{Error, Result};
 use dusk_bls12_381::{
-    multiscalar_mul::msm_variable_base, G1Affine, G1Projective, G2Affine, G2Prepared, Scalar,
+    multiscalar_mul::msm_variable_base, BlsScalar, G1Affine, G1Projective, G2Affine, G2Prepared,
 };
 use merlin::Transcript;
 
@@ -122,7 +122,7 @@ impl CommitKey {
     /// However we note that the quotient polynomial is invariant under the value f(z)
     /// ie. only the remainder changes. We can therefore compute the witness as f(x) / x - z
     /// and only use the remainder term f(z) during verification.
-    pub fn compute_single_witness(&self, polynomial: &Polynomial, point: &Scalar) -> Polynomial {
+    pub fn compute_single_witness(&self, polynomial: &Polynomial, point: &BlsScalar) -> Polynomial {
         // Computes `f(x) / x-z`, returning it as the witness poly
         polynomial.ruffini(*point)
     }
@@ -133,7 +133,7 @@ impl CommitKey {
     pub(crate) fn compute_aggregate_witness(
         &self,
         polynomials: &[Polynomial],
-        point: &Scalar,
+        point: &BlsScalar,
         transcript: &mut Transcript,
     ) -> Polynomial {
         let challenge = transcript.challenge_scalar(b"aggregate_witness");
@@ -155,8 +155,8 @@ impl CommitKey {
     pub fn open_single(
         &self,
         polynomial: &Polynomial,
-        value: &Scalar,
-        point: &Scalar,
+        value: &BlsScalar,
+        point: &BlsScalar,
     ) -> Result<Proof, Error> {
         let witness_poly = self.compute_single_witness(polynomial, point);
         Ok(Proof {
@@ -172,8 +172,8 @@ impl CommitKey {
     pub fn open_multiple(
         &self,
         polynomials: &[Polynomial],
-        evaluations: Vec<Scalar>,
-        point: &Scalar,
+        evaluations: Vec<BlsScalar>,
+        point: &BlsScalar,
         transcript: &mut Transcript,
     ) -> Result<AggregateProof, Error> {
         // Commit to polynomials
@@ -243,7 +243,7 @@ impl OpeningKey {
 
     /// Checks that a polynomial `p` was evaluated at a point `z` and returned the value specified `v`.
     /// ie. v = p(z).
-    pub fn check(&self, point: Scalar, proof: Proof) -> bool {
+    pub fn check(&self, point: BlsScalar, proof: Proof) -> bool {
         let inner_a: G1Affine =
             (proof.commitment_to_polynomial.0 - (self.g * proof.evaluated_point)).into();
 
@@ -262,7 +262,7 @@ impl OpeningKey {
     /// Checks whether a batch of polynomials evaluated at different points, returned their specified value.
     pub fn batch_check(
         &self,
-        points: &[Scalar],
+        points: &[BlsScalar],
         proofs: &[Proof],
         transcript: &mut Transcript,
     ) -> Result<(), Error> {
@@ -273,7 +273,7 @@ impl OpeningKey {
         let powers = util::powers_of(&challenge, proofs.len() - 1);
         // Instead of multiplying g and gamma_g in each turn, we simply accumulate
         // their coefficients and perform a final multiplication at the end.
-        let mut g_multiplier = Scalar::zero();
+        let mut g_multiplier = BlsScalar::zero();
 
         for ((proof, challenge), point) in proofs.iter().zip(powers).zip(points) {
             let mut c = G1Projective::from(proof.commitment_to_polynomial.0);
@@ -332,7 +332,7 @@ mod test {
     fn test_basic_commit() {
         let degree = 25;
         let (proving_key, opening_key) = setup_test(degree);
-        let point = Scalar::from(10);
+        let point = BlsScalar::from(10);
 
         let poly = Polynomial::rand(degree, &mut rand::thread_rng());
         let value = poly.evaluate(&point);
@@ -347,8 +347,8 @@ mod test {
         let degree = 25;
         let (proving_key, vk) = setup_test(degree);
 
-        let point_a = Scalar::from(10);
-        let point_b = Scalar::from(11);
+        let point_a = BlsScalar::from(10);
+        let point_b = BlsScalar::from(11);
 
         // Compute secret polynomial a
         let poly_a = Polynomial::rand(degree, &mut rand::thread_rng());
@@ -378,7 +378,7 @@ mod test {
     fn test_aggregate_witness() {
         let max_degree = 27;
         let (proving_key, opening_key) = setup_test(max_degree);
-        let point = Scalar::from(10);
+        let point = BlsScalar::from(10);
 
         // Committer's View
         let aggregated_proof = {
@@ -415,8 +415,8 @@ mod test {
     fn test_batch_with_aggregation() {
         let max_degree = 28;
         let (proving_key, opening_key) = setup_test(max_degree);
-        let point_a = Scalar::from(10);
-        let point_b = Scalar::from(11);
+        let point_a = BlsScalar::from(10);
+        let point_b = BlsScalar::from(11);
 
         // Committer's View
         let (aggregated_proof, single_proof) = {

src/commitment_scheme/kzg10/key.rs

@@ -14,7 +14,7 @@ pub use srs::PublicParameters;
 
 use crate::transcript::TranscriptProtocol;
 use crate::util::powers_of;
-use dusk_bls12_381::{G1Affine, G1Projective, Scalar};
+use dusk_bls12_381::{BlsScalar, G1Affine, G1Projective};
 use merlin::Transcript;
 
 #[derive(Copy, Clone, Debug)]
@@ -24,7 +24,7 @@ pub struct Proof {
     /// This is a commitment to the witness polynomial.
     pub commitment_to_witness: Commitment,
     /// This is the result of evaluating a polynomial at the point `z`.
-    pub evaluated_point: Scalar,
+    pub evaluated_point: BlsScalar,
     /// This is the commitment to the polynomial that you want to prove a statement about.
     pub commitment_to_polynomial: Commitment,
 }
@@ -36,7 +36,7 @@ pub struct AggregateProof {
     /// This is a commitment to the aggregated witness polynomial.
     pub commitment_to_witness: Commitment,
     /// These are the results of the evaluating each polynomial at the point `z`.
-    pub evaluated_points: Vec<Scalar>,
+    pub evaluated_points: Vec<BlsScalar>,
     /// These are the commitments to the polynomials which you want to prove a statement about.
     pub commitments_to_polynomials: Vec<Commitment>,
 }
@@ -52,7 +52,7 @@ impl AggregateProof {
     }
 
     /// Adds an evaluated point with the commitment to the polynomial which produced it.
-    pub fn add_part(&mut self, part: (Scalar, Commitment)) {
+    pub fn add_part(&mut self, part: (BlsScalar, Commitment)) {
         self.evaluated_points.push(part.0);
         self.commitments_to_polynomials.push(part.1);
     }
@@ -71,12 +71,12 @@ impl AggregateProof {
             .map(|(poly, challenge)| poly.0 * challenge)
             .sum();
         // Flattened evaluation points
-        let flattened_poly_evaluations: Scalar = self
+        let flattened_poly_evaluations: BlsScalar = self
             .evaluated_points
             .iter()
             .zip(powers.iter())
             .map(|(eval, challenge)| eval * challenge)
-            .fold(Scalar::zero(), |acc, current_val| acc + current_val);
+            .fold(BlsScalar::zero(), |acc, current_val| acc + current_val);
 
         Proof {
             commitment_to_witness: self.commitment_to_witness,

src/commitment_scheme/kzg10/mod.rs

@@ -112,10 +112,10 @@ impl PublicParameters {
 #[cfg(test)]
 mod test {
     use super::*;
-    use dusk_bls12_381::Scalar;
+    use dusk_bls12_381::BlsScalar;
     #[test]
     fn test_powers_of() {
-        let x = Scalar::from(10u64);
+        let x = BlsScalar::from(10u64);
         let degree = 100u64;
 
         let powers_of_x = util::powers_of(&x, degree as usize);