Make traits public to allow PCC to use formatting traits

Adjust public visibility so that structs and methods can be used from PCC WASM package
Merge branch 'feature/covidcredentials' of https://github.com/nymtech/nym into feature/covidcredentials
2021-11-16 16:01:30 +00:00 · 2021-11-16 10:52:07 +00:00 · 2021-11-12 11:04:33 +00:00 · 2021-11-12 11:04:19 +00:00 · 2021-11-08 17:01:40 +00:00 · 2021-11-08 14:53:35 +00:00
34 changed files with 5240 additions and 175 deletions
@@ -396,7 +396,10 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
 dependencies = [
 "lazy_static",
 "memchr",
 "regex-automata",
 "serde",
 ]
 [[package]]
@@ -468,6 +471,15 @@ dependencies = [
 "system-deps 3.2.0",
 ]
 [[package]]
 name = "cast"
 version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c24dab4283a142afa2fdca129b80ad2c6284e073930f964c3a1293c225ee39a"
 dependencies = [
 "rustc_version 0.4.0",
 ]
 [[package]]
 name = "cc"
 version = "1.0.70"
@@ -631,30 +643,11 @@ dependencies = [
 name = "coconut-interface"
 version = "0.1.0"
 dependencies = [
 "coconut-rs",
 "getset",
 "nymcoconut",
 "serde",
 ]
 [[package]]
 name = "coconut-rs"
 version = "0.5.0"
 source = "git+https://github.com/nymtech/coconut.git?branch=0.5.0#a1b72d51aa2a67b73b9f58d707030ae6dc70af7f"
 dependencies = [
 "bls12_381",
 "bs58",
 "digest 0.9.0",
 "ff",
 "getrandom 0.2.3",
 "group",
 "itertools",
 "rand 0.8.4",
 "serde",
 "serde_derive",
 "sha2",
 "thiserror",
 ]
 [[package]]
 name = "colored"
 version = "2.0.0"
@@ -948,6 +941,42 @@ dependencies = [
 "validator-client",
 ]
 [[package]]
 name = "criterion"
 version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1604dafd25fba2fe2d5895a9da139f8dc9b319a5fe5354ca137cbbce4e178d10"
 dependencies = [
 "atty",
 "cast",
 "clap",
 "criterion-plot",
 "csv",
 "itertools",
 "lazy_static",
 "num-traits",
 "oorandom",
 "plotters",
 "rayon",
 "regex",
 "serde",
 "serde_cbor",
 "serde_derive",
 "serde_json",
 "tinytemplate",
 "walkdir",
 ]
 [[package]]
 name = "criterion-plot"
 version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d00996de9f2f7559f7f4dc286073197f83e92256a59ed395f9aac01fe717da57"
 dependencies = [
 "cast",
 "itertools",
 ]
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.1"
@@ -1087,6 +1116,28 @@ dependencies = [
 "syn",
 ]
 [[package]]
 name = "csv"
 version = "1.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1"
 dependencies = [
 "bstr",
 "csv-core",
 "itoa",
 "ryu",
 "serde",
 ]
 [[package]]
 name = "csv-core"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
 dependencies = [
 "memchr",
 ]
 [[package]]
 name = "ct-logs"
 version = "0.8.0"
@@ -2271,6 +2322,12 @@ dependencies = [
 "tracing",
 ]
 [[package]]
 name = "half"
 version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62aca2aba2d62b4a7f5b33f3712cb1b0692779a56fb510499d5c0aa594daeaf3"
 [[package]]
 name = "handlebars"
 version = "3.5.5"
@@ -3454,6 +3511,27 @@ dependencies = [
 "version-checker",
 ]
 [[package]]
 name = "nymcoconut"
 version = "0.5.0"
 dependencies = [
 "bincode",
 "bls12_381",
 "bs58",
 "criterion",
 "digest 0.9.0",
 "doc-comment",
 "ff",
 "getrandom 0.2.3",
 "group",
 "itertools",
 "rand 0.8.4",
 "serde",
 "serde_derive",
 "sha2",
 "thiserror",
 ]
 [[package]]
 name = "nymsphinx"
 version = "0.1.0"
@@ -3618,6 +3696,12 @@ version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
 [[package]]
 name = "oorandom"
 version = "11.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 [[package]]
 name = "opaque-debug"
 version = "0.2.3"
@@ -4022,6 +4106,34 @@ version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c9b1041b4387893b91ee6746cddfc28516aff326a3519fb2adf820932c5e6cb"
 [[package]]
 name = "plotters"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a3fd9ec30b9749ce28cd91f255d569591cdf937fe280c312143e3c4bad6f2a"
 dependencies = [
 "num-traits",
 "plotters-backend",
 "plotters-svg",
 "wasm-bindgen",
 "web-sys",
 ]
 [[package]]
 name = "plotters-backend"
 version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d88417318da0eaf0fdcdb51a0ee6c3bed624333bff8f946733049380be67ac1c"
 [[package]]
 name = "plotters-svg"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521fa9638fa597e1dc53e9412a4f9cefb01187ee1f7413076f9e6749e2885ba9"
 dependencies = [
 "plotters-backend",
 ]
 [[package]]
 name = "pmutil"
 version = "0.5.3"
@@ -4549,6 +4661,12 @@ dependencies = [
 "regex-syntax",
 ]
 [[package]]
 name = "regex-automata"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 [[package]]
 name = "regex-syntax"
 version = "0.6.25"
@@ -4814,6 +4932,15 @@ dependencies = [
 "semver 0.11.0",
 ]
 [[package]]
 name = "rustc_version"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
 "semver 1.0.4",
 ]
 [[package]]
 name = "rustls"
 version = "0.19.1"
@@ -5035,6 +5162,16 @@ dependencies = [
 "serde",
 ]
 [[package]]
 name = "serde_cbor"
 version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
 dependencies = [
 "half",
 "serde",
 ]
 [[package]]
 name = "serde_derive"
 version = "1.0.130"
@@ -6283,6 +6420,16 @@ dependencies = [
 "syn",
 ]
 [[package]]
 name = "tinytemplate"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
 dependencies = [
 "serde",
 "serde_json",
 ]
 [[package]]
 name = "tokio"
 version = "1.12.0"
@@ -29,6 +29,7 @@ members = [
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
    "common/nymcoconut",
    "common/nymsphinx",
    "common/nymsphinx/acknowledgements",
    "common/nymsphinx/addressing",
@@ -1,8 +1,10 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-use crate::client::config::{Config, SocketType};
+use futures::channel::mpsc;
-use crate::websocket;
+use log::*;
 use tokio::runtime::Runtime;
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
@@ -22,23 +24,26 @@ use client_core::client::topology_control::{
    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 #[cfg(feature = "coconut")]
 use coconut_interface::{hash_to_scalar, Credential, Parameters};
 #[cfg(feature = "coconut")]
 use credentials::bandwidth::{
    prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES,
 };
 #[cfg(feature = "coconut")]
 use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
 use gateway_client::{
    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
    MixnetMessageSender,
 };
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
 use tokio::runtime::Runtime;
-#[cfg(feature = "coconut")]
+use crate::client::config::{Config, SocketType};
-use coconut_interface::Credential;
+use crate::websocket;
 #[cfg(feature = "coconut")]
 use credentials::{bandwidth::prepare_for_spending, obtain_aggregate_verification_key};
 pub(crate) mod config;
@@ -176,8 +181,17 @@ impl NymClient {
        .await
        .expect("could not obtain aggregate verification key of validators");
        let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
        let bandwidth_credential_attributes = BandwidthVoucherAttributes {
            serial_number: params.random_scalar(),
            binding_number: params.random_scalar(),
            voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
            voucher_info: hash_to_scalar(String::from("BandwidthVoucher").as_bytes()),
        };
        let bandwidth_credential = credentials::bandwidth::obtain_signature(
-            &self.key_manager.identity_keypair().public_key().to_bytes(),
+            &params,
            &bandwidth_credential_attributes,
            &self.config.get_base().get_validator_api_endpoints(),
        )
        .await
@@ -188,6 +202,7 @@ impl NymClient {
        prepare_for_spending(
            &self.key_manager.identity_keypair().public_key().to_bytes(),
            &bandwidth_credential,
            &bandwidth_credential_attributes,
            &verification_key,
        )
        .expect("could not prepare out bandwidth credential for spending")
@@ -1,25 +1,36 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-use crate::client::config::Config;
+use std::convert::TryInto;
-use crate::commands::override_config;
+use std::sync::Arc;
 use std::time::Duration;
 use clap::{App, Arg, ArgMatches};
 use rand::rngs::OsRng;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 use url::Url;
 use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 #[cfg(feature = "coconut")]
 use coconut_interface::{hash_to_scalar, Credential, Parameters};
 use config::NymConfig;
 #[cfg(feature = "coconut")]
 use credentials::bandwidth::{
    prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES,
 };
 #[cfg(feature = "coconut")]
 use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::rngs::OsRng;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 use std::convert::TryInto;
 use std::sync::Arc;
 use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
-use url::Url;
+
 use crate::client::config::Config;
 use crate::commands::override_config;
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    App::new("init")
@@ -36,9 +47,9 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
            .takes_value(true)
        )
        .arg(Arg::with_name("validators")
-                .long("validators")
+                 .long("validators")
-                .help("Comma separated list of rest endpoints of the validators")
+                 .help("Comma separated list of rest endpoints of the validators")
-                .takes_value(true),
+                 .takes_value(true),
        )
        .arg(Arg::with_name("disable-socket")
            .long("disable-socket")
@@ -57,6 +68,39 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
        )
 }
 // this behaviour should definitely be changed, we shouldn't
 // need to get bandwidth credential for registration
 #[cfg(feature = "coconut")]
 async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
    let verification_key = obtain_aggregate_verification_key(validators)
        .await
        .expect("could not obtain aggregate verification key of validators");
    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
    let bandwidth_credential_attributes = BandwidthVoucherAttributes {
        serial_number: params.random_scalar(),
        binding_number: params.random_scalar(),
        voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
        voucher_info: hash_to_scalar(String::from("BandwidthVoucher").as_bytes()),
    };
    let bandwidth_credential = credentials::bandwidth::obtain_signature(
        &params,
        &bandwidth_credential_attributes,
        validators,
    )
    .await
    .expect("could not obtain bandwidth credential");
    prepare_for_spending(
        raw_identity,
        &bandwidth_credential,
        &bandwidth_credential_attributes,
        &verification_key,
    )
    .expect("could not prepare out bandwidth credential for spending")
 }
 async fn register_with_gateway(
    gateway: &gateway::Node,
    our_identity: Arc<identity::KeyPair>,
@@ -1,11 +1,10 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-use crate::client::config::Config;
+use futures::channel::mpsc;
-use crate::socks::{
+use log::*;
-    authentication::{AuthenticationMethods, Authenticator, User},
+use tokio::runtime::Runtime;
-    server::SphinxSocksServer,
+
 };
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
@@ -23,21 +22,27 @@ use client_core::client::topology_control::{
    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 #[cfg(feature = "coconut")]
 use coconut_interface::{hash_to_scalar, Credential, Parameters};
 #[cfg(feature = "coconut")]
 use credentials::bandwidth::{
    prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES,
 };
 #[cfg(feature = "coconut")]
 use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
 use gateway_client::{
    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
    MixnetMessageSender,
 };
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use tokio::runtime::Runtime;
-#[cfg(feature = "coconut")]
+use crate::client::config::Config;
-use coconut_interface::Credential;
+use crate::socks::{
-#[cfg(feature = "coconut")]
+    authentication::{AuthenticationMethods, Authenticator, User},
-use credentials::{bandwidth::prepare_for_spending, obtain_aggregate_verification_key};
+    server::SphinxSocksServer,
 };
 pub(crate) mod config;
@@ -164,8 +169,17 @@ impl NymClient {
        .await
        .expect("could not obtain aggregate verification key of validators");
        let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
        let bandwidth_credential_attributes = BandwidthVoucherAttributes {
            serial_number: params.random_scalar(),
            binding_number: params.random_scalar(),
            voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
            voucher_info: hash_to_scalar(String::from("BandwidthVoucher").as_bytes()),
        };
        let bandwidth_credential = credentials::bandwidth::obtain_signature(
-            &self.key_manager.identity_keypair().public_key().to_bytes(),
+            &params,
            &bandwidth_credential_attributes,
            &self.config.get_base().get_validator_api_endpoints(),
        )
        .await
@@ -176,6 +190,7 @@ impl NymClient {
        prepare_for_spending(
            &self.key_manager.identity_keypair().public_key().to_bytes(),
            &bandwidth_credential,
            &bandwidth_credential_attributes,
            &verification_key,
        )
        .expect("could not prepare out bandwidth credential for spending")
@@ -1,23 +1,34 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-use crate::client::config::Config;
+use std::convert::TryInto;
-use crate::commands::override_config;
+use std::sync::Arc;
 use std::time::Duration;
 use clap::{App, Arg, ArgMatches};
 use rand::{prelude::SliceRandom, rngs::OsRng, thread_rng};
 use url::Url;
 use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 #[cfg(feature = "coconut")]
 use coconut_interface::{hash_to_scalar, Credential, Parameters};
 use config::NymConfig;
 #[cfg(feature = "coconut")]
 use credentials::bandwidth::{
    prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES,
 };
 #[cfg(feature = "coconut")]
 use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::{prelude::SliceRandom, rngs::OsRng, thread_rng};
 use std::convert::TryInto;
 use std::sync::Arc;
 use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
-use url::Url;
+
 use crate::client::config::Config;
 use crate::commands::override_config;
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    App::new("init")
@@ -40,9 +51,9 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
            .takes_value(true)
        )
        .arg(Arg::with_name("validators")
-                .long("validators")
+                 .long("validators")
-                .help("Comma separated list of rest endpoints of the validators")
+                 .help("Comma separated list of rest endpoints of the validators")
-                .takes_value(true),
+                 .takes_value(true),
        )
        .arg(Arg::with_name("port")
            .short("p")
@@ -57,6 +68,39 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
        )
 }
 // this behaviour should definitely be changed, we shouldn't
 // need to get bandwidth credential for registration
 #[cfg(feature = "coconut")]
 async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
    let verification_key = obtain_aggregate_verification_key(validators)
        .await
        .expect("could not obtain aggregate verification key of validators");
    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
    let bandwidth_credential_attributes = BandwidthVoucherAttributes {
        serial_number: params.random_scalar(),
        binding_number: params.random_scalar(),
        voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
        voucher_info: hash_to_scalar("BandwidthVoucher"),
    };
    let bandwidth_credential = credentials::bandwidth::obtain_signature(
        &params,
        &bandwidth_credential_attributes,
        validators,
    )
    .await
    .expect("could not obtain bandwidth credential");
    prepare_for_spending(
        raw_identity,
        &bandwidth_credential,
        &bandwidth_credential_attributes,
        &verification_key,
    )
    .expect("could not prepare out bandwidth credential for spending")
 }
 async fn register_with_gateway(
    gateway: &gateway::Node,
    our_identity: Arc<identity::KeyPair>,
@@ -3,21 +3,24 @@
  windows_subsystem = "windows"
 )]
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use url::Url;
 use coconut_interface::{
  self, hash_to_scalar, Attribute, Credential, Parameters, Signature, Theta, VerificationKey,
 };
 use credentials::{obtain_aggregate_signature, obtain_aggregate_verification_key};
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use url::Url;
 struct State {
  signatures: Vec<Signature>,
  n_attributes: u32,
  params: Parameters,
-  public_attributes_bytes: Vec<Vec<u8>>,
+  serial_number: Attribute,
-  public_attributes: Vec<Attribute>,
+  binding_number: Attribute,
-  private_attributes: Vec<Attribute>,
+  voucher_value: Attribute,
  voucher_info: Attribute,
  aggregated_verification_key: Option<VerificationKey>,
 }
@@ -37,9 +40,10 @@ impl State {
      signatures: Vec::new(),
      n_attributes,
      params,
-      public_attributes_bytes,
+      serial_number: private_attributes[0],
-      public_attributes,
+      binding_number: private_attributes[1],
-      private_attributes,
+      voucher_value: public_attributes[0],
      voucher_info: public_attributes[1],
      aggregated_verification_key: None,
    }
  }
@@ -63,8 +67,8 @@ async fn randomise_credential(
 ) -> Result<Vec<Signature>, String> {
  let mut state = state.write().await;
  let signature = state.signatures.remove(idx);
-  let new = signature.randomise(&state.params);
+  let (new_signature, _) = signature.randomise(&state.params);
-  state.signatures.insert(idx, new);
+  state.signatures.insert(idx, new_signature);
  Ok(state.signatures.clone())
 }
@@ -117,14 +121,15 @@ async fn prove_credential(
  let state = state.read().await;
  if let Some(signature) = state.signatures.get(idx) {
-    match coconut_interface::prove_credential(
+    match coconut_interface::prove_bandwidth_credential(
      &state.params,
      &verification_key,
      signature,
-      &state.private_attributes,
+      state.serial_number,
      state.binding_number,
    ) {
      Ok(theta) => Ok(theta),
-      Err(e) => Err(format!("{}", e)),
+      Err(e) => Err(format!("{:?}", e)),
    }
  } else {
    Err("Got invalid Signature idx".to_string())
@@ -144,10 +149,15 @@ async fn verify_credential(
  let state = state.read().await;
  let public_attributes_bytes = vec![
    state.voucher_value.to_bytes().to_vec(),
    state.voucher_info.to_bytes().to_vec(),
  ];
  let credential = Credential::new(
    state.n_attributes,
    theta,
-    state.public_attributes_bytes.clone(),
+    public_attributes_bytes,
    state
      .signatures
      .get(idx)
@@ -164,11 +174,13 @@ async fn get_credential(
 ) -> Result<Vec<Signature>, String> {
  let guard = state.read().await;
  let parsed_urls = parse_url_validators(&validator_urls)?;
  let public_attributes = vec![guard.voucher_value, guard.voucher_info];
  let private_attributes = vec![guard.serial_number, guard.binding_number];
  let signature = obtain_aggregate_signature(
    &guard.params,
-    &guard.public_attributes,
+    &public_attributes,
-    &guard.private_attributes,
+    &private_attributes,
    &parsed_urls,
  )
  .await
@@ -1,26 +1,31 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
 use gateway_client::GatewayClient;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::preparer::MessagePreparer;
 use rand::rngs::OsRng;
 use received_processor::ReceivedMessagesProcessor;
 use std::sync::Arc;
 use std::time::Duration;
-use topology::{gateway, nym_topology_from_bonds, NymTopology};
+
 use futures::channel::mpsc;
 use rand::rngs::OsRng;
 use url::Url;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::spawn_local;
 use wasm_utils::{console_log, console_warn};
 #[cfg(feature = "coconut")]
 use coconut_interface::Credential;
 #[cfg(feature = "coconut")]
 use coconut_interface::{hash_to_scalar, Parameters};
 #[cfg(feature = "coconut")]
 use credentials::bandwidth::{BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES};
 #[cfg(feature = "coconut")]
 use credentials::{bandwidth::prepare_for_spending, obtain_aggregate_verification_key};
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::preparer::MessagePreparer;
 use received_processor::ReceivedMessagesProcessor;
 use topology::{gateway, nym_topology_from_bonds, NymTopology};
 use wasm_utils::{console_log, console_warn};
 pub(crate) mod received_processor;
@@ -109,15 +114,31 @@ impl NymClient {
            .await
            .expect("could not obtain aggregate verification key of validators");
-        let bandwidth_credential =
+        let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-            credentials::bandwidth::obtain_signature(identity_bytes, validators)
+        let bandwidth_credential_attributes = BandwidthVoucherAttributes {
-                .await
+            serial_number: params.random_scalar(),
-                .expect("could not obtain bandwidth credential");
+            binding_number: params.random_scalar(),
            voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
            voucher_info: hash_to_scalar(String::from("BandwidthVoucher").as_bytes()),
        };
        let bandwidth_credential = credentials::bandwidth::obtain_signature(
            &params,
            &bandwidth_credential_attributes,
            validators,
        )
        .await
        .expect("could not obtain bandwidth credential");
        // the above would presumably be loaded from a file
        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
-        prepare_for_spending(identity_bytes, &bandwidth_credential, &verification_key)
+        prepare_for_spending(
-            .expect("could not prepare out bandwidth credential for spending")
+            identity_bytes,
            &bandwidth_credential,
            &bandwidth_credential_attributes,
            &verification_key,
        )
        .expect("could not prepare out bandwidth credential for spending")
    }
    // Right now it's impossible to have async exported functions to take `&self` rather than self
@@ -275,7 +296,7 @@ impl NymClient {
        let validator_client = validator_client::ApiClient::new(self.validator_server.clone());
        let mixnodes = match validator_client.get_cached_active_mixnodes().await {
-            Err(err) => panic!("{}", err),
+            Err(err) => panic!("{:?}", err),
            Ok(mixes) => mixes,
        };
@@ -8,4 +8,4 @@ description = "Crutch library until there is proper SerDe support for coconut st
 serde = { version = "1.0", features = ["derive"] }
 getset = "0.1.1"
-coconut-rs = { git = "https://github.com/nymtech/coconut.git", branch = "0.5.0" }
+nymcoconut = {path = "../nymcoconut" }
@@ -4,7 +4,7 @@
 use getset::{CopyGetters, Getters};
 use serde::{Deserialize, Serialize};
-pub use coconut_rs::*;
+pub use nymcoconut::*;
 #[derive(Serialize, Deserialize, Getters, CopyGetters, Clone)]
 pub struct Credential {
@@ -42,7 +42,7 @@ impl Credential {
            .iter()
            .map(hash_to_scalar)
            .collect::<Vec<Attribute>>();
-        coconut_rs::verify_credential(&params, verification_key, &self.theta, &public_attributes)
+        nymcoconut::verify_credential(&params, verification_key, &self.theta, &public_attributes)
    }
 }
@@ -84,7 +84,7 @@ pub struct BlindSignRequestBody {
    #[getset(get = "pub")]
    blind_sign_request: BlindSignRequest,
    #[getset(get = "pub")]
-    public_key: coconut_rs::PublicKey,
+    public_key: nymcoconut::PublicKey,
    public_attributes: Vec<String>,
    #[getset(get = "pub")]
    total_params: u32,
@@ -92,13 +92,13 @@ pub struct BlindSignRequestBody {
 impl BlindSignRequestBody {
    pub fn new(
-        blind_sign_request: BlindSignRequest,
+        blind_sign_request: &BlindSignRequest,
-        public_key: &coconut_rs::PublicKey,
+        public_key: &nymcoconut::PublicKey,
        public_attributes: &[Attribute],
        total_params: u32,
    ) -> BlindSignRequestBody {
        BlindSignRequestBody {
-            blind_sign_request,
+            blind_sign_request: blind_sign_request.clone(),
            public_key: public_key.clone(),
            public_attributes: public_attributes
                .iter()
@@ -8,40 +8,74 @@
 use url::Url;
 use coconut_interface::{
    Credential, Parameters, PrivateAttribute, PublicAttribute, Signature, VerificationKey,
 };
 use crate::error::Error;
 use crate::utils::{obtain_aggregate_signature, prepare_credential_for_spending};
 use coconut_interface::{hash_to_scalar, Credential, Parameters, Signature, VerificationKey};
-const BANDWIDTH_VALUE: u64 = 10 * 1024 * 1024 * 1024; // 10 GB
+pub const BANDWIDTH_VALUE: u64 = 10 * 1024 * 1024 * 1024; // 10 GB
-pub const PUBLIC_ATTRIBUTES: u32 = 1;
+pub const PUBLIC_ATTRIBUTES: u32 = 2;
-pub const PRIVATE_ATTRIBUTES: u32 = 1;
+pub const PRIVATE_ATTRIBUTES: u32 = 2;
 pub const TOTAL_ATTRIBUTES: u32 = PUBLIC_ATTRIBUTES + PRIVATE_ATTRIBUTES;
 pub const SERIAL_NUMBER_LEN: usize = 47;
 pub const BINDING_NUMBER_LEN: usize = 47;
 pub const VOUCHER_INFO_LEN: usize = 47;
 pub struct BandwidthVoucherAttributes {
    // a random secret value generated by the client used for double-spending detection
    pub serial_number: PrivateAttribute,
    // a random secret value generated by the client used to bind multiple credentials together
    pub binding_number: PrivateAttribute,
    // the value (e.g., bandwidth) encoded in this voucher
    pub voucher_value: PublicAttribute,
    // a field with public information, e.g., type of voucher, epoch etc.
    pub voucher_info: PublicAttribute,
 }
 impl BandwidthVoucherAttributes {
    pub fn get_public_attributes(&self) -> Vec<PublicAttribute> {
        vec![self.voucher_value, self.voucher_info]
    }
    pub fn get_private_attributes(&self) -> Vec<PrivateAttribute> {
        vec![self.serial_number, self.binding_number]
    }
 }
 // TODO: this definitely has to be moved somewhere else. It's just a temporary solution
-pub async fn obtain_signature(raw_identity: &[u8], validators: &[Url]) -> Result<Signature, Error> {
+pub async fn obtain_signature(
-    let public_attributes = vec![hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes())];
+    params: &Parameters,
-    let private_attributes = vec![hash_to_scalar(raw_identity)];
+    attributes: &BandwidthVoucherAttributes,
    validators: &[Url],
 ) -> Result<Signature, Error> {
    let public_attributes = attributes.get_public_attributes();
    let private_attributes = attributes.get_private_attributes();
-    let params = Parameters::new(TOTAL_ATTRIBUTES)?;
+    obtain_aggregate_signature(params, &public_attributes, &private_attributes, validators).await
    obtain_aggregate_signature(&params, &public_attributes, &private_attributes, validators).await
 }
 pub fn prepare_for_spending(
    raw_identity: &[u8],
    signature: &Signature,
    attributes: &BandwidthVoucherAttributes,
    verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
-    let public_attributes = vec![BANDWIDTH_VALUE.to_be_bytes().to_vec()];
+    let public_attributes = vec![
-    let private_attributes = vec![raw_identity.to_vec()];
+        raw_identity.to_vec(),
        BANDWIDTH_VALUE.to_be_bytes().to_vec(),
    ];
    let params = Parameters::new(TOTAL_ATTRIBUTES)?;
    prepare_credential_for_spending(
        &params,
        public_attributes,
-        private_attributes,
+        attributes.serial_number,
        attributes.binding_number,
        signature,
        verification_key,
    )
@@ -5,4 +5,7 @@ pub mod bandwidth;
 pub mod error;
 mod utils;
-pub use utils::{obtain_aggregate_signature, obtain_aggregate_verification_key};
+pub use utils::{
    blind_sign_partial_credential, create_aggregate_verification_key, get_verification_keys,
    obtain_aggregate_signature, obtain_aggregate_verification_key,
 };
@@ -1,14 +1,17 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 use crate::error::Error;
 use coconut_interface::{
-    aggregate_signature_shares, aggregate_verification_keys, hash_to_scalar, prepare_blind_sign,
+    aggregate_signature_shares, aggregate_verification_keys, prepare_blind_sign,
-    prove_credential, Attribute, BlindSignRequestBody, Credential, Parameters, Signature,
+    prove_bandwidth_credential, Attribute, BlindSignRequest, BlindSignRequestBody,
-    SignatureShare, VerificationKey,
+    BlindedSignature, Credential, ElGamalKeyPair, Parameters, Signature, SignatureShare,
    VerificationKey,
 };
 use url::Url;
 use crate::bandwidth::PRIVATE_ATTRIBUTES;
 use crate::error::Error;
 /// Contacts all provided validators and then aggregate their verification keys.
 ///
 /// # Arguments
@@ -32,6 +35,43 @@ use url::Url;
 ///     Ok(())
 /// }
 /// ```
 pub async fn get_verification_keys(validators: &[Url]) -> Result<Vec<VerificationKey>, Error> {
    if validators.is_empty() {
        return Err(Error::NoValidatorsAvailable);
    }
    let mut shares = Vec::with_capacity(validators.len());
    let mut client = validator_client::ApiClient::new(validators[0].clone());
    let response = client.get_coconut_verification_key().await?;
    shares.push(response.key);
    for validator_url in validators.iter().enumerate().skip(1) {
        client.change_validator_api(validator_url.1.clone());
        let response = client.get_coconut_verification_key().await?;
        shares.push(response.key);
    }
    Ok(shares)
 }
 pub fn create_aggregate_verification_key(
    verification_keys: &Vec<VerificationKey>,
 ) -> Result<VerificationKey, Error> {
    if verification_keys.is_empty() {
        return Err(Error::NoValidatorsAvailable);
    }
    // creates a vec of [1, 2, .. n] where n is length of verification_keys, e.g. [1,2,3] for 3 keys
    let indices: Vec<u64> = (1u64..(verification_keys.len() + 1) as u64).collect();
    Ok(aggregate_verification_keys(
        &verification_keys,
        Some(&indices.as_slice()),
    )?)
 }
 pub async fn obtain_aggregate_verification_key(
    validators: &[Url],
 ) -> Result<VerificationKey, Error> {
@@ -58,22 +98,45 @@ pub async fn obtain_aggregate_verification_key(
    Ok(aggregate_verification_keys(&shares, Some(&indices))?)
 }
 pub async fn blind_sign_partial_credential(
    validator_url: &Url,
    elgamal_keypair: &ElGamalKeyPair,
    blind_sign_request: &BlindSignRequest,
    public_attributes: &[Attribute],
    total_params: u32,
 ) -> Result<BlindedSignature, Error> {
    let client = validator_client::ApiClient::new(validator_url.clone());
    let blind_sign_request_body = BlindSignRequestBody::new(
        &blind_sign_request,
        elgamal_keypair.public_key(),
        public_attributes,
        total_params,
    );
    Ok(client
        .blind_sign(&blind_sign_request_body)
        .await?
        .blinded_signature)
 }
 async fn obtain_partial_credential(
    params: &Parameters,
    public_attributes: &[Attribute],
    private_attributes: &[Attribute],
    client: &validator_client::ApiClient,
    validator_vk: &VerificationKey,
 ) -> Result<Signature, Error> {
    let elgamal_keypair = coconut_interface::elgamal_keygen(params);
    let blind_sign_request = prepare_blind_sign(
        params,
-        elgamal_keypair.public_key(),
+        &elgamal_keypair,
        private_attributes,
        public_attributes,
    )?;
    let blind_sign_request_body = BlindSignRequestBody::new(
-        blind_sign_request,
+        &blind_sign_request,
        elgamal_keypair.public_key(),
        public_attributes,
        (public_attributes.len() + private_attributes.len()) as u32,
@@ -83,7 +146,16 @@ async fn obtain_partial_credential(
        .blind_sign(&blind_sign_request_body)
        .await?
        .blinded_signature;
-    Ok(blinded_signature.unblind(elgamal_keypair.private_key()))
+    Ok(blinded_signature
        .unblind(
            params,
            elgamal_keypair.private_key(),
            validator_vk,
            private_attributes,
            public_attributes,
            &blind_sign_request.get_commitment_hash(),
        )
        .unwrap())
 }
 pub async fn obtain_aggregate_signature(
@@ -97,40 +169,75 @@ pub async fn obtain_aggregate_signature(
    }
    let mut shares = Vec::with_capacity(validators.len());
    let mut validators_partial_vks: Vec<VerificationKey> = Vec::with_capacity(validators.len());
    let mut client = validator_client::ApiClient::new(validators[0].clone());
-    let first =
+    let validator_partial_vk = client.get_coconut_verification_key().await?;
-        obtain_partial_credential(params, public_attributes, private_attributes, &client).await?;
+    validators_partial_vks.push(validator_partial_vk.key.clone());
    let first = obtain_partial_credential(
        params,
        public_attributes,
        private_attributes,
        &client,
        &validator_partial_vk.key,
    )
    .await?;
    shares.push(SignatureShare::new(first, 0));
    for (id, validator_url) in validators.iter().enumerate().skip(1) {
        client.change_validator_api(validator_url.clone());
-        let signature =
+        let validator_partial_vk = client.get_coconut_verification_key().await?;
-            obtain_partial_credential(params, public_attributes, private_attributes, &client)
+        validators_partial_vks.push(validator_partial_vk.key.clone());
-                .await?;
+        let signature = obtain_partial_credential(
            params,
            public_attributes,
            private_attributes,
            &client,
            &validator_partial_vk.key,
        )
        .await?;
        let share = SignatureShare::new(signature, id as u64);
        shares.push(share)
    }
-    Ok(aggregate_signature_shares(&shares)?)
+    let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
    attributes.extend_from_slice(private_attributes);
    attributes.extend_from_slice(public_attributes);
    let mut indices: Vec<u64> = Vec::with_capacity(validators_partial_vks.len());
    for i in 1..validators_partial_vks.len() {
        indices.push(i as u64);
    }
    let verification_key =
        aggregate_verification_keys(&validators_partial_vks, Some(indices.as_ref())).unwrap();
    Ok(aggregate_signature_shares(
        params,
        &verification_key,
        &attributes,
        &shares,
    )?)
 }
 // TODO: better type flow
 pub fn prepare_credential_for_spending(
    params: &Parameters,
    public_attributes: Vec<Vec<u8>>,
-    private_attributes: Vec<Vec<u8>>,
+    serial_number: Attribute,
    binding_number: Attribute,
    signature: &Signature,
    verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
-    let private_attributes = private_attributes
+    let theta = prove_bandwidth_credential(
-        .iter()
+        params,
-        .map(hash_to_scalar)
+        verification_key,
-        .collect::<Vec<Attribute>>();
+        signature,
-    let theta = prove_credential(params, verification_key, signature, &private_attributes)?;
+        serial_number,
        binding_number,
    )?;
    Ok(Credential::new(
-        (public_attributes.len() + private_attributes.len()) as u32,
+        (public_attributes.len() + PRIVATE_ATTRIBUTES as usize) as u32,
        theta,
        public_attributes,
        signature,
@@ -0,0 +1,43 @@
 [package]
 name = "nymcoconut"
 version = "0.5.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>", "Ania Piotrowska <ania@nymtech.net>"]
 edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 bls12_381 = { version = "0.5", default-features = false, features = ["pairings", "alloc", "experimental"] }
 itertools = "0.10"
 digest = "0.9"
 rand = "0.8"
 thiserror = "1.0"
 serde = "1.0"
 serde_derive = "1.0"
 bs58 = "0.4.0"
 sha2 = "0.9"
 [dependencies.ff]
 version = "0.10"
 default-features = false
 [dependencies.group]
 version = "0.10"
 default-features = false
 [dev-dependencies]
 criterion = { version="0.3", features=["html_reports"] }
 doc-comment = "0.3"
 [dev-dependencies.bincode]
 version = "1"
 #[[bench]]
 #name = "benchmarks"
 #harness = false
 [features]
 default = []
 [target.'cfg(target_env = "wasm32-unknown-unknown")'.dependencies]
 getrandom = { version="0.2", features=["js"] }
@@ -0,0 +1,333 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use core::ops::{Deref, Mul};
 use std::convert::TryFrom;
 use std::convert::TryInto;
 use bls12_381::{G1Projective, Scalar};
 use group::Curve;
 use serde_derive::{Deserialize, Serialize};
 use crate::error::{CoconutError, Result};
 use crate::scheme::setup::Parameters;
 use crate::traits::{Base58, Bytable};
 use crate::utils::{try_deserialize_g1_projective, try_deserialize_scalar};
 /// Type alias for the ephemeral key generated during ElGamal encryption
 pub type EphemeralKey = Scalar;
 /// Two G1 points representing ElGamal ciphertext
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct Ciphertext(pub(crate) G1Projective, pub(crate) G1Projective);
 impl TryFrom<&[u8]> for Ciphertext {
    type Error = CoconutError;
    fn try_from(bytes: &[u8]) -> Result<Ciphertext> {
        if bytes.len() != 96 {
            return Err(CoconutError::Deserialization(format!(
                "Ciphertext must be exactly 96 bytes, got {}",
                bytes.len()
            )));
        }
        let c1_bytes: &[u8; 48] = &bytes[..48].try_into().unwrap();
        let c2_bytes: &[u8; 48] = &bytes[48..].try_into().unwrap();
        let c1 = try_deserialize_g1_projective(
            c1_bytes,
            CoconutError::Deserialization("Failed to deserialize compressed c1".to_string()),
        )?;
        let c2 = try_deserialize_g1_projective(
            c2_bytes,
            CoconutError::Deserialization("Failed to deserialize compressed c2".to_string()),
        )?;
        Ok(Ciphertext(c1, c2))
    }
 }
 impl Ciphertext {
    pub fn c1(&self) -> &G1Projective {
        &self.0
    }
    pub fn c2(&self) -> &G1Projective {
        &self.1
    }
    pub fn to_bytes(&self) -> [u8; 96] {
        let mut bytes = [0u8; 96];
        bytes[..48].copy_from_slice(&self.0.to_affine().to_compressed());
        bytes[48..].copy_from_slice(&self.1.to_affine().to_compressed());
        bytes
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<Ciphertext> {
        Ciphertext::try_from(bytes)
    }
 }
 /// PrivateKey used in the ElGamal encryption scheme to recover the plaintext
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct PrivateKey(pub(crate) Scalar);
 impl PrivateKey {
    /// Decrypt takes the ElGamal encryption of a message and returns a point on the G1 curve
    /// that represents original h^m.
    pub fn decrypt(&self, ciphertext: &Ciphertext) -> G1Projective {
        let (c1, c2) = &(ciphertext.0, ciphertext.1);
        // (gamma^k * h^m) / (g1^{d * k})   |   note: gamma = g1^d
        c2 - c1 * self.0
    }
    pub fn public_key(&self, params: &Parameters) -> PublicKey {
        PublicKey(params.gen1() * self.0)
    }
    pub fn to_bytes(&self) -> [u8; 32] {
        self.0.to_bytes()
    }
    pub fn from_bytes(bytes: &[u8; 32]) -> Result<PrivateKey> {
        try_deserialize_scalar(
            bytes,
            CoconutError::Deserialization(
                "Failed to deserialize ElGamal private key - it was not in the canonical form"
                    .to_string(),
            ),
        )
        .map(PrivateKey)
    }
 }
 impl Bytable for PrivateKey {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.to_bytes().to_vec()
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        PrivateKey::from_bytes(slice.try_into().unwrap())
    }
 }
 impl Base58 for PrivateKey {}
 // TODO: perhaps be more explicit and apart from gamma also store generator and group order?
 /// PublicKey used in the ElGamal encryption scheme to produce the ciphertext
 #[derive(Debug, Clone)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct PublicKey(G1Projective);
 impl PublicKey {
    /// Encrypt encrypts the given message in the form of h^m,
    /// where h is a point on the G1 curve using the given public key.
    /// The random k is returned alongside the encryption
    /// as it is required by the Coconut Scheme to create proofs of knowledge.
    pub fn encrypt(
        &self,
        params: &Parameters,
        h: &G1Projective,
        msg: &Scalar,
    ) -> (Ciphertext, EphemeralKey) {
        let k = params.random_scalar();
        // c1 = g1^k
        let c1 = params.gen1() * k;
        // c2 = gamma^k * h^m
        let c2 = self.0 * k + h * msg;
        (Ciphertext(c1, c2), k)
    }
    pub fn to_bytes(&self) -> [u8; 48] {
        self.to_byte_vec().try_into().unwrap()
    }
    pub fn from_bytes(bytes: &[u8; 48]) -> Result<PublicKey> {
        Ok(PublicKey::try_from(bytes.to_vec().as_slice()).unwrap())
    }
 }
 impl Bytable for PublicKey {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.0.to_affine().to_compressed().into()
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        Ok(PublicKey::from_bytes(slice.try_into().unwrap()).unwrap())
    }
 }
 impl TryFrom<&[u8]> for PublicKey {
    type Error = CoconutError;
    fn try_from(slice: &[u8]) -> Result<PublicKey> {
        try_deserialize_g1_projective(
            slice.try_into().unwrap(),
            CoconutError::Deserialization(
                "Failed to deserialize compressed ElGamal public key".to_string(),
            ),
        )
        .map(PublicKey)
    }
 }
 impl Base58 for PublicKey {}
 impl Deref for PublicKey {
    type Target = G1Projective;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
 }
 impl<'a, 'b> Mul<&'b Scalar> for &'a PublicKey {
    type Output = G1Projective;
    fn mul(self, rhs: &'b Scalar) -> Self::Output {
        self.0 * rhs
    }
 }
 #[derive(Serialize, Deserialize)]
 /// A convenient wrapper for both keys of the ElGamal keypair
 pub struct ElGamalKeyPair {
    private_key: PrivateKey,
    public_key: PublicKey,
 }
 impl ElGamalKeyPair {
    pub fn public_key(&self) -> &PublicKey {
        &self.public_key
    }
    pub fn private_key(&self) -> &PrivateKey {
        &self.private_key
    }
 }
 /// Generate a fresh ElGamal keypair using the group generator specified by the provided [Parameters]
 pub fn elgamal_keygen(params: &Parameters) -> ElGamalKeyPair {
    let private_key = params.random_scalar();
    let gamma = params.gen1() * private_key;
    ElGamalKeyPair {
        private_key: PrivateKey(private_key),
        public_key: PublicKey(gamma),
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn keygen() {
        let params = Parameters::default();
        let keypair = super::elgamal_keygen(&params);
        let expected = params.gen1() * keypair.private_key.0;
        let gamma = keypair.public_key.0;
        assert_eq!(
            expected, gamma,
            "Public key, gamma, should be equal to g1^d, where d is the private key"
        );
    }
    #[test]
    fn encryption() {
        let params = Parameters::default();
        let keypair = super::elgamal_keygen(&params);
        let r = params.random_scalar();
        let h = params.gen1() * r;
        let m = params.random_scalar();
        let (ciphertext, ephemeral_key) = keypair.public_key.encrypt(&params, &h, &m);
        let expected_c1 = params.gen1() * ephemeral_key;
        assert_eq!(expected_c1, ciphertext.0, "c1 should be equal to g1^k");
        let expected_c2 = keypair.public_key.0 * ephemeral_key + h * m;
        assert_eq!(
            expected_c2, ciphertext.1,
            "c2 should be equal to gamma^k * h^m"
        );
    }
    #[test]
    fn decryption() {
        let params = Parameters::default();
        let keypair = super::elgamal_keygen(&params);
        let r = params.random_scalar();
        let h = params.gen1() * r;
        let m = params.random_scalar();
        let (ciphertext, _) = keypair.public_key.encrypt(&params, &h, &m);
        let dec = keypair.private_key.decrypt(&ciphertext);
        let expected = h * m;
        assert_eq!(
            expected, dec,
            "after ElGamal decryption, original h^m should be obtained"
        );
    }
    #[test]
    fn private_key_bytes_roundtrip() {
        let params = Parameters::default();
        let private_key = PrivateKey(params.random_scalar());
        let bytes = private_key.to_bytes();
        // also make sure it is equivalent to the internal scalar's bytes
        assert_eq!(private_key.0.to_bytes(), bytes);
        assert_eq!(private_key, PrivateKey::from_bytes(&bytes).unwrap())
    }
    #[test]
    fn public_key_bytes_roundtrip() {
        let params = Parameters::default();
        let r = params.random_scalar();
        let public_key = PublicKey(params.gen1() * r);
        let bytes = public_key.to_bytes();
        // also make sure it is equivalent to the internal g1 compressed bytes
        assert_eq!(public_key.0.to_affine().to_compressed(), bytes);
        assert_eq!(public_key, PublicKey::from_bytes(&bytes).unwrap())
    }
    #[test]
    fn ciphertext_bytes_roundtrip() {
        let params = Parameters::default();
        let r = params.random_scalar();
        let s = params.random_scalar();
        let ciphertext = Ciphertext(params.gen1() * r, params.gen1() * s);
        let bytes = ciphertext.to_bytes();
        // also make sure it is equivalent to the internal g1 compressed bytes concatenated
        let expected_bytes = [
            ciphertext.0.to_affine().to_compressed(),
            ciphertext.1.to_affine().to_compressed(),
        ]
        .concat();
        assert_eq!(expected_bytes, bytes);
        assert_eq!(ciphertext, Ciphertext::try_from(&bytes[..]).unwrap())
    }
 }
@@ -0,0 +1,64 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use thiserror::Error;
 /// A `Result` alias where the `Err` case is `coconut_rs::Error`.
 pub type Result<T> = std::result::Result<T, CoconutError>;
 #[derive(Error, Debug)]
 pub enum CoconutError {
    #[error("Setup error: {0}")]
    Setup(String),
    #[error("encountered error during keygen")]
    Keygen,
    #[error("Issuance related error: {0}")]
    Issuance(String),
    #[error("Tried to prepare blind sign request for higher than specified number of attributes (max: {}, requested: {})", max, requested)]
    IssuanceMaxAttributes { max: usize, requested: usize },
    #[error("Interpolation error: {0}")]
    Interpolation(String),
    #[error("Aggregation error: {0}")]
    Aggregation(String),
    #[error("Unblind error: {0}")]
    Unblind(String),
    #[error("Verification error: {0}")]
    Verification(String),
    #[error("Deserialization error: {0}")]
    Deserialization(String),
    #[error(
        "Deserailization error, expected at least {} bytes, got {}",
        min,
        actual
    )]
    DeserializationMinLength { min: usize, actual: usize },
    #[error("Tried to deserialize {object} with bytes of invalid length. Expected {actual} < {} or {modulus_target} % {modulus} == 0")]
    DeserializationInvalidLength {
        actual: usize,
        target: usize,
        modulus_target: usize,
        modulus: usize,
        object: String,
    },
 }
@@ -0,0 +1,15 @@
 use crate::{BlindSignRequest, BlindedSignature, Bytable, Theta};
 macro_rules! impl_clone {
    ($struct:ident) => {
        impl Clone for $struct {
            fn clone(&self) -> Self {
                Self::try_from_byte_slice(&self.to_byte_vec()).unwrap()
            }
        }
    };
 }
 impl_clone!(BlindSignRequest);
 impl_clone!(BlindedSignature);
 impl_clone!(Theta);
@@ -0,0 +1,2 @@
 mod clone;
 mod serde;
@@ -0,0 +1,56 @@
 use crate::elgamal::PrivateKey;
 use crate::scheme::SecretKey;
 use crate::{
    Base58, BlindSignRequest, BlindedSignature, PublicKey, Signature, Theta, VerificationKey,
 };
 use serde::de::Unexpected;
 use serde::{de::Error, de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt;
 macro_rules! impl_serde {
    ($struct:ident, $visitor:ident) => {
        pub struct $visitor {}
        impl Serialize for $struct {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                serializer.serialize_str(&self.to_bs58())
            }
        }
        impl<'de> Visitor<'de> for $visitor {
            type Value = $struct;
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                write!(formatter, "A base58 encoded struct")
            }
            fn visit_str<E: Error>(self, s: &str) -> Result<Self::Value, E> {
                match $struct::try_from_bs58(s) {
                    Ok(x) => Ok(x),
                    Err(_) => Err(Error::invalid_value(Unexpected::Str(s), &self)),
                }
            }
        }
        impl<'de> Deserialize<'de> for $struct {
            fn deserialize<D>(deserializer: D) -> Result<$struct, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_str($visitor {})
            }
        }
    };
 }
 impl_serde!(SecretKey, V1);
 impl_serde!(VerificationKey, V2);
 impl_serde!(PublicKey, V3);
 impl_serde!(PrivateKey, V4);
 impl_serde!(BlindSignRequest, V5);
 impl_serde!(BlindedSignature, V6);
 impl_serde!(Signature, V7);
 impl_serde!(Theta, V8);
@@ -0,0 +1,68 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use std::convert::TryInto;
 use bls12_381::Scalar;
 pub use elgamal::elgamal_keygen;
 pub use elgamal::ElGamalKeyPair;
 pub use elgamal::PublicKey;
 pub use error::CoconutError;
 pub use scheme::aggregation::aggregate_signature_shares;
 pub use scheme::aggregation::aggregate_verification_keys;
 pub use scheme::issuance::blind_sign;
 pub use scheme::issuance::prepare_blind_sign;
 pub use scheme::issuance::BlindSignRequest;
 pub use scheme::keygen::ttp_keygen;
 pub use scheme::keygen::KeyPair;
 pub use scheme::keygen::VerificationKey;
 pub use scheme::setup::setup;
 pub use scheme::setup::Parameters;
 pub use scheme::verification::prove_bandwidth_credential;
 pub use scheme::verification::verify_credential;
 pub use scheme::verification::Theta;
 pub use scheme::BlindedSignature;
 pub use scheme::Signature;
 pub use scheme::SignatureShare;
 pub use traits::Base58;
 pub use utils::hash_to_scalar;
 use crate::traits::Bytable;
 pub mod elgamal;
 mod error;
 mod impls;
 pub mod proofs;
 pub mod scheme;
 #[cfg(test)]
 mod tests;
 pub mod traits;
 mod utils;
 pub type Attribute = Scalar;
 pub type PrivateAttribute = Attribute;
 pub type PublicAttribute = Attribute;
 impl Bytable for Attribute {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.to_bytes().to_vec()
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self, CoconutError> {
        Ok(Attribute::from_bytes(slice.try_into().unwrap()).unwrap())
    }
 }
 impl Base58 for Attribute {}
@@ -0,0 +1,836 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // TODO: look at https://crates.io/crates/merlin to perhaps use it instead?
 use std::borrow::Borrow;
 use std::convert::TryInto;
 use bls12_381::{G1Projective, G2Projective, Scalar};
 use digest::generic_array::typenum::Unsigned;
 use digest::Digest;
 use group::GroupEncoding;
 use itertools::izip;
 use sha2::Sha256;
 use crate::elgamal::Ciphertext;
 use crate::error::{CoconutError, Result};
 use crate::scheme::setup::Parameters;
 use crate::scheme::VerificationKey;
 use crate::utils::{hash_g1, try_deserialize_scalar, try_deserialize_scalar_vec};
 use crate::{elgamal, Attribute, ElGamalKeyPair};
 // as per the reference python implementation
 type ChallengeDigest = Sha256;
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct ProofCmCs {
    challenge: Scalar,
    response_opening: Scalar,
    response_private_elgamal_key: Scalar,
    response_keys: Vec<Scalar>,
    response_attributes: Vec<Scalar>,
 }
 // note: this is slightly different from the reference python implementation
 // as we omit the unnecessary string conversion. Instead we concatenate byte
 // representations together and hash that.
 // note2: G1 and G2 elements are using their compressed representations
 // and as per the bls12-381 library all elements are using big-endian form
 /// Generates a Scalar [or Fp] challenge by hashing a number of elliptic curve points.
 fn compute_challenge<D, I, B>(iter: I) -> Scalar
 where
    D: Digest,
    I: Iterator<Item = B>,
    B: AsRef<[u8]>,
 {
    let mut h = D::new();
    for point_representation in iter {
        h.update(point_representation);
    }
    let digest = h.finalize();
    // TODO: I don't like the 0 padding here (though it's what we've been using before,
    // but we never had a security audit anyway...)
    // instead we could maybe use the `from_bytes` variant and adding some suffix
    // when computing the digest until we produce a valid scalar.
    let mut bytes = [0u8; 64];
    let pad_size = 64usize
        .checked_sub(D::OutputSize::to_usize())
        .unwrap_or_default();
    bytes[pad_size..].copy_from_slice(&digest);
    Scalar::from_bytes_wide(&bytes)
 }
 fn produce_response(witness: &Scalar, challenge: &Scalar, secret: &Scalar) -> Scalar {
    witness - challenge * secret
 }
 // note: it's caller's responsibility to ensure witnesses.len() = secrets.len()
 fn produce_responses<S>(witnesses: &[Scalar], challenge: &Scalar, secrets: &[S]) -> Vec<Scalar>
 where
    S: Borrow<Scalar>,
 {
    debug_assert_eq!(witnesses.len(), secrets.len());
    witnesses
        .iter()
        .zip(secrets.iter())
        .map(|(w, x)| produce_response(w, challenge, x.borrow()))
        .collect()
 }
 impl ProofCmCs {
    /// Construct non-interactive zero-knowledge proof of correctness of the ciphertexts and the commitment
    /// using the Fiat-Shamir heuristic.
    pub(crate) fn construct(
        params: &Parameters,
        elgamal_keypair: &ElGamalKeyPair,
        ephemeral_keys: &[elgamal::EphemeralKey],
        commitment: &G1Projective,
        commitment_opening: &Scalar,
        private_attributes: &[Attribute],
        priv_attributes_ciphertexts: &[Ciphertext],
    ) -> Self {
        // note: this is only called from `prepare_blind_sign` that already checks
        // whether private attributes are non-empty and whether we don't have too many
        // attributes in total to sign.
        // we also know, due to the single call place, that ephemeral_keys.len() == private_attributes.len()
        // witness creation
        let witness_commitment_opening = params.random_scalar();
        let witness_private_elgamal_key = params.random_scalar();
        let witness_keys = params.n_random_scalars(ephemeral_keys.len());
        let witness_attributes = params.n_random_scalars(private_attributes.len());
        // recompute h
        let h = hash_g1(commitment.to_bytes());
        let hs_bytes = params
            .gen_hs()
            .iter()
            .map(|h| h.to_bytes())
            .collect::<Vec<_>>();
        let g1 = params.gen1();
        // compute commitments
        let commitment_private_key_elgamal = g1 * witness_private_elgamal_key;
        // Aw[i] = (wk[i] * g1)
        let commitment_keys1_bytes = witness_keys
            .iter()
            .map(|wk_i| g1 * wk_i)
            .map(|witness| witness.to_bytes())
            .collect::<Vec<_>>();
        // Bw[i] = (wm[i] * h) + (wk[i] * gamma)
        let commitment_keys2_bytes = witness_keys
            .iter()
            .zip(witness_attributes.iter())
            .map(|(wk_i, wm_i)| elgamal_keypair.public_key() * wk_i + h * wm_i)
            .map(|witness| witness.to_bytes())
            .collect::<Vec<_>>();
        // zkp commitment for the attributes commitment cm
        // Ccm = (wr * g1) + (wm[0] * hs[0]) + ... + (wm[i] * hs[i])
        let commitment_attributes = g1 * witness_commitment_opening
            + witness_attributes
                .iter()
                .zip(params.gen_hs().iter())
                .map(|(wm_i, hs_i)| hs_i * wm_i)
                .sum::<G1Projective>();
        let ciphertexts_bytes = priv_attributes_ciphertexts
            .iter()
            .map(|c| c.to_bytes())
            .collect::<Vec<_>>();
        // compute challenge
        let challenge = compute_challenge::<ChallengeDigest, _, _>(
            std::iter::once(params.gen1().to_bytes().as_ref())
                .chain(hs_bytes.iter().map(|hs| hs.as_ref()))
                .chain(std::iter::once(h.to_bytes().as_ref()))
                .chain(std::iter::once(
                    elgamal_keypair.public_key().to_bytes().as_ref(),
                ))
                .chain(std::iter::once(commitment.to_bytes().as_ref()))
                .chain(std::iter::once(commitment_attributes.to_bytes().as_ref()))
                .chain(std::iter::once(
                    commitment_private_key_elgamal.to_bytes().as_ref(),
                ))
                .chain(commitment_keys1_bytes.iter().map(|aw| aw.as_ref()))
                .chain(commitment_keys2_bytes.iter().map(|bw| bw.as_ref()))
                .chain(ciphertexts_bytes.iter().map(|c| c.as_ref())),
        );
        // Responses
        let response_opening =
            produce_response(&witness_commitment_opening, &challenge, commitment_opening);
        let response_private_elgamal_key = produce_response(
            &witness_private_elgamal_key,
            &challenge,
            &elgamal_keypair.private_key().0,
        );
        let response_keys = produce_responses(&witness_keys, &challenge, ephemeral_keys);
        let response_attributes = produce_responses(
            &witness_attributes,
            &challenge,
            &private_attributes.iter().collect::<Vec<_>>(),
        );
        ProofCmCs {
            challenge,
            response_opening,
            response_private_elgamal_key,
            response_keys,
            response_attributes,
        }
    }
    pub(crate) fn verify(
        &self,
        params: &Parameters,
        pub_key: &elgamal::PublicKey,
        commitment: &G1Projective,
        attributes_ciphertexts: &[elgamal::Ciphertext],
    ) -> bool {
        if self.response_keys.len() != attributes_ciphertexts.len() {
            return false;
        }
        // recompute h
        let h = hash_g1(commitment.to_bytes());
        let g1 = params.gen1();
        let hs_bytes = params
            .gen_hs()
            .iter()
            .map(|h| h.to_bytes())
            .collect::<Vec<_>>();
        // recompute witnesses commitments
        let commitment_private_key_elgamal =
            pub_key * &self.challenge + g1 * self.response_private_elgamal_key;
        // Aw[i] = (c * c1[i]) + (rk[i] * g1)
        let commitment_keys1_bytes = attributes_ciphertexts
            .iter()
            .map(|ciphertext| ciphertext.c1())
            .zip(self.response_keys.iter())
            .map(|(c1, res_k)| c1 * self.challenge + g1 * res_k)
            .map(|witness| witness.to_bytes())
            .collect::<Vec<_>>();
        // Bw[i] = (c * c2[i]) + (rk[i] * gamma) + (rm[i] * h)
        let commitment_keys2_bytes = izip!(
            attributes_ciphertexts
                .iter()
                .map(|ciphertext| ciphertext.c2()),
            self.response_keys.iter(),
            self.response_attributes.iter()
        )
        .map(|(c2, res_key, res_attr)| c2 * self.challenge + pub_key * res_key + h * res_attr)
        .map(|witness| witness.to_bytes())
        .collect::<Vec<_>>();
        // Cw = (cm * c) + (rr * g1) + (rm[0] * hs[0]) + ... + (rm[n] * hs[n])
        let commitment_attributes = commitment * self.challenge
            + g1 * self.response_opening
            + self
                .response_attributes
                .iter()
                .zip(params.gen_hs().iter())
                .map(|(res_attr, hs)| hs * res_attr)
                .sum::<G1Projective>();
        let ciphertexts_bytes = attributes_ciphertexts
            .iter()
            .map(|c| c.to_bytes())
            .collect::<Vec<_>>();
        // re-compute the challenge
        let challenge = compute_challenge::<ChallengeDigest, _, _>(
            std::iter::once(params.gen1().to_bytes().as_ref())
                .chain(hs_bytes.iter().map(|hs| hs.as_ref()))
                .chain(std::iter::once(h.to_bytes().as_ref()))
                .chain(std::iter::once(pub_key.to_bytes().as_ref()))
                .chain(std::iter::once(commitment.to_bytes().as_ref()))
                .chain(std::iter::once(commitment_attributes.to_bytes().as_ref()))
                .chain(std::iter::once(
                    commitment_private_key_elgamal.to_bytes().as_ref(),
                ))
                .chain(commitment_keys1_bytes.iter().map(|aw| aw.as_ref()))
                .chain(commitment_keys2_bytes.iter().map(|bw| bw.as_ref()))
                .chain(ciphertexts_bytes.iter().map(|c| c.as_ref())),
        );
        challenge == self.challenge
    }
    // challenge || rr || rk.len() || rk || rm.len() || rm
    pub(crate) fn to_bytes(&self) -> Vec<u8> {
        let keys_len = self.response_keys.len() as u64;
        let attributes_len = self.response_attributes.len() as u64;
        let mut bytes = Vec::with_capacity(16 + (keys_len + attributes_len + 3) as usize * 32);
        bytes.extend_from_slice(&self.challenge.to_bytes());
        bytes.extend_from_slice(&self.response_opening.to_bytes());
        bytes.extend_from_slice(&self.response_private_elgamal_key.to_bytes());
        bytes.extend_from_slice(&keys_len.to_le_bytes());
        for rk in &self.response_keys {
            bytes.extend_from_slice(&rk.to_bytes());
        }
        bytes.extend_from_slice(&attributes_len.to_le_bytes());
        for rm in &self.response_attributes {
            bytes.extend_from_slice(&rm.to_bytes());
        }
        bytes
    }
    pub(crate) fn from_bytes(bytes: &[u8]) -> Result<Self> {
        // at the very minimum there must be a single attribute being proven
        if bytes.len() < 32 * 4 + 16 || (bytes.len() - 16) % 32 != 0 {
            return Err(
                CoconutError::Deserialization(
                    "tried to deserialize proof of ciphertexts and commitment with bytes of invalid length".to_string())
            );
        }
        let mut idx = 0;
        let challenge_bytes = bytes[idx..idx + 32].try_into().unwrap();
        idx += 32;
        let response_opening_bytes = bytes[idx..idx + 32].try_into().unwrap();
        idx += 32;
        let response_private_elgamal_key_bytes = bytes[idx..idx + 32].try_into().unwrap();
        idx += 32;
        let challenge = try_deserialize_scalar(
            &challenge_bytes,
            CoconutError::Deserialization("Failed to deserialize challenge".to_string()),
        )?;
        let response_opening = try_deserialize_scalar(
            &response_opening_bytes,
            CoconutError::Deserialization(
                "Failed to deserialize the response to the random".to_string(),
            ),
        )?;
        let response_private_elgamal_key = try_deserialize_scalar(
            &response_private_elgamal_key_bytes,
            CoconutError::Deserialization(
                "Failed to deserialize the response to the private ElGamal key".to_string(),
            ),
        )?;
        let rk_len = u64::from_le_bytes(bytes[idx..idx + 8].try_into().unwrap());
        idx += 8;
        if bytes[idx..].len() < rk_len as usize * 32 + 8 {
            return Err(
                CoconutError::Deserialization(
                    "tried to deserialize proof of ciphertexts and commitment with insufficient number of bytes provided".to_string()),
            );
        }
        let rk_end = idx + rk_len as usize * 32;
        let response_keys = try_deserialize_scalar_vec(
            rk_len,
            &bytes[idx..rk_end],
            CoconutError::Deserialization("Failed to deserialize keys response".to_string()),
        )?;
        let rm_len = u64::from_le_bytes(bytes[rk_end..rk_end + 8].try_into().unwrap());
        let response_attributes = try_deserialize_scalar_vec(
            rm_len,
            &bytes[rk_end + 8..],
            CoconutError::Deserialization("Failed to deserialize attributes response".to_string()),
        )?;
        Ok(ProofCmCs {
            challenge,
            response_opening,
            response_private_elgamal_key,
            response_keys,
            response_attributes,
        })
    }
 }
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct ProofKappa {
    challenge: Scalar,
    response_attributes: Vec<Scalar>,
    response_blinder: Scalar,
 }
 impl ProofKappa {
    pub fn construct(
        params: &Parameters,
        verification_key: &VerificationKey,
        blinding_factor: &Scalar,
        blinded_message: &G2Projective,
        private_attributes: &[Attribute],
        verifier_id: &[u8; 32],
        timestamp: &[u8; 32],
    ) -> Self {
        // create the witnesses
        let witness_blinder = params.random_scalar();
        let witness_attributes = params.n_random_scalars(private_attributes.len());
        let beta_bytes = verification_key
            .beta
            .iter()
            .map(|beta_i| beta_i.to_bytes())
            .collect::<Vec<_>>();
        // witnesses commitments
        // Aw = g2 * wt + alpha + beta[0] * wm[0] + ... + beta[i] * wm[i]
        let commitment_kappa = params.gen2() * witness_blinder
            + verification_key.alpha
            + witness_attributes
                .iter()
                .zip(verification_key.beta.iter())
                .map(|(wm_i, beta_i)| beta_i * wm_i)
                .sum::<G2Projective>();
        let challenge = compute_challenge::<ChallengeDigest, _, _>(
            std::iter::once(params.gen2().to_bytes().as_ref())
                .chain(std::iter::once(blinded_message.to_bytes().as_ref())) //kappa
                .chain(std::iter::once(verification_key.alpha.to_bytes().as_ref()))
                .chain(beta_bytes.iter().map(|b| b.as_ref()))
                .chain(std::iter::once(commitment_kappa.to_bytes().as_ref()))
                .chain(std::iter::once(verifier_id.as_ref()))
                .chain(std::iter::once(timestamp.as_ref())),
        );
        // responses
        let response_blinder = produce_response(&witness_blinder, &challenge, blinding_factor);
        let response_attributes =
            produce_responses(&witness_attributes, &challenge, private_attributes);
        ProofKappa {
            challenge,
            response_attributes,
            response_blinder,
        }
    }
    pub fn private_attributes_len(&self) -> usize {
        self.response_attributes.len()
    }
    pub fn verify(
        &self,
        params: &Parameters,
        verification_key: &VerificationKey,
        kappa: &G2Projective,
        verifier_id: &[u8; 32],
        timestamp: &[u8; 32],
    ) -> bool {
        let beta_bytes = verification_key
            .beta
            .iter()
            .map(|beta_i| beta_i.to_bytes())
            .collect::<Vec<_>>();
        // re-compute witnesses commitments
        // Aw = (c * kappa) + (rt * g2) + ((1 - c) * alpha) + (rm[0] * beta[0]) + ... + (rm[i] * beta[i])
        let commitment_kappa = kappa * self.challenge
            + params.gen2() * self.response_blinder
            + verification_key.alpha * (Scalar::one() - self.challenge)
            + self
                .response_attributes
                .iter()
                .zip(verification_key.beta.iter())
                .map(|(priv_attr, beta_i)| beta_i * priv_attr)
                .sum::<G2Projective>();
        // compute the challenge
        let challenge = compute_challenge::<ChallengeDigest, _, _>(
            std::iter::once(params.gen2().to_bytes().as_ref())
                .chain(std::iter::once(kappa.to_bytes().as_ref()))
                .chain(std::iter::once(verification_key.alpha.to_bytes().as_ref()))
                .chain(beta_bytes.iter().map(|b| b.as_ref()))
                .chain(std::iter::once(commitment_kappa.to_bytes().as_ref()))
                .chain(std::iter::once(verifier_id.as_ref()))
                .chain(std::iter::once(timestamp.as_ref())),
        );
        challenge == self.challenge
    }
    pub fn to_bytes(&self) -> Vec<u8> {
        let attributes_len = self.response_attributes.len() as u64;
        let mut bytes = Vec::with_capacity(8 + (attributes_len + 2) as usize * 32);
        bytes.extend_from_slice(&self.challenge.to_bytes());
        bytes.extend_from_slice(&self.response_blinder.to_bytes());
        bytes.extend_from_slice(&attributes_len.to_le_bytes());
        for rm in &self.response_attributes {
            bytes.extend_from_slice(&rm.to_bytes());
        }
        bytes
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
        // at the very minimum there must be a single attribute being proven
        if bytes.len() < 32 * 2 + 8 || (bytes.len() - 8) % 32 != 0 {
            return Err(
                CoconutError::Deserialization(
                    "tried to deserialize proof of ciphertexts and commitment with bytes of invalid length".to_string())
            );
        }
        let challenge_bytes = bytes[..32].try_into().unwrap();
        let challenge = try_deserialize_scalar(
            &challenge_bytes,
            CoconutError::Deserialization("Failed to deserialize challenge".to_string()),
        )?;
        let blinder_bytes = bytes[32..64].try_into().unwrap();
        let response_blinder = try_deserialize_scalar(
            &blinder_bytes,
            CoconutError::Deserialization("failed to deserialize the blinder".to_string()),
        )?;
        let rm_len = u64::from_le_bytes(bytes[64..64 + 8].try_into().unwrap());
        let response_attributes = try_deserialize_scalar_vec(
            rm_len,
            &bytes[64 + 8..],
            CoconutError::Deserialization("Failed to deserialize attributes response".to_string()),
        )?;
        Ok(ProofKappa {
            challenge,
            response_attributes,
            response_blinder,
        })
    }
 }
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct ProofKappaNu {
    // c
    challenge: Scalar,
    // responses
    response_serial_number: Scalar,
    response_binding_number: Scalar,
    response_blinder: Scalar,
 }
 impl ProofKappaNu {
    pub(crate) fn construct(
        params: &Parameters,
        verification_key: &VerificationKey,
        serial_number: &Attribute,
        binding_number: &Attribute,
        blinding_factor: &Scalar,
        blinded_message: &G2Projective,
        blinded_serial_number: &G2Projective,
    ) -> Self {
        // create the witnesses
        let witness_blinder = params.random_scalar();
        let witness_serial_number = params.random_scalar();
        let witness_binding_number = params.random_scalar();
        let witness_attributes = vec![witness_serial_number, witness_binding_number];
        let beta_bytes = verification_key
            .beta
            .iter()
            .map(|beta_i| beta_i.to_bytes())
            .collect::<Vec<_>>();
        // witnesses commitments
        // Aw = g2 * wt + alpha + beta[0] * wm[0] + ... + beta[i] * wm[i]
        let commitment_kappa = params.gen2() * witness_blinder
            + verification_key.alpha
            + witness_attributes
                .iter()
                .zip(verification_key.beta.iter())
                .map(|(wm_i, beta_i)| beta_i * wm_i)
                .sum::<G2Projective>();
        // zeta is the public value associated with the serial number
        let commitment_zeta = params.gen2() * witness_serial_number;
        let challenge = compute_challenge::<ChallengeDigest, _, _>(
            std::iter::once(params.gen2().to_bytes().as_ref())
                .chain(std::iter::once(blinded_message.to_bytes().as_ref()))
                .chain(std::iter::once(blinded_serial_number.to_bytes().as_ref())) //kappa
                .chain(std::iter::once(verification_key.alpha.to_bytes().as_ref()))
                .chain(beta_bytes.iter().map(|b| b.as_ref()))
                .chain(std::iter::once(commitment_kappa.to_bytes().as_ref()))
                .chain(std::iter::once(commitment_zeta.to_bytes().as_ref())),
        );
        // responses
        let response_blinder = produce_response(&witness_blinder, &challenge, blinding_factor);
        let response_serial_number =
            produce_response(&witness_serial_number, &challenge, serial_number);
        let response_binding_number =
            produce_response(&witness_binding_number, &challenge, binding_number);
        ProofKappaNu {
            challenge,
            response_serial_number,
            response_binding_number,
            response_blinder,
        }
    }
    pub(crate) fn private_attributes_len(&self) -> usize {
        2
    }
    pub(crate) fn verify(
        &self,
        params: &Parameters,
        verification_key: &VerificationKey,
        kappa: &G2Projective,
        zeta: &G2Projective,
    ) -> bool {
        let beta_bytes = verification_key
            .beta
            .iter()
            .map(|beta_i| beta_i.to_bytes())
            .collect::<Vec<_>>();
        let response_attributes = vec![self.response_serial_number, self.response_binding_number];
        // re-compute witnesses commitments
        // Aw = (c * kappa) + (rt * g2) + ((1 - c) * alpha) + (rm[0] * beta[0]) + ... + (rm[i] * beta[i])
        let commitment_kappa = kappa * self.challenge
            + params.gen2() * self.response_blinder
            + verification_key.alpha * (Scalar::one() - self.challenge)
            + response_attributes
                .iter()
                .zip(verification_key.beta.iter())
                .map(|(priv_attr, beta_i)| beta_i * priv_attr)
                .sum::<G2Projective>();
        // zeta is the public value associated with the serial number
        let commitment_zeta = zeta * self.challenge + params.gen2() * self.response_serial_number;
        // compute the challenge
        let challenge = compute_challenge::<ChallengeDigest, _, _>(
            std::iter::once(params.gen2().to_bytes().as_ref())
                .chain(std::iter::once(kappa.to_bytes().as_ref()))
                .chain(std::iter::once(zeta.to_bytes().as_ref()))
                .chain(std::iter::once(verification_key.alpha.to_bytes().as_ref()))
                .chain(beta_bytes.iter().map(|b| b.as_ref()))
                .chain(std::iter::once(commitment_kappa.to_bytes().as_ref()))
                .chain(std::iter::once(commitment_zeta.to_bytes().as_ref())),
        );
        challenge == self.challenge
    }
    // challenge || rm.len() || rm || rt
    pub(crate) fn to_bytes(&self) -> Vec<u8> {
        //let attributes_len = self.response_attributes.len() as u64;
        let attributes_len = 2;
        let mut bytes = Vec::with_capacity((attributes_len + 1) as usize * 32);
        bytes.extend_from_slice(&self.challenge.to_bytes());
        bytes.extend_from_slice(&self.response_serial_number.to_bytes());
        bytes.extend_from_slice(&self.response_binding_number.to_bytes());
        bytes.extend_from_slice(&self.response_blinder.to_bytes());
        bytes
    }
    pub(crate) fn from_bytes(bytes: &[u8]) -> Result<Self> {
        // at the very minimum there must be a single attribute being proven
        if bytes.len() < 32 * 3 || (bytes.len()) % 32 != 0 {
            return Err(CoconutError::DeserializationInvalidLength {
                actual: bytes.len(),
                modulus_target: bytes.len(),
                modulus: 32,
                object: "kappa and zeta".to_string(),
                target: 32 * 3 + 8,
            });
        }
        let challenge_bytes = bytes[..32].try_into().unwrap();
        let challenge = try_deserialize_scalar(
            &challenge_bytes,
            CoconutError::Deserialization("Failed to deserialize challenge".to_string()),
        )?;
        // let rm_len = u64::from_le_bytes(bytes[32..40].try_into().unwrap());
        if bytes[32..].len() != (2 + 1) as usize * 32 {
            return Err(
                CoconutError::Deserialization(
                    format!("Tried to deserialize proof of kappa and zeta with insufficient number of bytes provided, expected {} got {}.", (2 + 1) as usize * 32, bytes[32..].len())
                )
            );
        }
        let serial_number_bytes = &bytes[32..64].try_into().unwrap();
        let response_serial_number = try_deserialize_scalar(
            serial_number_bytes,
            CoconutError::Deserialization("failed to deserialize the serial number".to_string()),
        )?;
        let binding_number_bytes = &bytes[64..96].try_into().unwrap();
        let response_binding_number = try_deserialize_scalar(
            binding_number_bytes,
            CoconutError::Deserialization("failed to deserialize the binding number".to_string()),
        )?;
        let blinder_bytes = bytes[96..].try_into().unwrap();
        let response_blinder = try_deserialize_scalar(
            &blinder_bytes,
            CoconutError::Deserialization("failed to deserialize the blinder".to_string()),
        )?;
        Ok(ProofKappaNu {
            challenge,
            response_serial_number,
            response_binding_number,
            response_blinder,
        })
    }
 }
 // proof builder:
 // - commitment
 // - challenge
 // - responses
 #[cfg(test)]
 mod tests {
    use group::Group;
    use rand::thread_rng;
    use crate::scheme::issuance::{compute_attribute_encryption, compute_commitment_hash};
    use crate::scheme::keygen::keygen;
    use crate::scheme::setup::setup;
    use crate::scheme::verification::{compute_kappa, compute_zeta};
    use super::*;
    #[test]
    fn proof_cm_cs_bytes_roundtrip() {
        let mut rng = thread_rng();
        let mut params = setup(1).unwrap();
        let elgamal_keypair = elgamal::elgamal_keygen(&params);
        let private_attributes = params.n_random_scalars(1);
        // we don't care about 'correctness' of the proof. only whether we can correctly recover it from bytes
        let cm = G1Projective::random(&mut rng);
        let r = params.random_scalar();
        let commitment_hash = compute_commitment_hash(cm);
        let (attributes_ciphertexts, _): (Vec<_>, Vec<_>) = compute_attribute_encryption(
            &params,
            private_attributes.as_ref(),
            elgamal_keypair.public_key(),
            commitment_hash,
        );
        let ephemeral_keys = params.n_random_scalars(1);
        // 0 public 1 private
        let pi_s = ProofCmCs::construct(
            &mut params,
            &elgamal_keypair,
            &ephemeral_keys,
            &cm,
            &r,
            &private_attributes,
            &*attributes_ciphertexts,
        );
        let bytes = pi_s.to_bytes();
        assert_eq!(ProofCmCs::from_bytes(&bytes).unwrap(), pi_s);
        // 2 private
        let private_attributes = params.n_random_scalars(2);
        let ephemeral_keys = params.n_random_scalars(2);
        let pi_s = ProofCmCs::construct(
            &mut params,
            &elgamal_keypair,
            &ephemeral_keys,
            &cm,
            &r,
            &private_attributes,
            &*attributes_ciphertexts,
        );
        let bytes = pi_s.to_bytes();
        assert_eq!(ProofCmCs::from_bytes(&bytes).unwrap(), pi_s);
    }
    #[test]
    fn proof_kappa_nu_bytes_roundtrip() {
        let mut params = setup(1).unwrap();
        let keypair = keygen(&mut params);
        // we don't care about 'correctness' of the proof. only whether we can correctly recover it from bytes
        let serial_number = params.random_scalar();
        let binding_number = params.random_scalar();
        let private_attributes = vec![serial_number, binding_number];
        let r = params.random_scalar();
        let kappa = compute_kappa(&params, &keypair.verification_key(), &private_attributes, r);
        let zeta = compute_zeta(&params, serial_number);
        // 0 public 2 private
        let pi_v = ProofKappaNu::construct(
            &mut params,
            &keypair.verification_key(),
            &serial_number,
            &binding_number,
            &r,
            &kappa,
            &zeta,
        );
        let bytes = pi_v.to_bytes();
        assert_eq!(ProofKappaNu::from_bytes(&bytes).unwrap(), pi_v);
        // 2 public 2 private
        let mut params = setup(4).unwrap();
        let keypair = keygen(&mut params);
        let pi_v = ProofKappaNu::construct(
            &mut params,
            &keypair.verification_key(),
            &serial_number,
            &binding_number,
            &r,
            &kappa,
            &zeta,
        );
        let bytes = pi_v.to_bytes();
        assert_eq!(ProofKappaNu::from_bytes(&bytes).unwrap(), pi_v);
    }
 }
@@ -0,0 +1,388 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use core::iter::Sum;
 use core::ops::Mul;
 use bls12_381::{G2Prepared, G2Projective, Scalar};
 use group::Curve;
 use itertools::Itertools;
 use crate::error::{CoconutError, Result};
 use crate::scheme::verification::check_bilinear_pairing;
 use crate::scheme::{PartialSignature, Signature, SignatureShare, SignerIndex, VerificationKey};
 use crate::utils::perform_lagrangian_interpolation_at_origin;
 use crate::{Attribute, Parameters};
 pub(crate) trait Aggregatable: Sized {
    fn aggregate(aggregatable: &[Self], indices: Option<&[SignerIndex]>) -> Result<Self>;
    fn check_unique_indices(indices: &[SignerIndex]) -> bool {
        // if aggregation is a threshold one, all indices should be unique
        indices.iter().unique_by(|&index| index).count() == indices.len()
    }
 }
 // includes `VerificationKey`
 impl<T> Aggregatable for T
 where
    T: Sum,
    for<'a> T: Sum<&'a T>,
    for<'a> &'a T: Mul<Scalar, Output = T>,
 {
    fn aggregate(aggregatable: &[T], indices: Option<&[u64]>) -> Result<T> {
        if aggregatable.is_empty() {
            return Err(CoconutError::Aggregation("Empty set of values".to_string()));
        }
        if let Some(indices) = indices {
            if !Self::check_unique_indices(indices) {
                return Err(CoconutError::Aggregation("Non-unique indices".to_string()));
            }
            perform_lagrangian_interpolation_at_origin(indices, aggregatable)
        } else {
            // non-threshold
            Ok(aggregatable.iter().sum())
        }
    }
 }
 impl Aggregatable for PartialSignature {
    fn aggregate(sigs: &[PartialSignature], indices: Option<&[u64]>) -> Result<Signature> {
        let h = sigs
            .get(0)
            .ok_or_else(|| CoconutError::Aggregation("Empty set of signatures".to_string()))?
            .sig1();
        // TODO: is it possible to avoid this allocation?
        let sigmas = sigs.iter().map(|sig| *sig.sig2()).collect::<Vec<_>>();
        let aggr_sigma = Aggregatable::aggregate(&sigmas, indices)?;
        Ok(Signature(*h, aggr_sigma))
    }
 }
 /// Ensures all provided verification keys were generated to verify the same number of attributes.
 fn check_same_key_size(keys: &[VerificationKey]) -> bool {
    keys.iter().map(|vk| vk.beta.len()).all_equal()
 }
 pub fn aggregate_verification_keys(
    keys: &[VerificationKey],
    indices: Option<&[SignerIndex]>,
 ) -> Result<VerificationKey> {
    if !check_same_key_size(keys) {
        return Err(CoconutError::Aggregation(
            "Verification keys are of different sizes".to_string(),
        ));
    }
    Aggregatable::aggregate(keys, indices)
 }
 pub fn aggregate_signatures(
    params: &Parameters,
    verification_key: &VerificationKey,
    attributes: &[Attribute],
    signatures: &[PartialSignature],
    indices: Option<&[SignerIndex]>,
 ) -> Result<Signature> {
    // aggregate the signature
    let signature = match Aggregatable::aggregate(signatures, indices) {
        Ok(res) => res,
        Err(err) => return Err(err),
    };
    // Verify the signature
    let alpha = verification_key.alpha;
    let tmp = attributes
        .iter()
        .zip(verification_key.beta.iter())
        .map(|(attr, beta_i)| beta_i * attr)
        .sum::<G2Projective>();
    if !check_bilinear_pairing(
        &signature.0.to_affine(),
        &G2Prepared::from((alpha + tmp).to_affine()),
        &signature.1.to_affine(),
        params.prepared_miller_g2(),
    ) {
        return Err(CoconutError::Aggregation(
            "Verification of the aggregated signature failed".to_string(),
        ));
    }
    Ok(signature)
 }
 pub fn aggregate_signature_shares(
    params: &Parameters,
    verification_key: &VerificationKey,
    attributes: &[Attribute],
    shares: &[SignatureShare],
 ) -> Result<Signature> {
    let (signatures, indices): (Vec<_>, Vec<_>) = shares
        .iter()
        .map(|share| (*share.signature(), share.index()))
        .unzip();
    aggregate_signatures(
        params,
        verification_key,
        attributes,
        &signatures,
        Some(&indices),
    )
 }
 #[cfg(test)]
 mod tests {
    use bls12_381::G1Projective;
    use group::Group;
    use crate::scheme::issuance::sign;
    use crate::scheme::keygen::ttp_keygen;
    use crate::scheme::setup::Parameters;
    use crate::scheme::verification::verify;
    use super::*;
    #[test]
    fn key_aggregation_works_for_any_subset_of_keys() {
        let mut params = Parameters::new(2).unwrap();
        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
        let vks = keypairs
            .into_iter()
            .map(|keypair| keypair.verification_key())
            .collect::<Vec<_>>();
        let aggr_vk1 = aggregate_verification_keys(&vks[..3], Some(&[1, 2, 3])).unwrap();
        let aggr_vk2 = aggregate_verification_keys(&vks[2..], Some(&[3, 4, 5])).unwrap();
        assert_eq!(aggr_vk1, aggr_vk2);
        // TODO: should those two actually work or not?
        // aggregating threshold+1
        let aggr_more = aggregate_verification_keys(&vks[1..], Some(&[2, 3, 4, 5])).unwrap();
        assert_eq!(aggr_vk1, aggr_more);
        // aggregating all
        let aggr_all = aggregate_verification_keys(&vks, Some(&[1, 2, 3, 4, 5])).unwrap();
        assert_eq!(aggr_all, aggr_vk1);
        // not taking enough points (threshold was 3)
        let aggr_not_enough = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
        assert_ne!(aggr_not_enough, aggr_vk1);
        // taking wrong index
        let aggr_bad = aggregate_verification_keys(&vks[2..], Some(&[42, 123, 100])).unwrap();
        assert_ne!(aggr_vk1, aggr_bad);
    }
    #[test]
    fn key_aggregation_doesnt_work_for_empty_set_of_keys() {
        let keys: Vec<VerificationKey> = vec![];
        assert!(aggregate_verification_keys(&keys, None).is_err());
    }
    #[test]
    fn key_aggregation_doesnt_work_if_indices_have_invalid_length() {
        let keys = vec![VerificationKey::identity(3)];
        assert!(aggregate_verification_keys(&keys, Some(&[])).is_err());
        assert!(aggregate_verification_keys(&keys, Some(&[1, 2])).is_err());
    }
    #[test]
    fn key_aggregation_doesnt_work_for_non_unique_indices() {
        let keys = vec![VerificationKey::identity(3), VerificationKey::identity(3)];
        assert!(aggregate_verification_keys(&keys, Some(&[1, 1])).is_err());
    }
    #[test]
    fn key_aggregation_doesnt_work_for_keys_of_different_size() {
        let keys = vec![VerificationKey::identity(3), VerificationKey::identity(1)];
        assert!(aggregate_verification_keys(&keys, None).is_err())
    }
    #[test]
    fn signature_aggregation_works_for_any_subset_of_signatures() {
        let mut params = Parameters::new(2).unwrap();
        let attributes = params.n_random_scalars(2);
        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
        let (sks, vks): (Vec<_>, Vec<_>) = keypairs
            .into_iter()
            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
            .unzip();
        let sigs = sks
            .iter()
            .map(|sk| sign(&mut params, sk, &attributes).unwrap())
            .collect::<Vec<_>>();
        // aggregating (any) threshold works
        let aggr_vk_1 = aggregate_verification_keys(&vks[..3], Some(&[1, 2, 3])).unwrap();
        let aggr_sig1 = aggregate_signatures(
            &params,
            &aggr_vk_1,
            &attributes,
            &sigs[..3],
            Some(&[1, 2, 3]),
        )
        .unwrap();
        let aggr_vk_2 = aggregate_verification_keys(&vks[2..], Some(&[3, 4, 5])).unwrap();
        let aggr_sig2 = aggregate_signatures(
            &params,
            &aggr_vk_1,
            &attributes,
            &sigs[2..],
            Some(&[3, 4, 5]),
        )
        .unwrap();
        assert_eq!(aggr_sig1, aggr_sig2);
        // verify credential for good measure
        assert!(verify(&params, &aggr_vk_1, &attributes, &aggr_sig1));
        assert!(verify(&params, &aggr_vk_2, &attributes, &aggr_sig2));
        // aggregating threshold+1 works
        let aggr_vk_more = aggregate_verification_keys(&vks[1..], Some(&[2, 3, 4, 5])).unwrap();
        let aggr_more = aggregate_signatures(
            &params,
            &aggr_vk_more,
            &attributes,
            &sigs[1..],
            Some(&[2, 3, 4, 5]),
        )
        .unwrap();
        assert_eq!(aggr_sig1, aggr_more);
        // aggregating all
        let aggr_vk_all = aggregate_verification_keys(&vks, Some(&[1, 2, 3, 4, 5])).unwrap();
        let aggr_all = aggregate_signatures(
            &params,
            &aggr_vk_all,
            &attributes,
            &sigs,
            Some(&[1, 2, 3, 4, 5]),
        )
        .unwrap();
        assert_eq!(aggr_all, aggr_sig1);
        // not taking enough points (threshold was 3) should fail
        let aggr_vk_not_enough = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
        let aggr_not_enough = aggregate_signatures(
            &params,
            &aggr_vk_not_enough,
            &attributes,
            &sigs[..2],
            Some(&[1, 2]),
        )
        .unwrap();
        assert_ne!(aggr_not_enough, aggr_sig1);
        // taking wrong index should fail
        let aggr_vk_bad = aggregate_verification_keys(&vks[2..], Some(&[1, 2, 3])).unwrap();
        assert!(aggregate_signatures(
            &params,
            &aggr_vk_bad,
            &attributes,
            &sigs[2..],
            Some(&[42, 123, 100]),
        )
        .is_err());
    }
    fn random_signature() -> Signature {
        let mut rng = rand::thread_rng();
        Signature(
            G1Projective::random(&mut rng),
            G1Projective::random(&mut rng),
        )
    }
    #[test]
    fn signature_aggregation_doesnt_work_for_empty_set_of_signatures() {
        let signatures: Vec<Signature> = vec![];
        let mut params = Parameters::new(2).unwrap();
        let attributes = params.n_random_scalars(2);
        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
        let (_, vks): (Vec<_>, Vec<_>) = keypairs
            .into_iter()
            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
            .unzip();
        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
        assert!(
            aggregate_signatures(&params, &aggr_vk_all, &attributes, &signatures, None).is_err()
        );
    }
    #[test]
    fn signature_aggregation_doesnt_work_if_indices_have_invalid_length() {
        let signatures = vec![random_signature()];
        let mut params = Parameters::new(2).unwrap();
        let attributes = params.n_random_scalars(2);
        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
        let (_, vks): (Vec<_>, Vec<_>) = keypairs
            .into_iter()
            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
            .unzip();
        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
        assert!(
            aggregate_signatures(&params, &aggr_vk_all, &attributes, &signatures, Some(&[]))
                .is_err()
        );
        assert!(aggregate_signatures(
            &params,
            &aggr_vk_all,
            &attributes,
            &signatures,
            Some(&[1, 2]),
        )
        .is_err());
    }
    #[test]
    fn signature_aggregation_doesnt_work_for_non_unique_indices() {
        let signatures = vec![random_signature(), random_signature()];
        let mut params = Parameters::new(2).unwrap();
        let attributes = params.n_random_scalars(2);
        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
        let (_, vks): (Vec<_>, Vec<_>) = keypairs
            .into_iter()
            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
            .unzip();
        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
        assert!(aggregate_signatures(
            &params,
            &aggr_vk_all,
            &attributes,
            &signatures,
            Some(&[1, 1]),
        )
        .is_err());
    }
    // TODO: test for aggregating non-threshold keys
 }
@@ -0,0 +1,397 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use std::convert::TryFrom;
 use std::convert::TryInto;
 use bls12_381::{G1Affine, G1Projective, Scalar};
 use group::{Curve, GroupEncoding};
 use crate::elgamal::{Ciphertext, EphemeralKey};
 use crate::error::{CoconutError, Result};
 use crate::proofs::ProofCmCs;
 use crate::scheme::setup::Parameters;
 use crate::scheme::BlindedSignature;
 use crate::scheme::SecretKey;
 /// Creates a Coconut Signature under a given secret key on a set of public attributes only.
 #[cfg(test)]
 use crate::Signature;
 use crate::{elgamal, Attribute, ElGamalKeyPair};
 // TODO: possibly completely remove those two functions.
 // They only exist to have a simpler and smaller code snippets to test
 // basic functionalities.
 use crate::traits::{Base58, Bytable};
 use crate::utils::{hash_g1, try_deserialize_g1_projective};
 // TODO NAMING: double check this one
 // Lambda
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct BlindSignRequest {
    // cm
    commitment: G1Projective,
    // h
    commitment_hash: G1Projective,
    // c
    private_attributes_ciphertexts: Vec<elgamal::Ciphertext>,
    // pi_s
    pi_s: ProofCmCs,
 }
 impl TryFrom<&[u8]> for BlindSignRequest {
    type Error = CoconutError;
    fn try_from(bytes: &[u8]) -> Result<BlindSignRequest> {
        if bytes.len() < 48 + 48 + 8 + 96 {
            return Err(CoconutError::DeserializationMinLength {
                min: 48 + 48 + 8 + 9,
                actual: bytes.len(),
            });
        }
        let mut j = 0;
        let commitment_bytes_len = 48;
        let commitment_hash_bytes_len = 48;
        let cm_bytes = bytes[..j + commitment_bytes_len].try_into().unwrap();
        let commitment = try_deserialize_g1_projective(
            &cm_bytes,
            CoconutError::Deserialization(
                "Failed to deserialize compressed commitment".to_string(),
            ),
        )?;
        j += commitment_bytes_len;
        let cm_hash_bytes = bytes[j..j + commitment_hash_bytes_len].try_into().unwrap();
        let commitment_hash = try_deserialize_g1_projective(
            &cm_hash_bytes,
            CoconutError::Deserialization(
                "Failed to deserialize compressed commitment hash".to_string(),
            ),
        )?;
        j += commitment_hash_bytes_len;
        let c_len = u64::from_le_bytes(bytes[j..j + 8].try_into().unwrap());
        j += 8;
        if bytes[j..].len() < c_len as usize * 96 {
            return Err(CoconutError::DeserializationMinLength {
                min: c_len as usize * 96,
                actual: bytes[56..].len(),
            });
        }
        let mut private_attributes_ciphertexts = Vec::with_capacity(c_len as usize);
        for i in 0..c_len as usize {
            let start = j + i * 96;
            let end = start + 96;
            private_attributes_ciphertexts.push(Ciphertext::try_from(&bytes[start..end])?)
        }
        let pi_s = ProofCmCs::from_bytes(&bytes[j + c_len as usize * 96..])?;
        Ok(BlindSignRequest {
            commitment,
            commitment_hash,
            private_attributes_ciphertexts,
            pi_s,
        })
    }
 }
 impl Bytable for BlindSignRequest {
    fn to_byte_vec(&self) -> Vec<u8> {
        let cm_bytes = self.commitment.to_affine().to_compressed();
        let cm_hash_bytes = self.commitment_hash.to_affine().to_compressed();
        let c_len = self.private_attributes_ciphertexts.len() as u64;
        let proof_bytes = self.pi_s.to_bytes();
        let mut bytes = Vec::with_capacity(48 + 48 + 8 + c_len as usize * 96 + proof_bytes.len());
        bytes.extend_from_slice(&cm_bytes);
        bytes.extend_from_slice(&cm_hash_bytes);
        bytes.extend_from_slice(&c_len.to_le_bytes());
        for c in &self.private_attributes_ciphertexts {
            bytes.extend_from_slice(&c.to_bytes());
        }
        bytes.extend_from_slice(&proof_bytes);
        bytes
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        BlindSignRequest::from_bytes(slice)
    }
 }
 impl Base58 for BlindSignRequest {}
 impl BlindSignRequest {
    fn verify_proof(&self, params: &Parameters, pub_key: &elgamal::PublicKey) -> bool {
        self.pi_s.verify(
            params,
            pub_key,
            &self.commitment,
            &self.private_attributes_ciphertexts,
        )
    }
    pub fn get_commitment_hash(&self) -> G1Projective {
        self.commitment_hash
    }
    // TODO: perhaps also include pi_s.len()?
    // to be determined once we implement serde to make sure its 1:1 compatible
    // with bincode
    // cm || c.len() || c || pi_s
    pub fn to_bytes(&self) -> Vec<u8> {
        self.to_byte_vec()
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<BlindSignRequest> {
        BlindSignRequest::try_from(bytes)
    }
 }
 pub fn compute_private_attributes_commitment(
    params: &Parameters,
    private_attributes: &[Attribute],
    hs: &[G1Affine],
 ) -> (Scalar, G1Projective) {
    let commitment_opening = params.random_scalar();
    // Produces h0 ^ m0 * h1^m1 * .... * hn^mn
    // where m0, m1, ...., mn are private attributes
    let attr_cm = private_attributes
        .iter()
        .zip(hs)
        .map(|(&m, h)| h * m)
        .sum::<G1Projective>();
    // Produces g1^r * h0 ^ m0 * h1^m1 * .... * hn^mn
    let commitment = params.gen1() * commitment_opening + attr_cm;
    (commitment_opening, commitment)
 }
 pub fn compute_commitment_hash(commitment: G1Projective) -> G1Projective {
    hash_g1(commitment.to_bytes())
 }
 pub fn compute_attribute_encryption(
    params: &Parameters,
    private_attributes: &[Attribute],
    pub_key: &elgamal::PublicKey,
    commitment_hash: G1Projective,
 ) -> (Vec<Ciphertext>, Vec<EphemeralKey>) {
    private_attributes
        .iter()
        .map(|m| pub_key.encrypt(params, &commitment_hash, m))
        .unzip()
 }
 /// Builds cryptographic material required for blind sign.
 pub fn prepare_blind_sign(
    params: &Parameters,
    elgamal_keypair: &ElGamalKeyPair,
    private_attributes: &[Attribute],
    public_attributes: &[Attribute],
 ) -> Result<BlindSignRequest> {
    if private_attributes.is_empty() {
        return Err(CoconutError::Issuance(
            "Tried to prepare blind sign request for an empty set of private attributes"
                .to_string(),
        ));
    }
    let hs = params.gen_hs();
    if private_attributes.len() + public_attributes.len() > hs.len() {
        return Err(CoconutError::IssuanceMaxAttributes {
            max: hs.len(),
            requested: private_attributes.len() + public_attributes.len(),
        });
    }
    let (commitment_opening, commitment) =
        compute_private_attributes_commitment(params, private_attributes, hs);
    // Compute the challenge as the commitment hash
    let commitment_hash = compute_commitment_hash(commitment);
    // build ElGamal encryption
    let (private_attributes_ciphertexts, ephemeral_keys): (Vec<_>, Vec<_>) =
        compute_attribute_encryption(
            params,
            private_attributes,
            elgamal_keypair.public_key(),
            commitment_hash,
        );
    let pi_s = ProofCmCs::construct(
        params,
        elgamal_keypair,
        &ephemeral_keys,
        &commitment,
        &commitment_opening,
        private_attributes,
        &*private_attributes_ciphertexts,
    );
    Ok(BlindSignRequest {
        commitment,
        commitment_hash,
        private_attributes_ciphertexts,
        pi_s,
    })
 }
 pub fn blind_sign(
    params: &Parameters,
    signing_secret_key: &SecretKey,
    prover_pub_key: &elgamal::PublicKey,
    blind_sign_request: &BlindSignRequest,
    public_attributes: &[Attribute],
 ) -> Result<BlindedSignature> {
    let num_private = blind_sign_request.private_attributes_ciphertexts.len();
    let hs = params.gen_hs();
    if num_private + public_attributes.len() > hs.len() {
        return Err(CoconutError::IssuanceMaxAttributes {
            max: hs.len(),
            requested: num_private + public_attributes.len(),
        });
    }
    // Verify the commitment hash
    let h = hash_g1(blind_sign_request.commitment.to_bytes());
    if !(h == blind_sign_request.commitment_hash) {
        return Err(CoconutError::Issuance(
            "Failed to verify the commitment hash".to_string(),
        ));
    }
    // Verify the ZK proof
    if !blind_sign_request.verify_proof(params, prover_pub_key) {
        return Err(CoconutError::Issuance(
            "Failed to verify the proof of knowledge".to_string(),
        ));
    }
    // in python implementation there are n^2 G1 multiplications, let's do it with a single one instead.
    // i.e. compute h ^ (pub_m[0] * y[m + 1] + ... + pub_m[n] * y[m + n]) directly (where m is number of PRIVATE attributes)
    // rather than ((h ^ pub_m[0]) ^ y[m + 1] , (h ^ pub_m[1]) ^ y[m + 2] , ...).sum() separately
    let signed_public = h * public_attributes
        .iter()
        .zip(signing_secret_key.ys.iter().skip(num_private))
        .map(|(attr, yi)| attr * yi)
        .sum::<Scalar>();
    // c1[0] ^ y[0] * ... * c1[m] ^ y[m]
    let sig_1 = blind_sign_request
        .private_attributes_ciphertexts
        .iter()
        .map(|ciphertext| ciphertext.c1())
        .zip(signing_secret_key.ys.iter())
        .map(|(c1, yi)| c1 * yi)
        .sum();
    // h ^ x + c2[0] ^ y[0] + ... c2[m] ^ y[m] + h ^ (pub_m[0] * y[m + 1] + ... + pub_m[n] * y[m + n])
    let sig_2 = blind_sign_request
        .private_attributes_ciphertexts
        .iter()
        .map(|ciphertext| ciphertext.c2())
        .zip(signing_secret_key.ys.iter())
        .map(|(c2, yi)| c2 * yi)
        .chain(std::iter::once(h * signing_secret_key.x))
        .chain(std::iter::once(signed_public))
        .sum();
    Ok(BlindedSignature(h, elgamal::Ciphertext(sig_1, sig_2)))
 }
 #[cfg(test)]
 pub fn sign(
    params: &mut Parameters,
    secret_key: &SecretKey,
    public_attributes: &[Attribute],
 ) -> Result<Signature> {
    if public_attributes.len() > secret_key.ys.len() {
        return Err(CoconutError::IssuanceMaxAttributes {
            max: secret_key.ys.len(),
            requested: public_attributes.len(),
        });
    }
    // TODO: why in the python implementation this hash onto the curve is present
    // while it's not used in the paper? the paper uses random exponent instead.
    // (the python implementation hashes string representation of all attributes onto the curve,
    // but I think the same can be achieved by just summing the attributes thus avoiding the unnecessary
    // transformation. If I'm wrong, please correct me.)
    let attributes_sum = public_attributes.iter().sum::<Scalar>();
    let h = hash_g1((params.gen1() * attributes_sum).to_bytes());
    // x + m0 * y0 + m1 * y1 + ... mn * yn
    let exponent = secret_key.x
        + public_attributes
            .iter()
            .zip(secret_key.ys.iter())
            .map(|(m_i, y_i)| m_i * y_i)
            .sum::<Scalar>();
    let sig2 = h * exponent;
    Ok(Signature(h, sig2))
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn blind_sign_request_bytes_roundtrip() {
        let mut params = Parameters::new(1).unwrap();
        let public_attributes = params.n_random_scalars(0);
        let private_attributes = params.n_random_scalars(1);
        let elgamal_keypair = elgamal::elgamal_keygen(&params);
        let lambda = prepare_blind_sign(
            &mut params,
            &elgamal_keypair,
            &private_attributes,
            &public_attributes,
        )
        .unwrap();
        let bytes = lambda.to_bytes();
        println!("{:?}", bytes.len());
        assert_eq!(
            BlindSignRequest::try_from(bytes.as_slice()).unwrap(),
            lambda
        );
        let mut params = Parameters::new(4).unwrap();
        let public_attributes = params.n_random_scalars(2);
        let private_attributes = params.n_random_scalars(2);
        let lambda = prepare_blind_sign(
            &mut params,
            &elgamal_keypair,
            &private_attributes,
            &public_attributes,
        )
        .unwrap();
        let bytes = lambda.to_bytes();
        assert_eq!(
            BlindSignRequest::try_from(bytes.as_slice()).unwrap(),
            lambda
        );
    }
 }
@@ -0,0 +1,550 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use core::borrow::Borrow;
 use core::iter::Sum;
 use core::ops::{Add, Mul};
 use std::convert::TryFrom;
 use std::convert::TryInto;
 use bls12_381::{G2Projective, Scalar};
 use group::Curve;
 use serde_derive::{Deserialize, Serialize};
 use crate::error::{CoconutError, Result};
 use crate::scheme::aggregation::aggregate_verification_keys;
 use crate::scheme::setup::Parameters;
 use crate::scheme::SignerIndex;
 use crate::traits::Bytable;
 use crate::utils::{
    try_deserialize_g2_projective, try_deserialize_scalar, try_deserialize_scalar_vec, Polynomial,
 };
 use crate::Base58;
 #[derive(Debug, Clone)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct SecretKey {
    pub(crate) x: Scalar,
    pub(crate) ys: Vec<Scalar>,
 }
 impl TryFrom<&[u8]> for SecretKey {
    type Error = CoconutError;
    fn try_from(bytes: &[u8]) -> Result<SecretKey> {
        if bytes.len() < 32 * 2 + 8 || (bytes.len() - 8) % 32 != 0 {
            return Err(CoconutError::DeserializationInvalidLength {
                actual: bytes.len(),
                modulus_target: bytes.len() - 8,
                target: 32 * 2 + 8,
                modulus: 32,
                object: "secret key".to_string(),
            });
        }
        // this conversion will not fail as we are taking the same length of data
        let x_bytes: [u8; 32] = bytes[..32].try_into().unwrap();
        let ys_len = u64::from_le_bytes(bytes[32..40].try_into().unwrap());
        let actual_ys_len = (bytes.len() - 40) / 32;
        if ys_len as usize != actual_ys_len {
            return Err(CoconutError::Deserialization(format!(
                "Tried to deserialize secret key with inconsistent ys len (expected {}, got {})",
                ys_len, actual_ys_len
            )));
        }
        let x = try_deserialize_scalar(
            &x_bytes,
            CoconutError::Deserialization("Failed to deserialize secret key scalar".to_string()),
        )?;
        let ys = try_deserialize_scalar_vec(
            ys_len,
            &bytes[40..],
            CoconutError::Deserialization("Failed to deserialize secret key scalars".to_string()),
        )?;
        Ok(SecretKey { x, ys })
    }
 }
 impl SecretKey {
    /// Derive verification key using this secret key.
    pub fn verification_key(&self, params: &Parameters) -> VerificationKey {
        let g2 = params.gen2();
        VerificationKey {
            alpha: g2 * self.x,
            beta: self.ys.iter().map(|y| g2 * y).collect(),
        }
    }
    // x || ys.len() || ys
    pub fn to_bytes(&self) -> Vec<u8> {
        let ys_len = self.ys.len() as u64;
        let mut bytes = Vec::with_capacity(8 + (ys_len + 1) as usize * 32);
        bytes.extend_from_slice(&self.x.to_bytes());
        bytes.extend_from_slice(&ys_len.to_le_bytes());
        for y in self.ys.iter() {
            bytes.extend_from_slice(&y.to_bytes())
        }
        bytes
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<SecretKey> {
        SecretKey::try_from(bytes)
    }
 }
 impl Bytable for SecretKey {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.to_bytes()
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        SecretKey::try_from(slice)
    }
 }
 impl Base58 for SecretKey {}
 // TODO: perhaps change points to affine representation
 // to make verification slightly more efficient?
 #[derive(Debug, PartialEq, Clone)]
 pub struct VerificationKey {
    // TODO add gen2 as per the paper or imply it from the fact library is using bls381?
    pub alpha: G2Projective,
    pub beta: Vec<G2Projective>,
 }
 impl TryFrom<&[u8]> for VerificationKey {
    type Error = CoconutError;
    fn try_from(bytes: &[u8]) -> Result<VerificationKey> {
        if bytes.len() < 96 * 2 + 8 || (bytes.len() - 8) % 96 != 0 {
            return Err(CoconutError::DeserializationInvalidLength {
                actual: bytes.len(),
                modulus_target: bytes.len() - 8,
                target: 96 * 2 + 8,
                modulus: 96,
                object: "secret key".to_string(),
            });
        }
        // this conversion will not fail as we are taking the same length of data
        let alpha_bytes: [u8; 96] = bytes[..96].try_into().unwrap();
        let beta_len = u64::from_le_bytes(bytes[96..104].try_into().unwrap());
        let actual_beta_len = (bytes.len() - 104) / 96;
        if beta_len as usize != actual_beta_len {
            return Err(
                CoconutError::Deserialization(
                    format!("Tried to deserialize verification key with inconsistent beta len (expected {}, got {})",
                            beta_len, actual_beta_len
                    )));
        }
        let alpha = try_deserialize_g2_projective(
            &alpha_bytes,
            CoconutError::Deserialization(
                "Failed to deserialize verification key G2 point (alpha)".to_string(),
            ),
        )?;
        let mut beta = Vec::with_capacity(actual_beta_len);
        for i in 0..actual_beta_len {
            let start = 104 + i * 96;
            let end = start + 96;
            let beta_i_bytes = bytes[start..end].try_into().unwrap();
            let beta_i = try_deserialize_g2_projective(
                &beta_i_bytes,
                CoconutError::Deserialization(
                    "Failed to deserialize verification key G2 point (beta)".to_string(),
                ),
            )?;
            beta.push(beta_i)
        }
        Ok(VerificationKey { alpha, beta })
    }
 }
 impl<'b> Add<&'b VerificationKey> for VerificationKey {
    type Output = VerificationKey;
    #[inline]
    fn add(self, rhs: &'b VerificationKey) -> VerificationKey {
        // If you're trying to add two keys together that were created
        // for different number of attributes, just panic as it's a
        // nonsense operation.
        assert_eq!(
            self.beta.len(),
            rhs.beta.len(),
            "trying to add verification keys generated for different number of attributes"
        );
        VerificationKey {
            alpha: self.alpha + rhs.alpha,
            beta: self
                .beta
                .iter()
                .zip(rhs.beta.iter())
                .map(|(self_beta, rhs_beta)| self_beta + rhs_beta)
                .collect(),
        }
    }
 }
 impl<'a> Mul<Scalar> for &'a VerificationKey {
    type Output = VerificationKey;
    #[inline]
    fn mul(self, rhs: Scalar) -> Self::Output {
        VerificationKey {
            alpha: self.alpha * rhs,
            beta: self.beta.iter().map(|b_i| b_i * rhs).collect(),
        }
    }
 }
 impl<T> Sum<T> for VerificationKey
 where
    T: Borrow<VerificationKey>,
 {
    #[inline]
    fn sum<I>(iter: I) -> Self
    where
        I: Iterator<Item = T>,
    {
        let mut peekable = iter.peekable();
        let head_attributes = match peekable.peek() {
            Some(head) => head.borrow().beta.len(),
            None => {
                // TODO: this is a really weird edge case. You're trying to sum an EMPTY iterator
                // of VerificationKey. So should it panic here or just return some nonsense value?
                return VerificationKey::identity(0);
            }
        };
        peekable.fold(VerificationKey::identity(head_attributes), |acc, item| {
            acc + item.borrow()
        })
    }
 }
 impl VerificationKey {
    /// Create a (kinda) identity verification key using specified
    /// number of 'beta' elements
    pub(crate) fn identity(beta_size: usize) -> Self {
        VerificationKey {
            alpha: G2Projective::identity(),
            beta: vec![G2Projective::identity(); beta_size],
        }
    }
    pub fn aggregate(sigs: &[Self], indices: Option<&[SignerIndex]>) -> Result<Self> {
        aggregate_verification_keys(sigs, indices)
    }
    pub fn alpha(&self) -> &G2Projective {
        &self.alpha
    }
    pub fn beta(&self) -> &Vec<G2Projective> {
        &self.beta
    }
    pub fn to_bytes(&self) -> Vec<u8> {
        let beta_len = self.beta.len() as u64;
        let mut bytes = Vec::with_capacity(8 + (beta_len + 1) as usize * 96);
        bytes.extend_from_slice(&self.alpha.to_affine().to_compressed());
        bytes.extend_from_slice(&beta_len.to_le_bytes());
        for beta in self.beta.iter() {
            bytes.extend_from_slice(&beta.to_affine().to_compressed())
        }
        bytes
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<VerificationKey> {
        VerificationKey::try_from(bytes)
    }
 }
 impl Bytable for VerificationKey {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.to_bytes()
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        VerificationKey::try_from(slice)
    }
 }
 impl Base58 for VerificationKey {}
 #[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct KeyPair {
    secret_key: SecretKey,
    verification_key: VerificationKey,
    /// Optional index value specifying polynomial point used during threshold key generation.
    pub index: Option<SignerIndex>,
 }
 impl KeyPair {
    const MARKER_BYTES: &'static [u8] = b"coconutkeypair";
    pub fn secret_key(&self) -> SecretKey {
        self.secret_key.clone()
    }
    pub fn verification_key(&self) -> VerificationKey {
        self.verification_key.clone()
    }
    pub fn to_bytes(&self) -> Vec<u8> {
        // Schema is coconutkeypair[14]|secret_key_len[8]|secret_key[secret_key_len]|verification_key_len[8]|verification_key[verification_key_len]|signer_index[8] - optional
        self.to_byte_vec()
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
        KeyPair::try_from_byte_slice(bytes)
    }
 }
 impl Bytable for KeyPair {
    fn to_byte_vec(&self) -> Vec<u8> {
        // Schema is coconutkeypair[14]|secret_key_len[8]|secret_key[secret_key_len]|verification_key_len[8]|verification_key[verification_key_len]|signer_index[8] - optional
        let mut byts = vec![];
        let secret_key_bytes = self.secret_key.to_bytes();
        let secret_key_len = (secret_key_bytes.len() as u64).to_le_bytes();
        let verification_key_bytes = self.verification_key.to_bytes();
        let verification_key_len = (verification_key_bytes.len() as u64).to_le_bytes();
        byts.extend_from_slice(Self::MARKER_BYTES);
        byts.extend_from_slice(&secret_key_len);
        byts.extend_from_slice(&secret_key_bytes);
        byts.extend_from_slice(&verification_key_len);
        byts.extend_from_slice(&verification_key_bytes);
        if let Some(index) = self.index {
            byts.extend_from_slice(&index.to_le_bytes())
        }
        byts
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        KeyPair::try_from(slice)
    }
 }
 impl Base58 for KeyPair {}
 impl TryFrom<&[u8]> for KeyPair {
    type Error = CoconutError;
    fn try_from(bytes: &[u8]) -> Result<KeyPair> {
        let header_len = Self::MARKER_BYTES.len();
        // we must be able to at the very least read the length of secret key which is past the header
        // and is 8 bytes long
        if bytes.len() < header_len + 8 {
            return Err(CoconutError::DeserializationMinLength {
                min: header_len + 8,
                actual: bytes.len(),
            });
        }
        let secret_key_len =
            u64::from_le_bytes(bytes[header_len..header_len + 8].try_into().unwrap()) as usize;
        let secret_key_start = header_len + 8;
        let secret_key =
            SecretKey::try_from(&bytes[secret_key_start..secret_key_start + secret_key_len])?;
        // we must be able to read the length of verification key
        if bytes.len() < secret_key_start + secret_key_len + 8 {
            return Err(CoconutError::DeserializationMinLength {
                min: secret_key_start + secret_key_len + 8,
                actual: bytes.len(),
            });
        }
        let verification_key_len = u64::from_le_bytes(
            bytes[secret_key_start + secret_key_len..secret_key_start + secret_key_len + 8]
                .try_into()
                .unwrap(),
        ) as usize;
        let verification_key_start = secret_key_start + secret_key_len + 8;
        let verification_key = VerificationKey::try_from(
            &bytes[verification_key_start..verification_key_start + verification_key_len],
        )?;
        let consumed_bytes = verification_key_start + verification_key_len;
        let index = if consumed_bytes < bytes.len() && [consumed_bytes..].len() == 8 {
            Some(u64::from_le_bytes(
                bytes[consumed_bytes..consumed_bytes + 8]
                    .try_into()
                    .unwrap(),
            ))
        } else {
            None
        };
        Ok(KeyPair {
            secret_key,
            verification_key,
            index,
        })
    }
 }
 /// Generate a single Coconut keypair ((x, y0, y1...), (g2^x, g2^y0, ...)).
 /// It is not suitable for threshold credentials as all subsequent calls to `keygen` generate keys
 /// that are independent of each other.
 #[cfg(test)]
 pub fn keygen(params: &Parameters) -> KeyPair {
    let attributes = params.gen_hs().len();
    let x = params.random_scalar();
    let ys = params.n_random_scalars(attributes);
    let secret_key = SecretKey { x, ys };
    let verification_key = secret_key.verification_key(params);
    KeyPair {
        secret_key,
        verification_key,
        index: None,
    }
 }
 /// Generate a set of n Coconut keypairs [((x, y0, y1...), (g2^x, g2^y0, ...)), ...],
 /// such that they support threshold aggregation by `threshold` number of parties.
 /// It is expected that this procedure is executed by a Trusted Third Party.
 pub fn ttp_keygen(
    params: &Parameters,
    threshold: u64,
    num_authorities: u64,
 ) -> Result<Vec<KeyPair>> {
    if threshold == 0 {
        return Err(CoconutError::Setup(
            "Tried to generate threshold keys with a 0 threshold value".to_string(),
        ));
    }
    if threshold > num_authorities {
        return Err(
            CoconutError::Setup(
                "Tried to generate threshold keys for threshold value being higher than number of the signing authorities".to_string(),
            ));
    }
    let attributes = params.gen_hs().len();
    // generate polynomials
    let v = Polynomial::new_random(params, threshold - 1);
    let ws = (0..attributes)
        .map(|_| Polynomial::new_random(params, threshold - 1))
        .collect::<Vec<_>>();
    // TODO: potentially if we had some known authority identifier we could use that instead
    // of the increasing (1,2,3,...) sequence
    let polynomial_indices = (1..=num_authorities).collect::<Vec<_>>();
    // generate polynomial shares
    let x = polynomial_indices
        .iter()
        .map(|&id| v.evaluate(&Scalar::from(id)));
    let ys = polynomial_indices.iter().map(|&id| {
        ws.iter()
            .map(|w| w.evaluate(&Scalar::from(id)))
            .collect::<Vec<_>>()
    });
    // finally set the keys
    let secret_keys = x.zip(ys).map(|(x, ys)| SecretKey { x, ys });
    let keypairs = secret_keys
        .zip(polynomial_indices.iter())
        .map(|(secret_key, index)| {
            let verification_key = secret_key.verification_key(params);
            KeyPair {
                secret_key,
                verification_key,
                index: Some(*index),
            }
        })
        .collect();
    Ok(keypairs)
 }
 #[cfg(test)]
 mod tests {
    use crate::scheme::setup::setup;
    use super::*;
    #[test]
    fn keypair_bytes_roundtrip() {
        let mut params1 = setup(1).unwrap();
        let mut params5 = setup(5).unwrap();
        let keypair1 = keygen(&mut params1);
        let keypair5 = keygen(&mut params5);
        let bytes1 = keypair1.to_bytes();
        let bytes5 = keypair5.to_bytes();
        assert_eq!(KeyPair::from_bytes(&bytes1).unwrap(), keypair1);
        assert_eq!(KeyPair::from_bytes(&bytes5).unwrap(), keypair5);
    }
    #[test]
    fn secret_key_bytes_roundtrip() {
        let mut params1 = setup(1).unwrap();
        let mut params5 = setup(5).unwrap();
        let keypair1 = keygen(&mut params1);
        let keypair5 = keygen(&mut params5);
        let bytes1 = keypair1.secret_key.to_bytes();
        let bytes5 = keypair5.secret_key.to_bytes();
        assert_eq!(SecretKey::from_bytes(&bytes1).unwrap(), keypair1.secret_key);
        assert_eq!(SecretKey::from_bytes(&bytes5).unwrap(), keypair5.secret_key);
    }
    #[test]
    fn verification_key_bytes_roundtrip() {
        let mut params1 = setup(1).unwrap();
        let mut params5 = setup(5).unwrap();
        let keypair1 = &keygen(&mut params1);
        let keypair5 = &keygen(&mut params5);
        let bytes1: Vec<u8> = keypair1.verification_key.to_bytes();
        let bytes5: Vec<u8> = keypair5.verification_key.to_bytes();
        assert_eq!(
            VerificationKey::try_from(bytes1.as_slice()).unwrap(),
            keypair1.verification_key
        );
        assert_eq!(
            VerificationKey::try_from(bytes5.as_slice()).unwrap(),
            keypair5.verification_key
        );
    }
 }
@@ -0,0 +1,600 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // TODO: implement https://crates.io/crates/signature traits?
 use std::convert::TryFrom;
 use std::convert::TryInto;
 use bls12_381::{G1Projective, G2Prepared, G2Projective, Scalar};
 use group::Curve;
 pub use keygen::{SecretKey, VerificationKey};
 use crate::elgamal::Ciphertext;
 use crate::error::{CoconutError, Result};
 use crate::scheme::setup::Parameters;
 use crate::scheme::verification::check_bilinear_pairing;
 use crate::traits::{Base58, Bytable};
 use crate::utils::try_deserialize_g1_projective;
 use crate::{elgamal, Attribute};
 pub mod aggregation;
 pub mod issuance;
 pub mod keygen;
 pub mod setup;
 pub mod verification;
 pub type SignerIndex = u64;
 // (h, s)
 #[derive(Debug, Clone, Copy)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct Signature(pub G1Projective, pub G1Projective);
 pub type PartialSignature = Signature;
 impl TryFrom<&[u8]> for Signature {
    type Error = CoconutError;
    fn try_from(bytes: &[u8]) -> Result<Signature> {
        if bytes.len() != 96 {
            return Err(CoconutError::Deserialization(format!(
                "Signature must be exactly 96 bytes, got {}",
                bytes.len()
            )));
        }
        let sig1_bytes: &[u8; 48] = &bytes[..48].try_into().expect("Slice size != 48");
        let sig2_bytes: &[u8; 48] = &bytes[48..].try_into().expect("Slice size != 48");
        let sig1 = try_deserialize_g1_projective(
            sig1_bytes,
            CoconutError::Deserialization("Failed to deserialize compressed sig1".to_string()),
        )?;
        let sig2 = try_deserialize_g1_projective(
            sig2_bytes,
            CoconutError::Deserialization("Failed to deserialize compressed sig2".to_string()),
        )?;
        Ok(Signature(sig1, sig2))
    }
 }
 impl Signature {
    pub(crate) fn sig1(&self) -> &G1Projective {
        &self.0
    }
    pub(crate) fn sig2(&self) -> &G1Projective {
        &self.1
    }
    pub fn randomise(&self, params: &Parameters) -> (Signature, Scalar) {
        let r = params.random_scalar();
        let r_prime = params.random_scalar();
        let h_prime = self.0 * r_prime;
        let s_prime = (self.1 * r_prime) + (h_prime * r);
        (Signature(h_prime, s_prime), r)
    }
    pub fn to_bytes(self) -> [u8; 96] {
        let mut bytes = [0u8; 96];
        bytes[..48].copy_from_slice(&self.0.to_affine().to_compressed());
        bytes[48..].copy_from_slice(&self.1.to_affine().to_compressed());
        bytes
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<Signature> {
        Signature::try_from(bytes)
    }
 }
 impl Bytable for Signature {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.to_bytes().to_vec()
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        Signature::from_bytes(slice)
    }
 }
 impl Base58 for Signature {}
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct BlindedSignature(G1Projective, elgamal::Ciphertext);
 impl Bytable for BlindedSignature {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.to_bytes().to_vec()
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        Self::from_bytes(slice)
    }
 }
 impl Base58 for BlindedSignature {}
 impl TryFrom<&[u8]> for BlindedSignature {
    type Error = CoconutError;
    fn try_from(bytes: &[u8]) -> Result<BlindedSignature> {
        if bytes.len() != 144 {
            return Err(CoconutError::Deserialization(format!(
                "BlindedSignature must be exactly 144 bytes, got {}",
                bytes.len()
            )));
        }
        let h_bytes: &[u8; 48] = &bytes[..48].try_into().expect("Slice size != 48");
        let h = try_deserialize_g1_projective(
            h_bytes,
            CoconutError::Deserialization("Failed to deserialize compressed h".to_string()),
        )?;
        let c_tilde = Ciphertext::try_from(&bytes[48..])?;
        Ok(BlindedSignature(h, c_tilde))
    }
 }
 impl BlindedSignature {
    pub fn unblind(
        &self,
        params: &Parameters,
        private_key: &elgamal::PrivateKey,
        partial_verification_key: &VerificationKey,
        private_attributes: &[Attribute],
        public_attributes: &[Attribute],
        commitment_hash: &G1Projective,
    ) -> Result<Signature> {
        // parse the signature
        let h = &self.0;
        let c = &self.1;
        let sig2 = private_key.decrypt(c);
        // Verify the commitment hash
        if !(commitment_hash == h) {
            return Err(CoconutError::Unblind(
                "Verification of commitment hash from signature failed".to_string(),
            ));
        }
        let alpha = partial_verification_key.alpha;
        let tmp = private_attributes
            .iter()
            .chain(public_attributes.iter())
            .zip(partial_verification_key.beta.iter())
            .map(|(attr, beta_i)| beta_i * attr)
            .sum::<G2Projective>();
        // Verify the signature share
        if !check_bilinear_pairing(
            &h.to_affine(),
            &G2Prepared::from((alpha + tmp).to_affine()),
            &sig2.to_affine(),
            params.prepared_miller_g2(),
        ) {
            return Err(CoconutError::Unblind(
                "Verification of signature share failed".to_string(),
            ));
        }
        Ok(Signature(self.0, sig2))
    }
    pub fn to_bytes(&self) -> [u8; 144] {
        let mut bytes = [0u8; 144];
        bytes[..48].copy_from_slice(&self.0.to_affine().to_compressed());
        bytes[48..].copy_from_slice(&self.1.to_bytes());
        bytes
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<BlindedSignature> {
        BlindedSignature::try_from(bytes)
    }
 }
 // perhaps this should take signature by reference? we'll see how it goes
 pub struct SignatureShare {
    signature: Signature,
    index: SignerIndex,
 }
 impl SignatureShare {
    pub fn new(signature: Signature, index: SignerIndex) -> Self {
        SignatureShare { signature, index }
    }
    pub fn signature(&self) -> &Signature {
        &self.signature
    }
    pub fn index(&self) -> SignerIndex {
        self.index
    }
    // pub fn aggregate(shares: &[Self]) -> Result<Signature> {
    //     aggregate_signature_shares(shares)
    // }
 }
 #[cfg(test)]
 mod tests {
    use crate::scheme::aggregation::{aggregate_signatures, aggregate_verification_keys};
    use crate::scheme::issuance::{blind_sign, prepare_blind_sign, sign};
    use crate::scheme::keygen::{keygen, ttp_keygen};
    use crate::scheme::verification::{prove_bandwidth_credential, verify, verify_credential};
    use super::*;
    #[test]
    fn verification_on_two_private_attributes() {
        let mut params = Parameters::new(2).unwrap();
        let serial_number = params.random_scalar();
        let binding_number = params.random_scalar();
        let private_attributes = vec![serial_number, binding_number];
        let elgamal_keypair = elgamal::elgamal_keygen(&mut params);
        let keypair1 = keygen(&mut params);
        let keypair2 = keygen(&mut params);
        let lambda =
            prepare_blind_sign(&mut params, &elgamal_keypair, &private_attributes, &[]).unwrap();
        let sig1 = blind_sign(
            &mut params,
            &keypair1.secret_key(),
            elgamal_keypair.public_key(),
            &lambda,
            &[],
        )
        .unwrap()
        .unblind(
            &params,
            elgamal_keypair.private_key(),
            &keypair1.verification_key(),
            &private_attributes,
            &[],
            &lambda.get_commitment_hash(),
        )
        .unwrap();
        let sig2 = blind_sign(
            &mut params,
            &keypair2.secret_key(),
            elgamal_keypair.public_key(),
            &lambda,
            &[],
        )
        .unwrap()
        .unblind(
            &params,
            elgamal_keypair.private_key(),
            &keypair2.verification_key(),
            &private_attributes,
            &[],
            &lambda.get_commitment_hash(),
        )
        .unwrap();
        let theta1 = prove_bandwidth_credential(
            &mut params,
            &keypair1.verification_key(),
            &sig1,
            serial_number,
            binding_number,
        )
        .unwrap();
        let theta2 = prove_bandwidth_credential(
            &mut params,
            &keypair2.verification_key(),
            &sig2,
            serial_number,
            binding_number,
        )
        .unwrap();
        assert!(verify_credential(
            &params,
            &keypair1.verification_key(),
            &theta1,
            &[],
        ));
        assert!(verify_credential(
            &params,
            &keypair2.verification_key(),
            &theta2,
            &[],
        ));
        assert!(!verify_credential(
            &params,
            &keypair1.verification_key(),
            &theta2,
            &[],
        ));
    }
    #[test]
    fn verification_on_two_public_attributes() {
        let mut params = Parameters::new(2).unwrap();
        let attributes = params.n_random_scalars(2);
        let keypair1 = keygen(&mut params);
        let keypair2 = keygen(&mut params);
        let sig1 = sign(&mut params, &keypair1.secret_key(), &attributes).unwrap();
        let sig2 = sign(&mut params, &keypair2.secret_key(), &attributes).unwrap();
        assert!(verify(
            &params,
            &keypair1.verification_key(),
            &attributes,
            &sig1,
        ));
        assert!(!verify(
            &params,
            &keypair2.verification_key(),
            &attributes,
            &sig1,
        ));
        assert!(!verify(
            &params,
            &keypair1.verification_key(),
            &attributes,
            &sig2,
        ));
    }
    #[test]
    fn verification_on_two_public_and_two_private_attributes() {
        let mut params = Parameters::new(4).unwrap();
        let public_attributes = params.n_random_scalars(2);
        let serial_number = params.random_scalar();
        let binding_number = params.random_scalar();
        let private_attributes = vec![serial_number, binding_number];
        let elgamal_keypair = elgamal::elgamal_keygen(&mut params);
        let keypair1 = keygen(&mut params);
        let keypair2 = keygen(&mut params);
        let lambda = prepare_blind_sign(
            &mut params,
            &elgamal_keypair,
            &private_attributes,
            &public_attributes,
        )
        .unwrap();
        let sig1 = blind_sign(
            &mut params,
            &keypair1.secret_key(),
            elgamal_keypair.public_key(),
            &lambda,
            &public_attributes,
        )
        .unwrap()
        .unblind(
            &params,
            elgamal_keypair.private_key(),
            &keypair1.verification_key(),
            &private_attributes,
            &public_attributes,
            &lambda.get_commitment_hash(),
        )
        .unwrap();
        let sig2 = blind_sign(
            &mut params,
            &keypair2.secret_key(),
            elgamal_keypair.public_key(),
            &lambda,
            &public_attributes,
        )
        .unwrap()
        .unblind(
            &params,
            elgamal_keypair.private_key(),
            &keypair2.verification_key(),
            &private_attributes,
            &public_attributes,
            &lambda.get_commitment_hash(),
        )
        .unwrap();
        let theta1 = prove_bandwidth_credential(
            &mut params,
            &keypair1.verification_key(),
            &sig1,
            serial_number,
            binding_number,
        )
        .unwrap();
        let theta2 = prove_bandwidth_credential(
            &mut params,
            &keypair2.verification_key(),
            &sig2,
            serial_number,
            binding_number,
        )
        .unwrap();
        assert!(verify_credential(
            &params,
            &keypair1.verification_key(),
            &theta1,
            &public_attributes,
        ));
        assert!(verify_credential(
            &params,
            &keypair2.verification_key(),
            &theta2,
            &public_attributes,
        ));
        assert!(!verify_credential(
            &params,
            &keypair1.verification_key(),
            &theta2,
            &public_attributes,
        ));
    }
    #[test]
    fn verification_on_two_public_and_two_private_attributes_from_two_signers() {
        let mut params = Parameters::new(4).unwrap();
        let public_attributes = params.n_random_scalars(2);
        let serial_number = params.random_scalar();
        let binding_number = params.random_scalar();
        let private_attributes = vec![serial_number, binding_number];
        let elgamal_keypair = elgamal::elgamal_keygen(&params);
        let keypairs = ttp_keygen(&mut params, 2, 3).unwrap();
        let lambda = prepare_blind_sign(
            &mut params,
            &elgamal_keypair,
            &private_attributes,
            &public_attributes,
        )
        .unwrap();
        let sigs = keypairs
            .iter()
            .map(|keypair| {
                blind_sign(
                    &mut params,
                    &keypair.secret_key(),
                    elgamal_keypair.public_key(),
                    &lambda,
                    &public_attributes,
                )
                .unwrap()
                .unblind(
                    &params,
                    elgamal_keypair.private_key(),
                    &keypair.verification_key(),
                    &private_attributes,
                    &public_attributes,
                    &lambda.get_commitment_hash(),
                )
                .unwrap()
            })
            .collect::<Vec<_>>();
        let vks = keypairs
            .into_iter()
            .map(|keypair| keypair.verification_key())
            .collect::<Vec<_>>();
        let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
        attributes.extend_from_slice(&private_attributes);
        attributes.extend_from_slice(&public_attributes);
        let aggr_vk = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
        let aggr_sig =
            aggregate_signatures(&params, &aggr_vk, &attributes, &sigs[..2], Some(&[1, 2]))
                .unwrap();
        let theta = prove_bandwidth_credential(
            &mut params,
            &aggr_vk,
            &aggr_sig,
            serial_number,
            binding_number,
        )
        .unwrap();
        assert!(verify_credential(
            &params,
            &aggr_vk,
            &theta,
            &public_attributes,
        ));
        // taking different subset of keys and credentials
        let aggr_vk = aggregate_verification_keys(&vks[1..], Some(&[2, 3])).unwrap();
        let aggr_sig =
            aggregate_signatures(&params, &aggr_vk, &attributes, &sigs[1..], Some(&[2, 3]))
                .unwrap();
        let theta = prove_bandwidth_credential(
            &mut params,
            &aggr_vk,
            &aggr_sig,
            serial_number,
            binding_number,
        )
        .unwrap();
        assert!(verify_credential(
            &params,
            &aggr_vk,
            &theta,
            &public_attributes,
        ));
    }
    #[test]
    fn signature_bytes_roundtrip() {
        let params = Parameters::default();
        let r = params.random_scalar();
        let s = params.random_scalar();
        let signature = Signature(params.gen1() * r, params.gen1() * s);
        let bytes = signature.to_bytes();
        // also make sure it is equivalent to the internal g1 compressed bytes concatenated
        let expected_bytes = [
            signature.0.to_affine().to_compressed(),
            signature.1.to_affine().to_compressed(),
        ]
        .concat();
        assert_eq!(expected_bytes, bytes);
        assert_eq!(signature, Signature::try_from(&bytes[..]).unwrap())
    }
    #[test]
    fn blinded_signature_bytes_roundtrip() {
        let params = Parameters::default();
        let r = params.random_scalar();
        let s = params.random_scalar();
        let t = params.random_scalar();
        let blinded_sig = BlindedSignature(
            params.gen1() * t,
            Ciphertext(params.gen1() * r, params.gen1() * s),
        );
        let bytes = blinded_sig.to_bytes();
        // also make sure it is equivalent to the internal g1 compressed bytes concatenated
        let expected_bytes = [
            blinded_sig.0.to_affine().to_compressed(),
            blinded_sig.1 .0.to_affine().to_compressed(),
            blinded_sig.1 .1.to_affine().to_compressed(),
        ]
        .concat();
        assert_eq!(expected_bytes, bytes);
        assert_eq!(blinded_sig, BlindedSignature::try_from(&bytes[..]).unwrap())
    }
 }
@@ -0,0 +1,99 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use crate::error::{CoconutError, Result};
 use crate::utils::hash_g1;
 use bls12_381::{G1Affine, G2Affine, G2Prepared, Scalar};
 use ff::Field;
 use group::Curve;
 use rand::thread_rng;
 /// System-wide parameters used for the protocol
 pub struct Parameters {
    /// Generator of the G1 group
    g1: G1Affine,
    /// Additional generators of the G1 group
    hs: Vec<G1Affine>,
    /// Generator of the G2 group
    g2: G2Affine,
    /// Precomputed G2 generator used for the miller loop
    _g2_prepared_miller: G2Prepared,
 }
 impl Parameters {
    pub fn new(num_attributes: u32) -> Result<Parameters> {
        if num_attributes == 0 {
            return Err(CoconutError::Setup(
                "Tried to setup the scheme for 0 attributes".to_string(),
            ));
        }
        let hs = (1..=num_attributes)
            .map(|i| hash_g1(format!("h{}", i)).to_affine())
            .collect();
        Ok(Parameters {
            g1: G1Affine::generator(),
            hs,
            g2: G2Affine::generator(),
            _g2_prepared_miller: G2Prepared::from(G2Affine::generator()),
        })
    }
    pub(crate) fn gen1(&self) -> &G1Affine {
        &self.g1
    }
    pub fn gen2(&self) -> &G2Affine {
        &self.g2
    }
    pub fn prepared_miller_g2(&self) -> &G2Prepared {
        &self._g2_prepared_miller
    }
    pub fn gen_hs(&self) -> &[G1Affine] {
        &self.hs
    }
    pub fn random_scalar(&self) -> Scalar {
        // lazily-initialized thread-local random number generator, seeded by the system
        let mut rng = thread_rng();
        Scalar::random(&mut rng)
    }
    pub fn n_random_scalars(&self, n: usize) -> Vec<Scalar> {
        (0..n).map(|_| self.random_scalar()).collect()
    }
 }
 pub fn setup(num_attributes: u32) -> Result<Parameters> {
    Parameters::new(num_attributes)
 }
 // for ease of use in tests requiring params
 // TODO: not sure if this will have to go away when tests require some specific number of generators
 #[cfg(test)]
 impl Default for Parameters {
    fn default() -> Self {
        Parameters {
            g1: G1Affine::generator(),
            hs: Vec::new(),
            g2: G2Affine::generator(),
            _g2_prepared_miller: G2Prepared::from(G2Affine::generator()),
        }
    }
 }
@@ -0,0 +1,474 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use core::ops::Neg;
 use std::convert::TryFrom;
 use std::convert::TryInto;
 use bls12_381::{multi_miller_loop, G1Affine, G2Prepared, G2Projective, Scalar};
 use group::{Curve, Group};
 use crate::error::{CoconutError, Result};
 use crate::proofs::{ProofKappa, ProofKappaNu};
 use crate::scheme::setup::Parameters;
 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
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct ThetaCovid {
    // blinded_message (kappa)
    pub blinded_message: G2Projective,
    // sigma
    pub credential: Signature,
    // pi_v
    pub pi_v: ProofKappa,
 }
 impl ThetaCovid {
    pub fn verify_proof(
        &self,
        params: &Parameters,
        verification_key: &VerificationKey,
        verifier_id: &[u8; 32],
        timestamp: &[u8; 32],
    ) -> bool {
        self.pi_v.verify(
            params,
            verification_key,
            &self.blinded_message,
            verifier_id,
            timestamp,
        )
    }
    // kappa || credential || proof
    pub fn to_bytes(&self) -> Vec<u8> {
        let blinded_message_bytes = self.blinded_message.to_affine().to_compressed();
        let credential_bytes = self.credential.to_bytes();
        let proof_bytes = self.pi_v.to_bytes();
        let mut bytes = Vec::with_capacity(192 + proof_bytes.len());
        bytes.extend_from_slice(&blinded_message_bytes);
        bytes.extend_from_slice(&credential_bytes);
        bytes.extend_from_slice(&proof_bytes);
        bytes
    }
    pub fn to_bytes_tuple(&self) -> ([u8; 96], [u8; 96], Vec<u8>) {
        let blinded_message_bytes = self.blinded_message.to_affine().to_compressed();
        let credential_bytes = self.credential.to_bytes();
        let proof_bytes = self.pi_v.to_bytes();
        (blinded_message_bytes, credential_bytes, proof_bytes)
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<ThetaCovid> {
        if bytes.len() < 192 {
            return Err(
                CoconutError::Deserialization(
                    format!("Tried to deserialize theta with insufficient number of bytes, expected >= 192, got {}", bytes.len()),
                ));
        }
        let blinded_message_bytes = bytes[..96].try_into().unwrap();
        let blinded_message = try_deserialize_g2_projective(
            &blinded_message_bytes,
            CoconutError::Deserialization("failed to deserialize kappa".to_string()),
        )?;
        let credential = Signature::try_from(&bytes[96..192])?;
        let pi_v = ProofKappa::from_bytes(&bytes[192..])?;
        Ok(ThetaCovid {
            blinded_message,
            credential,
            pi_v,
        })
    }
 }
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct Theta {
    // blinded_message (kappa)
    pub blinded_message: G2Projective,
    // blinded serial number (zeta)
    pub blinded_serial_number: G2Projective,
    // sigma
    pub credential: Signature,
    // pi_v
    pub pi_v: ProofKappaNu,
 }
 impl TryFrom<&[u8]> for Theta {
    type Error = CoconutError;
    fn try_from(bytes: &[u8]) -> Result<Theta> {
        if bytes.len() < 288 {
            return Err(
                CoconutError::Deserialization(
                    format!("Tried to deserialize theta with insufficient number of bytes, expected >= 288, got {}", bytes.len()),
                ));
        }
        let blinded_message_bytes = bytes[..96].try_into().unwrap();
        let blinded_message = try_deserialize_g2_projective(
            &blinded_message_bytes,
            CoconutError::Deserialization("failed to deserialize kappa".to_string()),
        )?;
        let blinded_serial_number_bytes = bytes[96..192].try_into().unwrap();
        let blinded_serial_number = try_deserialize_g2_projective(
            &blinded_serial_number_bytes,
            CoconutError::Deserialization("failed to deserialize zeta".to_string()),
        )?;
        let credential = Signature::try_from(&bytes[192..288])?;
        let pi_v = ProofKappaNu::from_bytes(&bytes[288..])?;
        Ok(Theta {
            blinded_message,
            blinded_serial_number,
            credential,
            pi_v,
        })
    }
 }
 impl Theta {
    fn verify_proof(&self, params: &Parameters, verification_key: &VerificationKey) -> bool {
        self.pi_v.verify(
            params,
            verification_key,
            &self.blinded_message,
            &self.blinded_serial_number,
        )
    }
    // TODO: perhaps also include pi_v.len()?
    // to be determined once we implement serde to make sure its 1:1 compatible
    // with bincode
    // kappa || nu || credential || pi_v
    pub fn to_bytes(&self) -> Vec<u8> {
        let blinded_message_bytes = self.blinded_message.to_affine().to_compressed();
        let blinded_serial_number_bytes = self.blinded_serial_number.to_affine().to_compressed();
        let credential_bytes = self.credential.to_bytes();
        let proof_bytes = self.pi_v.to_bytes();
        let mut bytes = Vec::with_capacity(288 + proof_bytes.len());
        bytes.extend_from_slice(&blinded_message_bytes);
        bytes.extend_from_slice(&blinded_serial_number_bytes);
        bytes.extend_from_slice(&credential_bytes);
        bytes.extend_from_slice(&proof_bytes);
        bytes
    }
    pub fn from_bytes(bytes: &[u8]) -> Result<Theta> {
        Theta::try_from(bytes)
    }
 }
 impl Bytable for Theta {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.to_bytes()
    }
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
        Theta::try_from(slice)
    }
 }
 impl Base58 for Theta {}
 pub fn compute_kappa(
    params: &Parameters,
    verification_key: &VerificationKey,
    private_attributes: &[Attribute],
    blinding_factor: Scalar,
 ) -> G2Projective {
    params.gen2() * blinding_factor
        + verification_key.alpha
        + private_attributes
            .iter()
            .zip(verification_key.beta.iter())
            .map(|(priv_attr, beta_i)| beta_i * priv_attr)
            .sum::<G2Projective>()
 }
 pub fn compute_zeta(params: &Parameters, serial_number: Attribute) -> G2Projective {
    params.gen2() * serial_number
 }
 pub fn prove_covid_credential(
    params: &Parameters,
    verification_key: &VerificationKey,
    signature: &Signature,
    private_attributes: &[Attribute],
    verifier_id: &[u8; 32],
    timestamp: &[u8; 32],
 ) -> Result<ThetaCovid> {
    if verification_key.beta.len() < params.gen_hs().len() {
        return Err(
            CoconutError::Verification(
                format!("Tried to prove a credential for higher than supported by the provided verification key number of attributes (max: {}, requested: 2)",
                        verification_key.beta.len()
                )));
    }
    // Randomize the signature
    let (signature_prime, sign_blinding_factor) = signature.randomise(params);
    // blinded_message : kappa in the paper.
    // Value kappa is needed since we want to show a signature sigma'.
    // In order to verify sigma' we need both the verification key vk and the message m.
    // However, we do not want to reveal m to whomever we are showing the signature.
    // Thus, we need kappa which allows us to verify sigma'. In particular,
    // kappa is computed on m as input, but thanks to the use or random value r,
    // it does not reveal any information about m.
    let blinded_message = compute_kappa(
        params,
        verification_key,
        &private_attributes,
        sign_blinding_factor,
    );
    let pi_v = ProofKappa::construct(
        params,
        verification_key,
        &sign_blinding_factor,
        &blinded_message,
        &private_attributes,
        verifier_id,
        timestamp,
    );
    Ok(ThetaCovid {
        blinded_message,
        credential: signature_prime,
        pi_v,
    })
 }
 pub fn prove_bandwidth_credential(
    params: &Parameters,
    verification_key: &VerificationKey,
    signature: &Signature,
    serial_number: Attribute,
    binding_number: Attribute,
 ) -> Result<Theta> {
    if verification_key.beta.len() < 2 {
        return Err(
            CoconutError::Verification(
                format!("Tried to prove a credential for higher than supported by the provided verification key number of attributes (max: {}, requested: 2)",
                        verification_key.beta.len()
                )));
    }
    // Randomize the signature
    let (signature_prime, sign_blinding_factor) = signature.randomise(params);
    // blinded_message : kappa in the paper.
    // Value kappa is needed since we want to show a signature sigma'.
    // In order to verify sigma' we need both the verification key vk and the message m.
    // However, we do not want to reveal m to whomever we are showing the signature.
    // Thus, we need kappa which allows us to verify sigma'. In particular,
    // kappa is computed on m as input, but thanks to the use or random value r,
    // it does not reveal any information about m.
    let private_attributes = vec![serial_number, binding_number];
    let blinded_message = compute_kappa(
        params,
        verification_key,
        &private_attributes,
        sign_blinding_factor,
    );
    // zeta is a commitment to the serial number (i.e., a public value associated with the serial number)
    let blinded_serial_number = compute_zeta(params, serial_number);
    let pi_v = ProofKappaNu::construct(
        params,
        verification_key,
        &serial_number,
        &binding_number,
        &sign_blinding_factor,
        &blinded_message,
        &blinded_serial_number,
    );
    Ok(Theta {
        blinded_message,
        blinded_serial_number,
        credential: signature_prime,
        pi_v,
    })
 }
 /// Checks whether e(P, Q) * e(-R, S) == id
 pub fn check_bilinear_pairing(p: &G1Affine, q: &G2Prepared, r: &G1Affine, s: &G2Prepared) -> bool {
    // checking e(P, Q) * e(-R, S) == id
    // is equivalent to checking e(P, Q) == e(R, S)
    // but requires only a single final exponentiation rather than two of them
    // and therefore, as seen via benchmarks.rs, is almost 50% faster
    // (1.47ms vs 2.45ms, tested on R9 5900X)
    let multi_miller = multi_miller_loop(&[(p, q), (&r.neg(), s)]);
    multi_miller.final_exponentiation().is_identity().into()
 }
 pub fn verify_covid_credential(
    params: &Parameters,
    verification_key: &VerificationKey,
    theta: &ThetaCovid,
    public_attributes: &[Attribute],
    verifier_id: &[u8; 32],
    timestamp: &[u8; 32],
 ) -> bool {
    if public_attributes.len() + theta.pi_v.private_attributes_len() > verification_key.beta.len() {
        return false;
    }
    if !theta.verify_proof(params, verification_key, verifier_id, timestamp) {
        return false;
    }
    let kappa = if public_attributes.is_empty() {
        theta.blinded_message
    } else {
        let signed_public_attributes = public_attributes
            .iter()
            .zip(
                verification_key
                    .beta
                    .iter()
                    .skip(theta.pi_v.private_attributes_len()),
            )
            .map(|(pub_attr, beta_i)| beta_i * pub_attr)
            .sum::<G2Projective>();
        theta.blinded_message + signed_public_attributes
    };
    check_bilinear_pairing(
        &theta.credential.0.to_affine(),
        &G2Prepared::from(kappa.to_affine()),
        &(theta.credential.1).to_affine(),
        params.prepared_miller_g2(),
    ) && !bool::from(theta.credential.0.is_identity())
 }
 pub fn verify_credential(
    params: &Parameters,
    verification_key: &VerificationKey,
    theta: &Theta,
    public_attributes: &[Attribute],
 ) -> bool {
    if public_attributes.len() + theta.pi_v.private_attributes_len() > verification_key.beta.len() {
        return false;
    }
    if !theta.verify_proof(params, verification_key) {
        return false;
    }
    let kappa = if public_attributes.is_empty() {
        theta.blinded_message
    } else {
        let signed_public_attributes = public_attributes
            .iter()
            .zip(
                verification_key
                    .beta
                    .iter()
                    .skip(theta.pi_v.private_attributes_len()),
            )
            .map(|(pub_attr, beta_i)| beta_i * pub_attr)
            .sum::<G2Projective>();
        theta.blinded_message + signed_public_attributes
    };
    check_bilinear_pairing(
        &theta.credential.0.to_affine(),
        &G2Prepared::from(kappa.to_affine()),
        &(theta.credential.1).to_affine(),
        params.prepared_miller_g2(),
    ) && !bool::from(theta.credential.0.is_identity())
 }
 // Used in tests only
 #[cfg(test)]
 pub fn verify(
    params: &Parameters,
    verification_key: &VerificationKey,
    public_attributes: &[Attribute],
    sig: &Signature,
 ) -> bool {
    let kappa = (verification_key.alpha
        + public_attributes
            .iter()
            .zip(verification_key.beta.iter())
            .map(|(m_i, b_i)| b_i * m_i)
            .sum::<G2Projective>())
    .to_affine();
    check_bilinear_pairing(
        &sig.0.to_affine(),
        &G2Prepared::from(kappa),
        &sig.1.to_affine(),
        params.prepared_miller_g2(),
    ) && !bool::from(sig.0.is_identity())
 }
 #[cfg(test)]
 mod tests {
    use crate::scheme::keygen::keygen;
    use crate::scheme::setup::setup;
    use super::*;
    #[test]
    fn theta_bytes_roundtrip() {
        let mut params = setup(2).unwrap();
        let keypair = keygen(&mut params);
        let r = params.random_scalar();
        let s = params.random_scalar();
        let signature = Signature(params.gen1() * r, params.gen1() * s);
        let serial_number = params.random_scalar();
        let binding_number = params.random_scalar();
        let theta = prove_bandwidth_credential(
            &mut params,
            &keypair.verification_key(),
            &signature,
            serial_number,
            binding_number,
        )
        .unwrap();
        let bytes = theta.to_bytes();
        assert_eq!(Theta::try_from(bytes.as_slice()).unwrap(), theta);
    }
 }
@@ -0,0 +1,106 @@
 use crate::{
    aggregate_signature_shares, aggregate_verification_keys, blind_sign, elgamal_keygen,
    hash_to_scalar, prepare_blind_sign, prove_bandwidth_credential, setup, ttp_keygen,
    verify_credential, CoconutError, Signature, SignatureShare, VerificationKey,
 };
 #[test]
 fn main() -> Result<(), CoconutError> {
    let params = setup(5)?;
    let public_attributes = params.n_random_scalars(2);
    let serial_number = params.random_scalar();
    let binding_number = params.random_scalar();
    let private_attributes = vec![serial_number, binding_number];
    let elgamal_keypair = elgamal_keygen(&params);
    // generate commitment and encryption
    let blind_sign_request = prepare_blind_sign(
        &params,
        &elgamal_keypair,
        &private_attributes,
        &public_attributes,
    )?;
    // generate_keys
    let coconut_keypairs = ttp_keygen(&params, 2, 3)?;
    let verification_keys: Vec<VerificationKey> = coconut_keypairs
        .iter()
        .map(|keypair| keypair.verification_key())
        .collect();
    // aggregate verification keys
    let verification_key = aggregate_verification_keys(&verification_keys, Some(&[1, 2, 3]))?;
    // generate blinded signatures
    let mut blinded_signatures = Vec::new();
    for keypair in coconut_keypairs {
        let blinded_signature = blind_sign(
            &params,
            &keypair.secret_key(),
            &elgamal_keypair.public_key(),
            &blind_sign_request,
            &public_attributes,
        )?;
        blinded_signatures.push(blinded_signature)
    }
    // Unblind
    let unblinded_signatures: Vec<Signature> = blinded_signatures
        .into_iter()
        .zip(verification_keys.iter())
        .map(|(signature, verification_key)| {
            signature
                .unblind(
                    &params,
                    &elgamal_keypair.private_key(),
                    &verification_key,
                    &private_attributes,
                    &public_attributes,
                    &blind_sign_request.get_commitment_hash(),
                )
                .unwrap()
        })
        .collect();
    // Aggregate signatures
    let signature_shares: Vec<SignatureShare> = unblinded_signatures
        .iter()
        .enumerate()
        .map(|(idx, signature)| SignatureShare::new(*signature, (idx + 1) as u64))
        .collect();
    let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
    attributes.extend_from_slice(&private_attributes);
    attributes.extend_from_slice(&public_attributes);
    // Randomize credentials and generate any cryptographic material to verify them
    let signature =
        aggregate_signature_shares(&params, &verification_key, &attributes, &signature_shares)?;
    // Generate cryptographic material to verify them
    let theta = prove_bandwidth_credential(
        &params,
        &verification_key,
        &signature,
        serial_number,
        binding_number,
    )?;
    // Verify credentials
    assert!(verify_credential(
        &params,
        &verification_key,
        &theta,
        &public_attributes,
    ));
    Ok(())
 }
@@ -0,0 +1,153 @@
 use crate::scheme::verification::{prove_covid_credential, verify_covid_credential, ThetaCovid};
 use crate::{
    aggregate_signature_shares, aggregate_verification_keys, blind_sign, elgamal_keygen,
    hash_to_scalar, prepare_blind_sign, setup, ttp_keygen, CoconutError, Signature, SignatureShare,
    VerificationKey,
 };
 #[test]
 fn main() -> Result<(), CoconutError> {
    let params = setup(15)?;
    // validators keys
    let coconut_keypairs = ttp_keygen(&params, 2, 3)?;
    let verification_keys: Vec<VerificationKey> = coconut_keypairs
        .iter()
        .map(|keypair| keypair.verification_key())
        .collect();
    let verification_key = aggregate_verification_keys(&verification_keys, Some(&[1, 2, 3]))?;
    // user's ElGamal keypair
    let elgamal_keypair = elgamal_keygen(&params);
    // attributes to consider
    let patient_id = hash_to_scalar(String::from("NHS678777").as_bytes());
    let full_name = hash_to_scalar(String::from("JaneDoe").as_bytes());
    let vaccine_medication_product_id = hash_to_scalar(String::from("EU/1/20/1528").as_bytes());
    let country_of_vaccination = hash_to_scalar(String::from("UK").as_bytes());
    let issuer = hash_to_scalar(String::from("NHS").as_bytes());
    let dob = hash_to_scalar(String::from("2021-11-05").as_bytes());
    let public_attributes = vec![
        patient_id,
        full_name,
        vaccine_medication_product_id,
        country_of_vaccination,
        issuer,
        dob,
    ];
    let user_secret = params.random_scalar();
    let private_attributes = vec![user_secret];
    // ISSUANCE PROTOCOL
    let blind_sign_request = prepare_blind_sign(
        &params,
        &elgamal_keypair,
        &private_attributes,
        &public_attributes,
    )?;
    // generate blinded signatures
    let mut blinded_signatures = Vec::new();
    let is_vaccinated = hash_to_scalar(String::from("TRUE").as_bytes());
    let is_over_18 = hash_to_scalar(String::from("TRUE").as_bytes());
    let is_over_21 = hash_to_scalar(String::from("TRUE").as_bytes());
    // These are the attributes on which the validator issues a signature
    let public_attributes = [
        patient_id,
        full_name,
        vaccine_medication_product_id,
        country_of_vaccination,
        issuer,
        dob,
        is_vaccinated,
        is_over_18,
        is_over_21,
    ];
    for keypair in coconut_keypairs {
        let blinded_signature = blind_sign(
            &params,
            &keypair.secret_key(),
            &elgamal_keypair.public_key(),
            &blind_sign_request,
            &public_attributes,
        )?;
        blinded_signatures.push(blinded_signature)
    }
    let unblinded_signatures: Vec<Signature> = blinded_signatures
        .into_iter()
        .zip(verification_keys.iter())
        .map(|(signature, verification_key)| {
            signature
                .unblind(
                    &params,
                    &elgamal_keypair.private_key(),
                    &verification_key,
                    &private_attributes,
                    &public_attributes,
                    &blind_sign_request.get_commitment_hash(),
                )
                .unwrap()
        })
        .collect();
    let signature_shares: Vec<SignatureShare> = unblinded_signatures
        .iter()
        .enumerate()
        .map(|(idx, signature)| SignatureShare::new(*signature, (idx + 1) as u64))
        .collect();
    let mut attributes = Vec::with_capacity(1 + 9);
    attributes.extend_from_slice(&private_attributes);
    attributes.extend_from_slice(&public_attributes);
    // Randomize credentials and generate any cryptographic material to verify them
    let signature =
        aggregate_signature_shares(&params, &verification_key, &attributes, &signature_shares)?;
    // SHOW PROTOCOL
    let verifier_id = [11u8; 32];
    let timestamp = [12u8; 32];
    let show_private_attributes = vec![
        user_secret,
        patient_id,
        full_name,
        vaccine_medication_product_id,
        country_of_vaccination,
        issuer,
        dob,
    ];
    // Prove covid credential
    let theta_covid = prove_covid_credential(
        &params,
        &verification_key,
        &signature,
        &show_private_attributes,
        &verifier_id,
        &timestamp,
    )?;
    let theta_covid_bytes = theta_covid.to_bytes();
    println!("Length of theta in bytes: {:?}", theta_covid_bytes.len());
    let theta_covid_from_bytes = ThetaCovid::from_bytes(&*theta_covid_bytes).unwrap();
    // Verify covid credentials
    let disclosed_attributes = vec![is_vaccinated, is_over_18, is_over_21];
    assert!(verify_covid_credential(
        &params,
        &verification_key,
        &theta_covid_from_bytes,
        disclosed_attributes.as_ref(),
        &verifier_id,
        &timestamp,
    ));
    Ok(())
 }
@@ -0,0 +1,2 @@
 mod e2e;
 mod e2e_covid;
@@ -0,0 +1,22 @@
 use crate::CoconutError;
 pub trait Bytable
 where
    Self: Sized,
 {
    fn to_byte_vec(&self) -> Vec<u8>;
    fn try_from_byte_slice(slice: &[u8]) -> Result<Self, CoconutError>;
 }
 pub trait Base58
 where
    Self: Bytable,
 {
    fn try_from_bs58<S: AsRef<str>>(x: S) -> Result<Self, CoconutError> {
        Self::try_from_byte_slice(&bs58::decode(x.as_ref()).into_vec().unwrap())
    }
    fn to_bs58(&self) -> String {
        bs58::encode(self.to_byte_vec()).into_string()
    }
 }
@@ -0,0 +1,397 @@
 // Copyright 2021 Nym Technologies SA
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 use core::iter::Sum;
 use core::ops::Mul;
 use std::convert::TryInto;
 use bls12_381::hash_to_curve::{ExpandMsgXmd, HashToCurve, HashToField};
 use bls12_381::{G1Affine, G1Projective, G2Affine, G2Projective, Scalar};
 use ff::Field;
 use crate::error::{CoconutError, Result};
 use crate::scheme::setup::Parameters;
 use crate::scheme::SignerIndex;
 pub struct Polynomial {
    coefficients: Vec<Scalar>,
 }
 impl Polynomial {
    // for polynomial of degree n, we generate n+1 values
    // (for example for degree 1, like y = x + 2, we need [2,1])
    pub fn new_random(params: &Parameters, degree: u64) -> Self {
        Polynomial {
            coefficients: params.n_random_scalars((degree + 1) as usize),
        }
    }
    /// Evaluates the polynomial at point x.
    pub fn evaluate(&self, x: &Scalar) -> Scalar {
        if self.coefficients.is_empty() {
            Scalar::zero()
            // if x is zero then we can ignore most of the expensive computation and
            // just return the last term of the polynomial
        } else if x.is_zero() {
            // we checked that coefficients are not empty so unwrap here is fine
            *self.coefficients.first().unwrap()
        } else {
            self.coefficients
                .iter()
                .enumerate()
                // coefficient[n] * x ^ n
                .map(|(i, coefficient)| coefficient * x.pow(&[i as u64, 0, 0, 0]))
                .sum()
        }
    }
 }
 #[inline]
 fn generate_lagrangian_coefficients_at_origin(points: &[u64]) -> Vec<Scalar> {
    let x = Scalar::zero();
    points
        .iter()
        .enumerate()
        .map(|(i, point_i)| {
            let mut numerator = Scalar::one();
            let mut denominator = Scalar::one();
            let xi = Scalar::from(*point_i);
            for (j, point_j) in points.iter().enumerate() {
                if j != i {
                    let xj = Scalar::from(*point_j);
                    // numerator = (x - xs[0]) * ... * (x - xs[j]), j != i
                    numerator *= x - xj;
                    // denominator = (xs[i] - x[0]) * ... * (xs[i] - x[j]), j != i
                    denominator *= xi - xj;
                }
            }
            // numerator / denominator
            numerator * denominator.invert().unwrap()
        })
        .collect()
 }
 /// Performs a Lagrange interpolation at the origin for a polynomial defined by `points` and `values`.
 /// It can be used for Scalars, G1 and G2 points.
 pub(crate) fn perform_lagrangian_interpolation_at_origin<T>(
    points: &[SignerIndex],
    values: &[T],
 ) -> Result<T>
 where
    T: Sum,
    for<'a> &'a T: Mul<Scalar, Output = T>,
 {
    if points.is_empty() || values.is_empty() {
        return Err(CoconutError::Interpolation(
            "Tried to perform lagrangian interpolation for an empty set of coordinates".to_string(),
        ));
    }
    if points.len() != values.len() {
        return Err(CoconutError::Interpolation(
            "Tried to perform lagrangian interpolation for an incomplete set of coordinates"
                .to_string(),
        ));
    }
    let coefficients = generate_lagrangian_coefficients_at_origin(points);
    Ok(coefficients
        .into_iter()
        .zip(values.iter())
        .map(|(coeff, val)| val * coeff)
        .sum())
 }
 // A temporary way of hashing particular message into G1.
 // Implementation idea was taken from `threshold_crypto`:
 // https://github.com/poanetwork/threshold_crypto/blob/7709462f2df487ada3bb3243060504b5881f2628/src/lib.rs#L691
 // Eventually it should get replaced by, most likely, the osswu map
 // method once ideally it's implemented inside the pairing crate.
 // note: I have absolutely no idea what are the correct domains for those. I just used whatever
 // was given in the test vectors of `Hashing to Elliptic Curves draft-irtf-cfrg-hash-to-curve-11`
 // https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#appendix-J.9.1
 const G1_HASH_DOMAIN: &[u8] = b"QUUX-V01-CS02-with-BLS12381G1_XMD:SHA-256_SSWU_RO_";
 // https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#appendix-K.1
 const SCALAR_HASH_DOMAIN: &[u8] = b"QUUX-V01-CS02-with-expander";
 pub(crate) fn hash_g1<M: AsRef<[u8]>>(msg: M) -> G1Projective {
    <G1Projective as HashToCurve<ExpandMsgXmd<sha2::Sha256>>>::hash_to_curve(msg, G1_HASH_DOMAIN)
 }
 pub fn hash_to_scalar<M: AsRef<[u8]>>(msg: M) -> Scalar {
    let mut output = vec![Scalar::zero()];
    Scalar::hash_to_field::<ExpandMsgXmd<sha2::Sha256>>(
        msg.as_ref(),
        SCALAR_HASH_DOMAIN,
        &mut output,
    );
    output[0]
 }
 pub(crate) fn try_deserialize_scalar_vec(
    expected_len: u64,
    bytes: &[u8],
    err: CoconutError,
 ) -> Result<Vec<Scalar>> {
    if bytes.len() != expected_len as usize * 32 {
        return Err(err);
    }
    let mut out = Vec::with_capacity(expected_len as usize);
    for i in 0..expected_len as usize {
        let s_bytes = bytes[i * 32..(i + 1) * 32].try_into().unwrap();
        let s = match Into::<Option<Scalar>>::into(Scalar::from_bytes(&s_bytes)) {
            None => return Err(err),
            Some(scalar) => scalar,
        };
        out.push(s)
    }
    Ok(out)
 }
 pub(crate) fn try_deserialize_scalar(bytes: &[u8; 32], err: CoconutError) -> Result<Scalar> {
    Into::<Option<Scalar>>::into(Scalar::from_bytes(bytes)).ok_or(err)
 }
 pub(crate) fn try_deserialize_g1_projective(
    bytes: &[u8; 48],
    err: CoconutError,
 ) -> Result<G1Projective> {
    Into::<Option<G1Affine>>::into(G1Affine::from_compressed(bytes))
        .ok_or(err)
        .map(G1Projective::from)
 }
 pub(crate) fn try_deserialize_g2_projective(
    bytes: &[u8; 96],
    err: CoconutError,
 ) -> Result<G2Projective> {
    Into::<Option<G2Affine>>::into(G2Affine::from_compressed(bytes))
        .ok_or(err)
        .map(G2Projective::from)
 }
 // use core::fmt;
 // #[cfg(feature = "serde")]
 // use serde::de::Visitor;
 // #[cfg(feature = "serde")]
 // use serde::{self, Deserialize, Deserializer, Serialize, Serializer};
 //
 // // #[cfg(feature = "serde")]
 // #[serde(remote = "Scalar")]
 // pub(crate) struct ScalarDef(pub Scalar);
 //
 // // #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 //
 // impl Serialize for ScalarDef {
 //     fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
 //     where
 //         S: Serializer,
 //     {
 //         use serde::ser::SerializeTuple;
 //         let mut tup = serializer.serialize_tuple(32)?;
 //         for byte in self.0.to_bytes().iter() {
 //             tup.serialize_element(byte)?;
 //         }
 //         tup.end()
 //     }
 // }
 //
 // impl<'de> Deserialize<'de> for ScalarDef {
 //     fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
 //     where
 //         D: Deserializer<'de>,
 //     {
 //         struct ScalarVisitor;
 //
 //         impl<'de> Visitor<'de> for ScalarVisitor {
 //             type Value = ScalarDef;
 //
 //             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 //                 formatter.write_str("a 32-byte canonical bls12_381 scalar")
 //             }
 //
 //             fn visit_seq<A>(self, mut seq: A) -> core::result::Result<ScalarDef, A::Error>
 //             where
 //                 A: serde::de::SeqAccess<'de>,
 //             {
 //                 let mut bytes = [0u8; 32];
 //                 for i in 0..32 {
 //                     bytes[i] = seq
 //                         .next_element()?
 //                         .ok_or_else(|| serde::de::Error::invalid_length(i, &"expected 32 bytes"))?;
 //                 }
 //
 //                 let res = Scalar::from_bytes(&bytes);
 //                 if res.is_some().into() {
 //                     Ok(ScalarDef(res.unwrap()))
 //                 } else {
 //                     Err(serde::de::Error::custom(
 //                         &"scalar was not canonically encoded",
 //                     ))
 //                 }
 //             }
 //         }
 //
 //         deserializer.deserialize_tuple(32, ScalarVisitor)
 //     }
 // }
 //
 // #[cfg(feature = "serde")]
 // pub(crate) struct G1ProjectiveSerdeHelper(Scalar);
 //
 // #[cfg(feature = "serde")]
 // pub(crate) struct G2ProjectiveSerdeHelper(Scalar);
 #[cfg(test)]
 mod tests {
    use rand::RngCore;
    use super::*;
    #[test]
    fn polynomial_evaluation() {
        // y = 42 (it should be 42 regardless of x)
        let poly = Polynomial {
            coefficients: vec![Scalar::from(42)],
        };
        assert_eq!(Scalar::from(42), poly.evaluate(&Scalar::from(1)));
        assert_eq!(Scalar::from(42), poly.evaluate(&Scalar::from(0)));
        assert_eq!(Scalar::from(42), poly.evaluate(&Scalar::from(10)));
        // y = x + 10, at x = 2 (exp: 12)
        let poly = Polynomial {
            coefficients: vec![Scalar::from(10), Scalar::from(1)],
        };
        assert_eq!(Scalar::from(12), poly.evaluate(&Scalar::from(2)));
        // y = x^4 - 5x^2 + 2x - 3, at x = 3 (exp: 39)
        let poly = Polynomial {
            coefficients: vec![
                (-Scalar::from(3)),
                Scalar::from(2),
                (-Scalar::from(5)),
                Scalar::zero(),
                Scalar::from(1),
            ],
        };
        assert_eq!(Scalar::from(39), poly.evaluate(&Scalar::from(3)));
        // empty polynomial
        let poly = Polynomial {
            coefficients: vec![],
        };
        // should always be 0
        assert_eq!(Scalar::from(0), poly.evaluate(&Scalar::from(1)));
        assert_eq!(Scalar::from(0), poly.evaluate(&Scalar::from(0)));
        assert_eq!(Scalar::from(0), poly.evaluate(&Scalar::from(10)));
    }
    #[test]
    fn performing_lagrangian_scalar_interpolation_at_origin() {
        // x^2 + 3
        // x, f(x):
        // 1, 4,
        // 2, 7,
        // 3, 12,
        let points = vec![1, 2, 3];
        let values = vec![Scalar::from(4), Scalar::from(7), Scalar::from(12)];
        assert_eq!(
            Scalar::from(3),
            perform_lagrangian_interpolation_at_origin(&points, &values).unwrap()
        );
        // x^3 + 3x^2 - 5x + 11
        // x, f(x):
        // 1, 10
        // 2, 21
        // 3, 50
        // 4, 103
        let points = vec![1, 2, 3, 4];
        let values = vec![
            Scalar::from(10),
            Scalar::from(21),
            Scalar::from(50),
            Scalar::from(103),
        ];
        assert_eq!(
            Scalar::from(11),
            perform_lagrangian_interpolation_at_origin(&points, &values).unwrap()
        );
        // more points than it is required
        // x^2 + x + 10
        // x, f(x)
        // 1, 12
        // 2, 16
        // 3, 22
        // 4, 30
        // 5, 40
        let points = vec![1, 2, 3, 4, 5];
        let values = vec![
            Scalar::from(12),
            Scalar::from(16),
            Scalar::from(22),
            Scalar::from(30),
            Scalar::from(40),
        ];
        assert_eq!(
            Scalar::from(10),
            perform_lagrangian_interpolation_at_origin(&points, &values).unwrap()
        );
    }
    #[test]
    fn hash_g1_sanity_check() {
        let mut rng = rand::thread_rng();
        let mut msg1 = [0u8; 1024];
        rng.fill_bytes(&mut msg1);
        let mut msg2 = [0u8; 1024];
        rng.fill_bytes(&mut msg2);
        assert_eq!(hash_g1(msg1), hash_g1(msg1));
        assert_eq!(hash_g1(msg2), hash_g1(msg2));
        assert_ne!(hash_g1(msg1), hash_g1(msg2));
    }
    #[test]
    fn hash_scalar_sanity_check() {
        let mut rng = rand::thread_rng();
        let mut msg1 = [0u8; 1024];
        rng.fill_bytes(&mut msg1);
        let mut msg2 = [0u8; 1024];
        rng.fill_bytes(&mut msg2);
        assert_eq!(hash_to_scalar(msg1), hash_to_scalar(msg1));
        assert_eq!(hash_to_scalar(msg2), hash_to_scalar(msg2));
        assert_ne!(hash_to_scalar(msg1), hash_to_scalar(msg2));
    }
 }
@@ -446,30 +446,11 @@ dependencies = [
 name = "coconut-interface"
 version = "0.1.0"
 dependencies = [
 "coconut-rs",
 "getset",
 "nymcoconut",
 "serde",
 ]
 [[package]]
 name = "coconut-rs"
 version = "0.5.0"
 source = "git+https://github.com/nymtech/coconut.git?branch=0.5.0#a1b72d51aa2a67b73b9f58d707030ae6dc70af7f"
 dependencies = [
 "bls12_381",
 "bs58",
 "digest 0.9.0",
 "ff",
 "getrandom 0.2.3",
 "group",
 "itertools",
 "rand 0.8.4",
 "serde",
 "serde_derive",
 "sha2",
 "thiserror",
 ]
 [[package]]
 name = "com"
 version = "0.2.0"
@@ -2540,6 +2521,24 @@ dependencies = [
 "validator-client",
 ]
 [[package]]
 name = "nymcoconut"
 version = "0.5.0"
 dependencies = [
 "bls12_381",
 "bs58",
 "digest 0.9.0",
 "ff",
 "getrandom 0.2.3",
 "group",
 "itertools",
 "rand 0.8.4",
 "serde",
 "serde_derive",
 "sha2",
 "thiserror",
 ]
 [[package]]
 name = "objc"
 version = "0.2.7"
@@ -1,6 +1,23 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 use std::sync::Arc;
 use futures::channel::mpsc;
 use log::info;
 #[cfg(feature = "coconut")]
 use coconut_interface::{hash_to_scalar, Credential, Parameters};
 #[cfg(feature = "coconut")]
 use credentials::bandwidth::{
    prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES,
 };
 #[cfg(feature = "coconut")]
 use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use nymsphinx::addressing::clients::Recipient;
 use topology::NymTopology;
 use crate::cache::ValidatorCache;
 use crate::config::Config;
 use crate::network_monitor::monitor::preparer::PacketPreparer;
@@ -15,17 +32,6 @@ use crate::network_monitor::monitor::summary_producer::SummaryProducer;
 use crate::network_monitor::monitor::Monitor;
 use crate::network_monitor::tested_network::TestedNetwork;
 use crate::storage::ValidatorApiStorage;
 use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
 use log::info;
 use nymsphinx::addressing::clients::Recipient;
 use std::sync::Arc;
 use topology::NymTopology;
 #[cfg(feature = "coconut")]
 use coconut_interface::Credential;
 #[cfg(feature = "coconut")]
 use credentials::{bandwidth::prepare_for_spending, obtain_aggregate_verification_key};
 pub(crate) mod chunker;
 pub(crate) mod gateways_reader;
@@ -180,14 +186,26 @@ async fn TEMPORARY_obtain_bandwidth_credential(
        .await
        .expect("could not obtain aggregate verification key of ALL validators");
-    let bandwidth_credential =
+    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-        credentials::bandwidth::obtain_signature(&identity.to_bytes(), &validators)
+    let bandwidth_credential_attributes = BandwidthVoucherAttributes {
-            .await
+        serial_number: params.random_scalar(),
-            .expect("failed to obtain bandwidth credential!");
+        binding_number: params.random_scalar(),
        voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
        voucher_info: hash_to_scalar(String::from("BandwidthVoucher").as_bytes()),
    };
    let bandwidth_credential = credentials::bandwidth::obtain_signature(
        &params,
        &bandwidth_credential_attributes,
        &validators,
    )
    .await
    .expect("failed to obtain bandwidth credential!");
    prepare_for_spending(
        &identity.to_bytes(),
        &bandwidth_credential,
        &bandwidth_credential_attributes,
        &verification_key,
    )
    .expect("failed to prepare bandwidth credential for spending!")
Author	SHA1	Message	Date
Mark Sinclair	33c162f3b4	Make traits public to allow PCC to use formatting traits	2021-11-16 16:01:30 +00:00
Mark Sinclair	2809c23722	Adjust public visibility so that structs and methods can be used from PCC WASM package	2021-11-16 10:52:07 +00:00
aniampio	66830d0a8d	Merge branch 'feature/covidcredentials' of https://github.com/nymtech/nym into feature/covidcredentials	2021-11-12 11:04:33 +00:00
aniampio	802449d8af	Add function to turn theta into bytes and from bytes	2021-11-12 11:04:19 +00:00
aniampio	5dd4245d4c	[ci skip] Generate TS types	2021-11-08 17:01:40 +00:00
aniampio	c49498a669	Run cargo fmt	2021-11-08 14:53:35 +00:00
aniampio	7d123b9fce	Add functions for proving and verification of a covid credential + e2e test showing how it should work	2021-11-08 14:52:33 +00:00
aniampio	3c76b8386a	Run cargo fmt	2021-11-04 14:15:56 +00:00
aniampio	bdb021994e	Resolve double imports after merge	2021-11-04 14:15:35 +00:00
AniaPiotrowska	f732d83479	Merge branch 'develop' into feature/vouchers	2021-11-04 14:08:50 +00:00
aniampio	221d042a21	Fix merge conflict	2021-11-04 13:05:16 +00:00
aniampio	4dea20e15b	Merge commits	2021-11-04 12:52:10 +00:00
aniampio	6ae54b2f89	Remove old comment	2021-11-04 12:47:37 +00:00
AniaPiotrowska	fe2386eab2	Update common/nymcoconut/src/proofs/mod.rs Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com>	2021-11-04 12:37:56 +00:00
aniampio	2a551610ae	Remove empty file	2021-11-04 12:35:51 +00:00
aniampio	b00fa15b55	Change passing verification key as inpput to functions to actually computing it when it is needed	2021-11-04 12:30:43 +00:00
AniaPiotrowska	4d904257a9	Update common/credentials/src/bandwidth.rs Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com>	2021-11-04 10:55:14 +00:00
aniampio	f3a192a023	Merge branch 'feature/vouchers' of https://github.com/nymtech/nym into feature/vouchers	2021-11-03 20:44:23 +00:00
aniampio	c67c114af6	Fix for a failed clippy test	2021-11-03 20:41:26 +00:00
AniaPiotrowska	87c8b512b0	Update common/credentials/src/bandwidth.rs Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com>	2021-11-03 20:32:24 +00:00
AniaPiotrowska	36d8502fed	Update clients/socks5/src/commands/init.rs Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com>	2021-11-03 20:31:40 +00:00
aniampio	ec2bf0beaf	Fix incorrect error message	2021-11-03 19:34:39 +00:00
aniampio	36b20d4e6e	Add get attribute function instead of making it public	2021-11-03 19:30:27 +00:00
aniampio	9554cebb2b	Fix the error in wasm client	2021-11-03 16:52:33 +00:00
aniampio	b9c4922e1a	Merge branch 'feature/vouchers' of https://github.com/nymtech/nym into feature/vouchers	2021-11-03 16:16:28 +00:00
aniampio	65ef3f02e7	Run cargo fmt	2021-11-03 16:14:13 +00:00
aniampio	a75ca9f114	Rename function to indicate that it returns the number of attributes	2021-11-03 16:09:46 +00:00
aniampio	aa2410c99b	Remove commented code	2021-11-03 16:04:22 +00:00
aniampio	c1df8eef62	Replace numeric value with a constant	2021-11-03 15:59:10 +00:00
aniampio	f5726a07f3	Add docs for the bandwidth voucher struct	2021-11-03 15:51:57 +00:00
aniampio	639fb802a4	Add spacing between errors	2021-11-03 15:43:42 +00:00
aniampio	9b945acba3	Remove commented code	2021-11-03 15:41:14 +00:00
aniampio	70a28d3767	Change expect to unwrap	2021-11-03 15:38:32 +00:00
Jędrzej Stuczyński	533f6c5b24	cargo fmt	2021-11-03 09:05:10 +00:00
aniampio	fba653fcfd	Fix dead code warning	2021-10-28 16:36:42 +02:00
aniampio	22c0669f5d	Run cargo fmt	2021-10-28 16:09:50 +02:00
aniampio	edfd9531af	Fix warnings from clippy	2021-10-28 16:09:24 +02:00
aniampio	bbd35feb81	Run cargo fmt	2021-10-25 10:43:45 +02:00
aniampio	bd26bc192e	Update flag #[cfg(feature = coconut)]	2021-10-25 10:41:29 +02:00
aniampio	39af6abec7	Run cargo fmt	2021-10-25 09:59:05 +02:00
aniampio	d1563c079e	Fix the fields in tauri-client	2021-10-25 09:53:40 +02:00
aniampio	8250dca8be	Fix warnings from clippy	2021-10-22 17:59:53 +02:00
aniampio	5bf0a14c20	Rename prove_credential to prove_bandwidth_credential	2021-10-22 17:29:27 +02:00
aniampio	6a3d10bab7	Run cargo fmt	2021-10-22 17:16:19 +02:00
aniampio	842b58751a	Rename input variable to be more informative	2021-10-22 17:15:47 +02:00
aniampio	544355bbfd	Rename input variable to be more informative	2021-10-22 17:13:48 +02:00
aniampio	bd64a29932	Fix unused imports	2021-10-22 16:50:07 +02:00
aniampio	ed2cf1ced6	Fix breaking test and remove doctest from nymcoconut	2021-10-22 16:11:17 +02:00
aniampio	890b0bb677	Update nymcoconut/src/scheme/mod file	2021-10-22 15:37:15 +02:00
aniampio	09efb62fa1	Add features flag for coconut	2021-10-22 15:18:06 +02:00
AniaPiotrowska	4e80c57076	Merge branch 'develop' into feature/vouchers	2021-10-20 17:18:22 +01:00
aniampio	8c2361757e	Merge branch 'feature/vouchers' of https://github.com/nymtech/nym into feature/vouchers	2021-10-20 17:05:21 +01:00
aniampio	0eaad032f6	Run cargo fmt	2021-10-20 17:05:00 +01:00
aniampio	371467cede	[ci skip] Generate TS types	2021-10-20 15:45:26 +00:00
aniampio	9110a8eefd	Add proper creation of bandwidth attributes	2021-10-20 16:35:13 +01:00
aniampio	2e8a0e9a72	Add missing blinded serial number value and update accordingly the code	2021-10-20 16:06:30 +01:00
aniampio	b068dde7c7	Introduce specific field for the bandwidth voucher. Values need to be updated, tmp put what was already used	2021-10-18 18:56:20 +01:00
aniampio	d93918e99b	Move the Coconut library	2021-10-18 16:32:38 +01:00