Merge pull request #47 from dusk-network/v0.6.1

Bump to v0.6.1

CHANGELOG.md

@@ -8,8 +8,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 
-## [0.6.0] - 07-08-20
+## [0.6.1] - 13-08-20
+### Changed
+- `add_constant_witness` method replacement by `add_witness_to_circuit_description`.
+- Changed `dusk-plonk` version to `v0.2.7`.
+- Changed `Hades252` version to `v0.7.0`.
 
+## [0.6.0] - 07-08-20
 ### Changed
 - Use `dusk-plonk v0.2.0` as dependency.
 - Refactor the tests related to Proof generation to work with the Prover&Verifier abstraction.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "poseidon252"
-version = "0.6.0"
+version = "0.6.1"
 authors = [
   "zer0 <matteo@dusk.network>",	"vlopes11 <victor@dusk.network>",	"CPerezz <carlos@dusk.network>", "Kristoffer Ström <kristoffer@dusk.network>"
 ]
@@ -10,8 +10,8 @@ edition = "2018"
 kelvin = "0.18"
 nstack = "0.4"
 lazy_static = "1.3.0"
-hades252 = { git = "https://github.com/dusk-network/hades252", version = "0.6.1" }
-dusk-plonk = "0.2.6"
+hades252 = { git = "https://github.com/dusk-network/hades252", tag = "v0.7.0" }
+dusk-plonk = "0.2.7"
 anyhow = "1.0"
 thiserror = "1.0"
 

README.md

@@ -113,13 +113,13 @@ for i in [0u64, 567, 1023].iter() {
     // Proving
     let mut prover = Prover::new(b"merkle_opening_tester");
     gadget_tester(prover.mut_cs());
-    prover.preprocess(&ck).expect("Error on preprocessing");
-    let proof = prover.prove(&ck).expect("Error on proving");
+    prover.preprocess(&ck)?;
+    let proof = prover.prove(&ck)?;
 
     // Verify
     let mut verifier = Verifier::new(b"merkle_opening_tester");
     gadget_tester(verifier.mut_cs());
-    verifier.preprocess(&ck).expect("Error on preprocessing");
+    verifier.preprocess(&ck)?;
     assert!(verifier
         .verify(&proof, &vk, &vec![BlsScalar::zero()])
         .is_ok());

src/cipher/cipher.rs

@@ -192,10 +192,10 @@ impl PoseidonCipher {
         nonce: Variable,
     ) -> [Variable; WIDTH] {
         let domain = BlsScalar::from_raw([0x100000000u64, 0, 0, 0]);
-        let domain = composer.add_constant_witness(domain);
+        let domain = composer.add_witness_to_circuit_description(domain);
 
         let length = BlsScalar::from_raw([MESSAGE_CAPACITY as u64, 0, 0, 0]);
-        let length = composer.add_constant_witness(length);
+        let length = composer.add_witness_to_circuit_description(length);
 
         [domain, length, ks0, ks1, nonce]
     }

src/cipher/zk.rs

@@ -10,7 +10,7 @@ pub fn poseidon_cipher_gadget(
     nonce: Variable,
     message: &[Variable],
 ) -> [Variable; CIPHER_SIZE] {
-    let zero = composer.add_constant_witness(BlsScalar::zero());
+    let zero = composer.add_witness_to_circuit_description(BlsScalar::zero());
 
     let ks0 = *shared_secret.x();
     let ks1 = *shared_secret.y();
@@ -84,7 +84,8 @@ mod tests {
                        nonce: BlsScalar,
                        message: &[BlsScalar],
                        cipher: &[BlsScalar]| {
-            let zero = composer.add_constant_witness(BlsScalar::zero());
+            let zero =
+                composer.add_witness_to_circuit_description(BlsScalar::zero());
             let nonce = composer.add_input(nonce);
 
             let secret = composer.add_input((secret).into());

src/lib.rs

@@ -69,69 +69,72 @@
 //!
 //! ### Zero Knowledge Merkle Opening Proof example:
 //!
-//! ```rust
+//! ```no_run
 //! use poseidon252::{StorageScalar, PoseidonAnnotation};
 //! use poseidon252::merkle_proof::merkle_opening_gadget;
 //! use dusk_plonk::prelude::*;
 //! use poseidon252::PoseidonTree;
 //! use kelvin::{Blake2b, Compound};
+//! use anyhow::Result;
 //!
-//!
-//! // Generate Composer & Public Parameters
-//! let pub_params =
-//!     PublicParameters::setup(1 << 17, &mut rand::thread_rng()).unwrap();
-//! let (ck, vk) = pub_params.trim(1 << 16).unwrap();
-//! // Generate a tree with random scalars inside.
-//! let mut ptree: PoseidonTree<_, Blake2b> = PoseidonTree::new(17);
-//! for i in 0..1024u64 {
-//!     ptree
-//!         .push(StorageScalar(BlsScalar::from(i as u64)))
-//!         .unwrap();
-//! }
-//!
-//! for i in [0u64, 567, 1023].iter() {
-//!     let mut gadget_tester = |composer: &mut StandardComposer| {
-//!         // We want to proof that we know the Scalar tied to the key Xusize
-//!         // and that indeed, it is inside the merkle tree.
-//!
-//!         // In this case, the key X corresponds to the Scalar(X).
-//!         // We're supposing that we're provided with a Kelvin::Branch to perform
-//!         // the proof.
-//!         let branch = ptree.poseidon_branch(*i).unwrap().unwrap();
-//!
-//!         // Get tree root.
-//!         let root = ptree.root().unwrap();
-//!
-//!         // Add the proven leaf value to the Constraint System
-//!         let proven_leaf = composer.add_input(BlsScalar::from(*i));
-//!
-//!         merkle_opening_gadget(composer, branch, proven_leaf, root);
-//!
-//!         // Since we don't use all of the wires, we set some dummy constraints to avoid Committing
-//!         // to zero polynomials.
-//!         composer.add_dummy_constraints();
-//!     };
-//!
-//!     // Proving
-//!     let mut prover = Prover::new(b"merkle_opening_tester");
-//!     gadget_tester(prover.mut_cs());
-//!     prover.preprocess(&ck).expect("Error on preprocessing");
-//!     let proof = prover.prove(&ck).expect("Error on proving");
-//!
-//!     // Verify
-//!     let mut verifier = Verifier::new(b"merkle_opening_tester");
-//!     gadget_tester(verifier.mut_cs());
-//!     verifier.preprocess(&ck).expect("Error on preprocessing");
-//!     let pi = verifier.mut_cs().public_inputs.clone();
-//!     assert!(verifier
-//!         .verify(&proof, &vk, &pi)
-//!         .is_ok());
+//! fn main() -> Result<()> {
+//!  // Generate Composer & Public Parameters
+//!  let pub_params =
+//!      PublicParameters::setup(1 << 17, &mut rand::thread_rng())?;
+//!  let (ck, vk) = pub_params.trim(1 << 16)?;
+//!  // Generate a tree with random scalars inside.
+//!  let mut ptree: PoseidonTree<_, Blake2b> = PoseidonTree::new(17);
+//!  for i in 0..1024u64 {
+//!      ptree
+//!          .push(StorageScalar(BlsScalar::from(i as u64)))
+//!          .unwrap();
+//!  }
+//!
+//!  for i in [0u64, 567, 1023].iter() {
+//!      let mut gadget_tester = |composer: &mut StandardComposer| {
+//!          // We want to proof that we know the Scalar tied to the key Xusize
+//!          // and that indeed, it is inside the merkle tree.
+//!
+//!          // In this case, the key X corresponds to the Scalar(X).
+//!          // We're supposing that we're provided with a Kelvin::Branch to perform
+//!          // the proof.
+//!          let branch = ptree.poseidon_branch(*i).unwrap().unwrap();
+//!
+//!          // Get tree root.
+//!          let root = ptree.root().unwrap();
+//!
+//!          // Add the proven leaf value to the Constraint System
+//!          let proven_leaf = composer.add_input(BlsScalar::from(*i));
+//!
+//!          merkle_opening_gadget(composer, branch, proven_leaf, root);
+//!
+//!          // Since we don't use all of the wires, we set some dummy constraints to avoid Committing
+//!          // to zero polynomials.
+//!          composer.add_dummy_constraints();
+//!      };
+//!
+//!      // Proving
+//!      let mut prover = Prover::new(b"merkle_opening_tester");
+//!      gadget_tester(prover.mut_cs());
+//!      prover.preprocess(&ck)?;
+//!      let proof = prover.prove(&ck)?;
+//!
+//!      // Verify
+//!      let mut verifier = Verifier::new(b"merkle_opening_tester");
+//!      gadget_tester(verifier.mut_cs());
+//!      verifier.preprocess(&ck)?;
+//!      let pi = verifier.mut_cs().public_inputs.clone();
+//!      assert!(verifier
+//!          .verify(&proof, &vk, &pi)
+//!          .is_ok());
+//!  }
+//! Ok(())
 //! }
 //! ```
 //!
 //!
 //! ### Standard Merkle Opening Proof example:
-//! ```rust
+//! ```no_run
 //! use poseidon252::{StorageScalar, PoseidonAnnotation};
 //! use poseidon252::merkle_proof::merkle_opening_scalar_verification;
 //! use dusk_plonk::bls12_381::Scalar as BlsScalar;

src/merkle_lvl_hash/hash.rs

@@ -108,6 +108,7 @@ pub(crate) fn merkle_level_hash_gadget_without_bitflags(
 #[cfg(test)]
 pub mod tests {
     use super::*;
+    use anyhow::Result;
 
     fn gen_random_merkle_level() -> ([Option<BlsScalar>; ARITY], BlsScalar) {
         let mut input = [Some(BlsScalar::zero()); ARITY];
@@ -151,11 +152,11 @@ pub mod tests {
     }
 
     #[test]
-    fn test_merkle_level_gadget_bitflags() {
+    fn test_merkle_level_gadget_bitflags() -> Result<()> {
         // Gen Public Params and Keys.
         let pub_params =
-            PublicParameters::setup(1 << 12, &mut rand::thread_rng()).unwrap();
-        let (ck, vk) = pub_params.trim(1 << 11).unwrap();
+            PublicParameters::setup(1 << 12, &mut rand::thread_rng())?;
+        let (ck, vk) = pub_params.trim(1 << 11)?;
 
         // Generate input merkle level
         let (level_sacalars, expected_hash) = gen_random_merkle_level();
@@ -198,20 +199,14 @@ pub mod tests {
         // Proving
         let mut prover = Prover::new(b"merkle_gadget_tester");
         composer_fill(prover.mut_cs());
-        prover
-            .preprocess(&ck)
-            .expect("Error on preprocessing stage");
-        let proof = prover.prove(&ck).expect("Error in proof generation stage");
+        prover.preprocess(&ck)?;
+        let proof = prover.prove(&ck)?;
 
         // Verification
         let mut verifier = Verifier::new(b"merkle_gadget_tester");
         composer_fill(verifier.mut_cs());
-        verifier
-            .preprocess(&ck)
-            .expect("Error on preprocessing stage");
+        verifier.preprocess(&ck)?;
 
-        assert!(verifier
-            .verify(&proof, &vk, &vec![BlsScalar::zero()])
-            .is_ok())
+        verifier.verify(&proof, &vk, &vec![BlsScalar::zero()])
     }
 }

src/merkle_proof/proof.rs

@@ -160,6 +160,7 @@ mod tests {
     use super::*;
     use crate::hashing_utils::scalar_storage::StorageScalar;
     use crate::PoseidonTree;
+    use anyhow::Result;
     use kelvin::Blake2b;
 
     #[test]
@@ -193,11 +194,11 @@ mod tests {
     }
 
     #[test]
-    fn zero_knowledge_merkle_proof() {
+    fn zero_knowledge_merkle_proof() -> Result<()> {
         // Generate Composer & Public Parameters
         let pub_params =
-            PublicParameters::setup(1 << 17, &mut rand::thread_rng()).unwrap();
-        let (ck, vk) = pub_params.trim(1 << 16).unwrap();
+            PublicParameters::setup(1 << 17, &mut rand::thread_rng())?;
+        let (ck, vk) = pub_params.trim(1 << 16)?;
         // Generate a tree with random scalars inside.
         let mut ptree: PoseidonTree<_, Blake2b> = PoseidonTree::new(17);
         for i in 0..1024u64 {
@@ -235,19 +236,20 @@ mod tests {
             // Proving
             let mut prover = Prover::new(b"merkle_opening_tester");
             gadget_tester(prover.mut_cs());
-            prover.preprocess(&ck).expect("Error on preprocessing");
-            let proof = prover.prove(&ck).expect("Error on proving");
+            prover.preprocess(&ck)?;
+            let proof = prover.prove(&ck)?;
 
             // Verify
             let mut verifier = Verifier::new(b"merkle_opening_tester");
             gadget_tester(verifier.mut_cs());
-            verifier.preprocess(&ck).expect("Error on preprocessing");
+            verifier.preprocess(&ck)?;
             let pi = verifier.mut_cs().public_inputs.clone();
             assert!(verifier.verify(&proof, &vk, &pi).is_ok());
         }
 
         // Assert that all the proofs are of the same size
         composer_sizes.dedup();
-        assert_eq!(composer_sizes.len(), 1)
+        assert_eq!(composer_sizes.len(), 1);
+        Ok(())
     }
 }