From 2eed9fd2473219fa1e667b797ccde431f9425c2d Mon Sep 17 00:00:00 2001 From: aniampio Date: Tue, 19 Apr 2022 22:46:58 +0300 Subject: [PATCH] Add benchmarks --- Cargo.lock | 32 +- Cargo.toml | 2 +- .../Cargo.toml | 8 +- .../nym_compact_ecash/benches/benchmarks.rs | 274 ++++++++++++++++++ common/nym_compact_ecash/src/constants.rs | 1 + .../src/error.rs | 0 .../src/lib.rs | 12 + .../src/proofs/mod.rs | 0 .../src/proofs/proof_spend.rs | 42 +-- .../src/proofs/proof_withdrawal.rs | 0 .../src/scheme/aggregation.rs | 0 .../src/scheme/identify.rs | 0 .../src/scheme/keygen.rs | 0 .../src/scheme/mod.rs | 19 +- .../src/scheme/setup.rs | 7 +- .../src/scheme/withdrawal.rs | 0 .../src/tests/e2e.rs | 22 +- .../src/tests/mod.rs | 0 .../src/traits.rs | 0 .../src/utils.rs | 0 common/nymcoconut/benches/benchmarks.rs | 100 +++---- 21 files changed, 406 insertions(+), 113 deletions(-) rename common/{nym-compact-ecash => nym_compact_ecash}/Cargo.toml (85%) create mode 100644 common/nym_compact_ecash/benches/benchmarks.rs create mode 100644 common/nym_compact_ecash/src/constants.rs rename common/{nym-compact-ecash => nym_compact_ecash}/src/error.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/lib.rs (53%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/proofs/mod.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/proofs/proof_spend.rs (94%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/proofs/proof_withdrawal.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/scheme/aggregation.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/scheme/identify.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/scheme/keygen.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/scheme/mod.rs (95%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/scheme/setup.rs (97%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/scheme/withdrawal.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/tests/e2e.rs (83%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/tests/mod.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/traits.rs (100%) rename common/{nym-compact-ecash => nym_compact_ecash}/src/utils.rs (100%) diff --git a/Cargo.lock b/Cargo.lock index c748fdd173..9323829301 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2934,22 +2934,6 @@ dependencies = [ "websocket-requests", ] -[[package]] -name = "nym-compact-ecash" -version = "0.1.0" -dependencies = [ - "bls12_381", - "bs58", - "criterion", - "digest 0.9.0", - "ff 0.10.1", - "group 0.10.0", - "itertools", - "rand 0.8.5", - "sha2", - "thiserror", -] - [[package]] name = "nym-divisible-ecash" version = "0.1.0" @@ -3150,6 +3134,22 @@ dependencies = [ "version-checker", ] +[[package]] +name = "nym_compact_ecash" +version = "0.1.0" +dependencies = [ + "bls12_381", + "bs58", + "criterion", + "digest 0.9.0", + "ff 0.10.1", + "group 0.10.0", + "itertools", + "rand 0.8.5", + "sha2", + "thiserror", +] + [[package]] name = "nymcoconut" version = "0.5.0" diff --git a/Cargo.toml b/Cargo.toml index 31f8ee544f..82aab18442 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,7 +33,7 @@ members = [ "common/network-defaults", "common/nonexhaustive-delayqueue", "common/nymcoconut", - "common/nym-compact-ecash", + "common/nym_compact_ecash", "common/nym-divisible-ecash", "common/nymsphinx", "common/nymsphinx/acknowledgements", diff --git a/common/nym-compact-ecash/Cargo.toml b/common/nym_compact_ecash/Cargo.toml similarity index 85% rename from common/nym-compact-ecash/Cargo.toml rename to common/nym_compact_ecash/Cargo.toml index 44b05d74da..0d73627ca0 100644 --- a/common/nym-compact-ecash/Cargo.toml +++ b/common/nym_compact_ecash/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "nym-compact-ecash" +name = "nym_compact_ecash" version = "0.1.0" authors = ["Ania Piotrowska "] edition = "2021" @@ -24,4 +24,8 @@ default-features = false [dependencies.group] version = "0.10" -default-features = false \ No newline at end of file +default-features = false + +[[bench]] +name = "benchmarks" +harness = false \ No newline at end of file diff --git a/common/nym_compact_ecash/benches/benchmarks.rs b/common/nym_compact_ecash/benches/benchmarks.rs new file mode 100644 index 0000000000..f2fd7e0743 --- /dev/null +++ b/common/nym_compact_ecash/benches/benchmarks.rs @@ -0,0 +1,274 @@ +// Copyright 2021 - Nym Technologies SA +// SPDX-License-Identifier: Apache-2.0 + +use std::ops::Neg; +use std::time::Duration; + +use bls12_381::{G1Affine, G2Affine, G2Prepared, multi_miller_loop, Scalar}; +use criterion::{Criterion, criterion_group, criterion_main}; +use ff::Field; +use group::{Curve, Group}; +use itertools::izip; +use rand::seq::SliceRandom; + +use nym_compact_ecash::{aggregate_verification_keys, aggregate_wallets, generate_keypair_user, issue_verify, issue_wallet, PartialWallet, PayInfo, ttp_keygen, VerificationKeyAuth, withdrawal_request}; +use nym_compact_ecash::setup::setup; + +#[allow(unused)] +fn double_pairing(g11: &G1Affine, g21: &G2Affine, g12: &G1Affine, g22: &G2Affine) { + let gt1 = bls12_381::pairing(g11, g21); + let gt2 = bls12_381::pairing(g12, g22); + assert_eq!(gt1, gt2) +} + +#[allow(unused)] +fn multi_miller_pairing_affine(g11: &G1Affine, g21: &G2Affine, g12: &G1Affine, g22: &G2Affine) { + let miller_loop_result = multi_miller_loop(&[ + (g11, &G2Prepared::from(*g21)), + (&g12.neg(), &G2Prepared::from(*g22)), + ]); + assert!(bool::from( + miller_loop_result.final_exponentiation().is_identity() + )) +} + +#[allow(unused)] +fn multi_miller_pairing_with_prepared( + g11: &G1Affine, + g21: &G2Prepared, + g12: &G1Affine, + g22: &G2Prepared, +) { + let miller_loop_result = multi_miller_loop(&[(g11, g21), (&g12.neg(), g22)]); + assert!(bool::from( + miller_loop_result.final_exponentiation().is_identity() + )) +} + +// the case of being able to prepare G2 generator +#[allow(unused)] +fn multi_miller_pairing_with_semi_prepared( + g11: &G1Affine, + g21: &G2Affine, + g12: &G1Affine, + g22: &G2Prepared, +) { + let miller_loop_result = + multi_miller_loop(&[(g11, &G2Prepared::from(*g21)), (&g12.neg(), g22)]); + assert!(bool::from( + miller_loop_result.final_exponentiation().is_identity() + )) +} + +#[allow(unused)] +fn bench_pairings(c: &mut Criterion) { + let mut rng = rand::thread_rng(); + + let g1 = G1Affine::generator(); + let g2 = G2Affine::generator(); + let r = Scalar::random(&mut rng); + let s = Scalar::random(&mut rng); + + let g11 = (g1 * r).to_affine(); + let g21 = (g2 * s).to_affine(); + let g21_prep = G2Prepared::from(g21); + + let g12 = (g1 * s).to_affine(); + let g22 = (g2 * r).to_affine(); + let g22_prep = G2Prepared::from(g22); + + c.bench_function("double pairing", |b| { + b.iter(|| double_pairing(&g11, &g21, &g12, &g22)) + }); + + c.bench_function("multi miller in affine", |b| { + b.iter(|| multi_miller_pairing_affine(&g11, &g21, &g12, &g22)) + }); + + c.bench_function("multi miller with prepared g2", |b| { + b.iter(|| multi_miller_pairing_with_prepared(&g11, &g21_prep, &g12, &g22_prep)) + }); + + c.bench_function("multi miller with semi-prepared g2", |b| { + b.iter(|| multi_miller_pairing_with_semi_prepared(&g11, &g21, &g12, &g22_prep)) + }); +} + +struct BenchCase { + num_authorities: u64, + threshold_p: f32, + L: u64, +} + +fn bench_compact_ecash(c: &mut Criterion) { + let mut group = c.benchmark_group("benchmark-compact-ecash"); + group.measurement_time(Duration::from_secs(200)); + + let case = BenchCase { + num_authorities: 100, + threshold_p: 0.7, + L: 100, + }; + + let params = setup(case.L); + let grparams = params.grp(); + let user_keypair = generate_keypair_user(&grparams); + let authorities_keypairs = ttp_keygen(&grparams, 2, 3).unwrap(); + let verification_keys_auth: Vec = authorities_keypairs + .iter() + .map(|keypair| keypair.verification_key()) + .collect(); + + let verification_key = aggregate_verification_keys(&verification_keys_auth, Some(&[1, 2, 3])).unwrap(); + // ISSUANCE PHASE + + let (req, req_info) = withdrawal_request(grparams, &user_keypair.secret_key()).unwrap(); + + // CLIENT BENCHMARK: Prepare a single withdrawal request, i.e., + // a data needed to ask for a withdrawal of a wallet + // group.bench_function( + // &format!( + // "[Client] withdrawal_request_{}_authorities_{}_L_{}_threshold", + // case.num_authorities, + // case.L, + // case.threshold_p, + // ), + // |b| { + // b.iter(|| withdrawal_request(grparams, &user_keypair.secret_key()).unwrap()) + // }, + // ); + + + // ISSUING AUTHRORITY BENCHMARK: Benchmark the issue_wallet function + // called by an authority to issue a blind signature on a partial wallet + let mut rng = rand::thread_rng(); + let keypair = authorities_keypairs.choose(&mut rng).unwrap(); + // group.bench_function( + // &format!( + // "[Issuing Authority] issue_partial_wallet_with_L_{}", + // case.L, + // ), + // |b| { + // b.iter(|| { + // issue_wallet( + // &grparams, + // keypair.secret_key(), + // user_keypair.public_key(), + // &req, + // ) + // }) + // }, + // ); + + let mut wallet_blinded_signatures = Vec::new(); + for auth_keypair in authorities_keypairs { + let blind_signature = issue_wallet( + &grparams, + auth_keypair.secret_key(), + user_keypair.public_key(), + &req, + ); + wallet_blinded_signatures.push(blind_signature.unwrap()); + } + + // CLIENT BENCHMARK: verify the issued partial wallet + let w = wallet_blinded_signatures.get(0).clone().unwrap(); + let vk = verification_keys_auth.get(0).clone().unwrap(); + // group.bench_function( + // &format!( + // "[Client] issue_verify_of_a_partial_wallet_with_L_{}", + // case.L, + // ), + // |b| { + // b.iter(|| { + // issue_verify(&grparams, vk, &user_keypair.secret_key(), w, &req_info) + // }) + // }, + // ); + + let unblinded_wallet_shares: Vec = izip!( + wallet_blinded_signatures.iter(), + verification_keys_auth.iter() + ) + .map(|(w, vk)| issue_verify(&grparams, vk, &user_keypair.secret_key(), w, &req_info).unwrap()) + .collect(); + + // // CLIENT BENCHMARK: aggregating all partial wallets + // group.bench_function( + // &format!( + // "[Client] aggregate_wallets_with_L_{}_threshold_{}", + // case.L, + // case.threshold_p, + // ), + // |b| { + // b.iter(|| { + // aggregate_wallets( + // &grparams, + // &verification_key, + // &user_keypair.secret_key(), + // &unblinded_wallet_shares, + // &req_info, + // ).unwrap() + // }) + // }, + // ); + + // Aggregate partial wallets + let aggr_wallet = aggregate_wallets( + &grparams, + &verification_key, + &user_keypair.secret_key(), + &unblinded_wallet_shares, + &req_info, + ).unwrap(); + + // SPENDING PHASE + let pay_info = PayInfo { info: [6u8; 32] }; + + // CLIENT BENCHMARK: spend a single coin from the wallet + group.bench_function( + &format!( + "[Client] spend_a_single_coin_L_{}_threshold_{}", + case.L, + case.threshold_p, + ), + |b| { + b.iter(|| { + aggr_wallet.spend( + ¶ms, + &verification_key, + &user_keypair.secret_key(), + &pay_info, + true, + ).unwrap() + }) + }, + ); + + let (payment, upd_wallet) = aggr_wallet.spend( + ¶ms, + &verification_key, + &user_keypair.secret_key(), + &pay_info, + false, + ).unwrap(); + + // MERCHANT BENCHMARK: verify whether the submitted payment is legit + group.bench_function( + &format!( + "[Merchant] spend_verify_of_a_single_payment_L_{}_threshold_{}", + case.L, + case.threshold_p, + ), + |b| { + b.iter(|| { + payment + .spend_verify(¶ms, &verification_key, &pay_info) + .unwrap() + }) + }, + ); +} + +criterion_group!(benches, bench_compact_ecash); +criterion_main!(benches); \ No newline at end of file diff --git a/common/nym_compact_ecash/src/constants.rs b/common/nym_compact_ecash/src/constants.rs new file mode 100644 index 0000000000..b0d9ba9c96 --- /dev/null +++ b/common/nym_compact_ecash/src/constants.rs @@ -0,0 +1 @@ +pub const MAX_COIN_VALUE: u64 = 32; \ No newline at end of file diff --git a/common/nym-compact-ecash/src/error.rs b/common/nym_compact_ecash/src/error.rs similarity index 100% rename from common/nym-compact-ecash/src/error.rs rename to common/nym_compact_ecash/src/error.rs diff --git a/common/nym-compact-ecash/src/lib.rs b/common/nym_compact_ecash/src/lib.rs similarity index 53% rename from common/nym-compact-ecash/src/lib.rs rename to common/nym_compact_ecash/src/lib.rs index 6fbf2bcd35..4e0d5dde74 100644 --- a/common/nym-compact-ecash/src/lib.rs +++ b/common/nym_compact_ecash/src/lib.rs @@ -2,6 +2,17 @@ use std::convert::TryInto; use bls12_381::Scalar; +pub use scheme::aggregation::aggregate_verification_keys; +pub use scheme::aggregation::aggregate_wallets; +pub use scheme::keygen::generate_keypair_user; +pub use scheme::keygen::ttp_keygen; +pub use scheme::keygen::VerificationKeyAuth; +pub use scheme::PartialWallet; +pub use scheme::PayInfo; +pub use scheme::setup; +pub use scheme::withdrawal::issue_verify; +pub use scheme::withdrawal::issue_wallet; +pub use scheme::withdrawal::withdrawal_request; pub use traits::Base58; use crate::error::CompactEcashError; @@ -14,6 +25,7 @@ mod scheme; mod tests; mod traits; mod utils; +mod constants; pub type Attribute = Scalar; diff --git a/common/nym-compact-ecash/src/proofs/mod.rs b/common/nym_compact_ecash/src/proofs/mod.rs similarity index 100% rename from common/nym-compact-ecash/src/proofs/mod.rs rename to common/nym_compact_ecash/src/proofs/mod.rs diff --git a/common/nym-compact-ecash/src/proofs/proof_spend.rs b/common/nym_compact_ecash/src/proofs/proof_spend.rs similarity index 94% rename from common/nym-compact-ecash/src/proofs/proof_spend.rs rename to common/nym_compact_ecash/src/proofs/proof_spend.rs index 31c4cc4c26..13f90950c9 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::{compute_challenge, produce_response, produce_responses, ChallengeDigest}; +use crate::proofs::{ChallengeDigest, compute_challenge, produce_response, produce_responses}; 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,20 +317,21 @@ impl SpendProof { mod tests { use bls12_381::{G1Projective, G2Projective, Scalar}; use group::Curve; - use rand::{thread_rng, Rng}; + use rand::{Rng, thread_rng}; + use crate::constants::MAX_COIN_VALUE; use crate::proofs::proof_spend::{SpendInstance, SpendProof, SpendWitness}; - use crate::scheme::aggregation::aggregate_verification_keys; - use crate::scheme::keygen::{ttp_keygen, PublicKeyUser, VerificationKeyAuth}; - use crate::scheme::setup::{setup, GroupParameters}; - use crate::scheme::PayInfo; 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::PayInfo; + use crate::scheme::setup::{GroupParameters, setup}; use crate::utils::hash_to_scalar; #[test] fn spend_proof_construct_and_verify() { let rng = thread_rng(); - let params = setup(); + let params = setup(MAX_COIN_VALUE); let grparams = params.grp(); let sk = grparams.random_scalar(); let pk_user = PublicKeyUser { @@ -357,10 +358,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(); @@ -420,3 +421,4 @@ mod tests { assert!(zk_proof.verify(¶ms, &instance, &verification_key, rr)) } } + diff --git a/common/nym-compact-ecash/src/proofs/proof_withdrawal.rs b/common/nym_compact_ecash/src/proofs/proof_withdrawal.rs similarity index 100% rename from common/nym-compact-ecash/src/proofs/proof_withdrawal.rs rename to common/nym_compact_ecash/src/proofs/proof_withdrawal.rs diff --git a/common/nym-compact-ecash/src/scheme/aggregation.rs b/common/nym_compact_ecash/src/scheme/aggregation.rs similarity index 100% rename from common/nym-compact-ecash/src/scheme/aggregation.rs rename to common/nym_compact_ecash/src/scheme/aggregation.rs diff --git a/common/nym-compact-ecash/src/scheme/identify.rs b/common/nym_compact_ecash/src/scheme/identify.rs similarity index 100% rename from common/nym-compact-ecash/src/scheme/identify.rs rename to common/nym_compact_ecash/src/scheme/identify.rs diff --git a/common/nym-compact-ecash/src/scheme/keygen.rs b/common/nym_compact_ecash/src/scheme/keygen.rs similarity index 100% rename from common/nym-compact-ecash/src/scheme/keygen.rs rename to common/nym_compact_ecash/src/scheme/keygen.rs diff --git a/common/nym-compact-ecash/src/scheme/mod.rs b/common/nym_compact_ecash/src/scheme/mod.rs similarity index 95% rename from common/nym-compact-ecash/src/scheme/mod.rs rename to common/nym_compact_ecash/src/scheme/mod.rs index fb826a73f5..aed7a0e56f 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, try_deserialize_g1_projective, Signature, SignerIndex, + check_bilinear_pairing, hash_to_scalar, Signature, SignerIndex, try_deserialize_g1_projective, }; -use crate::Attribute; pub mod aggregation; pub mod identify; @@ -73,6 +73,7 @@ impl Wallet { verification_key: &VerificationKeyAuth, sk_user: &SecretKeyUser, pay_info: &PayInfo, + bench_flag: bool, ) -> Result<(Payment, &Self)> { if self.l() > params.L() { return Err(CompactEcashError::Spend( @@ -176,7 +177,9 @@ impl Wallet { zk_proof, }; - self.up(); + if !bench_flag { + self.up(); + } Ok((pay, self)) } @@ -201,14 +204,14 @@ 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 { - pub(crate) info: [u8; 32], + pub info: [u8; 32], } #[derive(Debug, Clone)] diff --git a/common/nym-compact-ecash/src/scheme/setup.rs b/common/nym_compact_ecash/src/scheme/setup.rs similarity index 97% rename from common/nym-compact-ecash/src/scheme/setup.rs rename to common/nym_compact_ecash/src/scheme/setup.rs index 0996b5c301..502b4be5f3 100644 --- a/common/nym-compact-ecash/src/scheme/setup.rs +++ b/common/nym_compact_ecash/src/scheme/setup.rs @@ -9,7 +9,6 @@ use crate::error::{CompactEcashError, Result}; use crate::utils::{hash_g1, Signature}; const ATTRIBUTES_LEN: usize = 3; -const MAX_COIN_VALUE: u64 = 32; pub struct GroupParameters { /// Generator of the G1 group @@ -134,14 +133,14 @@ impl Parameters { } } -pub fn setup() -> Parameters { +pub fn setup(L: u64) -> Parameters { let grp = GroupParameters::new().unwrap(); let x = grp.random_scalar(); let y = grp.random_scalar(); let skRP = SecretKeyRP { x, y }; let pkRP = skRP.public_key(&grp); let mut signs = HashMap::new(); - for l in 0..MAX_COIN_VALUE { + for l in 0..L { let r = grp.random_scalar(); let h = grp.gen1() * r; signs.insert( @@ -155,7 +154,7 @@ pub fn setup() -> Parameters { Parameters { grp, pkRP, - L: MAX_COIN_VALUE, + L, signs, } } diff --git a/common/nym-compact-ecash/src/scheme/withdrawal.rs b/common/nym_compact_ecash/src/scheme/withdrawal.rs similarity index 100% rename from common/nym-compact-ecash/src/scheme/withdrawal.rs rename to common/nym_compact_ecash/src/scheme/withdrawal.rs diff --git a/common/nym-compact-ecash/src/tests/e2e.rs b/common/nym_compact_ecash/src/tests/e2e.rs similarity index 83% rename from common/nym-compact-ecash/src/tests/e2e.rs rename to common/nym_compact_ecash/src/tests/e2e.rs index 40bcdefa79..13bd6992e9 100644 --- a/common/nym-compact-ecash/src/tests/e2e.rs +++ b/common/nym_compact_ecash/src/tests/e2e.rs @@ -1,22 +1,23 @@ use itertools::izip; +use crate::constants::MAX_COIN_VALUE; 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, ttp_keygen, PublicKeyUser, SecretKeyUser, VerificationKeyAuth, + generate_keypair_user, PublicKeyUser, SecretKeyUser, ttp_keygen, VerificationKeyAuth, }; -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::scheme::setup::{GroupParameters, Parameters, setup}; +use crate::scheme::withdrawal::{issue_verify, issue_wallet, withdrawal_request}; use crate::utils::{hash_to_scalar, SignatureShare}; #[test] fn main() -> Result<(), CompactEcashError> { - let params = setup(); + let params = setup(MAX_COIN_VALUE); let grparams = params.grp(); let user_keypair = generate_keypair_user(&grparams); @@ -45,8 +46,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( @@ -60,12 +61,7 @@ fn main() -> Result<(), CompactEcashError> { // Let's try to spend some coins let pay_info = PayInfo { info: [6u8; 32] }; - let (payment, upd_wallet) = aggr_wallet.spend( - ¶ms, - &verification_key, - &user_keypair.secret_key(), - &pay_info, - )?; + let (payment, upd_wallet) = aggr_wallet.spend(¶ms, &verification_key, &user_keypair.secret_key(), &pay_info, false)?; assert!(payment .spend_verify(¶ms, &verification_key, &pay_info) diff --git a/common/nym-compact-ecash/src/tests/mod.rs b/common/nym_compact_ecash/src/tests/mod.rs similarity index 100% rename from common/nym-compact-ecash/src/tests/mod.rs rename to common/nym_compact_ecash/src/tests/mod.rs diff --git a/common/nym-compact-ecash/src/traits.rs b/common/nym_compact_ecash/src/traits.rs similarity index 100% rename from common/nym-compact-ecash/src/traits.rs rename to common/nym_compact_ecash/src/traits.rs diff --git a/common/nym-compact-ecash/src/utils.rs b/common/nym_compact_ecash/src/utils.rs similarity index 100% rename from common/nym-compact-ecash/src/utils.rs rename to common/nym_compact_ecash/src/utils.rs diff --git a/common/nymcoconut/benches/benchmarks.rs b/common/nymcoconut/benches/benchmarks.rs index 45c277cf97..75578a35dd 100644 --- a/common/nymcoconut/benches/benchmarks.rs +++ b/common/nymcoconut/benches/benchmarks.rs @@ -1,19 +1,21 @@ // Copyright 2021 - Nym Technologies SA // SPDX-License-Identifier: Apache-2.0 -use bls12_381::{multi_miller_loop, G1Affine, G1Projective, G2Affine, G2Prepared, Scalar}; -use criterion::{criterion_group, criterion_main, Criterion}; -use ff::Field; -use group::{Curve, Group}; -use nymcoconut::{ - aggregate_signature_shares, aggregate_verification_keys, blind_sign, elgamal_keygen, - prepare_blind_sign, prove_bandwidth_credential, setup, ttp_keygen, verify_credential, - Attribute, BlindedSignature, Parameters, Signature, SignatureShare, VerificationKey, -}; -use rand::seq::SliceRandom; use std::ops::Neg; use std::time::Duration; +use bls12_381::{G1Affine, G1Projective, G2Affine, G2Prepared, multi_miller_loop, Scalar}; +use criterion::{Criterion, criterion_group, criterion_main}; +use ff::Field; +use group::{Curve, Group}; +use rand::seq::SliceRandom; + +use nymcoconut::{ + aggregate_signature_shares, aggregate_verification_keys, Attribute, blind_sign, + BlindedSignature, elgamal_keygen, Parameters, prepare_blind_sign, prove_bandwidth_credential, + setup, Signature, SignatureShare, ttp_keygen, VerificationKey, verify_credential, +}; + #[allow(unused)] fn double_pairing(g11: &G1Affine, g21: &G2Affine, g12: &G1Affine, g22: &G2Affine) { let gt1 = bls12_381::pairing(g11, g21); @@ -32,6 +34,40 @@ fn multi_miller_pairing_affine(g11: &G1Affine, g21: &G2Affine, g12: &G1Affine, g )) } +#[allow(unused)] +fn bench_pairings(c: &mut Criterion) { + let mut rng = rand::thread_rng(); + + let g1 = G1Affine::generator(); + let g2 = G2Affine::generator(); + let r = Scalar::random(&mut rng); + let s = Scalar::random(&mut rng); + + let g11 = (g1 * r).to_affine(); + let g21 = (g2 * s).to_affine(); + let g21_prep = G2Prepared::from(g21); + + let g12 = (g1 * s).to_affine(); + let g22 = (g2 * r).to_affine(); + let g22_prep = G2Prepared::from(g22); + + c.bench_function("double pairing", |b| { + b.iter(|| double_pairing(&g11, &g21, &g12, &g22)) + }); + + c.bench_function("multi miller in affine", |b| { + b.iter(|| multi_miller_pairing_affine(&g11, &g21, &g12, &g22)) + }); + + c.bench_function("multi miller with prepared g2", |b| { + b.iter(|| multi_miller_pairing_with_prepared(&g11, &g21_prep, &g12, &g22_prep)) + }); + + c.bench_function("multi miller with semi-prepared g2", |b| { + b.iter(|| multi_miller_pairing_with_semi_prepared(&g11, &g21, &g12, &g22_prep)) + }); +} + #[allow(unused)] fn multi_miller_pairing_with_prepared( g11: &G1Affine, @@ -104,7 +140,7 @@ fn unblind_and_aggregate( &attributes, &unblinded_signature_shares, ) - .unwrap() + .unwrap() } struct BenchCase { @@ -124,40 +160,6 @@ impl BenchCase { } } -#[allow(unused)] -fn bench_pairings(c: &mut Criterion) { - let mut rng = rand::thread_rng(); - - let g1 = G1Affine::generator(); - let g2 = G2Affine::generator(); - let r = Scalar::random(&mut rng); - let s = Scalar::random(&mut rng); - - let g11 = (g1 * r).to_affine(); - let g21 = (g2 * s).to_affine(); - let g21_prep = G2Prepared::from(g21); - - let g12 = (g1 * s).to_affine(); - let g22 = (g2 * r).to_affine(); - let g22_prep = G2Prepared::from(g22); - - c.bench_function("double pairing", |b| { - b.iter(|| double_pairing(&g11, &g21, &g12, &g22)) - }); - - c.bench_function("multi miller in affine", |b| { - b.iter(|| multi_miller_pairing_affine(&g11, &g21, &g12, &g22)) - }); - - c.bench_function("multi miller with prepared g2", |b| { - b.iter(|| multi_miller_pairing_with_prepared(&g11, &g21_prep, &g12, &g22_prep)) - }); - - c.bench_function("multi miller with semi-prepared g2", |b| { - b.iter(|| multi_miller_pairing_with_semi_prepared(&g11, &g21, &g12, &g22_prep)) - }); -} - fn bench_coconut(c: &mut Criterion) { let mut group = c.benchmark_group("benchmark-coconut"); group.measurement_time(Duration::from_secs(100)); @@ -218,7 +220,7 @@ fn bench_coconut(c: &mut Criterion) { &blind_sign_request, &public_attributes, ) - .unwrap() + .unwrap() }) }, ); @@ -233,7 +235,7 @@ fn bench_coconut(c: &mut Criterion) { &blind_sign_request, &public_attributes, ) - .unwrap(); + .unwrap(); blinded_signatures.push(blinded_signature) } @@ -291,7 +293,7 @@ fn bench_coconut(c: &mut Criterion) { serial_number, binding_number, ) - .unwrap(); + .unwrap(); // CLIENT BENCHMARK group.bench_function( @@ -310,7 +312,7 @@ fn bench_coconut(c: &mut Criterion) { serial_number, binding_number, ) - .unwrap() + .unwrap() }) }, );