add issuance logic client-side

common/bandwidth-controller/src/acquire/mod.rs

@@ -5,21 +5,24 @@ use crate::error::BandwidthControllerError;
 use nym_credential_storage::models::StorableIssuedCredential;
 use nym_credential_storage::storage::Storage;
 use nym_credentials::coconut::bandwidth::{CredentialType, IssuanceBandwidthCredential};
-use nym_credentials::coconut::utils::obtain_aggregate_signature;
+use nym_credentials::coconut::utils::{
+    obtain_aggregate_signature, obtain_coin_indices_signatures, obtain_expiration_date_signatures,
+    signatures_to_string,
+};
+use nym_credentials::obtain_aggregate_verification_key;
 use nym_crypto::asymmetric::{encryption, identity};
-use nym_validator_client::coconut::all_coconut_api_clients;
-use nym_validator_client::nyxd::contract_traits::CoconutBandwidthSigningClient;
+use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
-use nym_validator_client::nyxd::Coin;
+use nym_validator_client::nyxd::contract_traits::EcashSigningClient;
 use rand::rngs::OsRng;
 use state::State;
 use zeroize::Zeroizing;
 
 pub mod state;
 
-pub async fn deposit<C>(client: &C, amount: Coin) -> Result<State, BandwidthControllerError>
+pub async fn deposit<C>(client: &C, client_id: &[u8]) -> Result<State, BandwidthControllerError>
 where
-    C: CoconutBandwidthSigningClient + Sync,
+    C: EcashSigningClient + Sync,
 {
     let mut rng = OsRng;
     let signing_key = identity::PrivateKey::new(&mut rng);
@@ -27,8 +30,7 @@ where
 
     let tx_hash = client
         .deposit(
-            amount.clone(),
-            CredentialType::Voucher.to_string(),
+            CredentialType::TicketBook.to_string(),
             signing_key.public_key().to_base58_string(),
             encryption_key.public_key().to_base58_string(),
             None,
@@ -37,7 +39,7 @@ where
         .transaction_hash;
 
     let voucher =
-        IssuanceBandwidthCredential::new_voucher(amount, tx_hash, signing_key, encryption_key);
+        IssuanceBandwidthCredential::new_voucher(tx_hash, client_id, signing_key, encryption_key);
 
     let state = State { voucher };
 
@@ -55,7 +57,7 @@ where
     <St as Storage>::StorageError: Send + Sync + 'static,
 {
     // temporary
-    assert!(state.voucher.typ().is_voucher());
+    assert!(state.voucher.typ().is_ticketbook());
 
     let epoch_id = client.get_current_epoch().await?.epoch_id;
     let threshold = client
@@ -63,11 +65,40 @@ where
         .await?
         .ok_or(BandwidthControllerError::NoThreshold)?;
 
-    let coconut_api_clients = all_coconut_api_clients(client, epoch_id).await?;
+    let ecash_api_clients = all_ecash_api_clients(client, epoch_id).await?;
 
-    let signature =
-        obtain_aggregate_signature(&state.voucher, &coconut_api_clients, threshold).await?;
-    let issued = state.voucher.to_issued_credential(signature, epoch_id);
+    let verification_key = obtain_aggregate_verification_key(&ecash_api_clients)?;
+
+    log::info!("Querying wallet signatures");
+    let wallet = obtain_aggregate_signature(&state.voucher, &ecash_api_clients, threshold).await?;
+
+    log::info!("Querying expiration date signatures");
+    let exp_date_sig =
+        obtain_expiration_date_signatures(&ecash_api_clients, &verification_key, threshold).await?;
+
+    log::info!("Checking coin indices signatures presence");
+    if !storage
+        .is_coin_indices_sig_present(epoch_id.to_string())
+        .await
+        .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))?
+    {
+        log::info!("Querying coin indices signatures");
+        let coin_indices_signatures =
+            obtain_coin_indices_signatures(&ecash_api_clients, &verification_key, threshold)
+                .await?;
+
+        storage
+            .insert_coin_indices_sig(
+                epoch_id.to_string(),
+                signatures_to_string(&coin_indices_signatures),
+            )
+            .await
+            .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))?;
+    }
+
+    let issued = state
+        .voucher
+        .to_issued_credential(wallet, exp_date_sig, epoch_id);
 
     // make sure the data gets zeroized after persisting it
     let credential_data = Zeroizing::new(issued.pack_v1());

common/bandwidth-controller/src/error.rs

@@ -1,9 +1,9 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use nym_coconut::CoconutError;
 use nym_credential_storage::error::StorageError;
 use nym_credentials::error::Error as CredentialsError;
+use nym_credentials_interface::CompactEcashError;
 use nym_crypto::asymmetric::encryption::KeyRecoveryError;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use nym_validator_client::coconut::CoconutApiError;
@@ -28,8 +28,8 @@ pub enum BandwidthControllerError {
     #[error(transparent)]
     StorageError(#[from] StorageError),
 
-    #[error("Coconut error - {0}")]
-    CoconutError(#[from] CoconutError),
+    #[error("Ecash error - {0}")]
+    EcashError(#[from] CompactEcashError),
 
     #[error("Validator client error - {0}")]
     ValidatorError(#[from] ValidatorClientError),