From a1887356dc5b2a3f78310472fbc4288bc21d4a29 Mon Sep 17 00:00:00 2001 From: aniampio Date: Tue, 19 Apr 2022 19:33:08 +0300 Subject: [PATCH] Run cargo fmt --- common/nym-compact-ecash/src/proofs/mod.rs | 14 ++++---- .../src/proofs/proof_spend.rs | 36 +++++++++---------- .../src/proofs/proof_withdrawal.rs | 36 +++++++++---------- .../src/scheme/aggregation.rs | 14 ++++---- common/nym-compact-ecash/src/scheme/keygen.rs | 10 +++--- common/nym-compact-ecash/src/scheme/mod.rs | 16 ++++----- .../src/scheme/withdrawal.rs | 12 +++---- common/nym-compact-ecash/src/tests/e2e.rs | 12 +++---- common/nym-compact-ecash/src/traits.rs | 8 ++--- common/nym-compact-ecash/src/utils.rs | 12 +++---- common/nymcoconut/src/scheme/verification.rs | 24 ++++++------- 11 files changed, 97 insertions(+), 97 deletions(-) diff --git a/common/nym-compact-ecash/src/proofs/mod.rs b/common/nym-compact-ecash/src/proofs/mod.rs index 00cdf32437..7208560002 100644 --- a/common/nym-compact-ecash/src/proofs/mod.rs +++ b/common/nym-compact-ecash/src/proofs/mod.rs @@ -3,8 +3,8 @@ use std::convert::TryFrom; use std::convert::TryInto; use bls12_381::{G1Affine, G1Projective, Scalar}; -use digest::Digest; use digest::generic_array::typenum::Unsigned; +use digest::Digest; use group::GroupEncoding; use sha2::Sha256; @@ -20,10 +20,10 @@ type ChallengeDigest = Sha256; /// Generates a Scalar [or Fp] challenge by hashing a number of elliptic curve points. fn compute_challenge(iter: I) -> Scalar - where - D: Digest, - I: Iterator, - B: AsRef<[u8]>, +where + D: Digest, + I: Iterator, + B: AsRef<[u8]>, { let mut h = D::new(); for point_representation in iter { @@ -51,8 +51,8 @@ fn produce_response(witness_replacement: &Scalar, challenge: &Scalar, secret: &S // note: it's caller's responsibility to ensure witnesses.len() = secrets.len() fn produce_responses(witnesses: &[Scalar], challenge: &Scalar, secrets: &[S]) -> Vec - where - S: Borrow, +where + S: Borrow, { debug_assert_eq!(witnesses.len(), secrets.len()); diff --git a/common/nym-compact-ecash/src/proofs/proof_spend.rs b/common/nym-compact-ecash/src/proofs/proof_spend.rs index 0ac19e86a7..31c4cc4c26 100644 --- a/common/nym-compact-ecash/src/proofs/proof_spend.rs +++ b/common/nym-compact-ecash/src/proofs/proof_spend.rs @@ -5,7 +5,7 @@ use bls12_381::{G1Projective, G2Projective, Scalar}; use group::{Curve, Group, GroupEncoding}; use crate::error::{CompactEcashError, Result}; -use crate::proofs::{ChallengeDigest, compute_challenge, produce_response, produce_responses}; +use crate::proofs::{compute_challenge, produce_response, produce_responses, ChallengeDigest}; use crate::scheme::keygen::{SecretKeyUser, VerificationKeyAuth}; use crate::scheme::setup::{GroupParameters, Parameters}; use crate::utils::{try_deserialize_g1_projective, try_deserialize_g2_projective}; @@ -167,10 +167,10 @@ impl SpendProof { let zkcm_kappa = grparams.gen2() * r_r + verification_key.alpha + r_attributes - .iter() - .zip(verification_key.beta_g2.iter()) - .map(|(attr, beta_i)| beta_i * attr) - .sum::(); + .iter() + .zip(verification_key.beta_g2.iter()) + .map(|(attr, beta_i)| beta_i * attr) + .sum::(); let zkcm_aa = g1 * r_o_a + gamma1 * r_l; let zkcm_cc = g1 * r_o_c + gamma1 * r_v; @@ -257,11 +257,11 @@ impl SpendProof { + grparams.gen2() * self.response_r + verification_key.alpha * (Scalar::one() - self.challenge) + self - .response_attributes - .iter() - .zip(verification_key.beta_g2.iter()) - .map(|(attr, beta_i)| beta_i * attr) - .sum::(); + .response_attributes + .iter() + .zip(verification_key.beta_g2.iter()) + .map(|(attr, beta_i)| beta_i * attr) + .sum::(); let zkcm_aa = g1 * self.response_o_a + gamma1 * self.response_l + instance.aa * self.challenge; @@ -317,14 +317,14 @@ impl SpendProof { mod tests { use bls12_381::{G1Projective, G2Projective, Scalar}; use group::Curve; - use rand::{Rng, thread_rng}; + use rand::{thread_rng, Rng}; use crate::proofs::proof_spend::{SpendInstance, SpendProof, SpendWitness}; - use crate::scheme::{pseudorandom_fgt, pseudorandom_fgv}; use crate::scheme::aggregation::aggregate_verification_keys; - use crate::scheme::keygen::{PublicKeyUser, ttp_keygen, VerificationKeyAuth}; + use crate::scheme::keygen::{ttp_keygen, PublicKeyUser, VerificationKeyAuth}; + use crate::scheme::setup::{setup, GroupParameters}; use crate::scheme::PayInfo; - use crate::scheme::setup::{GroupParameters, setup}; + use crate::scheme::{pseudorandom_fgt, pseudorandom_fgv}; use crate::utils::hash_to_scalar; #[test] @@ -357,10 +357,10 @@ mod tests { let kappa = grparams.gen2() * r + verification_key.alpha + attributes - .iter() - .zip(verification_key.beta_g2.iter()) - .map(|(priv_attr, beta_i)| beta_i * priv_attr) - .sum::(); + .iter() + .zip(verification_key.beta_g2.iter()) + .map(|(priv_attr, beta_i)| beta_i * priv_attr) + .sum::(); let o_a = grparams.random_scalar(); let o_c = grparams.random_scalar(); diff --git a/common/nym-compact-ecash/src/proofs/proof_withdrawal.rs b/common/nym-compact-ecash/src/proofs/proof_withdrawal.rs index d2d8feb336..d44db84c42 100644 --- a/common/nym-compact-ecash/src/proofs/proof_withdrawal.rs +++ b/common/nym-compact-ecash/src/proofs/proof_withdrawal.rs @@ -5,7 +5,7 @@ use group::GroupEncoding; use itertools::izip; use crate::error::{CompactEcashError, Result}; -use crate::proofs::{ChallengeDigest, compute_challenge, produce_response, produce_responses}; +use crate::proofs::{compute_challenge, produce_response, produce_responses, ChallengeDigest}; use crate::scheme::keygen::PublicKeyUser; use crate::scheme::setup::GroupParameters; use crate::utils::try_deserialize_g1_projective; @@ -136,10 +136,10 @@ impl WithdrawalReqProof { // compute zkp commitments for each instance let zkcm_com = params.gen1() * r_com_opening + r_attributes - .iter() - .zip(params.gammas().iter()) - .map(|(rm_i, gamma_i)| gamma_i * rm_i) - .sum::(); + .iter() + .zip(params.gammas().iter()) + .map(|(rm_i, gamma_i)| gamma_i * rm_i) + .sum::(); let zkcm_pedcom = r_pedcom_openings .iter() @@ -201,21 +201,21 @@ impl WithdrawalReqProof { let zkcm_com = instance.com * self.challenge + params.gen1() * self.response_opening + self - .response_attributes - .iter() - .zip(params.gammas().iter()) - .map(|(m_i, gamma_i)| gamma_i * m_i) - .sum::(); + .response_attributes + .iter() + .zip(params.gammas().iter()) + .map(|(m_i, gamma_i)| gamma_i * m_i) + .sum::(); let zkcm_pedcom = izip!( instance.pc_coms.iter(), self.response_openings.iter(), self.response_attributes.iter() ) - .map(|(cm_j, resp_o_j, resp_m_j)| { - cm_j * self.challenge + params.gen1() * resp_o_j + instance.h * resp_m_j - }) - .collect::>(); + .map(|(cm_j, resp_o_j, resp_m_j)| { + cm_j * self.challenge + params.gen1() * resp_o_j + instance.h * resp_m_j + }) + .collect::>(); let zk_commitment_user_sk = instance.pk_user.pk * self.challenge + params.gen1() * self.response_attributes[0]; @@ -292,10 +292,10 @@ mod tests { let com_opening = params.random_scalar(); let com = params.gen1() * com_opening + attr - .iter() - .zip(params.gammas()) - .map(|(&m, gamma)| gamma * m) - .sum::(); + .iter() + .zip(params.gammas()) + .map(|(&m, gamma)| gamma * m) + .sum::(); let h = hash_g1(com.to_bytes()); let pc_openings = params.n_random_scalars(attr.len()); diff --git a/common/nym-compact-ecash/src/scheme/aggregation.rs b/common/nym-compact-ecash/src/scheme/aggregation.rs index d6f473ec43..30aa282798 100644 --- a/common/nym-compact-ecash/src/scheme/aggregation.rs +++ b/common/nym-compact-ecash/src/scheme/aggregation.rs @@ -6,16 +6,16 @@ use bls12_381::{G2Prepared, G2Projective, Scalar}; use group::Curve; use itertools::Itertools; -use crate::Attribute; use crate::error::{CompactEcashError, Result}; -use crate::scheme::{PartialWallet, Wallet}; use crate::scheme::keygen::{SecretKeyUser, VerificationKeyAuth}; use crate::scheme::setup::GroupParameters; use crate::scheme::withdrawal::RequestInfo; +use crate::scheme::{PartialWallet, Wallet}; use crate::utils::{ - check_bilinear_pairing, PartialSignature, perform_lagrangian_interpolation_at_origin, + check_bilinear_pairing, perform_lagrangian_interpolation_at_origin, PartialSignature, Signature, SignatureShare, SignerIndex, }; +use crate::Attribute; pub(crate) trait Aggregatable: Sized { fn aggregate(aggregatable: &[Self], indices: Option<&[SignerIndex]>) -> Result; @@ -27,10 +27,10 @@ pub(crate) trait Aggregatable: Sized { } impl Aggregatable for T - where - T: Sum, - for<'a> T: Sum<&'a T>, - for<'a> &'a T: Mul, +where + T: Sum, + for<'a> T: Sum<&'a T>, + for<'a> &'a T: Mul, { fn aggregate(aggregatable: &[T], indices: Option<&[u64]>) -> Result { if aggregatable.is_empty() { diff --git a/common/nym-compact-ecash/src/scheme/keygen.rs b/common/nym-compact-ecash/src/scheme/keygen.rs index f6eaf7b7f8..d0c62db429 100644 --- a/common/nym-compact-ecash/src/scheme/keygen.rs +++ b/common/nym-compact-ecash/src/scheme/keygen.rs @@ -11,11 +11,11 @@ use crate::error::{CompactEcashError, Result}; use crate::scheme::aggregation::aggregate_verification_keys; use crate::scheme::setup::GroupParameters; use crate::scheme::SignerIndex; +use crate::utils::Polynomial; use crate::utils::{ try_deserialize_g1_projective, try_deserialize_g2_projective, try_deserialize_scalar, try_deserialize_scalar_vec, }; -use crate::utils::Polynomial; #[derive(Debug, PartialEq, Clone)] pub struct SecretKeyAuth { @@ -242,13 +242,13 @@ impl<'a> Mul for &'a VerificationKeyAuth { } impl Sum for VerificationKeyAuth - where - T: Borrow, +where + T: Borrow, { #[inline] fn sum(iter: I) -> Self - where - I: Iterator, + where + I: Iterator, { let mut peekable = iter.peekable(); let head_attributes = match peekable.peek() { diff --git a/common/nym-compact-ecash/src/scheme/mod.rs b/common/nym-compact-ecash/src/scheme/mod.rs index c88a8f2637..fb826a73f5 100644 --- a/common/nym-compact-ecash/src/scheme/mod.rs +++ b/common/nym-compact-ecash/src/scheme/mod.rs @@ -5,14 +5,14 @@ use std::convert::TryInto; use bls12_381::{G1Projective, G2Prepared, G2Projective, Scalar}; use group::{Curve, Group}; -use crate::Attribute; use crate::error::{CompactEcashError, Result}; use crate::proofs::proof_spend::{SpendInstance, SpendProof, SpendWitness}; use crate::scheme::keygen::{SecretKeyUser, VerificationKeyAuth}; use crate::scheme::setup::{GroupParameters, Parameters}; use crate::utils::{ - check_bilinear_pairing, hash_to_scalar, Signature, SignerIndex, try_deserialize_g1_projective, + check_bilinear_pairing, hash_to_scalar, try_deserialize_g1_projective, Signature, SignerIndex, }; +use crate::Attribute; pub mod aggregation; pub mod identify; @@ -108,7 +108,8 @@ impl Wallet { // evaluate the pseudorandom functions let ss = pseudorandom_fgv(&grparams, self.v(), self.l()); - let tt = grparams.gen1() * sk_user.sk + pseudorandom_fgt(&grparams, self.t(), self.l()) * rr; + let tt = + grparams.gen1() * sk_user.sk + pseudorandom_fgt(&grparams, self.t(), self.l()) * rr; // compute values mu, o_mu, lambda, o_lambda let mu: Scalar = (self.v() + Scalar::from(self.l()) + Scalar::from(1)) @@ -200,10 +201,10 @@ pub fn compute_kappa( params.gen2() * blinding_factor + verification_key.alpha + attributes - .iter() - .zip(verification_key.beta_g2.iter()) - .map(|(priv_attr, beta_i)| beta_i * priv_attr) - .sum::() + .iter() + .zip(verification_key.beta_g2.iter()) + .map(|(priv_attr, beta_i)| beta_i * priv_attr) + .sum::() } pub struct PayInfo { @@ -266,7 +267,6 @@ impl Payment { )); } - // verify integrity of R if !(self.rr == hash_to_scalar(pay_info.info)) { return Err(CompactEcashError::Spend( diff --git a/common/nym-compact-ecash/src/scheme/withdrawal.rs b/common/nym-compact-ecash/src/scheme/withdrawal.rs index 047a1c46d2..90b9d5d39d 100644 --- a/common/nym-compact-ecash/src/scheme/withdrawal.rs +++ b/common/nym-compact-ecash/src/scheme/withdrawal.rs @@ -5,10 +5,10 @@ use crate::error::{CompactEcashError, Result}; use crate::proofs::proof_withdrawal::{ WithdrawalReqInstance, WithdrawalReqProof, WithdrawalReqWitness, }; -use crate::scheme::keygen::{PublicKeyUser, SecretKeyAuth, SecretKeyUser, VerificationKeyAuth}; use crate::scheme::keygen::ttp_keygen; -use crate::scheme::PartialWallet; +use crate::scheme::keygen::{PublicKeyUser, SecretKeyAuth, SecretKeyUser, VerificationKeyAuth}; use crate::scheme::setup::{GroupParameters, Parameters}; +use crate::scheme::PartialWallet; use crate::utils::{check_bilinear_pairing, hash_g1}; use crate::utils::{BlindedSignature, Signature}; @@ -57,10 +57,10 @@ pub fn withdrawal_request( let com_opening = params.random_scalar(); let com = params.gen1() * com_opening + attributes - .iter() - .zip(gammas) - .map(|(&m, gamma)| gamma * m) - .sum::(); + .iter() + .zip(gammas) + .map(|(&m, gamma)| gamma * m) + .sum::(); // Value h in the paper let com_hash = hash_g1(com.to_bytes()); diff --git a/common/nym-compact-ecash/src/tests/e2e.rs b/common/nym-compact-ecash/src/tests/e2e.rs index 03b4e92911..40bcdefa79 100644 --- a/common/nym-compact-ecash/src/tests/e2e.rs +++ b/common/nym-compact-ecash/src/tests/e2e.rs @@ -1,17 +1,17 @@ use itertools::izip; use crate::error::CompactEcashError; -use crate::scheme::{PartialWallet, Payment, pseudorandom_fgt}; use crate::scheme::aggregation::{ aggregate_signature_shares, aggregate_verification_keys, aggregate_wallets, }; use crate::scheme::identify::identify; use crate::scheme::keygen::{ - generate_keypair_user, PublicKeyUser, SecretKeyUser, ttp_keygen, VerificationKeyAuth, + generate_keypair_user, ttp_keygen, PublicKeyUser, SecretKeyUser, VerificationKeyAuth, }; -use crate::scheme::PayInfo; -use crate::scheme::setup::{GroupParameters, Parameters, setup}; +use crate::scheme::setup::{setup, GroupParameters, Parameters}; use crate::scheme::withdrawal::{issue_verify, issue_wallet, withdrawal_request}; +use crate::scheme::PayInfo; +use crate::scheme::{pseudorandom_fgt, PartialWallet, Payment}; use crate::utils::{hash_to_scalar, SignatureShare}; #[test] @@ -45,8 +45,8 @@ fn main() -> Result<(), CompactEcashError> { wallet_blinded_signatures.iter(), verification_keys_auth.iter() ) - .map(|(w, vk)| issue_verify(&grparams, vk, &user_keypair.secret_key(), w, &req_info).unwrap()) - .collect(); + .map(|(w, vk)| issue_verify(&grparams, vk, &user_keypair.secret_key(), w, &req_info).unwrap()) + .collect(); // Aggregate partial wallets let aggr_wallet = aggregate_wallets( diff --git a/common/nym-compact-ecash/src/traits.rs b/common/nym-compact-ecash/src/traits.rs index c2e93142f6..ca3d5c7ea8 100644 --- a/common/nym-compact-ecash/src/traits.rs +++ b/common/nym-compact-ecash/src/traits.rs @@ -1,8 +1,8 @@ use crate::CompactEcashError; pub trait Bytable - where - Self: Sized, +where + Self: Sized, { fn to_byte_vec(&self) -> Vec; @@ -10,8 +10,8 @@ pub trait Bytable } pub trait Base58 - where - Self: Bytable, +where + Self: Bytable, { fn try_from_bs58>(x: S) -> Result { Self::try_from_byte_slice(&bs58::decode(x.as_ref()).into_vec().unwrap()) diff --git a/common/nym-compact-ecash/src/utils.rs b/common/nym-compact-ecash/src/utils.rs index 293edce3f8..42c2303aa7 100644 --- a/common/nym-compact-ecash/src/utils.rs +++ b/common/nym-compact-ecash/src/utils.rs @@ -6,10 +6,10 @@ use core::ops::Mul; use std::convert::{TryFrom, TryInto}; use std::ops::Neg; -use bls12_381::{ - G1Affine, G1Projective, G2Affine, G2Prepared, G2Projective, multi_miller_loop, Scalar, -}; use bls12_381::hash_to_curve::{ExpandMsgXmd, HashToCurve, HashToField}; +use bls12_381::{ + multi_miller_loop, G1Affine, G1Projective, G2Affine, G2Prepared, G2Projective, Scalar, +}; use ff::Field; use group::{Curve, Group}; @@ -85,9 +85,9 @@ pub(crate) fn perform_lagrangian_interpolation_at_origin( points: &[SignerIndex], values: &[T], ) -> Result - where - T: Sum, - for<'a> &'a T: Mul, +where + T: Sum, + for<'a> &'a T: Mul, { if points.is_empty() || values.is_empty() { return Err(CompactEcashError::Interpolation( diff --git a/common/nymcoconut/src/scheme/verification.rs b/common/nymcoconut/src/scheme/verification.rs index e312864edb..c2ccd2da12 100644 --- a/common/nymcoconut/src/scheme/verification.rs +++ b/common/nymcoconut/src/scheme/verification.rs @@ -5,10 +5,9 @@ use core::ops::Neg; use std::convert::TryFrom; use std::convert::TryInto; -use bls12_381::{G1Affine, G2Prepared, G2Projective, multi_miller_loop, Scalar}; +use bls12_381::{multi_miller_loop, G1Affine, G2Prepared, G2Projective, Scalar}; use group::{Curve, Group}; -use crate::Attribute; use crate::error::{CoconutError, Result}; use crate::proofs::ProofKappaZeta; use crate::scheme::setup::Parameters; @@ -16,6 +15,7 @@ use crate::scheme::Signature; use crate::scheme::VerificationKey; use crate::traits::{Base58, Bytable}; use crate::utils::try_deserialize_g2_projective; +use crate::Attribute; // TODO NAMING: this whole thing // Theta @@ -123,10 +123,10 @@ pub fn compute_kappa( params.gen2() * blinding_factor + verification_key.alpha + private_attributes - .iter() - .zip(verification_key.beta_g2.iter()) - .map(|(priv_attr, beta_i)| beta_i * priv_attr) - .sum::() + .iter() + .zip(verification_key.beta_g2.iter()) + .map(|(priv_attr, beta_i)| beta_i * priv_attr) + .sum::() } pub fn compute_zeta(params: &Parameters, serial_number: Attribute) -> G2Projective { @@ -250,11 +250,11 @@ pub fn verify( ) -> bool { let kappa = (verification_key.alpha + public_attributes - .iter() - .zip(verification_key.beta_g2.iter()) - .map(|(m_i, b_i)| b_i * m_i) - .sum::()) - .to_affine(); + .iter() + .zip(verification_key.beta_g2.iter()) + .map(|(m_i, b_i)| b_i * m_i) + .sum::()) + .to_affine(); check_bilinear_pairing( &sig.0.to_affine(), @@ -290,7 +290,7 @@ mod tests { serial_number, binding_number, ) - .unwrap(); + .unwrap(); let bytes = theta.to_bytes(); assert_eq!(Theta::try_from(bytes.as_slice()).unwrap(), theta);