Do verification on validator-apis with hardcoded aggr vk

clients/tauri-client/src-tauri/src/main.rs

@@ -178,7 +178,6 @@ async fn verify_credential(
 
   let state = state.read().await;
 
-  let public_attributes = vec![state.voucher_value, state.voucher_info];
   let public_attributes_bytes = vec![
     state.voucher_value.to_byte_vec(),
     state.voucher_info.to_byte_vec(),
@@ -193,15 +192,15 @@ async fn verify_credential(
       .get(idx)
       .ok_or("Got invalid signature idx")?,
   );
+  println!("Using verification key: {:?}", verification_key.to_bs58());
   let local_check = credential.verify(&verification_key);
   println!("Local check: {}", local_check);
   if !local_check {
     return Ok(false);
   }
-  let remote_check =
-    verify_credential_remote(state.n_attributes, public_attributes, &parsed_urls, &theta)
-      .await
-      .unwrap();
+  let remote_check = verify_credential_remote(&parsed_urls, credential)
+    .await
+    .unwrap();
   println!("Remote check: {}", remote_check);
 
   Ok(remote_check)

common/client-libs/validator-client/src/client.rs

@@ -3,7 +3,7 @@
 
 use crate::{validator_api, ValidatorClientError};
 use coconut_interface::{
-    BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse, VerifyCredentialBody,
+    BlindSignRequestBody, BlindedSignatureResponse, Credential, VerificationKeyResponse,
     VerifyCredentialResponse,
 };
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
@@ -577,7 +577,7 @@ impl<C> Client<C> {
 
     pub async fn verify_credential(
         &self,
-        request_body: &VerifyCredentialBody,
+        request_body: &Credential,
     ) -> Result<VerifyCredentialResponse, ValidatorClientError> {
         Ok(self.validator_api.verify_credential(request_body).await?)
     }
@@ -686,7 +686,7 @@ impl ApiClient {
 
     pub async fn verify_credential(
         &self,
-        request_body: &VerifyCredentialBody,
+        request_body: &Credential,
     ) -> Result<VerifyCredentialResponse, ValidatorClientError> {
         Ok(self.validator_api.verify_credential(request_body).await?)
     }

common/client-libs/validator-client/src/validator_api/mod.rs

@@ -4,7 +4,7 @@
 use crate::validator_api::error::ValidatorAPIError;
 use crate::validator_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
 use coconut_interface::{
-    BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse, VerifyCredentialBody,
+    BlindSignRequestBody, BlindedSignatureResponse, Credential, VerificationKeyResponse,
     VerifyCredentialResponse,
 };
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
@@ -276,7 +276,7 @@ impl Client {
 
     pub async fn verify_credential(
         &self,
-        request_body: &VerifyCredentialBody,
+        request_body: &Credential,
     ) -> Result<VerifyCredentialResponse, ValidatorAPIError> {
         self.post_validator_api(
             &[routes::API_VERSION, routes::COCONUT_VERIFY_CREDENTIAL],

common/credentials/src/coconut/bandwidth.rs

@@ -7,7 +7,7 @@
 // it's the simplest possible case
 
 use coconut_interface::{
-    Credential, Parameters, PrivateAttribute, PublicAttribute, Signature, Theta, VerificationKey,
+    Credential, Parameters, PrivateAttribute, PublicAttribute, Signature, VerificationKey,
 };
 use network_defaults::BANDWIDTH_VALUE;
 use url::Url;
@@ -64,12 +64,10 @@ pub async fn obtain_signature(
 }
 
 pub async fn verify_credential_remote(
-    n_params: u32,
-    public_attributes: Vec<PublicAttribute>,
     validators: &[Url],
-    theta: &Theta,
+    credential: Credential,
 ) -> Result<bool, Error> {
-    obtain_aggregate_verify_credential(validators, n_params, theta, &public_attributes).await
+    obtain_aggregate_verify_credential(validators, credential).await
 }
 
 pub fn prepare_for_spending(

common/credentials/src/coconut/utils.rs

@@ -4,7 +4,7 @@
 use coconut_interface::{
     aggregate_signature_shares, aggregate_verification_keys, prepare_blind_sign,
     prove_bandwidth_credential, Attribute, BlindSignRequestBody, Credential, Parameters, Signature,
-    SignatureShare, Theta, VerificationKey, VerifyCredentialBody,
+    SignatureShare, VerificationKey,
 };
 use url::Url;
 
@@ -56,15 +56,14 @@ pub async fn obtain_aggregate_verification_key(
         indices.push(id as u64);
         shares.push(response.key);
     }
+    let ret = aggregate_verification_keys(&shares, Some(&indices))?;
 
-    Ok(aggregate_verification_keys(&shares, Some(&indices))?)
+    Ok(ret)
 }
 
 pub async fn obtain_aggregate_verify_credential(
     validators: &[Url],
-    n_params: u32,
-    theta: &Theta,
-    public_attributes: &[Attribute],
+    credential: Credential,
 ) -> Result<bool, Error> {
     if validators.is_empty() {
         return Err(Error::NoValidatorsAvailable);
@@ -72,20 +71,13 @@ pub async fn obtain_aggregate_verify_credential(
 
     let mut ret = true;
 
-    let verify_credential_request_body =
-        VerifyCredentialBody::new(n_params, theta, public_attributes);
-
     let mut client = validator_client::ApiClient::new(validators[0].clone());
-    let response = client
-        .verify_credential(&verify_credential_request_body)
-        .await?;
+    let response = client.verify_credential(&credential).await?;
     ret &= response.response;
 
     for validator_url in validators.iter().skip(1) {
         client.change_validator_api(validator_url.clone());
-        let response = client
-            .verify_credential(&verify_credential_request_body)
-            .await?;
+        let response = client.verify_credential(&credential).await?;
         ret &= response.response;
     }
 

common/nymcoconut/src/lib.rs

@@ -1,6 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+extern crate core;
+
 use std::convert::TryInto;
 
 use bls12_381::Scalar;

validator-api/src/coconut/mod.rs

@@ -4,9 +4,9 @@
 use bandwidth_claim_contract::events::{VOUCHER_ACQUIRED_EVENT_TYPE, VOUCHER_VALUE};
 use bip39::Mnemonic;
 use coconut_interface::{
-    elgamal::PublicKey, Attribute, BlindSignRequest, BlindSignRequestBody, BlindedSignature,
-    BlindedSignatureResponse, KeyPair, Parameters, VerificationKeyResponse, VerifyCredentialBody,
-    VerifyCredentialResponse,
+    elgamal::PublicKey, Attribute, Base58, BlindSignRequest, BlindSignRequestBody,
+    BlindedSignature, BlindedSignatureResponse, Credential, KeyPair, Parameters, VerificationKey,
+    VerificationKeyResponse, VerifyCredentialResponse,
 };
 use config::defaults::VALIDATOR_API_VERSION;
 use getset::{CopyGetters, Getters};
@@ -139,10 +139,19 @@ pub async fn get_verification_key(key_pair: &State<KeyPair>) -> Json<Verificatio
     Json(VerificationKeyResponse::new(key_pair.verification_key()))
 }
 
-#[post("/verify-credential", data = "<_verify_credential_request_body>")]
+#[post("/verify-credential", data = "<verify_credential_body>")]
 pub async fn post_verify_credential(
-    _verify_credential_request_body: Json<VerifyCredentialBody>,
-    _key_pair: &State<KeyPair>,
+    verify_credential_body: Json<Credential>,
+    key_pair: &State<KeyPair>,
 ) -> Json<VerifyCredentialResponse> {
-    Json(VerifyCredentialResponse { response: true })
+    println!(
+        "Using verification key: {:?}",
+        key_pair.verification_key().to_bs58()
+    );
+    let aggregated_verification_key = VerificationKey::try_from_bs58("4V4dv1G1sXaCndCUa8EBEubWZaxiHFJknBBakyKzPZGoGcGawyYgNoRBb2ipEckJA8hbmKETimkQZAdTjydUG1je3CVKnFh6xviFgE6SEUmKAyWVyT74MgagTdcEir5437kz7msyYnBa6eUznb2wsxQYjJHegZQs2BrEXjXbTn2pr4Nh1wcX6KYTUNTh5XfBHrhTWwDfmN7Smk2ta6hRPxroG3nFtzzUnswthtowBe5dhyJNV8AMaJ8uVmeSt6kk3uyy1T78LzCTC8nHTmgg91HRWLkNcimQFvbSLLiDsxoFLFKZ6hWw6cwXsToZ76xVyGCtKygBg2UMWdDHJwPR4QHypqrS8rbmxtXdhuBde1g5cKrppfwkLm5z9dRcnDpx8yuNszHc8vwdd66c8CP8yMdTaoyd9vpvmr1WRmX5bBJbbVLUG4N2jc91DcupmedPvEUgut7M75r5wW5GheK8jTQfAikJytYQFrY5oEMLq2f5PGAcjLCpqTLiMGJwHsJYxfGtmiPh17z6ogNN5A3FqW9sUT7gJfnLk6y1vPk1EJcRxFX22kH5bemBZRvF5JLb777SQS34gRSEYSfssNpAZfjyXDE4iuv5KX7m1UK1JP6FnyFw8FQx7BtAH6ydA2H3dCsoVPP9apTDPvMUcff4CQo29cH").unwrap();
+    let response = verify_credential_body
+        .0
+        .verify(&aggregated_verification_key);
+    println!("Sending response: {}", response);
+    Json(VerifyCredentialResponse { response })
 }