cargo fmt + add deprecation flag

Author: mmaker

benches/dleq_benches.rs

@@ -23,10 +23,10 @@ mod dleq_benches {
     use curve25519_dalek::constants as dalek_constants;
     use curve25519_dalek::ristretto::RistrettoPoint;
     use curve25519_dalek::scalar::Scalar;
+    use sigma_rs::old::Transcript;
     use sigma_rs::old::{
         batch_verifier::BatchVerifier, prover::Prover, verifier::Verifier, SchnorrCS,
     };
-    use sigma_rs::old::Transcript;
 
     #[allow(non_snake_case)]
     fn dleq_statement<CS: SchnorrCS>(

src/codec/keccak_codec.rs

@@ -20,14 +20,14 @@
 //! - `KeccakPermutationState`: Low-level Keccak-f[1600] state representation
 //! - `KeccakDuplexSponge`: Duplex sponge over 200-byte state buffer
 //! - `ByteSchnorrCodec`: Fiat-Shamir transcript codec compatible with Sage Schnorr proofs
-use crate::codec::r#trait::{DuplexSpongeInterface, Codec};
+use crate::codec::r#trait::{Codec, DuplexSpongeInterface};
 use crate::serialisation::GroupSerialisation;
 use ff::PrimeField;
 use group::{Group, GroupEncoding};
 use num_bigint::BigUint;
+use num_traits::identities::One;
 use std::convert::TryInto;
 use tiny_keccak::keccakf;
-use num_traits::identities::One;
 
 const R: usize = 136;
 const N: usize = 136 + 64;
@@ -162,7 +162,7 @@ impl DuplexSpongeInterface for KeccakDuplexSponge {
             self.squeeze_index += chunk_size;
             length -= chunk_size;
             output.extend_from_slice(
-                &self.state.state[self.squeeze_index..self.squeeze_index + chunk_size]
+                &self.state.state[self.squeeze_index..self.squeeze_index + chunk_size],
             );
         }
 

src/errors.rs

@@ -19,4 +19,4 @@ pub enum ProofError {
     /// Occurs when a feature is not implemented yet.
     #[error("The method is not yet implemented for this struct")]
     NotImplemented(&'static str),
-}
+}

src/fiat_shamir.rs

@@ -13,9 +13,7 @@
 //! - `C`: the codec (`Codec` trait).
 //! - `G`: the group used for commitments and operations (`Group` trait).
 
-use crate::{
-    codec::Codec, CompactProtocol, ProofError, SigmaProtocol
-};
+use crate::{codec::Codec, CompactProtocol, ProofError, SigmaProtocol};
 
 use group::{Group, GroupEncoding};
 use rand::{CryptoRng, RngCore};
@@ -67,7 +65,7 @@ where
     pub fn prove(
         &mut self,
         witness: &P::Witness,
-        rng: &mut (impl RngCore + CryptoRng)
+        rng: &mut (impl RngCore + CryptoRng),
     ) -> (P::Commitment, P::Challenge, P::Response) {
         let mut codec = self.hash_state.clone();
 
@@ -78,9 +76,7 @@ where
             data.extend_from_slice(commit.to_bytes().as_ref());
         }
         // Fiat Shamir challenge
-        let challenge = codec
-            .prover_message(&data)
-            .verifier_challenge();
+        let challenge = codec.prover_message(&data).verifier_challenge();
         // Prover's response
         let response = self.sigmap.prover_response(prover_state, &challenge);
         // Local verification of the proof
@@ -96,7 +92,7 @@ where
         &mut self,
         commitment: &P::Commitment,
         challenge: &P::Challenge,
-        response: &P::Response
+        response: &P::Response,
     ) -> Result<(), ProofError> {
         let mut codec = self.hash_state.clone();
 
@@ -106,9 +102,7 @@ where
             data.extend_from_slice(commit.to_bytes().as_ref());
         }
         // Recompute the challenge
-        let expected_challenge = codec
-            .prover_message(&data)
-            .verifier_challenge();
+        let expected_challenge = codec.prover_message(&data).verifier_challenge();
         // Verification of the proof
         match *challenge == expected_challenge {
             true => self.sigmap.verifier(commitment, challenge, response),
@@ -119,17 +113,14 @@ where
     pub fn prove_batchable(
         &mut self,
         witness: &P::Witness,
-        rng: &mut (impl RngCore + CryptoRng)
+        rng: &mut (impl RngCore + CryptoRng),
     ) -> Vec<u8> {
         let (commitment, challenge, response) = self.prove(witness, rng);
         self.sigmap
             .serialize_batchable(&commitment, &challenge, &response)
     }
 
-    pub fn verify_batchable(
-        &mut self,
-        proof: &[u8]
-    ) -> Result<(), ProofError> {
+    pub fn verify_batchable(&mut self, proof: &[u8]) -> Result<(), ProofError> {
         let (commitment, response) = self.sigmap.deserialize_batchable(proof).unwrap();
 
         let mut codec = self.hash_state.clone();
@@ -140,9 +131,7 @@ where
             data.extend_from_slice(commit.to_bytes().as_ref());
         }
         // Recompute the challenge
-        let challenge = codec
-            .prover_message(&data)
-            .verifier_challenge();
+        let challenge = codec.prover_message(&data).verifier_challenge();
         // Verification of the proof
         self.sigmap.verifier(&commitment, &challenge, &response)
     }
@@ -157,21 +146,18 @@ where
     pub fn prove_compact(
         &mut self,
         witness: &P::Witness,
-        rng: &mut (impl RngCore + CryptoRng)
+        rng: &mut (impl RngCore + CryptoRng),
     ) -> Vec<u8> {
         let (commitment, challenge, response) = self.prove(witness, rng);
         self.sigmap
             .serialize_compact(&commitment, &challenge, &response)
     }
 
-    pub fn verify_compact(
-        &mut self,
-        proof: &[u8]
-    ) -> Result<(), ProofError> {
+    pub fn verify_compact(&mut self, proof: &[u8]) -> Result<(), ProofError> {
         let (challenge, response) = self.sigmap.deserialize_compact(proof).unwrap();
         // Compute the commitments
         let commitment = self.sigmap.get_commitment(&challenge, &response);
         // Verify the proof
         self.verify(&commitment, &challenge, &response)
     }
-}
+}

src/group_morphism.rs

@@ -92,7 +92,8 @@ impl<G: Group> Morphism<G> {
         self.linear_combination
             .iter()
             .map(|lc| {
-                let coefficients: Vec<_> = lc.scalar_indices.iter().map(|&i| scalars[i.0]).collect();
+                let coefficients: Vec<_> =
+                    lc.scalar_indices.iter().map(|&i| scalars[i.0]).collect();
                 let elements: Vec<_> = lc
                     .element_indices
                     .iter()
@@ -172,7 +173,9 @@ where
         let start = self.morphism.num_elements;
         let indices: Vec<usize> = (start..start + n).collect();
 
-        self.morphism.group_elements.extend(iter::repeat(G::identity()).take(n));
+        self.morphism
+            .group_elements
+            .extend(iter::repeat(G::identity()).take(n));
         let mut points = Vec::new();
         for i in indices.iter() {
             points.push(PointVar(*i));

src/lib.rs

@@ -17,19 +17,23 @@ pub mod errors;
 pub mod fiat_shamir;
 pub mod group_morphism;
 pub mod group_serialisation;
+pub mod proof_builder;
 pub mod proof_composition;
 pub mod schnorr_proof;
-pub mod r#trait;
-pub mod proof_builder;
 pub mod serialisation;
+pub mod r#trait;
 
 pub use errors::*;
 pub use fiat_shamir::*;
 pub use group_morphism::*;
+pub use proof_builder::*;
 pub use proof_composition::*;
-pub use schnorr_proof::*;
 pub use r#trait::*;
-pub use proof_builder::*;
+pub use schnorr_proof::*;
 
 pub mod codec;
+#[deprecated(
+    since = "0.2.0",
+    note = "This module contains the old implementation of Sigma protocols from Henry de Valence."
+)]
 pub mod old;

src/old/mod.rs

@@ -1,9 +1,9 @@
-pub mod toolbox;
 pub mod macros;
 pub mod proofs;
+pub mod toolbox;
 pub mod util;
 
-pub use toolbox::*;
+pub use merlin::Transcript;
 pub use proofs::*;
+pub use toolbox::*;
 pub use util::*;
-pub use merlin::Transcript;

src/old/toolbox/mod.rs

@@ -35,10 +35,10 @@
 
 /// Implements batch verification of batchable proofs.
 pub mod batch_verifier;
-/// Implements proof creation.
-pub mod prover;
 /// Contains lower-level tools that allow programmable specification of proof statements.
 pub mod constraints;
+/// Implements proof creation.
+pub mod prover;
 /// Implements proof verification of compact and batchable proofs.
 pub mod verifier;
 
@@ -47,8 +47,7 @@ use curve25519_dalek::scalar::Scalar;
 use curve25519_dalek::traits::IsIdentity;
 
 use crate::old::Transcript;
-use crate::{ProofError};
-
+use crate::ProofError;
 
 /// An interface for specifying proof statements, common between
 /// provers and verifiers.

src/old/toolbox/prover.rs

@@ -4,8 +4,8 @@ use curve25519_dalek::ristretto::{CompressedRistretto, RistrettoPoint};
 use curve25519_dalek::scalar::Scalar;
 use curve25519_dalek::traits::MultiscalarMul;
 
-use crate::old::toolbox::SchnorrCS;
 use crate::old::toolbox::constraints::TranscriptProtocol;
+use crate::old::toolbox::SchnorrCS;
 use crate::old::{BatchableProof, CompactProof, Transcript};
 
 /// Used to create proofs.

src/old/toolbox/verifier.rs

@@ -5,8 +5,8 @@ use curve25519_dalek::ristretto::{CompressedRistretto, RistrettoPoint};
 use curve25519_dalek::scalar::Scalar;
 use curve25519_dalek::traits::{IsIdentity, VartimeMultiscalarMul};
 
-use crate::old::SchnorrCS;
 use crate::old::toolbox::constraints::TranscriptProtocol;
+use crate::old::SchnorrCS;
 use crate::old::{BatchableProof, CompactProof, Transcript};
 use crate::ProofError;