missing serialization

common/bandwidth-controller/src/error.rs

@@ -45,4 +45,7 @@ pub enum BandwidthControllerError {
 
     #[error("Threshold not set yet")]
     NoThreshold,
+
+    #[error("can't handle recovering storage with revision {stored}. {expected} was expected")]
+    UnsupportedCredentialStorageRevision { stored: u8, expected: u8 },
 }

common/bandwidth-controller/src/utils.rs

@@ -2,40 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::error::BandwidthControllerError;
-use nym_credential_storage::models::{StorableIssuedCredential, StoredIssuedCredential};
+use nym_credential_storage::models::StoredIssuedCredential;
+use nym_credentials::coconut::bandwidth::issued::CURRENT_SERIALIZATION_REVISION;
 use nym_credentials::coconut::bandwidth::IssuedBandwidthCredential;
-use nym_validator_client::nym_api::EpochId;
 
 pub fn stored_credential_to_issued_bandwidth(
     cred: StoredIssuedCredential,
 ) -> Result<IssuedBandwidthCredential, BandwidthControllerError> {
-    /*
-       let bandwidth_credential = self
-           .storage
-           .get_next_coconut_credential()
-           .await
-           .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))?;
-       let voucher_value = u64::from_str(&bandwidth_credential.voucher_value)
-           .map_err(|_| StorageError::InconsistentData)?;
-       let voucher_info = bandwidth_credential.voucher_info.clone();
-       let serial_number = Zeroizing::new(nym_coconut_interface::Attribute::try_from_bs58(
-           bandwidth_credential.serial_number,
-       )?);
-       let binding_number = Zeroizing::new(nym_coconut_interface::Attribute::try_from_bs58(
-           bandwidth_credential.binding_number,
-       )?);
-       let signature =
-           nym_coconut_interface::Signature::try_from_bs58(bandwidth_credential.signature)?;
-       let epoch_id = u64::from_str(&bandwidth_credential.epoch_id)
-           .map_err(|_| StorageError::InconsistentData)?;
+    if cred.serialization_revision != CURRENT_SERIALIZATION_REVISION {
+        return Err(
+            BandwidthControllerError::UnsupportedCredentialStorageRevision {
+                stored: cred.serialization_revision,
+                expected: CURRENT_SERIALIZATION_REVISION,
+            },
+        );
+    }
 
-    */
-    todo!()
-}
-
-pub fn issued_bandwidth_to_stored_credential(
-    issued: IssuedBandwidthCredential,
-    epoch_id: EpochId,
-) -> StoredIssuedCredential {
-    todo!()
+    Ok(IssuedBandwidthCredential::unpack_v1(&cred.credential_data)?)
 }