Rename to set_active_gateway_if_previously_registered

Revert set_active_gateway in base_client
Downgrade log statement to debug
2024-04-05 13:21:46 +02:00 · 2024-04-05 13:21:31 +02:00 · 2024-04-04 23:14:13 +02:00 · 2024-04-04 23:07:18 +02:00 · 2024-04-04 22:38:23 +02:00 · 2024-04-04 22:38:23 +02:00
443 changed files with 6943 additions and 27455 deletions
@@ -9,7 +9,7 @@ jobs:
    steps:
      - uses: actions/checkout@v3
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git
+        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
      - name: Install rsync
        run: sudo apt-get install rsync
      - uses: rlespinasse/github-slug-action@v3.x
@@ -30,24 +30,9 @@ jobs:
      - name: Remove existing Nym config directory (`~/.nym/`)
        run: cd documentation && ./remove_existing_config.sh
        continue-on-error: false
-# This is the original flow
-#      - name: Build all projects in documentation/ & move to ~/dist/docs/
-#        run: cd documentation && ./build_all_to_dist.sh
-
-# This is a workaround replacement which builds on the last working commit b332a6b55668f60988e36961f3f62a794ba82ddb and then on current branch
-      - name: Save current branch to ~/current_branch
-        run: git rev-parse --abbrev-ref HEAD > ~/current_branch
-      - name: Git pull & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
-        run: git pull && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
-      - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Build all projects in documentation/ & move to ~/dist/docs/
        run: cd documentation && ./build_all_to_dist.sh
-
-      - name: Switch to current branch
-        run: git checkout $echo "$(cat ~/current_branch)"
-      - name: Build all projects in documentation/ & move to ~/dist/docs/ on current branch
-        run: cd documentation && ./build_all_to_dist.sh && rm ~/current_branch
-
-# End of replacemet
+        continue-on-error: false

      - name: Post process
        run: cd documentation && ./post_process.sh
@@ -112,7 +112,6 @@ jobs:
            target/release/nym-network-statistics
            target/release/nym-cli
            target/release/nymvisor
-            target/release/nym-node
          retention-days: 30

      # If this was a pull_request or nightly, upload to build server
@@ -131,7 +130,6 @@ jobs:
          cp target/release/nym-network-requester $OUTPUT_DIR
          cp target/release/nym-network-statistics $OUTPUT_DIR
          cp target/release/nymvisor $OUTPUT_DIR
-          cp target/release/nym-node $OUTPUT_DIR
          cp target/release/nym-cli $OUTPUT_DIR
          cp target/release/explorer-api $OUTPUT_DIR
          if [ ${{ github.event_name == 'workflow_dispatch' && inputs.enable_deb == true }} = true ]; then
@@ -35,7 +35,7 @@ jobs:
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: 1.77
+          toolchain: stable
          target: wasm32-unknown-unknown
          override: true

@@ -60,7 +60,6 @@ jobs:
          cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/nym_service_provider_directory.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/nym_name_service.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_ecash.wasm $OUTPUT_DIR

      - name: Deploy branch to CI www
        continue-on-error: true
@@ -13,7 +13,7 @@ jobs:
    steps:
      - uses: actions/checkout@v3
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git
+        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
      - name: Install rsync
        run: sudo apt-get install rsync
      - uses: rlespinasse/github-slug-action@v3.x
@@ -34,25 +34,9 @@ jobs:
      - name: Remove existing Nym config directory (`~/.nym/`)
        run: cd documentation && ./remove_existing_config.sh
        continue-on-error: false
-
-# This is the original flow
-#      - name: Build all projects in documentation/ & move to ~/dist/docs/
-#        run: cd documentation && ./build_all_to_dist.sh
-
-# This is a workaround replacement which builds on the last working commit b332a6b55668f60988e36961f3f62a794ba82ddb and then on current branch
-      - name: Save current branch to ~/current_branch
-        run: git rev-parse --abbrev-ref HEAD > ~/current_branch
-      - name: Git pull & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
-        run: git pull && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
-      - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Build all projects in documentation/ & move to ~/dist/docs/
        run: cd documentation && ./build_all_to_dist.sh
-
-      - name: Switch to current branch
-        run: git checkout $echo "$(cat ~/current_branch)"
-      - name: Build all projects in documentation/ & move to ~/dist/docs/ on current branch
-        run: cd documentation && ./build_all_to_dist.sh && rm ~/current_branch
-
-# End of replacemet
+        continue-on-error: false

      - name: Deploy branch to CI www
        continue-on-error: true
@@ -30,7 +30,6 @@ jobs:
      mixnode_hash: ${{ steps.binary-hashes.outputs.mixnode_hash }}
      gateway_hash: ${{ steps.binary-hashes.outputs.gateway_hash }}
      nymvisor_hash: ${{ steps.binary-hashes.outputs.nymvisor_hash }}
-      nymnode_hash: ${{ steps.binary-hashes.outputs.nymnode_hash }}
      socks5_hash: ${{ steps.binary-hashes.outputs.socks5_hash }}
      netreq_hash: ${{ steps.binary-hashes.outputs.netreq_hash }}
      cli_hash: ${{ steps.binary-hashes.outputs.cli_hash }}
@@ -39,7 +38,6 @@ jobs:
      mixnode_version: ${{ steps.binary-versions.outputs.mixnode_version }}
      gateway_version: ${{ steps.binary-versions.outputs.gateway_version }}
      nymvisor_version: ${{ steps.binary-versions.outputs.nymvisor_version }}
-      nymnode_version: ${{ steps.binary-versions.outputs.nymnode_version }}
      socks5_version: ${{ steps.binary-versions.outputs.socks5_version }}
      netreq_version: ${{ steps.binary-versions.outputs.netreq_version }}
      cli_version: ${{ steps.binary-versions.outputs.cli_version }}
@@ -83,7 +81,6 @@ jobs:
            target/release/nym-network-statistics
            target/release/nym-cli
            target/release/nymvisor
-            target/release/nym-node
          retention-days: 30

      - id: create-release
@@ -102,7 +99,6 @@ jobs:
            target/release/nym-network-statistics
            target/release/nym-cli
            target/release/nymvisor
-            target/release/nym-node

  push-release-data-client:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
@@ -102,18 +102,6 @@ jobs:
            nym-wallet/target/release/bundle/dmg/*.dmg
            nym-wallet/target/release/bundle/macos/*.app.tar.gz*

-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/macos/nym-wallet.app.tar.gz"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"            
-
  push-release-data:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/release-calculate-hash.yml
@@ -77,18 +77,6 @@ jobs:
            nym-wallet/target/release/bundle/appimage/*.AppImage
            nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz*

-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"               
-
  push-release-data:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/release-calculate-hash.yml
@@ -97,18 +97,6 @@ jobs:
            nym-wallet/target/release/bundle/msi/*.msi
            nym-wallet/target/release/bundle/msi/*.msi.zip*

-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/msi/nym-wallet_1.*.msi"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"            
-
  push-release-data:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/release-calculate-hash.yml
@@ -4,20 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [2024.3-eclipse] (2024-04-22)
-
- Initial release of the first iteration of the Nym Node
- Improvements to gateway functionality
- IPR development
- Removal of allow list in favour of implementing an exit policy
- Explorer delegation: enables direct delegation to nodes via the Nym Explorer
-
-
-## [2024.2-fast-and-furious] (2024-03-25)
-
- Internal testing pre-release 
-
-
 ## [2024.1-marabou] (2024-02-15)

 **New Features:**
@@ -24,7 +24,6 @@ members = [
    "common/bandwidth-controller",
    "common/bin-common",
    "common/client-core",
-    "common/client-core/config-types",
    "common/client-core/surb-storage",
    "common/client-core/gateways-storage",
    "common/client-libs/gateway-client",
@@ -33,7 +32,6 @@ members = [
    "common/commands",
    "common/config",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
-    "common/cosmwasm-smart-contracts/ecash-contract",
    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
    #    "common/cosmwasm-smart-contracts/ephemera",
@@ -43,7 +41,6 @@ members = [
    "common/cosmwasm-smart-contracts/name-service",
    "common/cosmwasm-smart-contracts/service-provider-directory",
    "common/cosmwasm-smart-contracts/vesting-contract",
-    "common/country-group",
    "common/credential-storage",
    "common/credentials",
    "common/credential-utils",
@@ -53,7 +50,6 @@ members = [
    "common/execute",
    "common/exit-policy",
    "common/http-api-client",
-    "common/http-api-common",
    "common/inclusion-probability",
    "common/ip-packet-requests",
    "common/ledger",
@@ -62,7 +58,6 @@ members = [
    "common/node-tester-utils",
    "common/nonexhaustive-delayqueue",
    "common/nymcoconut",
-    "common/nym_offline_compact_ecash",
    "common/nym-id",
    "common/nym-metrics",
    "common/nymsphinx",
@@ -109,7 +104,6 @@ members = [
    "nym-browser-extension/storage",
    "nym-api/nym-api-requests",
    "nym-node",
-    "nym-node/nym-node-http-api",
    "nym-node/nym-node-requests",
    "nym-outfox",
    "nym-validator-rewarder",
@@ -124,6 +118,7 @@ members = [
    #    "wasm/full-nym-wasm",
    "wasm/mix-fetch",
    "wasm/node-tester",
+    "common/nym-metrics",
 ]

 default-members = [
@@ -137,7 +132,6 @@ default-members = [
    "tools/nymvisor",
    "explorer-api",
    "nym-validator-rewarder",
-    "nym-node"
 ]

 exclude = [
@@ -173,7 +167,6 @@ dotenvy = "0.15.6"
 futures = "0.3.28"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
-humantime-serde = "1.1.1"
 hyper = "0.14.27"
 k256 = "0.13"
 lazy_static = "1.4.0"
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.34"
+version = "1.1.33"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -8,7 +8,5 @@ use nym_client_core::cli_helpers::client_import_credential::{
 };

 pub(crate) async fn execute(args: CommonClientImportCredentialArgs) -> Result<(), ClientError> {
-    import_credential::<CliNativeClient, _>(args).await?;
-    println!("successfully imported credential!");
-    Ok(())
+    import_credential::<CliNativeClient, _>(args).await
 }
@@ -23,9 +23,6 @@ pub enum ClientError {
    #[error("Attempted to start the client in invalid socket mode")]
    InvalidSocketMode,

-    #[error(transparent)]
-    ConfigUpgradeFailure(#[from] nym_client_core::config::ConfigUpgradeFailure),
-
    #[error(transparent)]
    NymIdError(#[from] NymIdError),
 }
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.34"
+version = "1.1.33"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -10,7 +10,5 @@ use nym_client_core::cli_helpers::client_import_credential::{
 pub(crate) async fn execute(
    args: CommonClientImportCredentialArgs,
 ) -> Result<(), Socks5ClientError> {
-    import_credential::<CliSocks5Client, _>(args).await?;
-    println!("successfully imported credential!");
-    Ok(())
+    import_credential::<CliSocks5Client, _>(args).await
 }
@@ -23,9 +23,6 @@ pub enum Socks5ClientError {
    #[error(transparent)]
    ClientCoreError(#[from] ClientCoreError),

-    #[error(transparent)]
-    ConfigUpgradeFailure(#[from] nym_client_core::config::ConfigUpgradeFailure),
-
    #[error(transparent)]
    NymIdError(#[from] NymIdError),
 }
@@ -21,7 +21,6 @@ nym-credentials-interface = { path = "../credentials-interface" }
 nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
 nym-network-defaults = { path = "../network-defaults" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
-nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-validator-client]
 path = "../client-libs/validator-client"
@@ -5,24 +5,21 @@ 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, obtain_coin_indices_signatures, obtain_expiration_date_signatures,
-    signatures_to_string,
-};
-use nym_credentials::obtain_aggregate_verification_key;
+use nym_credentials::coconut::utils::obtain_aggregate_signature;
 use nym_crypto::asymmetric::{encryption, identity};
-use nym_validator_client::coconut::all_ecash_api_clients;
+use nym_validator_client::coconut::all_coconut_api_clients;
+use nym_validator_client::nyxd::contract_traits::CoconutBandwidthSigningClient;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
-use nym_validator_client::nyxd::contract_traits::EcashSigningClient;
+use nym_validator_client::nyxd::Coin;
 use rand::rngs::OsRng;
 use state::State;
 use zeroize::Zeroizing;

 pub mod state;

-pub async fn deposit<C>(client: &C, client_id: &[u8]) -> Result<State, BandwidthControllerError>
+pub async fn deposit<C>(client: &C, amount: Coin) -> Result<State, BandwidthControllerError>
 where
-    C: EcashSigningClient + Sync,
+    C: CoconutBandwidthSigningClient + Sync,
 {
    let mut rng = OsRng;
    let signing_key = identity::PrivateKey::new(&mut rng);
@@ -30,7 +27,8 @@ where

    let tx_hash = client
        .deposit(
-            CredentialType::TicketBook.to_string(),
+            amount.clone(),
+            CredentialType::Voucher.to_string(),
            signing_key.public_key().to_base58_string(),
            encryption_key.public_key().to_base58_string(),
            None,
@@ -39,7 +37,7 @@ where
        .transaction_hash;

    let voucher =
-        IssuanceBandwidthCredential::new_voucher(tx_hash, client_id, signing_key, encryption_key);
+        IssuanceBandwidthCredential::new_voucher(amount, tx_hash, signing_key, encryption_key);

    let state = State { voucher };

@@ -57,7 +55,7 @@ where
    <St as Storage>::StorageError: Send + Sync + 'static,
 {
    // temporary
-    assert!(state.voucher.typ().is_ticketbook());
+    assert!(state.voucher.typ().is_voucher());

    let epoch_id = client.get_current_epoch().await?.epoch_id;
    let threshold = client
@@ -65,40 +63,11 @@ where
        .await?
        .ok_or(BandwidthControllerError::NoThreshold)?;

-    let ecash_api_clients = all_ecash_api_clients(client, epoch_id).await?;
+    let coconut_api_clients = all_coconut_api_clients(client, epoch_id).await?;

-    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);
+    let signature =
+        obtain_aggregate_signature(&state.voucher, &coconut_api_clients, threshold).await?;
+    let issued = state.voucher.to_issued_credential(signature, epoch_id);

    // make sure the data gets zeroized after persisting it
    let credential_data = Zeroizing::new(issued.pack_v1());
@@ -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("Ecash error - {0}")]
-    EcashError(#[from] CompactEcashError),
+    #[error("Coconut error - {0}")]
+    CoconutError(#[from] CoconutError),

    #[error("Validator client error - {0}")]
    ValidatorError(#[from] ValidatorClientError),
@@ -3,23 +3,16 @@

 use crate::error::BandwidthControllerError;
 use crate::utils::stored_credential_to_issued_bandwidth;
-use log::info;
-use log::{error, warn};
-
-use nym_credential_storage::models::StorableIssuedCredential;
-use nym_credentials::coconut::utils::{obtain_coin_indices_signatures, signatures_to_string};
-use nym_credentials_interface::{constants, PayInfo, VerificationKeyAuth};
-
+use log::{debug, error, warn};
 use nym_credential_storage::storage::Storage;
-
+use nym_credentials::coconut::bandwidth::issued::BandwidthCredentialIssuedDataVariant;
 use nym_credentials::coconut::bandwidth::CredentialSpendingData;
-use nym_credentials::coconut::utils::signatures_from_string;
-use nym_credentials::obtain_aggregate_verification_key;
+use nym_credentials::coconut::utils::obtain_aggregate_verification_key;
 use nym_credentials::IssuedBandwidthCredential;
-use nym_validator_client::coconut::all_ecash_api_clients;
+use nym_credentials_interface::VerificationKey;
+use nym_validator_client::coconut::all_coconut_api_clients;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
-use zeroize::Zeroizing;

 pub mod acquire;
 pub mod error;
@@ -41,9 +34,6 @@ pub struct PreparedCredential {

    /// The database id of the stored credential.
    pub credential_id: i64,
-
-    ///the updated credential after the payment
-    pub updated_credential: IssuedBandwidthCredential,
 }

 pub struct RetrievedCredential {
@@ -60,6 +50,7 @@ impl<C, St: Storage> BandwidthController<C, St> {
    /// It marks any retrieved intermediate credentials as expired.
    pub async fn get_next_usable_credential(
        &self,
+        gateway_id: &str,
    ) -> Result<RetrievedCredential, BandwidthControllerError>
    where
        <St as Storage>::StorageError: Send + Sync + 'static,
@@ -67,7 +58,7 @@ impl<C, St: Storage> BandwidthController<C, St> {
        loop {
            let Some(maybe_next) = self
                .storage
-                .get_next_unspent_credential()
+                .get_next_unspent_credential(gateway_id)
                .await
                .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))?
            else {
@@ -78,16 +69,23 @@ impl<C, St: Storage> BandwidthController<C, St> {
            // try to deserialize it
            let valid_credential = match stored_credential_to_issued_bandwidth(maybe_next) {
                // check if it has already expired
-                Ok(credential) => {
-                    if credential.expired() {
-                        warn!("the credential (id: {id}) has already expired! The expiration was set to {}", credential.expiration_date_formatted());
-                        self.storage.mark_expired(id).await.map_err(|err| {
-                            BandwidthControllerError::CredentialStorageError(Box::new(err))
-                        })?;
-                        continue;
+                Ok(credential) => match credential.variant_data() {
+                    BandwidthCredentialIssuedDataVariant::Voucher(_) => {
+                        debug!("credential {id} is a bandwidth voucher");
+                        credential
                    }
-                    credential
-                }
+                    BandwidthCredentialIssuedDataVariant::FreePass(freepass_info) => {
+                        debug!("credential {id} is a free pass");
+                        if freepass_info.expired() {
+                            warn!("the free pass (id: {id}) has already expired! The expiration was set to {}", freepass_info.expiry_date());
+                            self.storage.mark_expired(id).await.map_err(|err| {
+                                BandwidthControllerError::CredentialStorageError(Box::new(err))
+                            })?;
+                            continue;
+                        }
+                        credential
+                    }
+                },
                Err(err) => {
                    error!("failed to deserialize credential with id {id}: {err}. it may need to be manually removed from the storage");
                    return Err(err);
@@ -107,108 +105,51 @@ impl<C, St: Storage> BandwidthController<C, St> {
    async fn get_aggregate_verification_key(
        &self,
        epoch_id: EpochId,
-    ) -> Result<VerificationKeyAuth, BandwidthControllerError>
+    ) -> Result<VerificationKey, BandwidthControllerError>
    where
        C: DkgQueryClient + Sync + Send,
        <St as Storage>::StorageError: Send + Sync + 'static,
    {
-        let coconut_api_clients = all_ecash_api_clients(&self.client, epoch_id).await?;
+        let coconut_api_clients = all_coconut_api_clients(&self.client, epoch_id).await?;
        Ok(obtain_aggregate_verification_key(&coconut_api_clients)?)
    }

-    pub async fn prepare_ecash_credential(
+    pub async fn prepare_bandwidth_credential(
        &self,
-        provider_pk: [u8; 32],
+        gateway_id: &str,
    ) -> Result<PreparedCredential, BandwidthControllerError>
    where
        C: DkgQueryClient + Sync + Send,
        <St as Storage>::StorageError: Send + Sync + 'static,
    {
-        let retrieved_credential = self.get_next_usable_credential().await?;
+        let retrieved_credential = self.get_next_usable_credential(gateway_id).await?;

        let epoch_id = retrieved_credential.credential.epoch_id();
        let credential_id = retrieved_credential.credential_id;

        let verification_key = self.get_aggregate_verification_key(epoch_id).await?;

-        let coin_indices_signatures_bs58 = self
-            .storage
-            .get_coin_indices_sig(epoch_id.to_string())
-            .await
-            .ok();
+        let spend_request = retrieved_credential
+            .credential
+            .prepare_for_spending(&verification_key)?;

-        let coin_indices_signatures = match coin_indices_signatures_bs58 {
-            Some(epoch_signatures) => signatures_from_string(epoch_signatures.signatures)?,
-            None => {
-                info!("We're missing some signatures, let's query them now");
-                //let's try to query them if we don't have them at that point
-                let ecash_api_client = all_ecash_api_clients(&self.client, epoch_id).await?;
-                let threshold = self
-                    .client
-                    .get_current_epoch_threshold()
-                    .await?
-                    .ok_or(BandwidthControllerError::NoThreshold)?;
-
-                let coin_indices_signatures =
-                    obtain_coin_indices_signatures(&ecash_api_client, &verification_key, threshold)
-                        .await?;
-
-                self.storage
-                    .insert_coin_indices_sig(
-                        epoch_id.to_string(),
-                        signatures_to_string(&coin_indices_signatures),
-                    )
-                    .await
-                    .map_err(|err| {
-                        BandwidthControllerError::CredentialStorageError(Box::new(err))
-                    })?;
-                coin_indices_signatures
-            }
-        };
-
-        let pay_info = PayInfo::generate_pay_info(provider_pk);
-
-        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
-
-        let spend_request = retrieved_credential.credential.prepare_for_spending(
-            &verification_key,
-            pay_info,
-            coin_indices_signatures,
-        )?;
        Ok(PreparedCredential {
            data: spend_request,
            epoch_id,
            credential_id,
-            updated_credential: retrieved_credential.credential,
        })
    }

-    pub async fn update_ecash_wallet(
+    pub async fn consume_credential(
        &self,
-        credential: IssuedBandwidthCredential,
        id: i64,
+        gateway_id: &str,
    ) -> Result<(), BandwidthControllerError>
    where
        <St as Storage>::StorageError: Send + Sync + 'static,
    {
-        // JS: shouldn't we send some contract/validator/gateway message here to actually, you know,
-        // consume it?
-        let consumed = credential.wallet().l() >= constants::NB_TICKETS;
-
-        // make sure the data gets zeroized after persisting it
-        let credential_data = Zeroizing::new(credential.pack_v1());
-        let storable = StorableIssuedCredential {
-            serialization_revision: credential.current_serialization_revision(),
-            credential_data: credential_data.as_ref(),
-            credential_type: credential.typ().to_string(),
-            epoch_id: credential
-                .epoch_id()
-                .try_into()
-                .expect("our epoch is has run over u32::MAX!"),
-        };
-
        self.storage
-            .update_issued_credential(storable, id, consumed)
+            .consume_coconut_credential(id, gateway_id)
            .await
            .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))
    }
@@ -8,6 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }

 [dependencies]
+atty = "0.2"
 const-str = "0.5.6"
 clap = { workspace = true, features = ["derive"] }
 clap_complete = "4.0"
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use serde::{Deserialize, Serialize};
-use std::io::IsTerminal;

 #[cfg(feature = "tracing")]
 pub use opentelemetry;
@@ -15,7 +14,7 @@ pub use tracing_subscriber;
 #[cfg(feature = "tracing")]
 pub use tracing_tree;

-#[derive(Debug, Default, Copy, Clone, Deserialize, PartialEq, Eq, Serialize)]
+#[derive(Debug, Default, Clone, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct LoggingSettings {
    // well, we need to implement something here at some point...
@@ -121,7 +120,7 @@ pub fn banner(crate_name: &str, crate_version: &str) -> String {
 }

 pub fn maybe_print_banner(crate_name: &str, crate_version: &str) {
-    if std::io::stdout().is_terminal() {
+    if atty::is(atty::Stream::Stdout) {
        println!("{}", banner(crate_name, crate_version))
    }
 }
@@ -15,7 +15,7 @@ bs58 = { workspace = true }
 cfg-if = "1.0.0"
 clap = { workspace = true, optional = true }
 futures = { workspace = true }
-humantime-serde = { workspace = true }
+humantime-serde = "1.0"
 log = { workspace = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { workspace = true, features = ["derive"] }
@@ -34,7 +34,6 @@ zeroize = { workspace = true }
 nym-id = { path = "../nym-id" }
 nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-config = { path = "../config" }
-nym-country-group = { path = "../country-group" }
 nym-crypto = { path = "../crypto" }
 nym-explorer-client = { path = "../../explorer-api/explorer-client" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
@@ -48,7 +47,6 @@ nym-validator-client = { path = "../client-libs/validator-client", default-featu
 nym-task = { path = "../task" }
 nym-credential-storage = { path = "../credential-storage" }
 nym-network-defaults = { path = "../network-defaults" }
-nym-client-core-config-types = { path = "./config-types", features = ["disk-persistence"]}
 nym-client-core-surb-storage = { path = "./surb-storage" }
 nym-client-core-gateways-storage = { path = "./gateways-storage" }

@@ -1,26 +0,0 @@
-[package]
-name = "nym-client-core-config-types"
-version = "0.1.0"
-edition = "2021"
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-humantime-serde = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-thiserror.workspace = true
-url = { workspace = true, features = ["serde"] }
-
-nym-config = { path = "../../config" }
-
-nym-country-group = { path = "../../country-group" }
-nym-pemstore = { path = "../../pemstore", optional = true }
-
-# those are pulling so many deps T.T
-nym-sphinx-params = { path = "../../nymsphinx/params" }
-nym-sphinx-addressing = { path = "../../nymsphinx/addressing" }
-
-
-[features]
-disk-persistence = ["nym-pemstore"]
@@ -1,9 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod v1;
-pub mod v2;
-
-// aliases for backwards compatibility
-pub use v1 as old_v1_1_20_2;
-pub use v2 as old_v1_1_33;
@@ -1,37 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::disk_persistence::old::v2::{
-    ClientKeysPathsV2, CommonClientPathsV2, DEFAULT_GATEWAY_DETAILS_FILENAME,
-};
-use crate::error::ConfigUpgradeFailure;
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
-
-// aliases for backwards compatibility
-pub type CommonClientPathsV1_1_20_2 = CommonClientPathsV1;
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct CommonClientPathsV1 {
-    pub keys: ClientKeysPathsV2,
-    pub credentials_database: PathBuf,
-    pub reply_surb_database: PathBuf,
-}
-
-impl CommonClientPathsV1 {
-    pub fn upgrade_default(self) -> Result<CommonClientPathsV2, ConfigUpgradeFailure> {
-        let data_dir = self
-            .reply_surb_database
-            .parent()
-            .ok_or_else(|| ConfigUpgradeFailure {
-                current_version: "1.1.20-2".to_string(),
-            })?;
-        Ok(CommonClientPathsV2 {
-            keys: self.keys,
-            gateway_details: data_dir.join(DEFAULT_GATEWAY_DETAILS_FILENAME),
-            credentials_database: self.credentials_database,
-            reply_surb_database: self.reply_surb_database,
-        })
-    }
-}
@@ -1,10 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-#[error("unable to upgrade config file from `{current_version}`")]
-pub struct ConfigUpgradeFailure {
-    pub current_version: String,
-}
@@ -1,602 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_config::defaults::NymNetworkDetails;
-use nym_sphinx_addressing::Recipient;
-use nym_sphinx_params::{PacketSize, PacketType};
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-use url::Url;
-
-#[cfg(feature = "disk-persistence")]
-pub mod disk_persistence;
-pub mod error;
-pub mod old;
-
-pub use error::ConfigUpgradeFailure;
-
-// 'DEBUG'
-const DEFAULT_ACK_WAIT_MULTIPLIER: f64 = 1.5;
-
-const DEFAULT_ACK_WAIT_ADDITION: Duration = Duration::from_millis(1_500);
-const DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(200);
-const DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(20);
-const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(50);
-const DEFAULT_TOPOLOGY_REFRESH_RATE: Duration = Duration::from_secs(5 * 60); // every 5min
-const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_000);
-const DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD: Duration = Duration::from_secs(70 * 60); // 70min -> full epoch (1h) + a bit of overhead
-
-// Set this to a high value for now, so that we don't risk sporadic timeouts that might cause
-// bought bandwidth tokens to not have time to be spent; Once we remove the gateway from the
-// bandwidth bridging protocol, we can come back to a smaller timeout value
-const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5 * 60);
-
-const DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO: f64 = 0.70;
-
-// reply-surbs related:
-
-// define when to request
-// clients/client-core/src/client/replies/reply_storage/surb_storage.rs
-const DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 10;
-const DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 200;
-
-// define how much to request at once
-// clients/client-core/src/client/replies/reply_controller.rs
-const DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 10;
-const DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 100;
-
-const DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE: u32 = 500;
-
-const DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD: Duration = Duration::from_secs(10);
-const DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD: Duration = Duration::from_secs(5 * 60);
-
-// 12 hours
-const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 60);
-
-// 24 hours
-const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
-
-pub use nym_country_group::CountryGroup;
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct Config {
-    pub client: Client,
-
-    #[serde(default)]
-    pub debug: DebugConfig,
-}
-
-impl Config {
-    pub fn new<S1, S2>(id: S1, version: S2) -> Self
-    where
-        S1: Into<String>,
-        S2: Into<String>,
-    {
-        Config {
-            client: Client::new_default(id, version),
-            debug: Default::default(),
-        }
-    }
-
-    pub fn from_client_config(client: Client, debug: DebugConfig) -> Self {
-        Config { client, debug }
-    }
-
-    pub fn validate(&self) -> bool {
-        self.debug.validate()
-    }
-
-    pub fn with_debug_config(mut self, debug: DebugConfig) -> Self {
-        self.debug = debug;
-        self
-    }
-
-    pub fn with_disabled_credentials(mut self, disabled_credentials_mode: bool) -> Self {
-        self.client.disabled_credentials_mode = disabled_credentials_mode;
-        self
-    }
-
-    pub fn with_custom_nyxd(mut self, urls: Vec<Url>) -> Self {
-        self.client.nyxd_urls = urls;
-        self
-    }
-
-    pub fn set_custom_nyxd(&mut self, nyxd_urls: Vec<Url>) {
-        self.client.nyxd_urls = nyxd_urls;
-    }
-
-    pub fn with_custom_nym_apis(mut self, nym_api_urls: Vec<Url>) -> Self {
-        self.client.nym_api_urls = nym_api_urls;
-        self
-    }
-
-    pub fn set_custom_nym_apis(&mut self, nym_api_urls: Vec<Url>) {
-        self.client.nym_api_urls = nym_api_urls;
-    }
-
-    pub fn with_high_default_traffic_volume(mut self, enabled: bool) -> Self {
-        if enabled {
-            self.set_high_default_traffic_volume();
-        }
-        self
-    }
-
-    pub fn with_packet_type(mut self, packet_type: PacketType) -> Self {
-        self.debug.traffic.packet_type = packet_type;
-        self
-    }
-
-    pub fn set_high_default_traffic_volume(&mut self) {
-        self.debug.traffic.average_packet_delay = Duration::from_millis(10);
-        // basically don't really send cover messages
-        self.debug.cover_traffic.loop_cover_traffic_average_delay =
-            Duration::from_millis(2_000_000);
-        // 250 "real" messages / s
-        self.debug.traffic.message_sending_average_delay = Duration::from_millis(4);
-    }
-
-    pub fn with_disabled_poisson_process(mut self, disabled: bool) -> Self {
-        if disabled {
-            self.set_no_poisson_process()
-        }
-        self
-    }
-
-    pub fn set_no_poisson_process(&mut self) {
-        self.debug.traffic.disable_main_poisson_packet_distribution = true;
-    }
-
-    pub fn with_disabled_cover_traffic(mut self, disabled: bool) -> Self {
-        if disabled {
-            self.set_no_cover_traffic()
-        }
-        self
-    }
-
-    pub fn set_no_cover_traffic(&mut self) {
-        self.debug.cover_traffic.disable_loop_cover_traffic_stream = true;
-        self.debug.traffic.disable_main_poisson_packet_distribution = true;
-    }
-
-    pub fn with_disabled_cover_traffic_with_keepalive(mut self, disabled: bool) -> Self {
-        if disabled {
-            self.set_no_cover_traffic_with_keepalive()
-        }
-        self
-    }
-    pub fn set_no_cover_traffic_with_keepalive(&mut self) {
-        self.debug.traffic.disable_main_poisson_packet_distribution = true;
-        self.debug.cover_traffic.loop_cover_traffic_average_delay = Duration::from_secs(5);
-    }
-
-    pub fn with_disabled_topology_refresh(mut self, disable_topology_refresh: bool) -> Self {
-        self.debug.topology.disable_refreshing = disable_topology_refresh;
-        self
-    }
-
-    pub fn with_topology_structure(mut self, topology_structure: TopologyStructure) -> Self {
-        self.set_topology_structure(topology_structure);
-        self
-    }
-
-    pub fn set_topology_structure(&mut self, topology_structure: TopologyStructure) {
-        self.debug.topology.topology_structure = topology_structure;
-    }
-
-    pub fn with_no_per_hop_delays(mut self, no_per_hop_delays: bool) -> Self {
-        if no_per_hop_delays {
-            self.set_no_per_hop_delays()
-        }
-        self
-    }
-
-    pub fn set_no_per_hop_delays(&mut self) {
-        self.debug.traffic.average_packet_delay = Duration::ZERO;
-        self.debug.acknowledgements.average_ack_delay = Duration::ZERO;
-    }
-
-    pub fn with_secondary_packet_size(mut self, secondary_packet_size: Option<PacketSize>) -> Self {
-        self.set_secondary_packet_size(secondary_packet_size);
-        self
-    }
-
-    pub fn set_secondary_packet_size(&mut self, secondary_packet_size: Option<PacketSize>) {
-        self.debug.traffic.secondary_packet_size = secondary_packet_size;
-    }
-
-    pub fn set_custom_version(&mut self, version: &str) {
-        self.client.version = version.to_string();
-    }
-
-    pub fn get_id(&self) -> String {
-        self.client.id.clone()
-    }
-
-    pub fn get_disabled_credentials_mode(&self) -> bool {
-        self.client.disabled_credentials_mode
-    }
-
-    pub fn get_validator_endpoints(&self) -> Vec<Url> {
-        self.client.nyxd_urls.clone()
-    }
-
-    pub fn get_nym_api_endpoints(&self) -> Vec<Url> {
-        self.client.nym_api_urls.clone()
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-// note: the deny_unknown_fields is VITAL here to allow upgrades from v1.1.20_2
-#[serde(deny_unknown_fields)]
-pub struct Client {
-    /// Version of the client for which this configuration was created.
-    pub version: String,
-
-    /// ID specifies the human readable ID of this particular client.
-    pub id: String,
-
-    /// Indicates whether this client is running in a disabled credentials mode, thus attempting
-    /// to claim bandwidth without presenting bandwidth credentials.
-    // TODO: this should be moved to `debug.gateway_connection`
-    #[serde(default)]
-    pub disabled_credentials_mode: bool,
-
-    /// Addresses to nyxd validators via which the client can communicate with the chain.
-    #[serde(alias = "validator_urls")]
-    pub nyxd_urls: Vec<Url>,
-
-    /// Addresses to APIs running on validator from which the client gets the view of the network.
-    #[serde(alias = "validator_api_urls")]
-    pub nym_api_urls: Vec<Url>,
-}
-
-impl Client {
-    pub fn new_default<S1, S2>(id: S1, version: S2) -> Self
-    where
-        S1: Into<String>,
-        S2: Into<String>,
-    {
-        let network = NymNetworkDetails::new_mainnet();
-        let nyxd_urls = network
-            .endpoints
-            .iter()
-            .map(|validator| validator.nyxd_url())
-            .collect();
-        let nym_api_urls = network
-            .endpoints
-            .iter()
-            .filter_map(|validator| validator.api_url())
-            .collect::<Vec<_>>();
-
-        Client {
-            version: version.into(),
-            id: id.into(),
-            disabled_credentials_mode: true,
-            nyxd_urls,
-            nym_api_urls,
-        }
-    }
-
-    pub fn new<S: Into<String>>(
-        id: S,
-        version: S,
-        disabled_credentials_mode: bool,
-        nyxd_urls: Vec<Url>,
-        nym_api_urls: Vec<Url>,
-    ) -> Self {
-        Client {
-            version: version.into(),
-            id: id.into(),
-            disabled_credentials_mode,
-            nyxd_urls,
-            nym_api_urls,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Traffic {
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// sent packet is going to be delayed at any given mix node.
-    /// So for a packet going through three mix nodes, on average, it will take three times this value
-    /// until the packet reaches its destination.
-    #[serde(with = "humantime_serde")]
-    pub average_packet_delay: Duration,
-
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take another 'real traffic stream' message to be sent.
-    /// If no real packets are available and cover traffic is enabled,
-    /// a loop cover message is sent instead in order to preserve the rate.
-    #[serde(with = "humantime_serde")]
-    pub message_sending_average_delay: Duration,
-
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    pub disable_main_poisson_packet_distribution: bool,
-
-    /// Specifies the packet size used for sent messages.
-    /// Do not override it unless you understand the consequences of that change.
-    pub primary_packet_size: PacketSize,
-
-    /// Specifies the optional auxiliary packet size for optimizing message streams.
-    /// Note that its use decreases overall anonymity.
-    /// Do not set it it unless you understand the consequences of that change.
-    pub secondary_packet_size: Option<PacketSize>,
-
-    pub packet_type: PacketType,
-}
-
-impl Traffic {
-    pub fn validate(&self) -> bool {
-        if let Some(secondary_packet_size) = self.secondary_packet_size {
-            if secondary_packet_size == PacketSize::AckPacket
-                || secondary_packet_size == self.primary_packet_size
-            {
-                return false;
-            }
-        }
-        true
-    }
-}
-
-impl Default for Traffic {
-    fn default() -> Self {
-        Traffic {
-            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
-            disable_main_poisson_packet_distribution: false,
-            primary_packet_size: PacketSize::RegularPacket,
-            secondary_packet_size: None,
-            packet_type: PacketType::Mix,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct CoverTraffic {
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take for another loop cover traffic message to be sent.
-    #[serde(with = "humantime_serde")]
-    pub loop_cover_traffic_average_delay: Duration,
-
-    /// Specifies the ratio of `primary_packet_size` to `secondary_packet_size` used in cover traffic.
-    /// Only applicable if `secondary_packet_size` is enabled.
-    pub cover_traffic_primary_size_ratio: f64,
-
-    /// Controls whether the dedicated loop cover traffic stream should be enabled.
-    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
-    pub disable_loop_cover_traffic_stream: bool,
-}
-
-impl Default for CoverTraffic {
-    fn default() -> Self {
-        CoverTraffic {
-            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
-            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
-            disable_loop_cover_traffic_stream: false,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct GatewayConnection {
-    /// How long we're willing to wait for a response to a message sent to the gateway,
-    /// before giving up on it.
-    #[serde(with = "humantime_serde")]
-    pub gateway_response_timeout: Duration,
-}
-
-impl Default for GatewayConnection {
-    fn default() -> Self {
-        GatewayConnection {
-            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Acknowledgements {
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// sent acknowledgement is going to be delayed at any given mix node.
-    /// So for an ack going through three mix nodes, on average, it will take three times this value
-    /// until the packet reaches its destination.
-    #[serde(with = "humantime_serde")]
-    pub average_ack_delay: Duration,
-
-    /// Value multiplied with the expected round trip time of an acknowledgement packet before
-    /// it is assumed it was lost and retransmission of the data packet happens.
-    /// In an ideal network with 0 latency, this value would have been 1.
-    pub ack_wait_multiplier: f64,
-
-    /// Value added to the expected round trip time of an acknowledgement packet before
-    /// it is assumed it was lost and retransmission of the data packet happens.
-    /// In an ideal network with 0 latency, this value would have been 0.
-    #[serde(with = "humantime_serde")]
-    pub ack_wait_addition: Duration,
-}
-
-impl Default for Acknowledgements {
-    fn default() -> Self {
-        Acknowledgements {
-            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
-            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Topology {
-    /// The uniform delay every which clients are querying the directory server
-    /// to try to obtain a compatible network topology to send sphinx packets through.
-    #[serde(with = "humantime_serde")]
-    pub topology_refresh_rate: Duration,
-
-    /// During topology refresh, test packets are sent through every single possible network
-    /// path. This timeout determines waiting period until it is decided that the packet
-    /// did not reach its destination.
-    #[serde(with = "humantime_serde")]
-    pub topology_resolution_timeout: Duration,
-
-    /// Specifies whether the client should not refresh the network topology after obtaining
-    /// the first valid instance.
-    /// Supersedes `topology_refresh_rate_ms`.
-    pub disable_refreshing: bool,
-
-    /// Defines how long the client is going to wait on startup for its gateway to come online,
-    /// before abandoning the procedure.
-    #[serde(with = "humantime_serde")]
-    pub max_startup_gateway_waiting_period: Duration,
-
-    /// Specifies the mixnode topology to be used for sending packets.
-    pub topology_structure: TopologyStructure,
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TopologyStructure {
-    #[default]
-    NymApi,
-    GeoAware(GroupBy),
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum GroupBy {
-    CountryGroup(CountryGroup),
-    NymAddress(Recipient),
-}
-
-impl std::fmt::Display for GroupBy {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GroupBy::CountryGroup(group) => write!(f, "group: {group}"),
-            GroupBy::NymAddress(address) => write!(f, "address: {address}"),
-        }
-    }
-}
-
-impl Default for Topology {
-    fn default() -> Self {
-        Topology {
-            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
-            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-            disable_refreshing: false,
-            max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
-            topology_structure: TopologyStructure::default(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct ReplySurbs {
-    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
-    /// It can only allow to go below that value if its to request additional reply surbs.
-    pub minimum_reply_surb_storage_threshold: usize,
-
-    /// Defines the maximum number of reply surbs the client wants to keep in its storage at any times.
-    pub maximum_reply_surb_storage_threshold: usize,
-
-    /// Defines the minimum number of reply surbs the client would request.
-    pub minimum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs the client would request.
-    pub maximum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs a remote party is allowed to request from this client at once.
-    pub maximum_allowed_reply_surb_request_size: u32,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
-    /// for more even though in theory they wouldn't need to.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_rerequest_waiting_period: Duration,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before
-    /// deciding it's never going to get them and would drop all pending messages
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_drop_waiting_period: Duration,
-
-    /// Defines maximum amount of time given reply surb is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_age: Duration,
-
-    /// Defines maximum amount of time given reply key is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_key_age: Duration,
-
-    /// Specifies the number of mixnet hops the packet should go through. If not specified, then
-    /// the default value is used.
-    pub surb_mix_hops: Option<u8>,
-}
-
-impl Default for ReplySurbs {
-    fn default() -> Self {
-        ReplySurbs {
-            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
-            maximum_reply_surb_request_size: DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
-            maximum_allowed_reply_surb_request_size: DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
-            maximum_reply_surb_rerequest_waiting_period:
-                DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
-            maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
-            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
-            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
-            surb_mix_hops: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct DebugConfig {
-    /// Defines all configuration options related to traffic streams.
-    pub traffic: Traffic,
-
-    /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTraffic,
-
-    /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnection,
-
-    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: Acknowledgements,
-
-    /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: Topology,
-
-    /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbs,
-}
-
-impl DebugConfig {
-    pub fn validate(&self) -> bool {
-        // no other sections have explicit requirements (yet)
-        self.traffic.validate()
-    }
-}
-
-// it could be derived, sure, but I'd rather have an explicit implementation in case we had to change
-// something manually at some point
-#[allow(clippy::derivable_impls)]
-impl Default for DebugConfig {
-    fn default() -> Self {
-        DebugConfig {
-            traffic: Default::default(),
-            cover_traffic: Default::default(),
-            gateway_connection: Default::default(),
-            acknowledgements: Default::default(),
-            topology: Default::default(),
-            reply_surbs: Default::default(),
-        }
-    }
-}
@@ -1,15 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod v1;
-pub mod v2;
-pub mod v3;
-pub mod v4;
-pub mod v5;
-
-// aliases for backwards compatibility
-pub use v1 as old_config_v1_1_13;
-pub use v2 as old_config_v1_1_20;
-pub use v3 as old_config_v1_1_20_2;
-pub use v4 as old_config_v1_1_30;
-pub use v5 as old_config_v1_1_33;
@@ -27,12 +27,6 @@ pub struct GatewayRegistration {
    pub registration_timestamp: OffsetDateTime,
 }

-impl GatewayRegistration {
-    pub fn gateway_id(&self) -> identity::PublicKey {
-        self.details.gateway_id()
-    }
-}
-
 impl<'a> From<&'a GatewayRegistration> for RawRegisteredGateway {
    fn from(value: &'a GatewayRegistration) -> Self {
        RawRegisteredGateway {
@@ -304,12 +298,3 @@ pub struct CustomGatewayDetails {
    pub gateway_id: identity::PublicKey,
    pub data: Option<Vec<u8>>,
 }
-
-impl CustomGatewayDetails {
-    pub fn new(gateway_id: identity::PublicKey) -> CustomGatewayDetails {
-        Self {
-            gateway_id,
-            data: None,
-        }
-    }
-}
@@ -7,7 +7,7 @@ use std::error::Error;
 use tokio::sync::Mutex;

 #[cfg(not(target_arch = "wasm32"))]
-use crate::config::disk_persistence::ClientKeysPaths;
+use crate::config::disk_persistence::keys_paths::ClientKeysPaths;
 #[cfg(not(target_arch = "wasm32"))]
 use nym_crypto::asymmetric::{encryption, identity};
 #[cfg(not(target_arch = "wasm32"))]
@@ -3,12 +3,10 @@

 use async_trait::async_trait;
 use log::{debug, error};
-use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_crypto::asymmetric::identity;
 use nym_gateway_client::GatewayClient;
 pub use nym_gateway_client::{GatewayPacketRouter, PacketRouter};
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use std::fmt::Debug;
 use std::os::raw::c_int as RawFd;
 use thiserror::Error;
@@ -113,9 +111,8 @@ impl<C, St> RemoteGateway<C, St> {

 impl<C, St> GatewayTransceiver for RemoteGateway<C, St>
 where
-    C: DkgQueryClient + Send + Sync,
-    St: CredentialStorage,
-    <St as CredentialStorage>::StorageError: Send + Sync + 'static,
+    C: Send,
+    St: Send,
 {
    fn gateway_identity(&self) -> identity::PublicKey {
        self.gateway_client.gateway_identity()
@@ -129,9 +126,8 @@ where
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl<C, St> GatewaySender for RemoteGateway<C, St>
 where
-    C: DkgQueryClient + Send + Sync,
-    St: CredentialStorage,
-    <St as CredentialStorage>::StorageError: Send + Sync + 'static,
+    C: Send,
+    St: Send,
 {
    async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
        self.gateway_client
@@ -1,5 +1,6 @@
-use crate::config::GroupBy;
-use log::{debug, error};
+use std::{collections::HashMap, fmt};
+
+use log::{debug, error, info};
 use nym_explorer_client::{ExplorerClient, PrettyDetailedMixNodeBond};
 use nym_network_defaults::var_names::EXPLORER_API;
 use nym_topology::{
@@ -9,11 +10,11 @@ use nym_topology::{
 };
 use nym_validator_client::client::MixId;
 use rand::{prelude::SliceRandom, thread_rng};
-use std::collections::HashMap;
+use serde::{Deserialize, Serialize};
 use tap::TapOptional;
 use url::Url;

-pub use nym_country_group::CountryGroup;
+use crate::config::GroupBy;

 const MIN_NODES_PER_LAYER: usize = 1;

@@ -37,6 +38,158 @@ fn create_explorer_client() -> Option<ExplorerClient> {
    Some(client)
 }

+#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
+pub enum CountryGroup {
+    Europe,
+    NorthAmerica,
+    SouthAmerica,
+    Oceania,
+    Asia,
+    Africa,
+    Unknown,
+}
+
+impl CountryGroup {
+    // We map contry codes into group, which initially are continent codes to a first approximation,
+    // but we do it manually to reserve the right to tweak this distribution for our purposes.
+    // NOTE: I did this quickly and it's not a complete list of all countries, but only those that
+    // were present in the network at the time. Please add more as needed.
+    fn new(country_code: &str) -> Self {
+        let country_code = country_code.to_uppercase();
+        use CountryGroup::*;
+        match country_code.as_ref() {
+            // Europe
+            "AT" => Europe,
+            "BG" => Europe,
+            "CH" => Europe,
+            "CY" => Europe,
+            "CZ" => Europe,
+            "DE" => Europe,
+            "DK" => Europe,
+            "ES" => Europe,
+            "FI" => Europe,
+            "FR" => Europe,
+            "GB" => Europe,
+            "GR" => Europe,
+            "IE" => Europe,
+            "IT" => Europe,
+            "LT" => Europe,
+            "LU" => Europe,
+            "LV" => Europe,
+            "MD" => Europe,
+            "MT" => Europe,
+            "NL" => Europe,
+            "NO" => Europe,
+            "PL" => Europe,
+            "RO" => Europe,
+            "SE" => Europe,
+            "SK" => Europe,
+            "TR" => Europe,
+            "UA" => Europe,
+
+            // North America
+            "CA" => NorthAmerica,
+            "MX" => NorthAmerica,
+            "US" => NorthAmerica,
+
+            // South America
+            "AR" => SouthAmerica,
+            "BR" => SouthAmerica,
+            "CL" => SouthAmerica,
+            "CO" => SouthAmerica,
+            "CR" => SouthAmerica,
+            "GT" => SouthAmerica,
+
+            // Oceania
+            "AU" => Oceania,
+
+            // Asia
+            "AM" => Asia,
+            "BH" => Asia,
+            "CN" => Asia,
+            "GE" => Asia,
+            "HK" => Asia,
+            "ID" => Asia,
+            "IL" => Asia,
+            "IN" => Asia,
+            "JP" => Asia,
+            "KH" => Asia,
+            "KR" => Asia,
+            "KZ" => Asia,
+            "MY" => Asia,
+            "RU" => Asia,
+            "SG" => Asia,
+            "TH" => Asia,
+            "VN" => Asia,
+
+            // Africa
+            "SC" => Africa,
+            "UG" => Africa,
+            "ZA" => Africa,
+
+            // And group level codes work too
+            "EU" => Europe,
+            "NA" => NorthAmerica,
+            "SA" => SouthAmerica,
+            "OC" => Oceania,
+            "AS" => Asia,
+            "AF" => Africa,
+
+            // And some aliases
+            "EUROPE" => Europe,
+            "NORTHAMERICA" => NorthAmerica,
+            "SOUTHAMERICA" => SouthAmerica,
+            "OCEANIA" => Oceania,
+            "ASIA" => Asia,
+            "AFRICA" => Africa,
+
+            _ => {
+                info!("Unknown country code: {}", country_code);
+                Unknown
+            }
+        }
+    }
+}
+
+impl fmt::Display for CountryGroup {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use CountryGroup::*;
+        match self {
+            Europe => write!(f, "EU"),
+            NorthAmerica => write!(f, "NA"),
+            SouthAmerica => write!(f, "SA"),
+            Oceania => write!(f, "OC"),
+            Asia => write!(f, "AS"),
+            Africa => write!(f, "AF"),
+            Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
+impl std::str::FromStr for CountryGroup {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let group = CountryGroup::new(s);
+        if group == CountryGroup::Unknown {
+            Err(())
+        } else {
+            Ok(group)
+        }
+    }
+}
+
+impl CountryGroup {
+    #[allow(unused)]
+    fn known(self) -> Option<CountryGroup> {
+        use CountryGroup::*;
+        match self {
+            Europe | NorthAmerica | SouthAmerica | Oceania | Asia | Africa => Some(self),
+            Unknown => None,
+        }
+    }
+}
+
 fn group_mixnodes_by_country_code(
    mixnodes: Vec<PrettyDetailedMixNodeBond>,
 ) -> HashMap<CountryGroup, Vec<MixId>> {
@@ -1,53 +1,15 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};

-pub mod old;
-
-// preserve old structure for easier migration
-pub use old::{old_v1_1_20_2, old_v1_1_33};
-
-pub const DEFAULT_REPLY_SURB_DB_FILENAME: &str = "persistent_reply_store.sqlite";
-pub const DEFAULT_CREDENTIALS_DB_FILENAME: &str = "credentials_database.db";
-pub const DEFAULT_GATEWAYS_DETAILS_DB_FILENAME: &str = "gateways_registrations.sqlite";
-
 pub const DEFAULT_PRIVATE_IDENTITY_KEY_FILENAME: &str = "private_identity.pem";
 pub const DEFAULT_PUBLIC_IDENTITY_KEY_FILENAME: &str = "public_identity.pem";
 pub const DEFAULT_PRIVATE_ENCRYPTION_KEY_FILENAME: &str = "private_encryption.pem";
 pub const DEFAULT_PUBLIC_ENCRYPTION_KEY_FILENAME: &str = "public_encryption.pem";
 pub const DEFAULT_ACK_KEY_FILENAME: &str = "ack_key.pem";

-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct CommonClientPaths {
-    pub keys: ClientKeysPaths,
-
-    /// Path to the file containing information about gateways used by this client,
-    /// i.e. details such as their public keys, owner addresses or the network information.
-    pub gateway_registrations: PathBuf,
-
-    /// Path to the database containing bandwidth credentials of this client.
-    pub credentials_database: PathBuf,
-
-    /// Path to the persistent store for received reply surbs, unused encryption keys and used sender tags.
-    pub reply_surb_database: PathBuf,
-}
-
-impl CommonClientPaths {
-    pub fn new_base<P: AsRef<Path>>(base_data_directory: P) -> Self {
-        let base_dir = base_data_directory.as_ref();
-
-        CommonClientPaths {
-            credentials_database: base_dir.join(DEFAULT_CREDENTIALS_DB_FILENAME),
-            reply_surb_database: base_dir.join(DEFAULT_REPLY_SURB_DB_FILENAME),
-            gateway_registrations: base_dir.join(DEFAULT_GATEWAYS_DETAILS_DB_FILENAME),
-            keys: ClientKeysPaths::new_base(base_data_directory),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 pub struct ClientKeysPaths {
    /// Path to file containing private identity key.
@@ -0,0 +1,43 @@
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::config::disk_persistence::keys_paths::ClientKeysPaths;
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+pub mod keys_paths;
+pub mod old_v1_1_20_2;
+pub mod old_v1_1_33;
+
+pub const DEFAULT_REPLY_SURB_DB_FILENAME: &str = "persistent_reply_store.sqlite";
+pub const DEFAULT_CREDENTIALS_DB_FILENAME: &str = "credentials_database.db";
+pub const DEFAULT_GATEWAYS_DETAILS_DB_FILENAME: &str = "gateways_registrations.sqlite";
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct CommonClientPaths {
+    pub keys: ClientKeysPaths,
+
+    /// Path to the file containing information about gateways used by this client,
+    /// i.e. details such as their public keys, owner addresses or the network information.
+    pub gateway_registrations: PathBuf,
+
+    /// Path to the database containing bandwidth credentials of this client.
+    pub credentials_database: PathBuf,
+
+    /// Path to the persistent store for received reply surbs, unused encryption keys and used sender tags.
+    pub reply_surb_database: PathBuf,
+}
+
+impl CommonClientPaths {
+    pub fn new_base<P: AsRef<Path>>(base_data_directory: P) -> Self {
+        let base_dir = base_data_directory.as_ref();
+
+        CommonClientPaths {
+            credentials_database: base_dir.join(DEFAULT_CREDENTIALS_DB_FILENAME),
+            reply_surb_database: base_dir.join(DEFAULT_REPLY_SURB_DB_FILENAME),
+            gateway_registrations: base_dir.join(DEFAULT_GATEWAYS_DETAILS_DB_FILENAME),
+            keys: ClientKeysPaths::new_base(base_data_directory),
+        }
+    }
+}
@@ -0,0 +1,33 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::config::disk_persistence::old_v1_1_33::{
+    ClientKeysPathsV1_1_33, CommonClientPathsV1_1_33, DEFAULT_GATEWAY_DETAILS_FILENAME,
+};
+use crate::error::ClientCoreError;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct CommonClientPathsV1_1_20_2 {
+    pub keys: ClientKeysPathsV1_1_33,
+    pub credentials_database: PathBuf,
+    pub reply_surb_database: PathBuf,
+}
+
+impl CommonClientPathsV1_1_20_2 {
+    pub fn upgrade_default(self) -> Result<CommonClientPathsV1_1_33, ClientCoreError> {
+        let data_dir = self.reply_surb_database.parent().ok_or_else(|| {
+            ClientCoreError::ConfigFileUpgradeFailure {
+                current_version: "1.1.20-2".to_string(),
+            }
+        })?;
+        Ok(CommonClientPathsV1_1_33 {
+            keys: self.keys,
+            gateway_details: data_dir.join(DEFAULT_GATEWAY_DETAILS_FILENAME),
+            credentials_database: self.credentials_database,
+            reply_surb_database: self.reply_surb_database,
+        })
+    }
+}
@@ -1,20 +1,16 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::disk_persistence::ClientKeysPaths;
-use crate::disk_persistence::{CommonClientPaths, DEFAULT_GATEWAYS_DETAILS_DB_FILENAME};
-use crate::error::ConfigUpgradeFailure;
+use crate::config::disk_persistence::keys_paths::ClientKeysPaths;
+use crate::config::disk_persistence::{CommonClientPaths, DEFAULT_GATEWAYS_DETAILS_DB_FILENAME};
+use crate::error::ClientCoreError;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;

 pub const DEFAULT_GATEWAY_DETAILS_FILENAME: &str = "gateway_details.json";

-// aliases for backwards compatibility
-pub type CommonClientPathsV1_1_33 = CommonClientPathsV2;
-pub type ClientKeysPathsV1_1_33 = ClientKeysPathsV2;
-
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-pub struct ClientKeysPathsV2 {
+pub struct ClientKeysPathsV1_1_33 {
    /// Path to file containing private identity key.
    pub private_identity_key_file: PathBuf,

@@ -36,7 +32,7 @@ pub struct ClientKeysPathsV2 {
    pub ack_key_file: PathBuf,
 }

-impl ClientKeysPathsV2 {
+impl ClientKeysPathsV1_1_33 {
    pub fn upgrade(self) -> ClientKeysPaths {
        ClientKeysPaths {
            private_identity_key_file: self.private_identity_key_file,
@@ -50,8 +46,8 @@ impl ClientKeysPathsV2 {

 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct CommonClientPathsV2 {
-    pub keys: ClientKeysPathsV2,
+pub struct CommonClientPathsV1_1_33 {
+    pub keys: ClientKeysPathsV1_1_33,

    /// Path to the file containing information about gateway used by this client,
    /// i.e. details such as its public key, owner address or the network information.
@@ -64,16 +60,15 @@ pub struct CommonClientPathsV2 {
    pub reply_surb_database: PathBuf,
 }

-impl CommonClientPathsV2 {
+impl CommonClientPathsV1_1_33 {
    // note that during the upgrade process, the caller will need to extract the key and gateway details
    // manually and resave them in the new database
-    pub fn upgrade_default(self) -> Result<CommonClientPaths, ConfigUpgradeFailure> {
-        let data_dir = self
-            .gateway_details
-            .parent()
-            .ok_or_else(|| ConfigUpgradeFailure {
+    pub fn upgrade_default(self) -> Result<CommonClientPaths, ClientCoreError> {
+        let data_dir = self.gateway_details.parent().ok_or_else(|| {
+            ClientCoreError::ConfigFileUpgradeFailure {
                current_version: "1.1.33".to_string(),
-            })?;
+            }
+        })?;

        Ok(CommonClientPaths {
            keys: self.keys.upgrade(),
@@ -1,9 +1,602 @@
-// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-pub use nym_client_core_config_types::disk_persistence;
-pub use nym_client_core_config_types::old::{
-    old_config_v1_1_13, old_config_v1_1_20, old_config_v1_1_20_2, old_config_v1_1_30,
-    old_config_v1_1_33,
+use crate::client::topology_control::geo_aware_provider::CountryGroup;
+use nym_config::defaults::NymNetworkDetails;
+use nym_sphinx::{
+    addressing::clients::Recipient,
+    params::{PacketSize, PacketType},
 };
-pub use nym_client_core_config_types::*;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+use url::Url;
+
+pub mod disk_persistence;
+pub mod old_config_v1_1_13;
+pub mod old_config_v1_1_20;
+pub mod old_config_v1_1_20_2;
+pub mod old_config_v1_1_30;
+pub mod old_config_v1_1_33;
+
+// 'DEBUG'
+const DEFAULT_ACK_WAIT_MULTIPLIER: f64 = 1.5;
+
+const DEFAULT_ACK_WAIT_ADDITION: Duration = Duration::from_millis(1_500);
+const DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(200);
+const DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(20);
+const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(50);
+const DEFAULT_TOPOLOGY_REFRESH_RATE: Duration = Duration::from_secs(5 * 60); // every 5min
+const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_000);
+const DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD: Duration = Duration::from_secs(70 * 60); // 70min -> full epoch (1h) + a bit of overhead
+
+// Set this to a high value for now, so that we don't risk sporadic timeouts that might cause
+// bought bandwidth tokens to not have time to be spent; Once we remove the gateway from the
+// bandwidth bridging protocol, we can come back to a smaller timeout value
+const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5 * 60);
+
+const DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO: f64 = 0.70;
+
+// reply-surbs related:
+
+// define when to request
+// clients/client-core/src/client/replies/reply_storage/surb_storage.rs
+const DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 10;
+const DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 200;
+
+// define how much to request at once
+// clients/client-core/src/client/replies/reply_controller.rs
+const DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 10;
+const DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 100;
+
+const DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE: u32 = 500;
+
+const DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD: Duration = Duration::from_secs(10);
+const DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD: Duration = Duration::from_secs(5 * 60);
+
+// 12 hours
+const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 60);
+
+// 24 hours
+const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Config {
+    pub client: Client,
+
+    #[serde(default)]
+    pub debug: DebugConfig,
+}
+
+impl Config {
+    pub fn new<S1, S2>(id: S1, version: S2) -> Self
+    where
+        S1: Into<String>,
+        S2: Into<String>,
+    {
+        Config {
+            client: Client::new_default(id, version),
+            debug: Default::default(),
+        }
+    }
+
+    pub fn from_client_config(client: Client, debug: DebugConfig) -> Self {
+        Config { client, debug }
+    }
+
+    pub fn validate(&self) -> bool {
+        self.debug.validate()
+    }
+
+    pub fn with_debug_config(mut self, debug: DebugConfig) -> Self {
+        self.debug = debug;
+        self
+    }
+
+    pub fn with_disabled_credentials(mut self, disabled_credentials_mode: bool) -> Self {
+        self.client.disabled_credentials_mode = disabled_credentials_mode;
+        self
+    }
+
+    pub fn with_custom_nyxd(mut self, urls: Vec<Url>) -> Self {
+        self.client.nyxd_urls = urls;
+        self
+    }
+
+    pub fn set_custom_nyxd(&mut self, nyxd_urls: Vec<Url>) {
+        self.client.nyxd_urls = nyxd_urls;
+    }
+
+    pub fn with_custom_nym_apis(mut self, nym_api_urls: Vec<Url>) -> Self {
+        self.client.nym_api_urls = nym_api_urls;
+        self
+    }
+
+    pub fn set_custom_nym_apis(&mut self, nym_api_urls: Vec<Url>) {
+        self.client.nym_api_urls = nym_api_urls;
+    }
+
+    pub fn with_high_default_traffic_volume(mut self, enabled: bool) -> Self {
+        if enabled {
+            self.set_high_default_traffic_volume();
+        }
+        self
+    }
+
+    pub fn with_packet_type(mut self, packet_type: PacketType) -> Self {
+        self.debug.traffic.packet_type = packet_type;
+        self
+    }
+
+    pub fn set_high_default_traffic_volume(&mut self) {
+        self.debug.traffic.average_packet_delay = Duration::from_millis(10);
+        // basically don't really send cover messages
+        self.debug.cover_traffic.loop_cover_traffic_average_delay =
+            Duration::from_millis(2_000_000);
+        // 250 "real" messages / s
+        self.debug.traffic.message_sending_average_delay = Duration::from_millis(4);
+    }
+
+    pub fn with_disabled_poisson_process(mut self, disabled: bool) -> Self {
+        if disabled {
+            self.set_no_poisson_process()
+        }
+        self
+    }
+
+    pub fn set_no_poisson_process(&mut self) {
+        self.debug.traffic.disable_main_poisson_packet_distribution = true;
+    }
+
+    pub fn with_disabled_cover_traffic(mut self, disabled: bool) -> Self {
+        if disabled {
+            self.set_no_cover_traffic()
+        }
+        self
+    }
+
+    pub fn set_no_cover_traffic(&mut self) {
+        self.debug.cover_traffic.disable_loop_cover_traffic_stream = true;
+        self.debug.traffic.disable_main_poisson_packet_distribution = true;
+    }
+
+    pub fn with_disabled_cover_traffic_with_keepalive(mut self, disabled: bool) -> Self {
+        if disabled {
+            self.set_no_cover_traffic_with_keepalive()
+        }
+        self
+    }
+    pub fn set_no_cover_traffic_with_keepalive(&mut self) {
+        self.debug.traffic.disable_main_poisson_packet_distribution = true;
+        self.debug.cover_traffic.loop_cover_traffic_average_delay = Duration::from_secs(5);
+    }
+
+    pub fn with_disabled_topology_refresh(mut self, disable_topology_refresh: bool) -> Self {
+        self.debug.topology.disable_refreshing = disable_topology_refresh;
+        self
+    }
+
+    pub fn with_topology_structure(mut self, topology_structure: TopologyStructure) -> Self {
+        self.set_topology_structure(topology_structure);
+        self
+    }
+
+    pub fn set_topology_structure(&mut self, topology_structure: TopologyStructure) {
+        self.debug.topology.topology_structure = topology_structure;
+    }
+
+    pub fn with_no_per_hop_delays(mut self, no_per_hop_delays: bool) -> Self {
+        if no_per_hop_delays {
+            self.set_no_per_hop_delays()
+        }
+        self
+    }
+
+    pub fn set_no_per_hop_delays(&mut self) {
+        self.debug.traffic.average_packet_delay = Duration::ZERO;
+        self.debug.acknowledgements.average_ack_delay = Duration::ZERO;
+    }
+
+    pub fn with_secondary_packet_size(mut self, secondary_packet_size: Option<PacketSize>) -> Self {
+        self.set_secondary_packet_size(secondary_packet_size);
+        self
+    }
+
+    pub fn set_secondary_packet_size(&mut self, secondary_packet_size: Option<PacketSize>) {
+        self.debug.traffic.secondary_packet_size = secondary_packet_size;
+    }
+
+    pub fn set_custom_version(&mut self, version: &str) {
+        self.client.version = version.to_string();
+    }
+
+    pub fn get_id(&self) -> String {
+        self.client.id.clone()
+    }
+
+    pub fn get_disabled_credentials_mode(&self) -> bool {
+        self.client.disabled_credentials_mode
+    }
+
+    pub fn get_validator_endpoints(&self) -> Vec<Url> {
+        self.client.nyxd_urls.clone()
+    }
+
+    pub fn get_nym_api_endpoints(&self) -> Vec<Url> {
+        self.client.nym_api_urls.clone()
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
+// note: the deny_unknown_fields is VITAL here to allow upgrades from v1.1.20_2
+#[serde(deny_unknown_fields)]
+pub struct Client {
+    /// Version of the client for which this configuration was created.
+    pub version: String,
+
+    /// ID specifies the human readable ID of this particular client.
+    pub id: String,
+
+    /// Indicates whether this client is running in a disabled credentials mode, thus attempting
+    /// to claim bandwidth without presenting bandwidth credentials.
+    // TODO: this should be moved to `debug.gateway_connection`
+    #[serde(default)]
+    pub disabled_credentials_mode: bool,
+
+    /// Addresses to nyxd validators via which the client can communicate with the chain.
+    #[serde(alias = "validator_urls")]
+    pub nyxd_urls: Vec<Url>,
+
+    /// Addresses to APIs running on validator from which the client gets the view of the network.
+    #[serde(alias = "validator_api_urls")]
+    pub nym_api_urls: Vec<Url>,
+}
+
+impl Client {
+    pub fn new_default<S1, S2>(id: S1, version: S2) -> Self
+    where
+        S1: Into<String>,
+        S2: Into<String>,
+    {
+        let network = NymNetworkDetails::new_mainnet();
+        let nyxd_urls = network
+            .endpoints
+            .iter()
+            .map(|validator| validator.nyxd_url())
+            .collect();
+        let nym_api_urls = network
+            .endpoints
+            .iter()
+            .filter_map(|validator| validator.api_url())
+            .collect::<Vec<_>>();
+
+        Client {
+            version: version.into(),
+            id: id.into(),
+            disabled_credentials_mode: true,
+            nyxd_urls,
+            nym_api_urls,
+        }
+    }
+
+    pub fn new<S: Into<String>>(
+        id: S,
+        disabled_credentials_mode: bool,
+        nyxd_urls: Vec<Url>,
+        nym_api_urls: Vec<Url>,
+    ) -> Self {
+        Client {
+            version: env!("CARGO_PKG_VERSION").to_string(),
+            id: id.into(),
+            disabled_credentials_mode,
+            nyxd_urls,
+            nym_api_urls,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Traffic {
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// sent packet is going to be delayed at any given mix node.
+    /// So for a packet going through three mix nodes, on average, it will take three times this value
+    /// until the packet reaches its destination.
+    #[serde(with = "humantime_serde")]
+    pub average_packet_delay: Duration,
+
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take another 'real traffic stream' message to be sent.
+    /// If no real packets are available and cover traffic is enabled,
+    /// a loop cover message is sent instead in order to preserve the rate.
+    #[serde(with = "humantime_serde")]
+    pub message_sending_average_delay: Duration,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    pub disable_main_poisson_packet_distribution: bool,
+
+    /// Specifies the packet size used for sent messages.
+    /// Do not override it unless you understand the consequences of that change.
+    pub primary_packet_size: PacketSize,
+
+    /// Specifies the optional auxiliary packet size for optimizing message streams.
+    /// Note that its use decreases overall anonymity.
+    /// Do not set it it unless you understand the consequences of that change.
+    pub secondary_packet_size: Option<PacketSize>,
+
+    pub packet_type: PacketType,
+}
+
+impl Traffic {
+    pub fn validate(&self) -> bool {
+        if let Some(secondary_packet_size) = self.secondary_packet_size {
+            if secondary_packet_size == PacketSize::AckPacket
+                || secondary_packet_size == self.primary_packet_size
+            {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+impl Default for Traffic {
+    fn default() -> Self {
+        Traffic {
+            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
+            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
+            disable_main_poisson_packet_distribution: false,
+            primary_packet_size: PacketSize::RegularPacket,
+            secondary_packet_size: None,
+            packet_type: PacketType::Mix,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct CoverTraffic {
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take for another loop cover traffic message to be sent.
+    #[serde(with = "humantime_serde")]
+    pub loop_cover_traffic_average_delay: Duration,
+
+    /// Specifies the ratio of `primary_packet_size` to `secondary_packet_size` used in cover traffic.
+    /// Only applicable if `secondary_packet_size` is enabled.
+    pub cover_traffic_primary_size_ratio: f64,
+
+    /// Controls whether the dedicated loop cover traffic stream should be enabled.
+    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
+    pub disable_loop_cover_traffic_stream: bool,
+}
+
+impl Default for CoverTraffic {
+    fn default() -> Self {
+        CoverTraffic {
+            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
+            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
+            disable_loop_cover_traffic_stream: false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct GatewayConnection {
+    /// How long we're willing to wait for a response to a message sent to the gateway,
+    /// before giving up on it.
+    #[serde(with = "humantime_serde")]
+    pub gateway_response_timeout: Duration,
+}
+
+impl Default for GatewayConnection {
+    fn default() -> Self {
+        GatewayConnection {
+            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Acknowledgements {
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// sent acknowledgement is going to be delayed at any given mix node.
+    /// So for an ack going through three mix nodes, on average, it will take three times this value
+    /// until the packet reaches its destination.
+    #[serde(with = "humantime_serde")]
+    pub average_ack_delay: Duration,
+
+    /// Value multiplied with the expected round trip time of an acknowledgement packet before
+    /// it is assumed it was lost and retransmission of the data packet happens.
+    /// In an ideal network with 0 latency, this value would have been 1.
+    pub ack_wait_multiplier: f64,
+
+    /// Value added to the expected round trip time of an acknowledgement packet before
+    /// it is assumed it was lost and retransmission of the data packet happens.
+    /// In an ideal network with 0 latency, this value would have been 0.
+    #[serde(with = "humantime_serde")]
+    pub ack_wait_addition: Duration,
+}
+
+impl Default for Acknowledgements {
+    fn default() -> Self {
+        Acknowledgements {
+            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
+            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
+            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Topology {
+    /// The uniform delay every which clients are querying the directory server
+    /// to try to obtain a compatible network topology to send sphinx packets through.
+    #[serde(with = "humantime_serde")]
+    pub topology_refresh_rate: Duration,
+
+    /// During topology refresh, test packets are sent through every single possible network
+    /// path. This timeout determines waiting period until it is decided that the packet
+    /// did not reach its destination.
+    #[serde(with = "humantime_serde")]
+    pub topology_resolution_timeout: Duration,
+
+    /// Specifies whether the client should not refresh the network topology after obtaining
+    /// the first valid instance.
+    /// Supersedes `topology_refresh_rate_ms`.
+    pub disable_refreshing: bool,
+
+    /// Defines how long the client is going to wait on startup for its gateway to come online,
+    /// before abandoning the procedure.
+    #[serde(with = "humantime_serde")]
+    pub max_startup_gateway_waiting_period: Duration,
+
+    /// Specifies the mixnode topology to be used for sending packets.
+    pub topology_structure: TopologyStructure,
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TopologyStructure {
+    #[default]
+    NymApi,
+    GeoAware(GroupBy),
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum GroupBy {
+    CountryGroup(CountryGroup),
+    NymAddress(Recipient),
+}
+
+impl std::fmt::Display for GroupBy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GroupBy::CountryGroup(group) => write!(f, "group: {}", group),
+            GroupBy::NymAddress(address) => write!(f, "address: {}", address),
+        }
+    }
+}
+
+impl Default for Topology {
+    fn default() -> Self {
+        Topology {
+            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
+            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
+            disable_refreshing: false,
+            max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
+            topology_structure: TopologyStructure::default(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct ReplySurbs {
+    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
+    /// It can only allow to go below that value if its to request additional reply surbs.
+    pub minimum_reply_surb_storage_threshold: usize,
+
+    /// Defines the maximum number of reply surbs the client wants to keep in its storage at any times.
+    pub maximum_reply_surb_storage_threshold: usize,
+
+    /// Defines the minimum number of reply surbs the client would request.
+    pub minimum_reply_surb_request_size: u32,
+
+    /// Defines the maximum number of reply surbs the client would request.
+    pub maximum_reply_surb_request_size: u32,
+
+    /// Defines the maximum number of reply surbs a remote party is allowed to request from this client at once.
+    pub maximum_allowed_reply_surb_request_size: u32,
+
+    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
+    /// for more even though in theory they wouldn't need to.
+    #[serde(with = "humantime_serde")]
+    pub maximum_reply_surb_rerequest_waiting_period: Duration,
+
+    /// Defines maximum amount of time the client is going to wait for reply surbs before
+    /// deciding it's never going to get them and would drop all pending messages
+    #[serde(with = "humantime_serde")]
+    pub maximum_reply_surb_drop_waiting_period: Duration,
+
+    /// Defines maximum amount of time given reply surb is going to be valid for.
+    /// This is going to be superseded by key rotation once implemented.
+    #[serde(with = "humantime_serde")]
+    pub maximum_reply_surb_age: Duration,
+
+    /// Defines maximum amount of time given reply key is going to be valid for.
+    /// This is going to be superseded by key rotation once implemented.
+    #[serde(with = "humantime_serde")]
+    pub maximum_reply_key_age: Duration,
+
+    /// Specifies the number of mixnet hops the packet should go through. If not specified, then
+    /// the default value is used.
+    pub surb_mix_hops: Option<u8>,
+}
+
+impl Default for ReplySurbs {
+    fn default() -> Self {
+        ReplySurbs {
+            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
+            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
+            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
+            maximum_reply_surb_request_size: DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
+            maximum_allowed_reply_surb_request_size: DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
+            maximum_reply_surb_rerequest_waiting_period:
+                DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
+            maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
+            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
+            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
+            surb_mix_hops: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct DebugConfig {
+    /// Defines all configuration options related to traffic streams.
+    pub traffic: Traffic,
+
+    /// Defines all configuration options related to cover traffic stream(s).
+    pub cover_traffic: CoverTraffic,
+
+    /// Defines all configuration options related to the gateway connection.
+    pub gateway_connection: GatewayConnection,
+
+    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
+    pub acknowledgements: Acknowledgements,
+
+    /// Defines all configuration options related topology, such as refresh rates or timeouts.
+    pub topology: Topology,
+
+    /// Defines all configuration options related to reply SURBs.
+    pub reply_surbs: ReplySurbs,
+}
+
+impl DebugConfig {
+    pub fn validate(&self) -> bool {
+        // no other sections have explicit requirements (yet)
+        self.traffic.validate()
+    }
+}
+
+// it could be derived, sure, but I'd rather have an explicit implementation in case we had to change
+// something manually at some point
+#[allow(clippy::derivable_impls)]
+impl Default for DebugConfig {
+    fn default() -> Self {
+        DebugConfig {
+            traffic: Default::default(),
+            cover_traffic: Default::default(),
+            gateway_connection: Default::default(),
+            acknowledgements: Default::default(),
+            topology: Default::default(),
+            reply_surbs: Default::default(),
+        }
+    }
+}
@@ -1,28 +1,23 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::old::v2::{
-    AcknowledgementsV2, ClientV2, ConfigV2, CoverTrafficV2, DebugConfigV2, GatewayConnectionV2,
-    LoggingV2, ReplySurbsV2, TopologyV2, TrafficV2, DEFAULT_ACK_WAIT_ADDITION,
-    DEFAULT_ACK_WAIT_MULTIPLIER, DEFAULT_AVERAGE_PACKET_DELAY, DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-    DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY, DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
-    DEFAULT_MAXIMUM_REPLY_KEY_AGE, DEFAULT_MAXIMUM_REPLY_SURB_AGE,
-    DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD, DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
-    DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
+use crate::config::old_config_v1_1_20::{
+    AcknowledgementsV1_1_20, ClientV1_1_20, ConfigV1_1_20, CoverTrafficV1_1_20, DebugConfigV1_1_20,
+    GatewayConnectionV1_1_20, LoggingV1_1_20, ReplySurbsV1_1_20, TopologyV1_1_20, TrafficV1_1_20,
+    DEFAULT_ACK_WAIT_ADDITION, DEFAULT_ACK_WAIT_MULTIPLIER, DEFAULT_AVERAGE_PACKET_DELAY,
+    DEFAULT_GATEWAY_RESPONSE_TIMEOUT, DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
+    DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE, DEFAULT_MAXIMUM_REPLY_KEY_AGE,
+    DEFAULT_MAXIMUM_REPLY_SURB_AGE, DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
+    DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE, DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
    DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD, DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
    DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE, DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
    DEFAULT_TOPOLOGY_REFRESH_RATE, DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
 };
-use nym_sphinx_params::PacketSize;
+use nym_sphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::time::Duration;

-// aliases for backwards compatibility
-pub type OldConfigV1_1_13<T> = ConfigV1<T>;
-pub type OldLoggingV1_1_13 = LoggingV1;
-pub type OldDebugConfigV1_1_13 = DebugConfigV1;
-
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 pub enum ExtendedPacketSize {
@@ -43,28 +38,28 @@ impl From<ExtendedPacketSize> for PacketSize {

 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV1<T> {
-    pub client: ClientV2<T>,
+pub struct OldConfigV1_1_13<T> {
+    pub client: ClientV1_1_20<T>,

    #[serde(default)]
-    pub logging: LoggingV1,
+    pub logging: OldLoggingV1_1_13,
    #[serde(default)]
-    pub debug: DebugConfigV1,
+    pub debug: OldDebugConfigV1_1_13,
 }

 #[derive(Debug, Clone, Default, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct LoggingV1 {}
+pub struct OldLoggingV1_1_13 {}

-impl From<LoggingV1> for LoggingV2 {
-    fn from(_value: LoggingV1) -> Self {
-        LoggingV2 {}
+impl From<OldLoggingV1_1_13> for LoggingV1_1_20 {
+    fn from(_value: OldLoggingV1_1_13) -> Self {
+        LoggingV1_1_20 {}
    }
 }

 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV1 {
+pub struct OldDebugConfigV1_1_13 {
    #[serde(with = "humantime_serde")]
    pub average_packet_delay: Duration,

@@ -119,10 +114,10 @@ pub struct DebugConfigV1 {
    pub maximum_reply_key_age: Duration,
 }

-impl From<DebugConfigV1> for DebugConfigV2 {
-    fn from(value: DebugConfigV1) -> Self {
-        DebugConfigV2 {
-            traffic: TrafficV2 {
+impl From<OldDebugConfigV1_1_13> for DebugConfigV1_1_20 {
+    fn from(value: OldDebugConfigV1_1_13) -> Self {
+        DebugConfigV1_1_20 {
+            traffic: TrafficV1_1_20 {
                average_packet_delay: value.average_packet_delay,
                message_sending_average_delay: value.message_sending_average_delay,
                disable_main_poisson_packet_distribution: value
@@ -130,25 +125,25 @@ impl From<DebugConfigV1> for DebugConfigV2 {
                primary_packet_size: PacketSize::RegularPacket,
                secondary_packet_size: value.use_extended_packet_size.map(Into::into),
            },
-            cover_traffic: CoverTrafficV2 {
+            cover_traffic: CoverTrafficV1_1_20 {
                loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
                disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
-                ..CoverTrafficV2::default()
+                ..CoverTrafficV1_1_20::default()
            },
-            gateway_connection: GatewayConnectionV2 {
+            gateway_connection: GatewayConnectionV1_1_20 {
                gateway_response_timeout: value.gateway_response_timeout,
            },
-            acknowledgements: AcknowledgementsV2 {
+            acknowledgements: AcknowledgementsV1_1_20 {
                average_ack_delay: value.average_ack_delay,
                ack_wait_multiplier: value.ack_wait_multiplier,
                ack_wait_addition: value.ack_wait_addition,
            },
-            topology: TopologyV2 {
+            topology: TopologyV1_1_20 {
                topology_refresh_rate: value.topology_refresh_rate,
                topology_resolution_timeout: value.topology_resolution_timeout,
                disable_refreshing: false,
            },
-            reply_surbs: ReplySurbsV2 {
+            reply_surbs: ReplySurbsV1_1_20 {
                minimum_reply_surb_storage_threshold: value.minimum_reply_surb_storage_threshold,
                maximum_reply_surb_storage_threshold: value.maximum_reply_surb_storage_threshold,
                minimum_reply_surb_request_size: value.minimum_reply_surb_request_size,
@@ -166,9 +161,9 @@ impl From<DebugConfigV1> for DebugConfigV2 {
    }
 }

-impl Default for DebugConfigV1 {
+impl Default for OldDebugConfigV1_1_13 {
    fn default() -> Self {
-        DebugConfigV1 {
+        OldDebugConfigV1_1_13 {
            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
@@ -195,10 +190,10 @@ impl Default for DebugConfigV1 {
    }
 }

-impl<T, U> From<ConfigV1<T>> for ConfigV2<U> {
-    fn from(value: ConfigV1<T>) -> Self {
-        ConfigV2 {
-            client: ClientV2 {
+impl<T, U> From<OldConfigV1_1_13<T>> for ConfigV1_1_20<U> {
+    fn from(value: OldConfigV1_1_13<T>) -> Self {
+        ConfigV1_1_20 {
+            client: ClientV1_1_20 {
                version: value.client.version,
                id: value.client.id,
                disabled_credentials_mode: value.client.disabled_credentials_mode,
@@ -1,11 +1,12 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::old::v3::{
-    AcknowledgementsV3, CoverTrafficV3, DebugConfigV3, GatewayConnectionV3,
-    GatewayEndpointConfigV3, ReplySurbsV3, TopologyV3, TrafficV3,
+use crate::config::old_config_v1_1_20_2::{
+    AcknowledgementsV1_1_20_2, CoverTrafficV1_1_20_2, DebugConfigV1_1_20_2,
+    GatewayConnectionV1_1_20_2, GatewayEndpointConfigV1_1_20_2, ReplySurbsV1_1_20_2,
+    TopologyV1_1_20_2, TrafficV1_1_20_2,
 };
-use nym_sphinx_params::{PacketSize, PacketType};
+use nym_sphinx::params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
@@ -53,41 +54,27 @@ pub(crate) const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(
 // 24 hours
 pub(crate) const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);

-// aliases for backwards compatibility
-pub type ConfigV1_1_20<T> = ConfigV2<T>;
-pub type ClientV1_1_20<T> = ClientV2<T>;
-pub type LoggingV1_1_20 = LoggingV2;
-pub type DebugConfigV1_1_20 = DebugConfigV2;
-pub type GatewayEndpointConfigV1_1_20 = GatewayEndpointConfigV2;
-
-pub type TrafficV1_1_20 = TrafficV2;
-pub type CoverTrafficV1_1_20 = CoverTrafficV2;
-pub type GatewayConnectionV1_1_20 = GatewayConnectionV2;
-pub type AcknowledgementsV1_1_20 = AcknowledgementsV2;
-pub type TopologyV1_1_20 = TopologyV2;
-pub type ReplySurbsV1_1_20 = ReplySurbsV2;
-
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV2<T> {
-    pub client: ClientV2<T>,
+pub struct ConfigV1_1_20<T> {
+    pub client: ClientV1_1_20<T>,

    #[serde(default)]
-    pub logging: LoggingV2,
+    pub logging: LoggingV1_1_20,
    #[serde(default)]
-    pub debug: DebugConfigV2,
+    pub debug: DebugConfigV1_1_20,
 }

 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
-pub struct GatewayEndpointConfigV2 {
+pub struct GatewayEndpointConfigV1_1_20 {
    pub gateway_id: String,
    pub gateway_owner: String,
    pub gateway_listener: String,
 }

-impl From<GatewayEndpointConfigV2> for GatewayEndpointConfigV3 {
-    fn from(value: GatewayEndpointConfigV2) -> Self {
-        GatewayEndpointConfigV3 {
+impl From<GatewayEndpointConfigV1_1_20> for GatewayEndpointConfigV1_1_20_2 {
+    fn from(value: GatewayEndpointConfigV1_1_20) -> Self {
+        GatewayEndpointConfigV1_1_20_2 {
            gateway_id: value.gateway_id,
            gateway_owner: value.gateway_owner,
            gateway_listener: value.gateway_listener,
@@ -96,7 +83,7 @@ impl From<GatewayEndpointConfigV2> for GatewayEndpointConfigV3 {
 }

 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-pub struct ClientV2<T> {
+pub struct ClientV1_1_20<T> {
    pub version: String,
    pub id: String,
    #[serde(default)]
@@ -111,7 +98,7 @@ pub struct ClientV2<T> {
    pub public_encryption_key_file: PathBuf,
    pub gateway_shared_key_file: PathBuf,
    pub ack_key_file: PathBuf,
-    pub gateway_endpoint: GatewayEndpointConfigV2,
+    pub gateway_endpoint: GatewayEndpointConfigV1_1_20,
    pub database_path: PathBuf,
    #[serde(default)]
    pub reply_surb_database_path: PathBuf,
@@ -123,11 +110,11 @@ pub struct ClientV2<T> {

 #[derive(Debug, Clone, Default, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct LoggingV2 {}
+pub struct LoggingV1_1_20 {}

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default)]
-pub struct TrafficV2 {
+pub struct TrafficV1_1_20 {
    #[serde(with = "humantime_serde")]
    pub average_packet_delay: Duration,
    #[serde(with = "humantime_serde")]
@@ -137,9 +124,9 @@ pub struct TrafficV2 {
    pub secondary_packet_size: Option<PacketSize>,
 }

-impl From<TrafficV2> for TrafficV3 {
-    fn from(value: TrafficV2) -> Self {
-        TrafficV3 {
+impl From<TrafficV1_1_20> for TrafficV1_1_20_2 {
+    fn from(value: TrafficV1_1_20) -> Self {
+        TrafficV1_1_20_2 {
            average_packet_delay: value.average_packet_delay,
            message_sending_average_delay: value.message_sending_average_delay,
            disable_main_poisson_packet_distribution: value
@@ -151,9 +138,9 @@ impl From<TrafficV2> for TrafficV3 {
    }
 }

-impl Default for TrafficV2 {
+impl Default for TrafficV1_1_20 {
    fn default() -> Self {
-        TrafficV2 {
+        TrafficV1_1_20 {
            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
            disable_main_poisson_packet_distribution: false,
@@ -165,16 +152,16 @@ impl Default for TrafficV2 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct CoverTrafficV2 {
+pub struct CoverTrafficV1_1_20 {
    #[serde(with = "humantime_serde")]
    pub loop_cover_traffic_average_delay: Duration,
    pub cover_traffic_primary_size_ratio: f64,
    pub disable_loop_cover_traffic_stream: bool,
 }

-impl From<CoverTrafficV2> for CoverTrafficV3 {
-    fn from(value: CoverTrafficV2) -> Self {
-        CoverTrafficV3 {
+impl From<CoverTrafficV1_1_20> for CoverTrafficV1_1_20_2 {
+    fn from(value: CoverTrafficV1_1_20) -> Self {
+        CoverTrafficV1_1_20_2 {
            loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
            cover_traffic_primary_size_ratio: value.cover_traffic_primary_size_ratio,
            disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
@@ -182,9 +169,9 @@ impl From<CoverTrafficV2> for CoverTrafficV3 {
    }
 }

-impl Default for CoverTrafficV2 {
+impl Default for CoverTrafficV1_1_20 {
    fn default() -> Self {
-        CoverTrafficV2 {
+        CoverTrafficV1_1_20 {
            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
            disable_loop_cover_traffic_stream: false,
@@ -194,22 +181,22 @@ impl Default for CoverTrafficV2 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct GatewayConnectionV2 {
+pub struct GatewayConnectionV1_1_20 {
    #[serde(with = "humantime_serde")]
    pub gateway_response_timeout: Duration,
 }

-impl From<GatewayConnectionV2> for GatewayConnectionV3 {
-    fn from(value: GatewayConnectionV2) -> Self {
-        GatewayConnectionV3 {
+impl From<GatewayConnectionV1_1_20> for GatewayConnectionV1_1_20_2 {
+    fn from(value: GatewayConnectionV1_1_20) -> Self {
+        GatewayConnectionV1_1_20_2 {
            gateway_response_timeout: value.gateway_response_timeout,
        }
    }
 }

-impl Default for GatewayConnectionV2 {
+impl Default for GatewayConnectionV1_1_20 {
    fn default() -> Self {
-        GatewayConnectionV2 {
+        GatewayConnectionV1_1_20 {
            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
        }
    }
@@ -217,7 +204,7 @@ impl Default for GatewayConnectionV2 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct AcknowledgementsV2 {
+pub struct AcknowledgementsV1_1_20 {
    #[serde(with = "humantime_serde")]
    pub average_ack_delay: Duration,
    pub ack_wait_multiplier: f64,
@@ -225,9 +212,9 @@ pub struct AcknowledgementsV2 {
    pub ack_wait_addition: Duration,
 }

-impl From<AcknowledgementsV2> for AcknowledgementsV3 {
-    fn from(value: AcknowledgementsV2) -> Self {
-        AcknowledgementsV3 {
+impl From<AcknowledgementsV1_1_20> for AcknowledgementsV1_1_20_2 {
+    fn from(value: AcknowledgementsV1_1_20) -> Self {
+        AcknowledgementsV1_1_20_2 {
            average_ack_delay: value.average_ack_delay,
            ack_wait_multiplier: value.ack_wait_multiplier,
            ack_wait_addition: value.ack_wait_addition,
@@ -235,9 +222,9 @@ impl From<AcknowledgementsV2> for AcknowledgementsV3 {
    }
 }

-impl Default for AcknowledgementsV2 {
+impl Default for AcknowledgementsV1_1_20 {
    fn default() -> Self {
-        AcknowledgementsV2 {
+        AcknowledgementsV1_1_20 {
            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
@@ -247,7 +234,7 @@ impl Default for AcknowledgementsV2 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TopologyV2 {
+pub struct TopologyV1_1_20 {
    #[serde(with = "humantime_serde")]
    pub topology_refresh_rate: Duration,
    #[serde(with = "humantime_serde")]
@@ -255,9 +242,9 @@ pub struct TopologyV2 {
    pub disable_refreshing: bool,
 }

-impl From<TopologyV2> for TopologyV3 {
-    fn from(value: TopologyV2) -> Self {
-        TopologyV3 {
+impl From<TopologyV1_1_20> for TopologyV1_1_20_2 {
+    fn from(value: TopologyV1_1_20) -> Self {
+        TopologyV1_1_20_2 {
            topology_refresh_rate: value.topology_refresh_rate,
            topology_resolution_timeout: value.topology_resolution_timeout,
            disable_refreshing: value.disable_refreshing,
@@ -265,9 +252,9 @@ impl From<TopologyV2> for TopologyV3 {
    }
 }

-impl Default for TopologyV2 {
+impl Default for TopologyV1_1_20 {
    fn default() -> Self {
-        TopologyV2 {
+        TopologyV1_1_20 {
            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
            disable_refreshing: false,
@@ -277,7 +264,7 @@ impl Default for TopologyV2 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct ReplySurbsV2 {
+pub struct ReplySurbsV1_1_20 {
    pub minimum_reply_surb_storage_threshold: usize,
    pub maximum_reply_surb_storage_threshold: usize,
    pub minimum_reply_surb_request_size: u32,
@@ -293,9 +280,9 @@ pub struct ReplySurbsV2 {
    pub maximum_reply_key_age: Duration,
 }

-impl From<ReplySurbsV2> for ReplySurbsV3 {
-    fn from(value: ReplySurbsV2) -> Self {
-        ReplySurbsV3 {
+impl From<ReplySurbsV1_1_20> for ReplySurbsV1_1_20_2 {
+    fn from(value: ReplySurbsV1_1_20) -> Self {
+        ReplySurbsV1_1_20_2 {
            minimum_reply_surb_storage_threshold: value.minimum_reply_surb_storage_threshold,
            maximum_reply_surb_storage_threshold: value.maximum_reply_surb_storage_threshold,
            minimum_reply_surb_request_size: value.minimum_reply_surb_request_size,
@@ -310,9 +297,9 @@ impl From<ReplySurbsV2> for ReplySurbsV3 {
    }
 }

-impl Default for ReplySurbsV2 {
+impl Default for ReplySurbsV1_1_20 {
    fn default() -> Self {
-        ReplySurbsV2 {
+        ReplySurbsV1_1_20 {
            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -329,18 +316,18 @@ impl Default for ReplySurbsV2 {

 #[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV2 {
-    pub traffic: TrafficV2,
-    pub cover_traffic: CoverTrafficV2,
-    pub gateway_connection: GatewayConnectionV2,
-    pub acknowledgements: AcknowledgementsV2,
-    pub topology: TopologyV2,
-    pub reply_surbs: ReplySurbsV2,
+pub struct DebugConfigV1_1_20 {
+    pub traffic: TrafficV1_1_20,
+    pub cover_traffic: CoverTrafficV1_1_20,
+    pub gateway_connection: GatewayConnectionV1_1_20,
+    pub acknowledgements: AcknowledgementsV1_1_20,
+    pub topology: TopologyV1_1_20,
+    pub reply_surbs: ReplySurbsV1_1_20,
 }

-impl From<DebugConfigV2> for DebugConfigV3 {
-    fn from(value: DebugConfigV2) -> Self {
-        DebugConfigV3 {
+impl From<DebugConfigV1_1_20> for DebugConfigV1_1_20_2 {
+    fn from(value: DebugConfigV1_1_20) -> Self {
+        DebugConfigV1_1_20_2 {
            traffic: value.traffic.into(),
            cover_traffic: value.cover_traffic.into(),
            gateway_connection: value.gateway_connection.into(),
@@ -1,12 +1,12 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::old::v4::{
-    AcknowledgementsV4, ClientV4, ConfigV4, CoverTrafficV4, DebugConfigV4, GatewayConnectionV4,
-    ReplySurbsV4, TopologyV4, TrafficV4,
+use crate::config::old_config_v1_1_30::{
+    AcknowledgementsV1_1_30, ClientV1_1_30, ConfigV1_1_30, CoverTrafficV1_1_30, DebugConfigV1_1_30,
+    GatewayConnectionV1_1_30, ReplySurbsV1_1_30, TopologyV1_1_30, TrafficV1_1_30,
 };
-use crate::old::v5::GatewayEndpointConfigV5;
-use nym_sphinx_params::{PacketSize, PacketType};
+use crate::config::old_config_v1_1_33::OldGatewayEndpointConfigV1_1_33;
+use nym_sphinx::params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -50,31 +50,18 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);

-// aliases for backwards compatibility
-pub type ConfigV1_1_20_2 = ConfigV3;
-pub type ClientV1_1_20_2 = ClientV3;
-pub type DebugConfigV1_1_20_2 = DebugConfigV3;
-pub type GatewayEndpointConfigV1_1_20_2 = GatewayEndpointConfigV3;
-
-pub type TrafficV1_1_20_2 = TrafficV3;
-pub type CoverTrafficV1_1_20_2 = CoverTrafficV3;
-pub type GatewayConnectionV1_1_20_2 = GatewayConnectionV3;
-pub type AcknowledgementsV1_1_20_2 = AcknowledgementsV3;
-pub type TopologyV1_1_20_2 = TopologyV3;
-pub type ReplySurbsV1_1_20_2 = ReplySurbsV3;
-
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV3 {
-    pub client: ClientV3,
+pub struct ConfigV1_1_20_2 {
+    pub client: ClientV1_1_20_2,

    #[serde(default)]
-    pub debug: DebugConfigV3,
+    pub debug: DebugConfigV1_1_20_2,
 }

-impl From<ConfigV3> for ConfigV4 {
-    fn from(value: ConfigV3) -> Self {
-        ConfigV4 {
+impl From<ConfigV1_1_20_2> for ConfigV1_1_30 {
+    fn from(value: ConfigV1_1_20_2) -> Self {
+        ConfigV1_1_30 {
            client: value.client.into(),
            debug: value.debug.into(),
        }
@@ -82,7 +69,7 @@ impl From<ConfigV3> for ConfigV4 {
 }

 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
-pub struct GatewayEndpointConfigV3 {
+pub struct GatewayEndpointConfigV1_1_20_2 {
    /// gateway_id specifies ID of the gateway to which the client should send messages.
    /// If initially omitted, a random gateway will be chosen from the available topology.
    pub gateway_id: String,
@@ -94,9 +81,9 @@ pub struct GatewayEndpointConfigV3 {
    pub gateway_listener: String,
 }

-impl From<GatewayEndpointConfigV3> for GatewayEndpointConfigV5 {
-    fn from(value: GatewayEndpointConfigV3) -> Self {
-        GatewayEndpointConfigV5 {
+impl From<GatewayEndpointConfigV1_1_20_2> for OldGatewayEndpointConfigV1_1_33 {
+    fn from(value: GatewayEndpointConfigV1_1_20_2) -> Self {
+        OldGatewayEndpointConfigV1_1_33 {
            gateway_id: value.gateway_id,
            gateway_owner: value.gateway_owner,
            gateway_listener: value.gateway_listener,
@@ -105,7 +92,7 @@ impl From<GatewayEndpointConfigV3> for GatewayEndpointConfigV5 {
 }

 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-pub struct ClientV3 {
+pub struct ClientV1_1_20_2 {
    pub version: String,

    pub id: String,
@@ -118,12 +105,12 @@ pub struct ClientV3 {

    #[serde(alias = "validator_api_urls")]
    pub nym_api_urls: Vec<Url>,
-    pub gateway_endpoint: GatewayEndpointConfigV3,
+    pub gateway_endpoint: GatewayEndpointConfigV1_1_20_2,
 }

-impl From<ClientV3> for ClientV4 {
-    fn from(value: ClientV3) -> Self {
-        ClientV4 {
+impl From<ClientV1_1_20_2> for ClientV1_1_30 {
+    fn from(value: ClientV1_1_20_2) -> Self {
+        ClientV1_1_30 {
            version: value.version,
            id: value.id,
            disabled_credentials_mode: value.disabled_credentials_mode,
@@ -135,7 +122,7 @@ impl From<ClientV3> for ClientV4 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default)]
-pub struct TrafficV3 {
+pub struct TrafficV1_1_20_2 {
    #[serde(with = "humantime_serde")]
    pub average_packet_delay: Duration,
    #[serde(with = "humantime_serde")]
@@ -146,9 +133,9 @@ pub struct TrafficV3 {
    pub packet_type: PacketType,
 }

-impl From<TrafficV3> for TrafficV4 {
-    fn from(value: TrafficV3) -> Self {
-        TrafficV4 {
+impl From<TrafficV1_1_20_2> for TrafficV1_1_30 {
+    fn from(value: TrafficV1_1_20_2) -> Self {
+        TrafficV1_1_30 {
            average_packet_delay: value.average_packet_delay,
            message_sending_average_delay: value.message_sending_average_delay,
            disable_main_poisson_packet_distribution: value
@@ -160,9 +147,9 @@ impl From<TrafficV3> for TrafficV4 {
    }
 }

-impl Default for TrafficV3 {
+impl Default for TrafficV1_1_20_2 {
    fn default() -> Self {
-        TrafficV3 {
+        TrafficV1_1_20_2 {
            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
            disable_main_poisson_packet_distribution: false,
@@ -175,16 +162,16 @@ impl Default for TrafficV3 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct CoverTrafficV3 {
+pub struct CoverTrafficV1_1_20_2 {
    #[serde(with = "humantime_serde")]
    pub loop_cover_traffic_average_delay: Duration,
    pub cover_traffic_primary_size_ratio: f64,
    pub disable_loop_cover_traffic_stream: bool,
 }

-impl From<CoverTrafficV3> for CoverTrafficV4 {
-    fn from(value: CoverTrafficV3) -> Self {
-        CoverTrafficV4 {
+impl From<CoverTrafficV1_1_20_2> for CoverTrafficV1_1_30 {
+    fn from(value: CoverTrafficV1_1_20_2) -> Self {
+        CoverTrafficV1_1_30 {
            loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
            cover_traffic_primary_size_ratio: value.cover_traffic_primary_size_ratio,
            disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
@@ -192,9 +179,9 @@ impl From<CoverTrafficV3> for CoverTrafficV4 {
    }
 }

-impl Default for CoverTrafficV3 {
+impl Default for CoverTrafficV1_1_20_2 {
    fn default() -> Self {
-        CoverTrafficV3 {
+        CoverTrafficV1_1_20_2 {
            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
            disable_loop_cover_traffic_stream: false,
@@ -204,22 +191,22 @@ impl Default for CoverTrafficV3 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct GatewayConnectionV3 {
+pub struct GatewayConnectionV1_1_20_2 {
    #[serde(with = "humantime_serde")]
    pub gateway_response_timeout: Duration,
 }

-impl From<GatewayConnectionV3> for GatewayConnectionV4 {
-    fn from(value: GatewayConnectionV3) -> Self {
-        GatewayConnectionV4 {
+impl From<GatewayConnectionV1_1_20_2> for GatewayConnectionV1_1_30 {
+    fn from(value: GatewayConnectionV1_1_20_2) -> Self {
+        GatewayConnectionV1_1_30 {
            gateway_response_timeout: value.gateway_response_timeout,
        }
    }
 }

-impl Default for GatewayConnectionV3 {
+impl Default for GatewayConnectionV1_1_20_2 {
    fn default() -> Self {
-        GatewayConnectionV3 {
+        GatewayConnectionV1_1_20_2 {
            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
        }
    }
@@ -227,7 +214,7 @@ impl Default for GatewayConnectionV3 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct AcknowledgementsV3 {
+pub struct AcknowledgementsV1_1_20_2 {
    #[serde(with = "humantime_serde")]
    pub average_ack_delay: Duration,
    pub ack_wait_multiplier: f64,
@@ -235,9 +222,9 @@ pub struct AcknowledgementsV3 {
    pub ack_wait_addition: Duration,
 }

-impl From<AcknowledgementsV3> for AcknowledgementsV4 {
-    fn from(value: AcknowledgementsV3) -> Self {
-        AcknowledgementsV4 {
+impl From<AcknowledgementsV1_1_20_2> for AcknowledgementsV1_1_30 {
+    fn from(value: AcknowledgementsV1_1_20_2) -> Self {
+        AcknowledgementsV1_1_30 {
            average_ack_delay: value.average_ack_delay,
            ack_wait_multiplier: value.ack_wait_multiplier,
            ack_wait_addition: value.ack_wait_addition,
@@ -245,9 +232,9 @@ impl From<AcknowledgementsV3> for AcknowledgementsV4 {
    }
 }

-impl Default for AcknowledgementsV3 {
+impl Default for AcknowledgementsV1_1_20_2 {
    fn default() -> Self {
-        AcknowledgementsV3 {
+        AcknowledgementsV1_1_20_2 {
            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
@@ -257,7 +244,7 @@ impl Default for AcknowledgementsV3 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TopologyV3 {
+pub struct TopologyV1_1_20_2 {
    #[serde(with = "humantime_serde")]
    pub topology_refresh_rate: Duration,
    #[serde(with = "humantime_serde")]
@@ -265,9 +252,9 @@ pub struct TopologyV3 {
    pub disable_refreshing: bool,
 }

-impl Default for TopologyV3 {
+impl Default for TopologyV1_1_20_2 {
    fn default() -> Self {
-        TopologyV3 {
+        TopologyV1_1_20_2 {
            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
            disable_refreshing: false,
@@ -275,9 +262,9 @@ impl Default for TopologyV3 {
    }
 }

-impl From<TopologyV3> for TopologyV4 {
-    fn from(value: TopologyV3) -> Self {
-        TopologyV4 {
+impl From<TopologyV1_1_20_2> for TopologyV1_1_30 {
+    fn from(value: TopologyV1_1_20_2) -> Self {
+        TopologyV1_1_30 {
            topology_refresh_rate: value.topology_refresh_rate,
            topology_resolution_timeout: value.topology_resolution_timeout,
            disable_refreshing: value.disable_refreshing,
@@ -288,7 +275,7 @@ impl From<TopologyV3> for TopologyV4 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct ReplySurbsV3 {
+pub struct ReplySurbsV1_1_20_2 {
    pub minimum_reply_surb_storage_threshold: usize,
    pub maximum_reply_surb_storage_threshold: usize,
    pub minimum_reply_surb_request_size: u32,
@@ -304,9 +291,9 @@ pub struct ReplySurbsV3 {
    pub maximum_reply_key_age: Duration,
 }

-impl Default for ReplySurbsV3 {
+impl Default for ReplySurbsV1_1_20_2 {
    fn default() -> Self {
-        ReplySurbsV3 {
+        ReplySurbsV1_1_20_2 {
            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -321,9 +308,9 @@ impl Default for ReplySurbsV3 {
    }
 }

-impl From<ReplySurbsV3> for ReplySurbsV4 {
-    fn from(value: ReplySurbsV3) -> Self {
-        ReplySurbsV4 {
+impl From<ReplySurbsV1_1_20_2> for ReplySurbsV1_1_30 {
+    fn from(value: ReplySurbsV1_1_20_2) -> Self {
+        ReplySurbsV1_1_30 {
            minimum_reply_surb_storage_threshold: value.minimum_reply_surb_storage_threshold,
            maximum_reply_surb_storage_threshold: value.maximum_reply_surb_storage_threshold,
            minimum_reply_surb_request_size: value.minimum_reply_surb_request_size,
@@ -340,18 +327,18 @@ impl From<ReplySurbsV3> for ReplySurbsV4 {

 #[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV3 {
-    pub traffic: TrafficV3,
-    pub cover_traffic: CoverTrafficV3,
-    pub gateway_connection: GatewayConnectionV3,
-    pub acknowledgements: AcknowledgementsV3,
-    pub topology: TopologyV3,
-    pub reply_surbs: ReplySurbsV3,
+pub struct DebugConfigV1_1_20_2 {
+    pub traffic: TrafficV1_1_20_2,
+    pub cover_traffic: CoverTrafficV1_1_20_2,
+    pub gateway_connection: GatewayConnectionV1_1_20_2,
+    pub acknowledgements: AcknowledgementsV1_1_20_2,
+    pub topology: TopologyV1_1_20_2,
+    pub reply_surbs: ReplySurbsV1_1_20_2,
 }

-impl From<DebugConfigV3> for DebugConfigV4 {
-    fn from(value: DebugConfigV3) -> Self {
-        DebugConfigV4 {
+impl From<DebugConfigV1_1_20_2> for DebugConfigV1_1_30 {
+    fn from(value: DebugConfigV1_1_20_2) -> Self {
+        DebugConfigV1_1_30 {
            traffic: value.traffic.into(),
            cover_traffic: value.cover_traffic.into(),
            gateway_connection: value.gateway_connection.into(),
@@ -1,13 +1,16 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::old::v5::{
-    AcknowledgementsV5, ClientV5, ConfigV5, CoverTrafficV5, DebugConfigV5, GatewayConnectionV5,
-    GroupByV5, ReplySurbsV5, TopologyStructureV5, TopologyV5, TrafficV5,
+use crate::client::topology_control::geo_aware_provider::CountryGroup;
+use crate::config::old_config_v1_1_33::{
+    AcknowledgementsV1_1_33, ClientV1_1_33, ConfigV1_1_33, CoverTrafficV1_1_33, DebugConfigV1_1_33,
+    GatewayConnectionV1_1_33, GroupByV1_1_33, ReplySurbsV1_1_33, TopologyStructureV1_1_33,
+    TopologyV1_1_33, TrafficV1_1_33,
+};
+use nym_sphinx::{
+    addressing::clients::Recipient,
+    params::{PacketSize, PacketType},
 };
-use crate::CountryGroup;
-use nym_sphinx_addressing::Recipient;
-use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -53,39 +56,27 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);

-// aliases for backwards compatibility
-pub type ConfigV1_1_30 = ConfigV4;
-pub type ClientV1_1_30 = ClientV4;
-pub type DebugConfigV1_1_30 = DebugConfigV4;
-
-pub type TrafficV1_1_30 = TrafficV4;
-pub type CoverTrafficV1_1_30 = CoverTrafficV4;
-pub type GatewayConnectionV1_1_30 = GatewayConnectionV4;
-pub type AcknowledgementsV1_1_30 = AcknowledgementsV4;
-pub type TopologyV1_1_30 = TopologyV4;
-pub type ReplySurbsV1_1_30 = ReplySurbsV4;
-
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV4 {
-    pub client: ClientV4,
+pub struct ConfigV1_1_30 {
+    pub client: ClientV1_1_30,

    #[serde(default)]
-    pub debug: DebugConfigV4,
+    pub debug: DebugConfigV1_1_30,
 }

-impl From<ConfigV4> for ConfigV5 {
-    fn from(value: ConfigV4) -> Self {
-        ConfigV5 {
-            client: ClientV5 {
+impl From<ConfigV1_1_30> for ConfigV1_1_33 {
+    fn from(value: ConfigV1_1_30) -> Self {
+        ConfigV1_1_33 {
+            client: ClientV1_1_33 {
                version: value.client.version,
                id: value.client.id,
                disabled_credentials_mode: value.client.disabled_credentials_mode,
                nyxd_urls: value.client.nyxd_urls,
                nym_api_urls: value.client.nym_api_urls,
            },
-            debug: DebugConfigV5 {
-                traffic: TrafficV5 {
+            debug: DebugConfigV1_1_33 {
+                traffic: TrafficV1_1_33 {
                    average_packet_delay: value.debug.traffic.average_packet_delay,
                    message_sending_average_delay: value
                        .debug
@@ -99,7 +90,7 @@ impl From<ConfigV4> for ConfigV5 {
                    secondary_packet_size: value.debug.traffic.secondary_packet_size,
                    packet_type: value.debug.traffic.packet_type,
                },
-                cover_traffic: CoverTrafficV5 {
+                cover_traffic: CoverTrafficV1_1_33 {
                    loop_cover_traffic_average_delay: value
                        .debug
                        .cover_traffic
@@ -113,18 +104,18 @@ impl From<ConfigV4> for ConfigV5 {
                        .cover_traffic
                        .disable_loop_cover_traffic_stream,
                },
-                gateway_connection: GatewayConnectionV5 {
+                gateway_connection: GatewayConnectionV1_1_33 {
                    gateway_response_timeout: value
                        .debug
                        .gateway_connection
                        .gateway_response_timeout,
                },
-                acknowledgements: AcknowledgementsV5 {
+                acknowledgements: AcknowledgementsV1_1_33 {
                    average_ack_delay: value.debug.acknowledgements.average_ack_delay,
                    ack_wait_multiplier: value.debug.acknowledgements.ack_wait_multiplier,
                    ack_wait_addition: value.debug.acknowledgements.ack_wait_addition,
                },
-                topology: TopologyV5 {
+                topology: TopologyV1_1_33 {
                    topology_refresh_rate: value.debug.topology.topology_refresh_rate,
                    topology_resolution_timeout: value.debug.topology.topology_resolution_timeout,
                    disable_refreshing: value.debug.topology.disable_refreshing,
@@ -134,7 +125,7 @@ impl From<ConfigV4> for ConfigV5 {
                        .max_startup_gateway_waiting_period,
                    topology_structure: value.debug.topology.topology_structure.into(),
                },
-                reply_surbs: ReplySurbsV5 {
+                reply_surbs: ReplySurbsV1_1_33 {
                    minimum_reply_surb_storage_threshold: value
                        .debug
                        .reply_surbs
@@ -178,7 +169,7 @@ impl From<ConfigV4> for ConfigV5 {
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 // note: the deny_unknown_fields is VITAL here to allow upgrades from v1.1.20_2
 #[serde(deny_unknown_fields)]
-pub struct ClientV4 {
+pub struct ClientV1_1_30 {
    /// Version of the client for which this configuration was created.
    pub version: String,

@@ -202,7 +193,7 @@ pub struct ClientV4 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TrafficV4 {
+pub struct TrafficV1_1_30 {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent packet is going to be delayed at any given mix node.
    /// So for a packet going through three mix nodes, on average, it will take three times this value
@@ -233,9 +224,9 @@ pub struct TrafficV4 {
    pub packet_type: PacketType,
 }

-impl Default for TrafficV4 {
+impl Default for TrafficV1_1_30 {
    fn default() -> Self {
-        TrafficV4 {
+        TrafficV1_1_30 {
            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
            disable_main_poisson_packet_distribution: false,
@@ -248,7 +239,7 @@ impl Default for TrafficV4 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct CoverTrafficV4 {
+pub struct CoverTrafficV1_1_30 {
    /// The parameter of Poisson distribution determining how long, on average,
    /// it is going to take for another loop cover traffic message to be sent.
    #[serde(with = "humantime_serde")]
@@ -263,9 +254,9 @@ pub struct CoverTrafficV4 {
    pub disable_loop_cover_traffic_stream: bool,
 }

-impl Default for CoverTrafficV4 {
+impl Default for CoverTrafficV1_1_30 {
    fn default() -> Self {
-        CoverTrafficV4 {
+        CoverTrafficV1_1_30 {
            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
            disable_loop_cover_traffic_stream: false,
@@ -275,16 +266,16 @@ impl Default for CoverTrafficV4 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct GatewayConnectionV4 {
+pub struct GatewayConnectionV1_1_30 {
    /// How long we're willing to wait for a response to a message sent to the gateway,
    /// before giving up on it.
    #[serde(with = "humantime_serde")]
    pub gateway_response_timeout: Duration,
 }

-impl Default for GatewayConnectionV4 {
+impl Default for GatewayConnectionV1_1_30 {
    fn default() -> Self {
-        GatewayConnectionV4 {
+        GatewayConnectionV1_1_30 {
            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
        }
    }
@@ -292,7 +283,7 @@ impl Default for GatewayConnectionV4 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct AcknowledgementsV4 {
+pub struct AcknowledgementsV1_1_30 {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent acknowledgement is going to be delayed at any given mix node.
    /// So for an ack going through three mix nodes, on average, it will take three times this value
@@ -312,9 +303,9 @@ pub struct AcknowledgementsV4 {
    pub ack_wait_addition: Duration,
 }

-impl Default for AcknowledgementsV4 {
+impl Default for AcknowledgementsV1_1_30 {
    fn default() -> Self {
-        AcknowledgementsV4 {
+        AcknowledgementsV1_1_30 {
            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
@@ -324,7 +315,7 @@ impl Default for AcknowledgementsV4 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TopologyV4 {
+pub struct TopologyV1_1_30 {
    /// The uniform delay every which clients are querying the directory server
    /// to try to obtain a compatible network topology to send sphinx packets through.
    #[serde(with = "humantime_serde")]
@@ -347,23 +338,23 @@ pub struct TopologyV4 {
    pub max_startup_gateway_waiting_period: Duration,

    /// Specifies the mixnode topology to be used for sending packets.
-    pub topology_structure: TopologyStructureV4,
+    pub topology_structure: TopologyStructureV1_1_30,
 }

 #[allow(clippy::large_enum_variant)]
 #[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TopologyStructureV4 {
+pub enum TopologyStructureV1_1_30 {
    #[default]
    NymApi,
-    GeoAware(GroupByV4),
+    GeoAware(GroupByV1_1_30),
 }

-impl From<TopologyStructureV4> for TopologyStructureV5 {
-    fn from(value: TopologyStructureV4) -> Self {
+impl From<TopologyStructureV1_1_30> for TopologyStructureV1_1_33 {
+    fn from(value: TopologyStructureV1_1_30) -> Self {
        match value {
-            TopologyStructureV4::NymApi => TopologyStructureV5::NymApi,
-            TopologyStructureV4::GeoAware(group_by) => {
-                TopologyStructureV5::GeoAware(group_by.into())
+            TopologyStructureV1_1_30::NymApi => TopologyStructureV1_1_33::NymApi,
+            TopologyStructureV1_1_30::GeoAware(group_by) => {
+                TopologyStructureV1_1_33::GeoAware(group_by.into())
            }
        }
    }
@@ -371,44 +362,44 @@ impl From<TopologyStructureV4> for TopologyStructureV5 {

 #[allow(clippy::large_enum_variant)]
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum GroupByV4 {
+pub enum GroupByV1_1_30 {
    CountryGroup(CountryGroup),
    NymAddress(Recipient),
 }

-impl From<GroupByV4> for GroupByV5 {
-    fn from(value: GroupByV4) -> Self {
+impl From<GroupByV1_1_30> for GroupByV1_1_33 {
+    fn from(value: GroupByV1_1_30) -> Self {
        match value {
-            GroupByV4::CountryGroup(country) => GroupByV5::CountryGroup(country),
-            GroupByV4::NymAddress(addr) => GroupByV5::NymAddress(addr),
+            GroupByV1_1_30::CountryGroup(country) => GroupByV1_1_33::CountryGroup(country),
+            GroupByV1_1_30::NymAddress(addr) => GroupByV1_1_33::NymAddress(addr),
        }
    }
 }

-impl std::fmt::Display for GroupByV4 {
+impl std::fmt::Display for GroupByV1_1_30 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            GroupByV4::CountryGroup(group) => write!(f, "group: {}", group),
-            GroupByV4::NymAddress(address) => write!(f, "address: {}", address),
+            GroupByV1_1_30::CountryGroup(group) => write!(f, "group: {}", group),
+            GroupByV1_1_30::NymAddress(address) => write!(f, "address: {}", address),
        }
    }
 }

-impl Default for TopologyV4 {
+impl Default for TopologyV1_1_30 {
    fn default() -> Self {
-        TopologyV4 {
+        TopologyV1_1_30 {
            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
            disable_refreshing: false,
            max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
-            topology_structure: TopologyStructureV4::default(),
+            topology_structure: TopologyStructureV1_1_30::default(),
        }
    }
 }

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct ReplySurbsV4 {
+pub struct ReplySurbsV1_1_30 {
    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
    /// It can only allow to go below that value if its to request additional reply surbs.
    pub minimum_reply_surb_storage_threshold: usize,
@@ -446,9 +437,9 @@ pub struct ReplySurbsV4 {
    pub maximum_reply_key_age: Duration,
 }

-impl Default for ReplySurbsV4 {
+impl Default for ReplySurbsV1_1_30 {
    fn default() -> Self {
-        ReplySurbsV4 {
+        ReplySurbsV1_1_30 {
            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -465,22 +456,22 @@ impl Default for ReplySurbsV4 {

 #[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV4 {
+pub struct DebugConfigV1_1_30 {
    /// Defines all configuration options related to traffic streams.
-    pub traffic: TrafficV4,
+    pub traffic: TrafficV1_1_30,

    /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTrafficV4,
+    pub cover_traffic: CoverTrafficV1_1_30,

    /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnectionV4,
+    pub gateway_connection: GatewayConnectionV1_1_30,

    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: AcknowledgementsV4,
+    pub acknowledgements: AcknowledgementsV1_1_30,

    /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: TopologyV4,
+    pub topology: TopologyV1_1_30,

    /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbsV4,
+    pub reply_surbs: ReplySurbsV1_1_30,
 }
@@ -1,12 +1,15 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::{
-    Acknowledgements, Client, Config, CountryGroup, CoverTraffic, DebugConfig, GatewayConnection,
-    GroupBy, ReplySurbs, Topology, TopologyStructure, Traffic,
+use crate::client::topology_control::geo_aware_provider::CountryGroup;
+use crate::config::{
+    Acknowledgements, Client, Config, CoverTraffic, DebugConfig, GatewayConnection, GroupBy,
+    ReplySurbs, Topology, TopologyStructure, Traffic,
+};
+use nym_sphinx::{
+    addressing::clients::Recipient,
+    params::{PacketSize, PacketType},
 };
-use nym_sphinx_addressing::Recipient;
-use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -52,21 +55,8 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);

-// aliases for backwards compatibility
-pub type ConfigV1_1_33 = ConfigV5;
-pub type ClientV1_1_33 = ClientV5;
-pub type DebugConfigV1_1_33 = DebugConfigV5;
-pub type OldGatewayEndpointConfigV1_1_33 = GatewayEndpointConfigV5;
-
-pub type TrafficV1_1_33 = TrafficV5;
-pub type CoverTrafficV1_1_33 = CoverTrafficV5;
-pub type GatewayConnectionV1_1_33 = GatewayConnectionV5;
-pub type AcknowledgementsV1_1_33 = AcknowledgementsV5;
-pub type TopologyV1_1_33 = TopologyV5;
-pub type ReplySurbsV1_1_33 = ReplySurbsV5;
-
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
-pub struct GatewayEndpointConfigV5 {
+pub struct OldGatewayEndpointConfigV1_1_33 {
    /// gateway_id specifies ID of the gateway to which the client should send messages.
    /// If initially omitted, a random gateway will be chosen from the available topology.
    pub gateway_id: String,
@@ -80,15 +70,15 @@ pub struct GatewayEndpointConfigV5 {

 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV5 {
-    pub client: ClientV5,
+pub struct ConfigV1_1_33 {
+    pub client: ClientV1_1_33,

    #[serde(default)]
-    pub debug: DebugConfigV5,
+    pub debug: DebugConfigV1_1_33,
 }

-impl From<ConfigV5> for Config {
-    fn from(value: ConfigV5) -> Self {
+impl From<ConfigV1_1_33> for Config {
+    fn from(value: ConfigV1_1_33) -> Self {
        Config {
            client: Client {
                version: value.client.version,
@@ -188,7 +178,7 @@ impl From<ConfigV5> for Config {
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 // note: the deny_unknown_fields is VITAL here to allow upgrades from v1.1.20_2
 #[serde(deny_unknown_fields)]
-pub struct ClientV5 {
+pub struct ClientV1_1_33 {
    /// Version of the client for which this configuration was created.
    pub version: String,

@@ -212,7 +202,7 @@ pub struct ClientV5 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TrafficV5 {
+pub struct TrafficV1_1_33 {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent packet is going to be delayed at any given mix node.
    /// So for a packet going through three mix nodes, on average, it will take three times this value
@@ -243,9 +233,9 @@ pub struct TrafficV5 {
    pub packet_type: PacketType,
 }

-impl Default for TrafficV5 {
+impl Default for TrafficV1_1_33 {
    fn default() -> Self {
-        TrafficV5 {
+        TrafficV1_1_33 {
            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
            disable_main_poisson_packet_distribution: false,
@@ -258,7 +248,7 @@ impl Default for TrafficV5 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct CoverTrafficV5 {
+pub struct CoverTrafficV1_1_33 {
    /// The parameter of Poisson distribution determining how long, on average,
    /// it is going to take for another loop cover traffic message to be sent.
    #[serde(with = "humantime_serde")]
@@ -273,9 +263,9 @@ pub struct CoverTrafficV5 {
    pub disable_loop_cover_traffic_stream: bool,
 }

-impl Default for CoverTrafficV5 {
+impl Default for CoverTrafficV1_1_33 {
    fn default() -> Self {
-        CoverTrafficV5 {
+        CoverTrafficV1_1_33 {
            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
            disable_loop_cover_traffic_stream: false,
@@ -285,16 +275,16 @@ impl Default for CoverTrafficV5 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct GatewayConnectionV5 {
+pub struct GatewayConnectionV1_1_33 {
    /// How long we're willing to wait for a response to a message sent to the gateway,
    /// before giving up on it.
    #[serde(with = "humantime_serde")]
    pub gateway_response_timeout: Duration,
 }

-impl Default for GatewayConnectionV5 {
+impl Default for GatewayConnectionV1_1_33 {
    fn default() -> Self {
-        GatewayConnectionV5 {
+        GatewayConnectionV1_1_33 {
            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
        }
    }
@@ -302,7 +292,7 @@ impl Default for GatewayConnectionV5 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct AcknowledgementsV5 {
+pub struct AcknowledgementsV1_1_33 {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent acknowledgement is going to be delayed at any given mix node.
    /// So for an ack going through three mix nodes, on average, it will take three times this value
@@ -322,9 +312,9 @@ pub struct AcknowledgementsV5 {
    pub ack_wait_addition: Duration,
 }

-impl Default for AcknowledgementsV5 {
+impl Default for AcknowledgementsV1_1_33 {
    fn default() -> Self {
-        AcknowledgementsV5 {
+        AcknowledgementsV1_1_33 {
            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
@@ -334,7 +324,7 @@ impl Default for AcknowledgementsV5 {

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TopologyV5 {
+pub struct TopologyV1_1_33 {
    /// The uniform delay every which clients are querying the directory server
    /// to try to obtain a compatible network topology to send sphinx packets through.
    #[serde(with = "humantime_serde")]
@@ -357,66 +347,68 @@ pub struct TopologyV5 {
    pub max_startup_gateway_waiting_period: Duration,

    /// Specifies the mixnode topology to be used for sending packets.
-    pub topology_structure: TopologyStructureV5,
+    pub topology_structure: TopologyStructureV1_1_33,
 }

 #[allow(clippy::large_enum_variant)]
 #[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TopologyStructureV5 {
+pub enum TopologyStructureV1_1_33 {
    #[default]
    NymApi,
-    GeoAware(GroupByV5),
+    GeoAware(GroupByV1_1_33),
 }

-impl From<TopologyStructureV5> for TopologyStructure {
-    fn from(value: TopologyStructureV5) -> Self {
+impl From<TopologyStructureV1_1_33> for TopologyStructure {
+    fn from(value: TopologyStructureV1_1_33) -> Self {
        match value {
-            TopologyStructureV5::NymApi => TopologyStructure::NymApi,
-            TopologyStructureV5::GeoAware(group_by) => TopologyStructure::GeoAware(group_by.into()),
+            TopologyStructureV1_1_33::NymApi => TopologyStructure::NymApi,
+            TopologyStructureV1_1_33::GeoAware(group_by) => {
+                TopologyStructure::GeoAware(group_by.into())
+            }
        }
    }
 }

 #[allow(clippy::large_enum_variant)]
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum GroupByV5 {
+pub enum GroupByV1_1_33 {
    CountryGroup(CountryGroup),
    NymAddress(Recipient),
 }

-impl From<GroupByV5> for GroupBy {
-    fn from(value: GroupByV5) -> Self {
+impl From<GroupByV1_1_33> for GroupBy {
+    fn from(value: GroupByV1_1_33) -> Self {
        match value {
-            GroupByV5::CountryGroup(country) => GroupBy::CountryGroup(country),
-            GroupByV5::NymAddress(addr) => GroupBy::NymAddress(addr),
+            GroupByV1_1_33::CountryGroup(country) => GroupBy::CountryGroup(country),
+            GroupByV1_1_33::NymAddress(addr) => GroupBy::NymAddress(addr),
        }
    }
 }

-impl std::fmt::Display for GroupByV5 {
+impl std::fmt::Display for GroupByV1_1_33 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            GroupByV5::CountryGroup(group) => write!(f, "group: {}", group),
-            GroupByV5::NymAddress(address) => write!(f, "address: {}", address),
+            GroupByV1_1_33::CountryGroup(group) => write!(f, "group: {}", group),
+            GroupByV1_1_33::NymAddress(address) => write!(f, "address: {}", address),
        }
    }
 }

-impl Default for TopologyV5 {
+impl Default for TopologyV1_1_33 {
    fn default() -> Self {
-        TopologyV5 {
+        TopologyV1_1_33 {
            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
            disable_refreshing: false,
            max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
-            topology_structure: TopologyStructureV5::default(),
+            topology_structure: TopologyStructureV1_1_33::default(),
        }
    }
 }

 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct ReplySurbsV5 {
+pub struct ReplySurbsV1_1_33 {
    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
    /// It can only allow to go below that value if its to request additional reply surbs.
    pub minimum_reply_surb_storage_threshold: usize,
@@ -458,9 +450,9 @@ pub struct ReplySurbsV5 {
    pub surb_mix_hops: Option<u8>,
 }

-impl Default for ReplySurbsV5 {
+impl Default for ReplySurbsV1_1_33 {
    fn default() -> Self {
-        ReplySurbsV5 {
+        ReplySurbsV1_1_33 {
            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -478,22 +470,22 @@ impl Default for ReplySurbsV5 {

 #[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV5 {
+pub struct DebugConfigV1_1_33 {
    /// Defines all configuration options related to traffic streams.
-    pub traffic: TrafficV5,
+    pub traffic: TrafficV1_1_33,

    /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTrafficV5,
+    pub cover_traffic: CoverTrafficV1_1_33,

    /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnectionV5,
+    pub gateway_connection: GatewayConnectionV1_1_33,

    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: AcknowledgementsV5,
+    pub acknowledgements: AcknowledgementsV1_1_33,

    /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: TopologyV5,
+    pub topology: TopologyV1_1_33,

    /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbsV5,
+    pub reply_surbs: ReplySurbsV1_1_33,
 }
@@ -16,8 +16,6 @@ thiserror = { workspace = true }
 url = { workspace = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 tokio = { version = "1.24.1", features = ["macros"] }
-si-scale = "0.2.2"
-time.workspace = true

 # internal
 nym-bandwidth-controller = { path = "../../bandwidth-controller" }
@@ -23,13 +23,12 @@ use nym_gateway_requests::{
    BinaryRequest, ClientControlRequest, ServerResponse, CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION,
    CURRENT_PROTOCOL_VERSION,
 };
-use nym_network_defaults::REMAINING_BANDWIDTH_THRESHOLD;
+use nym_network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_task::TaskClient;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use rand::rngs::OsRng;
-use std::convert::TryFrom;
-use std::sync::atomic::{AtomicI64, Ordering};
+
 use std::sync::Arc;
 use std::time::Duration;
 use tungstenite::protocol::Message;
@@ -84,7 +83,7 @@ impl GatewayConfig {
 pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
    authenticated: bool,
    disabled_credentials_mode: bool,
-    bandwidth_remaining: Arc<AtomicI64>,
+    bandwidth_remaining: i64,
    gateway_address: String,
    gateway_identity: identity::PublicKey,
    local_identity: Arc<identity::KeyPair>,
@@ -123,7 +122,7 @@ impl<C, St> GatewayClient<C, St> {
        GatewayClient {
            authenticated: false,
            disabled_credentials_mode: true,
-            bandwidth_remaining: Arc::new(AtomicI64::new(0)),
+            bandwidth_remaining: 0,
            gateway_address: config.gateway_listener,
            gateway_identity: config.gateway_identity,
            local_identity,
@@ -183,7 +182,7 @@ impl<C, St> GatewayClient<C, St> {
    }

    pub fn remaining_bandwidth(&self) -> i64 {
-        self.bandwidth_remaining.load(Ordering::Acquire)
+        self.bandwidth_remaining
    }

    #[cfg(not(target_arch = "wasm32"))]
@@ -443,7 +442,7 @@ impl<C, St> GatewayClient<C, St> {
        }

        debug_assert!(self.connection.is_available());
-        log::debug!("Registering gateway");
+        log::trace!("Registering gateway");

        // it's fine to instantiate it here as it's only used once (during authentication or registration)
        // and putting it into the GatewayClient struct would be a hassle
@@ -495,7 +494,6 @@ impl<C, St> GatewayClient<C, St> {
        if !self.connection.is_established() {
            return Err(GatewayClientError::ConnectionNotEstablished);
        }
-        log::debug!("Authenticating with gateway");

        // it's fine to instantiate it here as it's only used once (during authentication or registration)
        // and putting it into the GatewayClient struct would be a hassle
@@ -529,10 +527,8 @@ impl<C, St> GatewayClient<C, St> {
            } => {
                self.check_gateway_protocol(protocol_version)?;
                self.authenticated = status;
-                self.bandwidth_remaining
-                    .store(bandwidth_remaining, Ordering::Release);
+                self.bandwidth_remaining = bandwidth_remaining;
                self.negotiated_protocol = protocol_version;
-                log::debug!("authenticated: {status}, bandwidth remaining: {bandwidth_remaining}");
                Ok(())
            }
            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
@@ -545,11 +541,10 @@ impl<C, St> GatewayClient<C, St> {
        &mut self,
    ) -> Result<Arc<SharedKeys>, GatewayClientError> {
        if self.authenticated {
-            debug!("Already authenticated");
            return if let Some(shared_key) = &self.shared_key {
                Ok(Arc::clone(shared_key))
            } else {
-                Err(GatewayClientError::AuthenticationFailureWithPreexistingSharedKey)
+                Err(GatewayClientError::AuthenticationFailure)
            };
        }

@@ -566,38 +561,35 @@ impl<C, St> GatewayClient<C, St> {
        }
    }

-    async fn claim_ecash_bandwidth(
+    async fn claim_coconut_bandwidth(
        &mut self,
        credential: CredentialSpendingData,
    ) -> Result<(), GatewayClientError> {
        let mut rng = OsRng;
        let iv = IV::new_random(&mut rng);

-        let msg = ClientControlRequest::new_enc_ecash_credential(
+        let msg = ClientControlRequest::new_enc_coconut_bandwidth_credential_v2(
            credential,
            self.shared_key.as_ref().unwrap(),
            iv,
        )
        .into();
-        let bandwidth_remaining = match self.send_websocket_message(msg).await? {
+        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
            ServerResponse::Bandwidth { available_total } => Ok(available_total),
            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
            _ => Err(GatewayClientError::UnexpectedResponse),
        }?;
-        self.bandwidth_remaining
-            .store(bandwidth_remaining, Ordering::Release);
        Ok(())
    }

    async fn try_claim_testnet_bandwidth(&mut self) -> Result<(), GatewayClientError> {
        let msg = ClientControlRequest::ClaimFreeTestnetBandwidth.into();
-        let bandwidth_remaining = match self.send_websocket_message(msg).await? {
+        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
            ServerResponse::Bandwidth { available_total } => Ok(available_total),
            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
            _ => Err(GatewayClientError::UnexpectedResponse),
        }?;
-        self.bandwidth_remaining
-            .store(bandwidth_remaining, Ordering::Release);
+
        Ok(())
    }

@@ -634,45 +626,49 @@ impl<C, St> GatewayClient<C, St> {
                negotiated_protocol: Some(gateway_protocol),
            });
        }
+
+        let gateway_id = self.gateway_identity().to_base58_string();
+
        let prepared_credential = self
            .bandwidth_controller
            .as_ref()
            .unwrap()
-            .prepare_ecash_credential(self.gateway_identity.to_bytes())
+            .prepare_bandwidth_credential(&gateway_id)
            .await?;

-        self.claim_ecash_bandwidth(prepared_credential.data).await?;
+        self.claim_coconut_bandwidth(prepared_credential.data)
+            .await?;
        self.bandwidth_controller
            .as_ref()
            .unwrap()
-            .update_ecash_wallet(
-                prepared_credential.updated_credential,
-                prepared_credential.credential_id,
-            )
+            .consume_credential(prepared_credential.credential_id, &gateway_id)
            .await?;

        Ok(())
    }

+    fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
+        packets
+            .iter()
+            .map(|packet| packet.packet().len())
+            .sum::<usize>() as i64
+    }
+
    pub async fn batch_send_mix_packets(
        &mut self,
        packets: Vec<MixPacket>,
-    ) -> Result<(), GatewayClientError>
-    where
-        C: DkgQueryClient + Send + Sync,
-        St: CredentialStorage,
-        <St as CredentialStorage>::StorageError: Send + Sync + 'static,
-    {
+    ) -> Result<(), GatewayClientError> {
        debug!("Sending {} mix packets", packets.len());

        if !self.authenticated {
            return Err(GatewayClientError::NotAuthenticated);
        }
-        let bandwidth_remaining = self.bandwidth_remaining.load(Ordering::Acquire);
-        if bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
-            self.claim_bandwidth().await?;
+        if self.estimate_required_bandwidth(&packets) > self.bandwidth_remaining {
+            return Err(GatewayClientError::NotEnoughBandwidth(
+                self.estimate_required_bandwidth(&packets),
+                self.bandwidth_remaining,
+            ));
        }
-
        if !self.connection.is_established() {
            return Err(GatewayClientError::ConnectionNotEstablished);
        }
@@ -731,20 +727,19 @@ impl<C, St> GatewayClient<C, St> {
    }

    // TODO: possibly make responses optional
-    pub async fn send_mix_packet(&mut self, mix_packet: MixPacket) -> Result<(), GatewayClientError>
-    where
-        C: DkgQueryClient + Send + Sync,
-        St: CredentialStorage,
-        <St as CredentialStorage>::StorageError: Send + Sync + 'static,
-    {
+    pub async fn send_mix_packet(
+        &mut self,
+        mix_packet: MixPacket,
+    ) -> Result<(), GatewayClientError> {
        if !self.authenticated {
            return Err(GatewayClientError::NotAuthenticated);
        }
-        let bandwidth_remaining = self.bandwidth_remaining.load(Ordering::Acquire);
-        if bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
-            self.claim_bandwidth().await?;
+        if (mix_packet.packet().len() as i64) > self.bandwidth_remaining {
+            return Err(GatewayClientError::NotEnoughBandwidth(
+                mix_packet.packet().len() as i64,
+                self.bandwidth_remaining,
+            ));
        }
-
        if !self.connection.is_established() {
            return Err(GatewayClientError::ConnectionNotEstablished);
        }
@@ -798,7 +793,6 @@ impl<C, St> GatewayClient<C, St> {
                                .as_ref()
                                .expect("no shared key present even though we're authenticated!"),
                        ),
-                        self.bandwidth_remaining.clone(),
                        self.shutdown.clone(),
                    )
                }
@@ -839,9 +833,10 @@ impl<C, St> GatewayClient<C, St> {
            self.establish_connection().await?;
        }
        let shared_key = self.perform_initial_authentication().await?;
-        let bandwidth_remaining = self.bandwidth_remaining.load(Ordering::Acquire);
-        if bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
-            info!("Claiming more bandwidth with existing credentials. Stop the process now if you don't want that to happen.");
+
+        if self.bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
+            info!("Claiming more bandwidth for your tokens. This will use {} token(s) from your wallet. \
+            Stop the process now if you don't want that to happen.", TOKENS_TO_BURN);
            self.claim_bandwidth().await?;
        }

@@ -878,7 +873,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
        GatewayClient {
            authenticated: false,
            disabled_credentials_mode: true,
-            bandwidth_remaining: Arc::new(AtomicI64::new(0)),
+            bandwidth_remaining: 0,
            gateway_address: gateway_listener.to_string(),
            gateway_identity,
            local_identity,
@@ -71,9 +71,6 @@ pub enum GatewayClientError {
    #[error("Authentication failure")]
    AuthenticationFailure,

-    #[error("Authentication failure with preexisting shared key")]
-    AuthenticationFailureWithPreexistingSharedKey,
-
    #[error("Timed out")]
    Timeout,

@@ -10,14 +10,9 @@ use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
 use log::*;
 use nym_gateway_requests::registration::handshake::SharedKeys;
-use nym_gateway_requests::ServerResponse;
 use nym_task::TaskClient;
-use si_scale::helpers::bibytes2;
 use std::os::raw::c_int as RawFd;
-use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::Arc;
-use std::time::Duration;
-use time::OffsetDateTime;
 use tungstenite::Message;

 #[cfg(unix)]
@@ -53,21 +48,6 @@ pub(crate) fn ws_fd(_conn: &WsConn) -> Option<RawFd> {
    None
 }

-// disgusting? absolutely, but does the trick for now
-static LAST_LOGGED_BANDWIDTH_TS: AtomicI64 = AtomicI64::new(0);
-
-fn maybe_log_bandwidth(remaining: i64) {
-    // SAFETY: this value is always populated with valid timestamps
-    let last =
-        OffsetDateTime::from_unix_timestamp(LAST_LOGGED_BANDWIDTH_TS.load(Ordering::Relaxed))
-            .unwrap();
-    let now = OffsetDateTime::now_utc();
-    if last + Duration::from_secs(10) < now {
-        log::info!("remaining bandwidth: {}", bibytes2(remaining as f64));
-        LAST_LOGGED_BANDWIDTH_TS.store(now.unix_timestamp(), Ordering::Relaxed)
-    }
-}
-
 #[derive(Debug)]
 pub(crate) struct PartiallyDelegated {
    sink_half: SplitSink<WsConn, Message>,
@@ -76,11 +56,7 @@ pub(crate) struct PartiallyDelegated {
 }

 impl PartiallyDelegated {
-    fn recover_received_plaintexts(
-        ws_msgs: Vec<Message>,
-        shared_key: &SharedKeys,
-        bandwidth_remaining: Arc<AtomicI64>,
-    ) -> Result<Vec<Vec<u8>>, GatewayClientError> {
+    fn recover_received_plaintexts(ws_msgs: Vec<Message>, shared_key: &SharedKeys) -> Vec<Vec<u8>> {
        let mut plaintexts = Vec::with_capacity(ws_msgs.len());
        for ws_msg in ws_msgs {
            match ws_msg {
@@ -98,46 +74,23 @@ impl PartiallyDelegated {
                // TODO: those can return the "send confirmations" - perhaps it should be somehow worked around?
                Message::Text(text) => {
                    trace!(
-                    "received a text message - probably a response to some previous query! - {text}",
+                    "received a text message - probably a response to some previous query! - {}",
+                    text
                );
-                    match ServerResponse::try_from(text)
-                        .map_err(|_| GatewayClientError::MalformedResponse)?
-                    {
-                        ServerResponse::Send {
-                            remaining_bandwidth,
-                        } => {
-                            maybe_log_bandwidth(remaining_bandwidth);
-                            bandwidth_remaining
-                                .store(remaining_bandwidth, std::sync::atomic::Ordering::Release)
-                        }
-                        ServerResponse::Error { message } => {
-                            error!("gateway failure: {message}");
-                            return Err(GatewayClientError::GatewayError(message));
-                        }
-                        other => {
-                            warn!(
-                                "received illegal message of type {} in an authenticated client",
-                                other.name()
-                            )
-                        }
-                    }
-
                    continue;
                }
                _ => continue,
            }
        }
-        Ok(plaintexts)
+        plaintexts
    }

    fn route_socket_messages(
        ws_msgs: Vec<Message>,
        packet_router: &PacketRouter,
        shared_key: &SharedKeys,
-        bandwidth_remaining: Arc<AtomicI64>,
    ) -> Result<(), GatewayClientError> {
-        let plaintexts =
-            Self::recover_received_plaintexts(ws_msgs, shared_key, bandwidth_remaining)?;
+        let plaintexts = Self::recover_received_plaintexts(ws_msgs, shared_key);
        packet_router.route_received(plaintexts)
    }

@@ -145,7 +98,6 @@ impl PartiallyDelegated {
        conn: WsConn,
        mut packet_router: PacketRouter,
        shared_key: Arc<SharedKeys>,
-        bandwidth_remaining: Arc<AtomicI64>,
        mut shutdown: TaskClient,
    ) -> Self {
        // when called for, it NEEDS TO yield back the stream so that we could merge it and
@@ -177,9 +129,8 @@ impl PartiallyDelegated {
                            Ok(msgs) => msgs
                        };

-                        if let Err(err) = Self::route_socket_messages(ws_msgs, &packet_router, shared_key.as_ref(), bandwidth_remaining.clone()) {
-                            log::error!("Route socket messages failed: {err}");
-                            break Err(err)
+                        if let Err(err) = Self::route_socket_messages(ws_msgs, &packet_router, shared_key.as_ref()) {
+                            log::warn!("Route socket messages failed: {err}");
                        }
                    }
                };
@@ -18,7 +18,6 @@ nym-ephemera-common = { path = "../../cosmwasm-smart-contracts/ephemera" }
 nym-mixnet-contract-common = { path = "../../cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../../cosmwasm-smart-contracts/vesting-contract" }
 nym-coconut-bandwidth-contract-common = { path = "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
-nym-ecash-contract-common = { path = "../../cosmwasm-smart-contracts/ecash-contract" }
 nym-multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
 nym-name-service-common = { path = "../../cosmwasm-smart-contracts/name-service" }
 nym-group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contract" }
@@ -33,7 +32,7 @@ url = { workspace = true, features = ["serde"] }
 tokio = { workspace = true, features = ["sync", "time"] }
 futures = { workspace = true }

-nym-compact-ecash = { path = "../../nym_offline_compact_ecash" }
+nym-coconut = { path = "../../nymcoconut" }
 nym-network-defaults = { path = "../../network-defaults" }
 nym-api-requests = { path = "../../../nym-api/nym-api-requests" }

@@ -8,14 +8,10 @@ use crate::{
    nym_api, DirectSigningReqwestRpcValidatorClient, QueryReqwestRpcValidatorClient,
    ReqwestRpcClient, ValidatorClientError,
 };
-use nym_api_requests::coconut::models::{
-    FreePassNonceResponse, SpentCredentialsResponse, VerifyCredentialBody,
-    VerifyEcashCredentialResponse,
-};
+use nym_api_requests::coconut::models::FreePassNonceResponse;
 use nym_api_requests::coconut::{
-    BlindSignRequestBody, BlindedSignatureResponse, FreePassRequest,
-    PartialCoinIndicesSignatureResponse, PartialExpirationDateSignatureResponse,
-    VerifyCredentialResponse, VerifyEcashCredentialBody,
+    BlindSignRequestBody, BlindedSignatureResponse, FreePassRequest, VerifyCredentialBody,
+    VerifyCredentialResponse,
 };
 use nym_api_requests::models::{DescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::models::{
@@ -355,48 +351,6 @@ impl NymApiClient {
            .await?)
    }

-    pub async fn verify_offline_credential(
-        &self,
-        request_body: &VerifyEcashCredentialBody,
-    ) -> Result<VerifyEcashCredentialResponse, ValidatorClientError> {
-        Ok(self.nym_api.verify_offline_credential(request_body).await?)
-    }
-
-    pub async fn verify_online_credential(
-        &self,
-        request_body: &VerifyEcashCredentialBody,
-    ) -> Result<VerifyEcashCredentialResponse, ValidatorClientError> {
-        Ok(self.nym_api.verify_online_credential(request_body).await?)
-    }
-
-    pub async fn spent_credentials(
-        &self,
-    ) -> Result<SpentCredentialsResponse, ValidatorClientError> {
-        Ok(self.nym_api.spent_credentials().await?)
-    }
-
-    pub async fn expiration_date_signatures(
-        &self,
-    ) -> Result<PartialExpirationDateSignatureResponse, ValidatorClientError> {
-        Ok(self.nym_api.expiration_date_signatures().await?)
-    }
-
-    pub async fn expiration_date_signatures_timestamp(
-        &self,
-        timestamp: u64,
-    ) -> Result<PartialExpirationDateSignatureResponse, ValidatorClientError> {
-        Ok(self
-            .nym_api
-            .expiration_date_signatures_timestamp(&timestamp.to_string())
-            .await?)
-    }
-
-    pub async fn coin_indices_signatures(
-        &self,
-    ) -> Result<PartialCoinIndicesSignatureResponse, ValidatorClientError> {
-        Ok(self.nym_api.coin_indices_signatures().await?)
-    }
-
    pub async fn free_pass_nonce(&self) -> Result<FreePassNonceResponse, ValidatorClientError> {
        Ok(self.nym_api.free_pass_nonce().await?)
    }
@@ -4,10 +4,9 @@
 use crate::nyxd::contract_traits::{DkgQueryClient, PagedDkgQueryClient};
 use crate::nyxd::error::NyxdError;
 use crate::NymApiClient;
+use nym_coconut::{Base58, CoconutError, VerificationKey};
 use nym_coconut_dkg_common::types::{EpochId, NodeIndex};
 use nym_coconut_dkg_common::verification_key::ContractVKShare;
-use nym_compact_ecash::error::CompactEcashError;
-use nym_compact_ecash::{Base58, VerificationKeyAuth};
 use thiserror::Error;
 use url::Url;

@@ -15,7 +14,7 @@ use url::Url;
 #[derive(Clone)]
 pub struct CoconutApiClient {
    pub api_client: NymApiClient,
-    pub verification_key: VerificationKeyAuth,
+    pub verification_key: VerificationKey,
    pub node_id: NodeIndex,
    pub cosmos_address: cosmrs::AccountId,
 }
@@ -44,7 +43,7 @@ pub enum CoconutApiError {
    #[error("the provided verification key is malformed: {source}")]
    MalformedVerificationKey {
        #[from]
-        source: CompactEcashError,
+        source: CoconutError,
    },

    #[error("the provided account address is malformed: {source}")]
@@ -66,14 +65,14 @@ impl TryFrom<ContractVKShare> for CoconutApiClient {

        Ok(CoconutApiClient {
            api_client: NymApiClient::new(url_address),
-            verification_key: VerificationKeyAuth::try_from_bs58(&share.share)?,
+            verification_key: VerificationKey::try_from_bs58(&share.share)?,
            node_id: share.node_index,
            cosmos_address: share.owner.as_str().parse()?,
        })
    }
 }

-pub async fn all_ecash_api_clients<C>(
+pub async fn all_coconut_api_clients<C>(
    client: &C,
    epoch_id: EpochId,
 ) -> Result<Vec<CoconutApiClient>, CoconutApiError>
@@ -8,11 +8,10 @@ pub use nym_api_requests::{
    coconut::{
        models::{
            EpochCredentialsResponse, IssuedCredential, IssuedCredentialBody,
-            IssuedCredentialResponse, IssuedCredentialsResponse, SpentCredentialsResponse,
+            IssuedCredentialResponse, IssuedCredentialsResponse,
        },
        BlindSignRequestBody, BlindedSignatureResponse, CredentialsRequestBody,
-        PartialCoinIndicesSignatureResponse, PartialExpirationDateSignatureResponse,
-        VerifyCredentialResponse, VerifyEcashCredentialBody,
+        VerifyCredentialBody, VerifyCredentialResponse,
    },
    models::{
        ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
@@ -32,9 +31,7 @@ use nym_service_provider_directory_common::response::ServicesListResponse;
 pub mod error;
 pub mod routes;

-use nym_api_requests::coconut::models::{
-    FreePassNonceResponse, VerifyCredentialBody, VerifyEcashCredentialResponse,
-};
+use nym_api_requests::coconut::models::FreePassNonceResponse;
 use nym_api_requests::coconut::FreePassRequest;
 pub use nym_http_api_client::Client;

@@ -442,100 +439,6 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

-    async fn verify_offline_credential(
-        &self,
-        request_body: &VerifyEcashCredentialBody,
-    ) -> Result<VerifyEcashCredentialResponse, NymAPIError> {
-        self.post_json(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::ECASH_VERIFY_OFFLINE_CREDENTIAL,
-            ],
-            NO_PARAMS,
-            request_body,
-        )
-        .await
-    }
-
-    async fn verify_online_credential(
-        &self,
-        request_body: &VerifyEcashCredentialBody,
-    ) -> Result<VerifyEcashCredentialResponse, NymAPIError> {
-        self.post_json(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::ECASH_VERIFY_ONLINE_CREDENTIAL,
-            ],
-            NO_PARAMS,
-            request_body,
-        )
-        .await
-    }
-
-    async fn spent_credentials(&self) -> Result<SpentCredentialsResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::SPENT_CREDENTIALS,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    async fn expiration_date_signatures(
-        &self,
-    ) -> Result<PartialExpirationDateSignatureResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::EXPIRATION_DATE_SIGNATURES,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    async fn expiration_date_signatures_timestamp(
-        &self,
-        timestamp: &str,
-    ) -> Result<PartialExpirationDateSignatureResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::EXPIRATION_DATE_SIGNATURES,
-                timestamp,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    async fn coin_indices_signatures(
-        &self,
-    ) -> Result<PartialCoinIndicesSignatureResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::COIN_INDICES_SIGNATURES,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
    async fn epoch_credentials(
        &self,
        dkg_epoch: EpochId,
@@ -14,17 +14,11 @@ pub const ACTIVE: &str = "active";
 pub const REWARDED: &str = "rewarded";
 pub const COCONUT_ROUTES: &str = "coconut";
 pub const BANDWIDTH: &str = "bandwidth";
-pub const SPENT_CREDENTIALS: &str = "spent-credentials";

 pub const COCONUT_FREE_PASS: &str = "free-pass";
 pub const COCONUT_FREE_PASS_NONCE: &str = "free-pass-nonce";
 pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
-pub const ECASH_VERIFY_OFFLINE_CREDENTIAL: &str = "verify-offline-credential";
-pub const ECASH_VERIFY_ONLINE_CREDENTIAL: &str = "verify-online-credential";
 pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";
-pub const EXPIRATION_DATE_SIGNATURES: &str = "expiration-date-signatures";
-pub const EXPIRATION_DATE_SIGNATURES_TIMESTAMP: &str = "expiration-date-signatures-ts";
-pub const COIN_INDICES_SIGNATURES: &str = "coin-indices-signatures";
 pub const COCONUT_EPOCH_CREDENTIALS: &str = "epoch-credentials";
 pub const COCONUT_ISSUED_CREDENTIAL: &str = "issued-credential";
 pub const COCONUT_ISSUED_CREDENTIALS: &str = "issued-credentials";
@@ -0,0 +1,100 @@
+// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::collect_paged;
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::CosmWasmClient;
+use async_trait::async_trait;
+use nym_coconut_bandwidth_contract_common::msg::QueryMsg as CoconutBandwidthQueryMsg;
+use nym_coconut_bandwidth_contract_common::spend_credential::{
+    PagedSpendCredentialResponse, SpendCredential, SpendCredentialResponse,
+};
+use serde::Deserialize;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait CoconutBandwidthQueryClient {
+    async fn query_coconut_bandwidth_contract<T>(
+        &self,
+        query: CoconutBandwidthQueryMsg,
+    ) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_spent_credential(
+        &self,
+        blinded_serial_number: String,
+    ) -> Result<SpendCredentialResponse, NyxdError> {
+        self.query_coconut_bandwidth_contract(CoconutBandwidthQueryMsg::GetSpentCredential {
+            blinded_serial_number,
+        })
+        .await
+    }
+
+    async fn get_all_spent_credential_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedSpendCredentialResponse, NyxdError> {
+        self.query_coconut_bandwidth_contract(CoconutBandwidthQueryMsg::GetAllSpentCredentials {
+            limit,
+            start_after,
+        })
+        .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait PagedCoconutBandwidthQueryClient: CoconutBandwidthQueryClient {
+    async fn get_all_spent_credentials(&self) -> Result<Vec<SpendCredential>, NyxdError> {
+        collect_paged!(self, get_all_spent_credential_paged, spend_credentials)
+    }
+}
+
+#[async_trait]
+impl<T> PagedCoconutBandwidthQueryClient for T where T: CoconutBandwidthQueryClient {}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> CoconutBandwidthQueryClient for C
+where
+    C: CosmWasmClient + NymContractsProvider + Send + Sync,
+{
+    async fn query_coconut_bandwidth_contract<T>(
+        &self,
+        query: CoconutBandwidthQueryMsg,
+    ) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        let coconut_bandwidth_contract_address = self
+            .coconut_bandwidth_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
+        self.query_contract_smart(coconut_bandwidth_contract_address, &query)
+            .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::IgnoreValue;
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_query_variants_are_covered<C: CoconutBandwidthQueryClient + Send + Sync>(
+        client: C,
+        msg: CoconutBandwidthQueryMsg,
+    ) {
+        match msg {
+            CoconutBandwidthQueryMsg::GetSpentCredential {
+                blinded_serial_number,
+            } => client.get_spent_credential(blinded_serial_number).ignore(),
+            CoconutBandwidthQueryMsg::GetAllSpentCredentials { limit, start_after } => client
+                .get_all_spent_credential_paged(start_after, limit)
+                .ignore(),
+        };
+    }
+}
@@ -0,0 +1,153 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::cosmwasm_client::types::ExecuteResult;
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
+use crate::signing::signer::OfflineSigner;
+use async_trait::async_trait;
+use nym_coconut_bandwidth_contract_common::spend_credential::SpendCredentialData;
+use nym_coconut_bandwidth_contract_common::{
+    deposit::DepositData, msg::ExecuteMsg as CoconutBandwidthExecuteMsg,
+};
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait CoconutBandwidthSigningClient {
+    async fn execute_coconut_bandwidth_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: CoconutBandwidthExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn deposit(
+        &self,
+        amount: Coin,
+        info: String,
+        verification_key: String,
+        encryption_key: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = CoconutBandwidthExecuteMsg::DepositFunds {
+            data: DepositData::new(info, verification_key, encryption_key),
+        };
+        self.execute_coconut_bandwidth_contract(
+            fee,
+            req,
+            "CoconutBandwidth::Deposit".to_string(),
+            vec![amount],
+        )
+        .await
+    }
+
+    async fn spend_credential(
+        &self,
+        funds: Coin,
+        blinded_serial_number: String,
+        gateway_cosmos_address: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = CoconutBandwidthExecuteMsg::SpendCredential {
+            data: SpendCredentialData::new(
+                funds.into(),
+                blinded_serial_number,
+                gateway_cosmos_address,
+            ),
+        };
+        self.execute_coconut_bandwidth_contract(
+            fee,
+            req,
+            "CoconutBandwidth::SpendCredential".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn release_funds(
+        &self,
+        amount: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_coconut_bandwidth_contract(
+            fee,
+            CoconutBandwidthExecuteMsg::ReleaseFunds {
+                funds: amount.into(),
+            },
+            "CoconutBandwidth::ReleaseFunds".to_string(),
+            vec![],
+        )
+        .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> CoconutBandwidthSigningClient for C
+where
+    C: SigningCosmWasmClient + NymContractsProvider + Sync,
+    NyxdError: From<<Self as OfflineSigner>::Error>,
+{
+    async fn execute_coconut_bandwidth_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: CoconutBandwidthExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let coconut_bandwidth_contract_address = self
+            .coconut_bandwidth_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
+
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
+        let signer_address = &self.signer_addresses()?[0];
+
+        self.execute(
+            signer_address,
+            coconut_bandwidth_contract_address,
+            &msg,
+            fee,
+            memo,
+            funds,
+        )
+        .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue};
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: CoconutBandwidthSigningClient + Send + Sync>(
+        client: C,
+        msg: CoconutBandwidthExecuteMsg,
+    ) {
+        match msg {
+            CoconutBandwidthExecuteMsg::DepositFunds { data } => client
+                .deposit(
+                    mock_coin(),
+                    data.deposit_info().to_string(),
+                    data.identity_key().to_string(),
+                    data.encryption_key().to_string(),
+                    None,
+                )
+                .ignore(),
+            CoconutBandwidthExecuteMsg::SpendCredential { data } => client
+                .spend_credential(
+                    mock_coin(),
+                    data.blinded_serial_number().to_string(),
+                    data.gateway_cosmos_address().to_string(),
+                    None,
+                )
+                .ignore(),
+            CoconutBandwidthExecuteMsg::ReleaseFunds { funds } => {
+                client.release_funds(funds.into(), None).ignore()
+            }
+        };
+    }
+}
@@ -1,101 +0,0 @@
-// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::collect_paged;
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::CosmWasmClient;
-use async_trait::async_trait;
-use nym_ecash_contract_common::blacklist::BlacklistedAccountResponse;
-use nym_ecash_contract_common::msg::QueryMsg as EcashQueryMsg;
-use nym_ecash_contract_common::spend_credential::{
-    EcashSpentCredential, EcashSpentCredentialResponse, PagedEcashSpentCredentialResponse,
-};
-use serde::Deserialize;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait EcashQueryClient {
-    async fn query_ecash_contract<T>(&self, query: EcashQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>;
-
-    async fn get_spent_credential(
-        &self,
-        serial_number: String,
-    ) -> Result<EcashSpentCredentialResponse, NyxdError> {
-        self.query_ecash_contract(EcashQueryMsg::GetSpentCredential { serial_number })
-            .await
-    }
-
-    async fn get_all_spent_credential_paged(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> Result<PagedEcashSpentCredentialResponse, NyxdError> {
-        self.query_ecash_contract(EcashQueryMsg::GetAllSpentCredentials { limit, start_after })
-            .await
-    }
-
-    async fn get_blacklisted_account(
-        &self,
-        public_key: String,
-    ) -> Result<BlacklistedAccountResponse, NyxdError> {
-        self.query_ecash_contract(EcashQueryMsg::GetBlacklistedAccount { public_key })
-            .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PagedEcashQueryClient: EcashQueryClient {
-    async fn get_all_spent_credentials(&self) -> Result<Vec<EcashSpentCredential>, NyxdError> {
-        collect_paged!(self, get_all_spent_credential_paged, spend_credentials)
-    }
-}
-
-#[async_trait]
-impl<T> PagedEcashQueryClient for T where T: EcashQueryClient {}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> EcashQueryClient for C
-where
-    C: CosmWasmClient + NymContractsProvider + Send + Sync,
-{
-    async fn query_ecash_contract<T>(&self, query: EcashQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>,
-    {
-        let ecash_contract_address = self
-            .coconut_bandwidth_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
-        self.query_contract_smart(ecash_contract_address, &query)
-            .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_query_variants_are_covered<C: EcashQueryClient + Send + Sync>(
-        client: C,
-        msg: EcashQueryMsg,
-    ) {
-        match msg {
-            EcashQueryMsg::GetSpentCredential { serial_number } => {
-                client.get_spent_credential(serial_number).ignore()
-            }
-            EcashQueryMsg::GetAllSpentCredentials { limit, start_after } => client
-                .get_all_spent_credential_paged(start_after, limit)
-                .ignore(),
-            EcashQueryMsg::GetBlacklistedAccount { public_key } => {
-                client.get_blacklisted_account(public_key).ignore()
-            }
-        };
-    }
-}
@@ -1,143 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::cosmwasm_client::types::ExecuteResult;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
-use crate::signing::signer::OfflineSigner;
-use async_trait::async_trait;
-use nym_ecash_contract_common::events::TICKET_BOOK_VALUE;
-use nym_ecash_contract_common::msg::ExecuteMsg as EcashExecuteMsg;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait EcashSigningClient {
-    async fn execute_ecash_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: EcashExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError>;
-
-    async fn deposit(
-        &self,
-        info: String,
-        verification_key: String,
-        encryption_key: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let req = EcashExecuteMsg::DepositFunds {
-            deposit_info: info,
-            identity_key: verification_key,
-            encryption_key,
-        };
-        let amount = Coin::new(TICKET_BOOK_VALUE, "unym");
-        self.execute_ecash_contract(fee, req, "Ecash::Deposit".to_string(), vec![amount])
-            .await
-    }
-
-    async fn prepare_credential(
-        &self,
-        serial_number: String,
-        gateway_cosmos_address: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let req = EcashExecuteMsg::PrepareCredential {
-            serial_number,
-            gateway_cosmos_address,
-        };
-        self.execute_ecash_contract(fee, req, "Ecash::PrepareCredential".to_string(), vec![])
-            .await
-    }
-
-    async fn propose_for_blacklist(
-        &self,
-        public_key: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let req = EcashExecuteMsg::ProposeToBlacklist { public_key };
-        self.execute_ecash_contract(fee, req, "Ecash::ProposeToBlacklist".to_string(), vec![])
-            .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> EcashSigningClient for C
-where
-    C: SigningCosmWasmClient + NymContractsProvider + Sync,
-    NyxdError: From<<Self as OfflineSigner>::Error>,
-{
-    async fn execute_ecash_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: EcashExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let coconut_bandwidth_contract_address = self
-            .coconut_bandwidth_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
-
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-        let signer_address = &self.signer_addresses()?[0];
-
-        self.execute(
-            signer_address,
-            coconut_bandwidth_contract_address,
-            &msg,
-            fee,
-            memo,
-            funds,
-        )
-        .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_execute_variants_are_covered<C: EcashSigningClient + Send + Sync>(
-        client: C,
-        msg: EcashExecuteMsg,
-    ) {
-        match msg {
-            EcashExecuteMsg::DepositFunds {
-                deposit_info,
-                identity_key,
-                encryption_key,
-            } => client
-                .deposit(
-                    deposit_info.to_string(),
-                    identity_key.to_string(),
-                    encryption_key.to_string(),
-                    None,
-                )
-                .ignore(),
-            EcashExecuteMsg::PrepareCredential {
-                serial_number,
-                gateway_cosmos_address,
-            } => client
-                .prepare_credential(
-                    serial_number.to_string(),
-                    gateway_cosmos_address.to_string(),
-                    None,
-                )
-                .ignore(),
-            EcashExecuteMsg::SpendCredential {
-                serial_number: _,
-                gateway_cosmos_address: _,
-            } => unimplemented!(), //no spend credential method for the client
-            EcashExecuteMsg::AddToBlacklist { public_key: _ } => unimplemented!(), //no add to blacklist method on client
-            EcashExecuteMsg::ProposeToBlacklist { public_key } => {
-                client.propose_for_blacklist(public_key, None).ignore()
-            }
-        };
-    }
-}
@@ -8,8 +8,8 @@ use std::str::FromStr;
 // TODO: all of those could/should be derived via a macro

 // query clients
+pub mod coconut_bandwidth_query_client;
 pub mod dkg_query_client;
-pub mod ecash_query_client;
 pub mod ephemera_query_client;
 pub mod group_query_client;
 pub mod mixnet_query_client;
@@ -19,8 +19,8 @@ pub mod sp_directory_query_client;
 pub mod vesting_query_client;

 // signing clients
+pub mod coconut_bandwidth_signing_client;
 pub mod dkg_signing_client;
-pub mod ecash_signing_client;
 pub mod ephemera_signing_client;
 pub mod group_signing_client;
 pub mod mixnet_signing_client;
@@ -30,8 +30,10 @@ pub mod sp_directory_signing_client;
 pub mod vesting_signing_client;

 // re-export query traits
+pub use coconut_bandwidth_query_client::{
+    CoconutBandwidthQueryClient, PagedCoconutBandwidthQueryClient,
+};
 pub use dkg_query_client::{DkgQueryClient, PagedDkgQueryClient};
-pub use ecash_query_client::{EcashQueryClient, PagedEcashQueryClient};
 pub use ephemera_query_client::{EphemeraQueryClient, PagedEphemeraQueryClient};
 pub use group_query_client::{GroupQueryClient, PagedGroupQueryClient};
 pub use mixnet_query_client::{MixnetQueryClient, PagedMixnetQueryClient};
@@ -41,8 +43,8 @@ pub use sp_directory_query_client::{PagedSpDirectoryQueryClient, SpDirectoryQuer
 pub use vesting_query_client::{PagedVestingQueryClient, VestingQueryClient};

 // re-export signing traits
+pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
 pub use dkg_signing_client::DkgSigningClient;
-pub use ecash_signing_client::EcashSigningClient;
 pub use ephemera_signing_client::EphemeraSigningClient;
 pub use group_signing_client::GroupSigningClient;
 pub use mixnet_signing_client::MixnetSigningClient;
@@ -5,8 +5,8 @@ use crate::nyxd::error::NyxdError;
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};

+pub use nym_coconut_bandwidth_contract_common::event_attributes::*;
 pub use nym_coconut_dkg_common::event_attributes::*;
-pub use nym_ecash_contract_common::event_attributes::*;

 // it seems that currently validators just emit stringified events (which are also returned as part of deliverTx response)
 // as theirs logs
@@ -17,7 +17,7 @@ csv = "1.3.0"
 cw-utils = { workspace = true }
 futures = { workspace = true }
 handlebars = "3.0.1"
-humantime-serde = { workspace = true }
+humantime-serde = "1.0"
 inquire = "0.6.2"
 k256 = { workspace = true, features = ["ecdsa", "sha256"] }
 log = { workspace = true }
@@ -43,9 +43,9 @@ nym-contracts-common = { path = "../cosmwasm-smart-contracts/contracts-common" }
 nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-contract" }
+nym-coconut-bandwidth-contract-common = { path = "../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 nym-coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
 nym-multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-contract" }
-nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
 nym-service-provider-directory-common = { path = "../cosmwasm-smart-contracts/service-provider-directory" }
 nym-name-service-common = { path = "../cosmwasm-smart-contracts/name-service" }
 nym-sphinx = { path = "../../common/nymsphinx" }
@@ -9,15 +9,12 @@ use futures::StreamExt;
 use log::{error, info};
 use nym_coconut_dkg_common::types::EpochId;
 use nym_credential_utils::utils::block_until_coconut_is_available;
-use nym_credentials::coconut::bandwidth::bandwidth_credential_params;
-use nym_credentials::coconut::utils::freepass_exp_date_timestamp;
-use nym_credentials::coconut::utils::today_timestamp;
+use nym_credentials::coconut::bandwidth::freepass::MAX_FREE_PASS_VALIDITY;
 use nym_credentials::{
    obtain_aggregate_verification_key, IssuanceBandwidthCredential, IssuedBandwidthCredential,
 };
-use nym_credentials_interface::aggregate_expiration_signatures;
-use nym_credentials_interface::VerificationKeyAuth;
-use nym_validator_client::coconut::all_ecash_api_clients;
+use nym_credentials_interface::VerificationKey;
+use nym_validator_client::coconut::all_coconut_api_clients;
 use nym_validator_client::nyxd::contract_traits::{DkgQueryClient, NymContractsProvider};
 use nym_validator_client::nyxd::CosmWasmClient;
 use nym_validator_client::signing::AccountData;
@@ -27,7 +24,6 @@ use std::io::Write;
 use std::path::PathBuf;
 use std::sync::Arc;
 use time::format_description::well_known::Rfc3339;
-use time::macros::time;
 use time::OffsetDateTime;
 use zeroize::Zeroizing;

@@ -59,17 +55,17 @@ pub struct Args {

 async fn get_freepass(
    api_clients: Vec<CoconutApiClient>,
-    aggregate_vk: &VerificationKeyAuth,
+    aggregate_vk: &VerificationKey,
    threshold: u64,
    epoch_id: EpochId,
    signing_account: &AccountData,
-    expiration_date_ts: u64,
+    expiration_date: OffsetDateTime,
 ) -> anyhow::Result<IssuedBandwidthCredential> {
-    let issuance_pass = IssuanceBandwidthCredential::new_freepass(expiration_date_ts);
+    let issuance_pass = IssuanceBandwidthCredential::new_freepass(Some(expiration_date));
    let signing_data = issuance_pass.prepare_for_signing();

-    let wallet_shares = Arc::new(tokio::sync::Mutex::new(Vec::new()));
-    let signatures_shares = Arc::new(tokio::sync::Mutex::new(Vec::new()));
+    let credential_shares = Arc::new(tokio::sync::Mutex::new(Vec::new()));
+
    futures::stream::iter(api_clients)
        .for_each_concurrent(None, |client| async {
            // move the client into the block
@@ -81,65 +77,35 @@ async fn get_freepass(
            match issuance_pass
                .obtain_partial_freepass_credential(
                    &client.api_client,
-                    client.node_id,
                    signing_account,
                    &client.verification_key,
                    signing_data.clone(),
                )
                .await
            {
-                Ok(partial_wallet) => {
-                    wallet_shares.lock().await.push(partial_wallet);
+                Ok(partial_credential) => {
+                    credential_shares
+                        .lock()
+                        .await
+                        .push((partial_credential, client.node_id).into());
                }
                Err(err) => {
                    error!("failed to obtain partial free pass from {api_url}: {err}")
                }
            }
-
-            info!("contacting {api_url} for expiration date signatures");
-            match client
-                .api_client
-                .expiration_date_signatures_timestamp(expiration_date_ts)
-                .await
-            {
-                Ok(signature) => {
-                    let index = client.node_id;
-                    let share = client.verification_key.clone();
-                    signatures_shares
-                        .lock()
-                        .await
-                        .push((index, share, signature.signs));
-                }
-                Err(err) => {
-                    error!("failed to obtain expiration date signature from {api_url}: {err}");
-                }
-            }
        })
        .await;

    // SAFETY: the futures have completed, so we MUST have the only arc reference
    #[allow(clippy::unwrap_used)]
-    let wallet_shares = Arc::into_inner(wallet_shares).unwrap().into_inner();
-    let signatures_shares = Arc::into_inner(signatures_shares).unwrap().into_inner();
+    let credential_shares = Arc::into_inner(credential_shares).unwrap().into_inner();

-    if wallet_shares.len() < threshold as usize {
-        bail!("we managed to obtain only {} partial credentials while the minimum threshold is {threshold}", wallet_shares.len());
+    if credential_shares.len() < threshold as usize {
+        bail!("we managed to obtain only {} partial credentials while the minimum threshold is {threshold}", credential_shares.len());
    }

-    let wallet =
-        issuance_pass.aggregate_signature_shares(aggregate_vk, &wallet_shares, signing_data)?;
-
-    if signatures_shares.len() < threshold as usize {
-        bail!("we managed to obtain only {} partial expiration date signatures while the minimum threshold is {threshold}", signatures_shares.len());
-    }
-
-    let exp_date_sigs = aggregate_expiration_signatures(
-        bandwidth_credential_params(),
-        aggregate_vk,
-        expiration_date_ts,
-        &signatures_shares,
-    )?;
-    Ok(issuance_pass.into_issued_credential(wallet, exp_date_sigs, epoch_id))
+    let signature = issuance_pass.aggregate_signature_shares(aggregate_vk, &credential_shares)?;
+    Ok(issuance_pass.into_issued_credential(signature, epoch_id))
 }

 pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
@@ -176,21 +142,12 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
        None => OffsetDateTime::from_unix_timestamp(args.expiration_timestamp.unwrap())?,
    };

-    //SAFETY : positive timestamp, so conversion to unsigned will not fail
-    let expiration_date_ts: u64 = expiration_date
-        .replace_time(time!(0:00))
-        .unix_timestamp()
-        .try_into()
-        .unwrap();
+    let now = OffsetDateTime::now_utc();

-    if expiration_date_ts > freepass_exp_date_timestamp() {
+    if expiration_date > now + MAX_FREE_PASS_VALIDITY {
        bail!("the provided free pass request has too long expiry (expiry is set to on {expiration_date})")
    }

-    if expiration_date_ts < today_timestamp() {
-        bail!("the provided free pass expiry is set in the past!")
-    }
-
    // issuance start
    block_until_coconut_is_available(&client).await?;

@@ -201,7 +158,7 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
        .get_current_epoch_threshold()
        .await?
        .ok_or(anyhow!("no threshold available"))?;
-    let api_clients = all_ecash_api_clients(&client, epoch_id).await?;
+    let api_clients = all_coconut_api_clients(&client, epoch_id).await?;

    if api_clients.len() < threshold as usize {
        bail!(
@@ -220,7 +177,7 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
            threshold,
            epoch_id,
            &signing_account,
-            expiration_date_ts,
+            expiration_date,
        )
        .await?;
        let credential_data = Zeroizing::new(free_pass.pack_v1());
@@ -7,7 +7,7 @@ use anyhow::bail;
 use clap::Parser;
 use nym_credential_storage::initialise_persistent_storage;
 use nym_credential_utils::utils;
-use nym_crypto::asymmetric::identity;
+use nym_validator_client::nyxd::Coin;
 use std::path::PathBuf;

 #[derive(Debug, Parser)]
@@ -16,12 +16,20 @@ pub struct Args {
    #[clap(long)]
    pub(crate) client_config: PathBuf,

+    /// The amount of utokens the credential will hold.
+    #[clap(long, default_value = "0")]
+    pub(crate) amount: u64,
+
    /// Path to a directory used to store recovery files for unconsumed deposits
    #[clap(long)]
    pub(crate) recovery_dir: PathBuf,
 }

 pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
+    if args.amount == 0 {
+        bail!("did not specify credential amount")
+    }
+
    let loaded = CommonConfigsWrapper::try_load(args.client_config)?;

    if let Ok(id) = loaded.try_get_id() {
@@ -32,24 +40,16 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
        bail!("the loaded config does not have a credentials store information")
    };

-    let Ok(private_id_key) = loaded.try_get_private_id_key() else {
-        bail!("the loaded config does not have a public id key information")
-    };
-
    println!(
        "using credentials store at '{}'",
        credentials_store.display()
    );

+    let denom = &client.current_chain_details().mix_denom.base;
+    let coin = Coin::new(args.amount as u128, denom);
+
    let persistent_storage = initialise_persistent_storage(credentials_store).await;
-    let private_id_key: identity::PrivateKey = nym_pemstore::load_key(private_id_key)?;
-    utils::issue_credential(
-        &client,
-        &private_id_key.to_bytes(),
-        &persistent_storage,
-        args.recovery_dir,
-    )
-    .await?;
+    utils::issue_credential(&client, coin, &persistent_storage, args.recovery_dir).await?;

    Ok(())
 }
@@ -123,21 +123,6 @@ impl CommonConfigsWrapper {
        }
    }

-    pub(crate) fn try_get_private_id_key(&self) -> anyhow::Result<PathBuf> {
-        match self {
-            CommonConfigsWrapper::NymClients(cfg) => Ok(cfg
-                .storage_paths
-                .inner
-                .keys
-                .private_identity_key_file
-                .clone()),
-            CommonConfigsWrapper::NymApi(_cfg) => {
-                todo!() //SW this will depend on the new network monitor structure. Ping @Drazen
-            }
-            CommonConfigsWrapper::Unknown(cfg) => cfg.try_get_private_id_key(),
-        }
-    }
-
    pub(crate) fn try_get_credentials_store(&self) -> anyhow::Result<PathBuf> {
        match self {
            CommonConfigsWrapper::NymClients(cfg) => {
@@ -240,17 +225,4 @@ impl UnknownConfigWrapper {
            bail!("no 'credentials_database_path' field present in the config")
        }
    }
-
-    pub(crate) fn try_get_private_id_key(&self) -> anyhow::Result<PathBuf> {
-        let id_val = self
-            .find_value("keys.private_identity_key_file")
-            .ok_or_else(|| {
-                anyhow!("no 'keys.private_identity_key_file' field present in the config")
-            })?;
-        if let toml::Value::String(pub_id_key) = id_val {
-            Ok(pub_id_key.parse()?)
-        } else {
-            bail!("no 'keys.private_identity_key_file' field present in the config")
-        }
-    }
 }
@@ -6,13 +6,13 @@ use std::str::FromStr;
 use clap::Parser;
 use log::{debug, info};

-use nym_ecash_contract_common::msg::InstantiateMsg;
+use nym_coconut_bandwidth_contract_common::msg::InstantiateMsg;
 use nym_validator_client::nyxd::AccountId;

 #[derive(Debug, Parser)]
 pub struct Args {
    #[clap(long)]
-    pub group_addr: Option<AccountId>,
+    pub pool_addr: String,

    #[clap(long)]
    pub multisig_addr: Option<AccountId>,
@@ -26,15 +26,8 @@ pub async fn generate(args: Args) {

    debug!("Received arguments: {:?}", args);

-    let group_addr = args.group_addr.unwrap_or_else(|| {
-        let address = std::env::var(nym_network_defaults::var_names::GROUP_CONTRACT_ADDRESS)
-            .expect("Multisig address has to be set");
-        AccountId::from_str(address.as_str())
-            .expect("Failed converting multisig address to AccountId")
-    });
-
    let multisig_addr = args.multisig_addr.unwrap_or_else(|| {
-        let address = std::env::var(nym_network_defaults::var_names::MULTISIG_CONTRACT_ADDRESS)
+        let address = std::env::var(nym_network_defaults::var_names::REWARDING_VALIDATOR_ADDRESS)
            .expect("Multisig address has to be set");
        AccountId::from_str(address.as_str())
            .expect("Failed converting multisig address to AccountId")
@@ -45,7 +38,7 @@ pub async fn generate(args: Args) {
    });

    let instantiate_msg = InstantiateMsg {
-        group_addr: group_addr.to_string(),
+        pool_addr: args.pool_addr,
        multisig_addr: multisig_addr.to_string(),
        mix_denom,
    };
@@ -1,354 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::cmp::Ordering;
-use std::collections::{HashMap, HashSet};
-use std::fs;
-use std::fs::OpenOptions;
-
-use clap::Parser;
-use comfy_table::Table;
-use csv::WriterBuilder;
-use log::info;
-use nym_mixnet_contract_common::ExecuteMsg;
-use nym_mixnet_contract_common::ExecuteMsg::{DelegateToMixnode, UndelegateFromMixnode};
-
-use nym_mixnet_contract_common::PendingEpochEventKind::{Delegate, Undelegate};
-use nym_validator_client::nyxd::contract_traits::{NymContractsProvider, PagedMixnetQueryClient};
-use nym_validator_client::nyxd::Coin;
-
-use crate::context::SigningClient;
-use crate::utils::pretty_coin;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(long)]
-    pub memo: Option<String>,
-
-    #[clap(
-        long,
-        help = "Input csv files with delegation amounts. Format: (mixID, amount(in NYM))"
-    )]
-    pub input: String,
-
-    #[clap(
-        long,
-        help = "An output file path (CSV format) to create or append a log of results to"
-    )]
-    pub output: Option<String>,
-}
-
-#[derive(Debug)]
-pub struct InputFileRow {
-    pub mix_id: String,
-    pub amount: Coin,
-}
-#[derive(Debug)]
-pub struct InputFileReader {
-    pub rows: Vec<InputFileRow>,
-}
-
-impl InputFileReader {
-    pub fn new(path: &str) -> Result<InputFileReader, anyhow::Error> {
-        let file_contents = fs::read_to_string(path)?;
-        let mut rows = Vec::new();
-        let mut mix_id_set = HashSet::new();
-
-        for line in file_contents
-            .lines()
-            .map(str::trim)
-            .filter(|line| !line.is_empty())
-        {
-            let tokens: Vec<_> = line.split(',').collect();
-            if tokens.len() != 2 {
-                anyhow::bail!("Incorrect format: {}", line);
-            }
-            let mix_id = tokens[0].trim().to_string();
-            let input_amount = tokens[1]
-                .trim()
-                .parse::<u128>()
-                .map_err(|_| anyhow::anyhow!("'{}' has an invalid amount", line))?;
-
-            let micro_nym_amount = input_amount * 1_000_000;
-
-            if !mix_id_set.insert(mix_id.clone()) {
-                anyhow::bail!("Duplicate mix_id found: {}", mix_id);
-            }
-
-            rows.push(InputFileRow {
-                mix_id,
-                amount: Coin {
-                    amount: micro_nym_amount,
-                    denom: "unym".to_string(),
-                },
-            });
-        }
-        Ok(InputFileReader { rows })
-    }
-}
-
-fn write_to_csv(
-    output_details: Vec<[String; 3]>,
-    output_file: Option<String>,
-) -> Result<(), anyhow::Error> {
-    if let Some(file_path) = output_file {
-        // Determine if the file exists and is not empty
-        let file_exists = fs::metadata(&file_path)
-            .map(|metadata| metadata.len() > 0)
-            .unwrap_or(false);
-
-        // Open the file for appending or creation
-        let file = OpenOptions::new()
-            .append(true)
-            .create(true)
-            .open(&file_path)?;
-
-        if !file_exists {
-            let mut wtr = csv::Writer::from_writer(&file);
-            wtr.write_record(["Operation", "Transaction Hash", "Timestamp"])?;
-            wtr.flush()?;
-        }
-
-        let mut wtr = WriterBuilder::new()
-            .has_headers(!file_exists)
-            .from_writer(file);
-
-        // Write the details to the CSV file
-        for detail in output_details {
-            wtr.write_record(&detail)?;
-        }
-        wtr.flush()?;
-        info!("All operations saved to output file");
-    }
-    Ok(())
-}
-
-async fn fetch_delegation_data(
-    client: &SigningClient,
-) -> Result<HashMap<String, Coin>, anyhow::Error> {
-    let address = client.address();
-    // Fetch all delegations for the user
-    let delegations = match client.get_all_delegator_delegations(&address).await {
-        Ok(delegations) => delegations,
-        Err(e) => {
-            anyhow::bail!("Error fetching delegations: {}", e)
-        }
-    };
-
-    // Build a map to make it easier to handle delegation data
-    let mut existing_delegation_map: HashMap<String, Coin> = HashMap::new();
-    let mut pending_delegation_map: HashMap<String, Coin> = HashMap::new();
-
-    for delegation in delegations {
-        existing_delegation_map
-            .insert(delegation.mix_id.to_string(), Coin::from(delegation.amount));
-    }
-
-    // Look for pending delegate / undelegate events which might be of interest to us
-    let pending_events = match client.get_all_pending_epoch_events().await {
-        Ok(events) => events,
-        Err(e) => {
-            anyhow::bail!("Error fetching pending epoch events: {}", e);
-        }
-    };
-
-    for event in pending_events {
-        match event.event.kind {
-            // If a pending undelegate tx is found, remove it from delegation map
-            Undelegate { owner, mix_id, .. } => {
-                if owner == address.as_ref()
-                    && existing_delegation_map.get(&mix_id.to_string()).is_some()
-                {
-                    existing_delegation_map.remove(&mix_id.to_string());
-                }
-            }
-
-            // If a pending delegation event is found, gather them to consolidate later
-            Delegate {
-                owner,
-                mix_id,
-                amount,
-                ..
-            } => {
-                if owner == address.as_ref() {
-                    let mut amount = Coin::from(amount);
-                    if let Some(pending_record) = pending_delegation_map.get(&mix_id.to_string()) {
-                        amount.amount += pending_record.amount;
-                    }
-                    pending_delegation_map.insert(mix_id.to_string(), amount);
-                }
-            }
-            _ => {}
-        };
-    }
-
-    // Consolidate pending events into delegation map
-    for (mix_id, amount) in pending_delegation_map {
-        existing_delegation_map
-            .entry(mix_id)
-            .and_modify(|e| e.amount += amount.amount)
-            .or_insert(amount);
-    }
-
-    Ok(existing_delegation_map)
-}
-
-pub async fn delegate_to_multiple_mixnodes(args: Args, client: SigningClient) {
-    let records = match InputFileReader::new(&args.input) {
-        Ok(records) => records,
-        Err(e) => {
-            println!("Error reading input file: {}", e);
-            return;
-        }
-    };
-
-    let existing_delegation_map = fetch_delegation_data(&client)
-        .await
-        .expect("Could not fetch existing delegations");
-
-    let mut delegation_table = Table::new();
-    let mut undelegation_table = Table::new();
-    let mut delegation_msgs: Vec<(ExecuteMsg, Vec<Coin>)> = Vec::new();
-    let mut undelegation_msgs: Vec<(ExecuteMsg, Vec<Coin>)> = Vec::new();
-
-    delegation_table.set_header(["Mix ID", "Input Amount", "Adjusted Amount"]);
-    undelegation_table.set_header(["Mix ID"]);
-
-    for row in &records.rows {
-        let input_amount = row.amount.amount;
-        let existing_delegation_amount = existing_delegation_map
-            .get(&row.mix_id)
-            .map_or(0, |coin| coin.amount);
-
-        match existing_delegation_amount.cmp(&input_amount) {
-            Ordering::Equal => continue, // No action needed if amounts are equal
-
-            Ordering::Less => {
-                // Delegate the difference if the existing delegation is less
-                let difference = Coin {
-                    amount: input_amount - existing_delegation_amount,
-                    denom: row.amount.denom.clone(),
-                };
-                let mix_id = row.mix_id.clone().parse::<u32>().unwrap();
-                delegation_msgs.push((DelegateToMixnode { mix_id }, vec![difference.clone()]));
-                delegation_table.add_row(&[
-                    row.mix_id.clone(),
-                    pretty_coin(&row.amount),
-                    pretty_coin(&difference),
-                ]);
-            }
-
-            Ordering::Greater => {
-                let mix_id = row.mix_id.clone().parse::<u32>().unwrap();
-                let coins: Vec<Coin> = vec![];
-                undelegation_msgs.push((UndelegateFromMixnode { mix_id }, coins));
-                undelegation_table.add_row(&[row.mix_id.clone()]);
-
-                if row.amount.amount > 0 {
-                    delegation_msgs.push((DelegateToMixnode { mix_id }, vec![row.amount.clone()]));
-                    delegation_table.add_row(&[
-                        row.mix_id.clone(),
-                        pretty_coin(&row.amount),
-                        pretty_coin(&row.amount),
-                    ]);
-                }
-            }
-        }
-    }
-
-    if delegation_msgs.is_empty() && undelegation_msgs.is_empty() {
-        println!("Nothing to do. Delegations are up-to-date!");
-        return;
-    }
-
-    if !undelegation_msgs.is_empty() {
-        println!("Undelegation records : \n{}\n\n", undelegation_table);
-    }
-
-    if !delegation_msgs.is_empty() {
-        println!("Delegation records : \n{}\n\n", delegation_table);
-    }
-
-    let ans = inquire::Confirm::new("Do you want to continue with the shown operations?")
-        .with_default(false)
-        .with_help_message("You must confirm before the transactions are signed")
-        .prompt();
-
-    if let Err(e) = ans {
-        info!("Aborting, {}...", e);
-        return;
-    }
-
-    if let Ok(false) = ans {
-        info!("Aborting:: User denied proceeding with signing!");
-        return;
-    }
-
-    let mut output_details: Vec<[String; 3]> = Vec::new();
-    let now = time::OffsetDateTime::now_utc();
-    let now = now
-        .format(&time::format_description::well_known::Rfc3339)
-        .unwrap();
-
-    let mixnet_contract = client
-        .mixnet_contract_address()
-        .expect("mixnet contract address is not available");
-
-    // Execute all undelegation transactions
-    if !undelegation_msgs.is_empty() {
-        let res = client
-            .execute_multiple(
-                mixnet_contract,
-                undelegation_msgs.clone(),
-                None,
-                format!(
-                    "Undelegate from {} nodes via nym-cli",
-                    undelegation_msgs.len()
-                ),
-            )
-            .await
-            .expect("Could not undelegate!");
-
-        println!(
-            "Undelegation transaction successful : {}",
-            res.transaction_hash
-        );
-        output_details.push([
-            "Undelegate".to_string(),
-            res.transaction_hash.to_string(),
-            now.clone(),
-        ]);
-    }
-
-    // Execute all  delegation delegations
-    if !delegation_msgs.is_empty() {
-        let res = client
-            .execute_multiple(
-                mixnet_contract,
-                delegation_msgs,
-                None,
-                format!(
-                    "Delegatation to {} nodes via nym-cli",
-                    undelegation_msgs.len()
-                ),
-            )
-            .await
-            .expect("Could not delegate");
-
-        println!(
-            "Delegation transaction successful : {}",
-            res.transaction_hash
-        );
-        output_details.push([
-            "Delegate".to_string(),
-            res.transaction_hash.to_string(),
-            now.clone(),
-        ]);
-    }
-
-    if args.output.is_some() {
-        if let Err(e) = write_to_csv(output_details, args.output) {
-            info!("Failed to write to CSV, {}", e);
-        }
-    }
-}
@@ -6,7 +6,6 @@ use clap::{Args, Subcommand};
 pub mod rewards;

 pub mod delegate_to_mixnode;
-pub mod delegate_to_multiple_mixnodes;
 pub mod query_for_delegations;
 pub mod undelegate_from_mixnode;
 pub mod vesting_delegate_to_mixnode;
@@ -27,8 +26,6 @@ pub enum MixnetDelegatorsCommands {
    Rewards(rewards::MixnetDelegatorsReward),
    /// Delegate to a mixnode
    Delegate(delegate_to_mixnode::Args),
-    /// Perform bulk delegations from an input file
-    DelegateMulti(delegate_to_multiple_mixnodes::Args),
    /// Undelegate from a mixnode
    Undelegate(undelegate_from_mixnode::Args),
    /// Delegate to a mixnode with locked tokens
@@ -1,16 +0,0 @@
-[package]
-name = "nym-ecash-contract-common"
-version = "0.1.0"
-edition = "2021"
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cosmwasm-std = { workspace = true }
-cosmwasm-schema = { workspace = true }
-cw2 = { workspace = true, optional = true }
-nym-multisig-contract-common = { path = "../multisig-contract" }
-
-[features]
-schema = ["cw2"]
@@ -1,110 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::cw_serde;
-
-#[cw_serde]
-pub struct BlacklistedAccount {
-    public_key: String,
-}
-
-impl BlacklistedAccount {
-    pub fn new(public_key: String) -> Self {
-        BlacklistedAccount { public_key }
-    }
-
-    pub fn public_key(&self) -> &str {
-        &self.public_key
-    }
-}
-
-#[cw_serde]
-pub struct PagedBlacklistedAccountResponse {
-    pub accounts: Vec<BlacklistedAccount>,
-    pub per_page: usize,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<String>,
-}
-
-impl PagedBlacklistedAccountResponse {
-    pub fn new(
-        accounts: Vec<BlacklistedAccount>,
-        per_page: usize,
-        start_next_after: Option<String>,
-    ) -> Self {
-        PagedBlacklistedAccountResponse {
-            accounts,
-            per_page,
-            start_next_after,
-        }
-    }
-}
-
-#[cw_serde]
-pub struct BlacklistedAccountResponse {
-    pub account: Option<BlacklistedAccount>,
-}
-
-impl BlacklistedAccountResponse {
-    pub fn new(account: Option<BlacklistedAccount>) -> Self {
-        BlacklistedAccountResponse { account }
-    }
-}
-
-#[cw_serde]
-pub struct BlacklistProposal {
-    public_key: String,
-    proposal_id: u64,
-}
-
-impl BlacklistProposal {
-    pub fn new(public_key: String, proposal_id: u64) -> Self {
-        BlacklistProposal {
-            public_key,
-            proposal_id,
-        }
-    }
-
-    pub fn public_key(&self) -> &str {
-        &self.public_key
-    }
-
-    pub fn proposal_id(&self) -> u64 {
-        self.proposal_id
-    }
-}
-
-#[cw_serde]
-pub struct PagedBlacklistProposalResponse {
-    pub accounts: Vec<BlacklistProposal>,
-    pub per_page: usize,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<String>,
-}
-
-impl PagedBlacklistProposalResponse {
-    pub fn new(
-        accounts: Vec<BlacklistProposal>,
-        per_page: usize,
-        start_next_after: Option<String>,
-    ) -> Self {
-        PagedBlacklistProposalResponse {
-            accounts,
-            per_page,
-            start_next_after,
-        }
-    }
-}
-
-#[cw_serde]
-pub struct BlacklistProposalResponse {
-    pub account: Option<BlacklistProposal>,
-}
-
-impl BlacklistProposalResponse {
-    pub fn new(account: Option<BlacklistProposal>) -> Self {
-        BlacklistProposalResponse { account }
-    }
-}
@@ -1,4 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub const BANDWIDTH_PROPOSAL_ID: &str = "proposal_id";
@@ -1,20 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// event types
-pub const DEPOSITED_FUNDS_EVENT_TYPE: &str = "deposited-funds";
-
-// a 'wasm-' prefix is added to all cosmwasm events
-pub const COSMWASM_DEPOSITED_FUNDS_EVENT_TYPE: &str = "wasm-deposited-funds";
-
-// attributes that are used in multiple places
-pub const DEPOSIT_VALUE: &str = "deposit-value";
-pub const DEPOSIT_INFO: &str = "deposit-info";
-pub const DEPOSIT_IDENTITY_KEY: &str = "deposit-identity-key";
-pub const DEPOSIT_ENCRYPTION_KEY: &str = "deposit-encryption-key";
-
-pub const TICKET_BOOK_VALUE: u128 = 50_000_000;
-pub const TICKET_VALUE: u128 = 50_000;
-
-pub const BLACKLIST_PROPOSAL_ID: &str = "proposal_id";
-pub const BLACKLIST_PROPOSAL_REPLY_ID: u64 = 7759;
@@ -1,5 +0,0 @@
-pub mod blacklist;
-pub mod event_attributes;
-pub mod events;
-pub mod msg;
-pub mod spend_credential;
@@ -1,58 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::cw_serde;
-
-#[cfg(feature = "schema")]
-use crate::blacklist::BlacklistedAccountResponse;
-#[cfg(feature = "schema")]
-use cosmwasm_schema::QueryResponses;
-
-#[cw_serde]
-pub struct InstantiateMsg {
-    pub multisig_addr: String,
-    pub group_addr: String,
-    pub mix_denom: String,
-}
-
-#[cw_serde]
-pub enum ExecuteMsg {
-    DepositFunds {
-        deposit_info: String,
-        identity_key: String,
-        encryption_key: String,
-    },
-    PrepareCredential {
-        serial_number: String,
-        gateway_cosmos_address: String,
-    },
-    SpendCredential {
-        serial_number: String,
-        gateway_cosmos_address: String,
-    },
-    ProposeToBlacklist {
-        public_key: String,
-    },
-    AddToBlacklist {
-        public_key: String,
-    },
-}
-
-#[cw_serde]
-#[cfg_attr(feature = "schema", derive(QueryResponses))]
-pub enum QueryMsg {
-    #[cfg_attr(feature = "schema", returns(BlacklistedAccountResponse))]
-    GetBlacklistedAccount { public_key: String },
-
-    #[cfg_attr(feature = "schema", returns(SpendCredentialResponse))]
-    GetSpentCredential { serial_number: String },
-
-    #[cfg_attr(feature = "schema", returns(PagedSpendCredentialResponse))]
-    GetAllSpentCredentials {
-        limit: Option<u32>,
-        start_after: Option<String>,
-    },
-}
-
-// #[cw_serde]
-// pub struct MigrateMsg {}
@@ -1,77 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::msg::ExecuteMsg;
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{from_binary, CosmosMsg, WasmMsg};
-
-#[cw_serde]
-pub struct EcashSpentCredential {
-    serial_number: String,
-    gateway_cosmos_address: String,
-}
-
-impl EcashSpentCredential {
-    pub fn new(serial_number: String, gateway_cosmos_address: String) -> Self {
-        EcashSpentCredential {
-            serial_number,
-            gateway_cosmos_address,
-        }
-    }
-
-    pub fn serial_number(&self) -> &str {
-        &self.serial_number
-    }
-}
-
-#[cw_serde]
-pub struct PagedEcashSpentCredentialResponse {
-    pub spend_credentials: Vec<EcashSpentCredential>,
-    pub per_page: usize,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<String>,
-}
-
-impl PagedEcashSpentCredentialResponse {
-    pub fn new(
-        spend_credentials: Vec<EcashSpentCredential>,
-        per_page: usize,
-        start_next_after: Option<String>,
-    ) -> Self {
-        PagedEcashSpentCredentialResponse {
-            spend_credentials,
-            per_page,
-            start_next_after,
-        }
-    }
-}
-
-#[cw_serde]
-pub struct EcashSpentCredentialResponse {
-    pub spend_credential: Option<EcashSpentCredential>,
-}
-
-impl EcashSpentCredentialResponse {
-    pub fn new(spend_credential: Option<EcashSpentCredential>) -> Self {
-        EcashSpentCredentialResponse { spend_credential }
-    }
-}
-
-pub fn check_proposal(msgs: Vec<CosmosMsg>) -> bool {
-    if let Some(CosmosMsg::Wasm(WasmMsg::Execute {
-        contract_addr: _,
-        msg,
-        funds: _,
-    })) = msgs.first()
-    {
-        if let Ok(ExecuteMsg::SpendCredential {
-            serial_number: _,
-            gateway_cosmos_address: _,
-        }) = from_binary::<ExecuteMsg>(msg)
-        {
-            return true;
-        }
-    }
-    false
-}
@@ -1,15 +0,0 @@
-[package]
-name = "nym-country-group"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-serde = { workspace = true, features = ["derive"] }
-tracing.workspace = true
@@ -1,158 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use serde::{Deserialize, Serialize};
-use std::fmt;
-use tracing::info;
-
-#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub enum CountryGroup {
-    Europe,
-    NorthAmerica,
-    SouthAmerica,
-    Oceania,
-    Asia,
-    Africa,
-    Unknown,
-}
-
-impl CountryGroup {
-    // We map country codes into group, which initially are continent codes to a first approximation,
-    // but we do it manually to reserve the right to tweak this distribution for our purposes.
-    // NOTE: I did this quickly, and it's not a complete list of all countries, but only those that
-    // were present in the network at the time. Please add more as needed.
-    pub fn new(country_code: &str) -> Self {
-        let country_code = country_code.to_uppercase();
-        use CountryGroup::*;
-        match country_code.as_ref() {
-            // Europe
-            "AT" => Europe,
-            "BG" => Europe,
-            "CH" => Europe,
-            "CY" => Europe,
-            "CZ" => Europe,
-            "DE" => Europe,
-            "DK" => Europe,
-            "ES" => Europe,
-            "FI" => Europe,
-            "FR" => Europe,
-            "GB" => Europe,
-            "GR" => Europe,
-            "IE" => Europe,
-            "IT" => Europe,
-            "LT" => Europe,
-            "LU" => Europe,
-            "LV" => Europe,
-            "MD" => Europe,
-            "MT" => Europe,
-            "NL" => Europe,
-            "NO" => Europe,
-            "PL" => Europe,
-            "RO" => Europe,
-            "SE" => Europe,
-            "SK" => Europe,
-            "TR" => Europe,
-            "UA" => Europe,
-
-            // North America
-            "CA" => NorthAmerica,
-            "MX" => NorthAmerica,
-            "US" => NorthAmerica,
-
-            // South America
-            "AR" => SouthAmerica,
-            "BR" => SouthAmerica,
-            "CL" => SouthAmerica,
-            "CO" => SouthAmerica,
-            "CR" => SouthAmerica,
-            "GT" => SouthAmerica,
-
-            // Oceania
-            "AU" => Oceania,
-
-            // Asia
-            "AM" => Asia,
-            "BH" => Asia,
-            "CN" => Asia,
-            "GE" => Asia,
-            "HK" => Asia,
-            "ID" => Asia,
-            "IL" => Asia,
-            "IN" => Asia,
-            "JP" => Asia,
-            "KH" => Asia,
-            "KR" => Asia,
-            "KZ" => Asia,
-            "MY" => Asia,
-            "RU" => Asia,
-            "SG" => Asia,
-            "TH" => Asia,
-            "VN" => Asia,
-
-            // Africa
-            "SC" => Africa,
-            "UG" => Africa,
-            "ZA" => Africa,
-
-            // And group level codes work too
-            "EU" => Europe,
-            "NA" => NorthAmerica,
-            "SA" => SouthAmerica,
-            "OC" => Oceania,
-            "AS" => Asia,
-            "AF" => Africa,
-
-            // And some aliases
-            "EUROPE" => Europe,
-            "NORTHAMERICA" => NorthAmerica,
-            "SOUTHAMERICA" => SouthAmerica,
-            "OCEANIA" => Oceania,
-            "ASIA" => Asia,
-            "AFRICA" => Africa,
-
-            _ => {
-                info!("Unknown country code: {country_code}");
-                Unknown
-            }
-        }
-    }
-}
-
-impl fmt::Display for CountryGroup {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use CountryGroup::*;
-        match self {
-            Europe => write!(f, "EU"),
-            NorthAmerica => write!(f, "NA"),
-            SouthAmerica => write!(f, "SA"),
-            Oceania => write!(f, "OC"),
-            Asia => write!(f, "AS"),
-            Africa => write!(f, "AF"),
-            Unknown => write!(f, "Unknown"),
-        }
-    }
-}
-
-impl std::str::FromStr for CountryGroup {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let group = CountryGroup::new(s);
-        if group == CountryGroup::Unknown {
-            Err(())
-        } else {
-            Ok(group)
-        }
-    }
-}
-
-impl CountryGroup {
-    #[allow(unused)]
-    fn known(self) -> Option<CountryGroup> {
-        use CountryGroup::*;
-        match self {
-            Europe | NorthAmerica | SouthAmerica | Oceania | Asia | Africa => Some(self),
-            Unknown => None,
-        }
-    }
-}
@@ -1,48 +0,0 @@
-/*
- * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-ALTER TABLE coconut_credentials
-    RENAME TO old_coconut_credentials;
-
-CREATE TABLE coconut_credentials
-(
-    id                     INTEGER                                                                     NOT NULL PRIMARY KEY AUTOINCREMENT,
-
--     introduce a way for us to introduce breaking changes in serialization
-    serialization_revision INTEGER                                                                     NOT NULL,
-
--     the best we can do without enums
-    credential_type        TEXT CHECK ( credential_type IN ('BandwidthVoucher', 'FreeBandwidthPass') ) NOT NULL,
-    credential_data        BLOB                                                                        NOT NULL UNIQUE,
-    epoch_id               INTEGER                                                                     NOT NULL,
-
--     this field is only really applicable to free passes
-    expired                BOOLEAN                                                                     NOT NULL
-);
-
-ALTER TABLE credential_usage
-    RENAME TO old_credential_usage;
-
-- for bandwidth vouchers there's going to be only a single entry; for freepasses there can be as many as there are gateways
-CREATE TABLE credential_usage
-(
-    credential_id   INTEGER NOT NULL REFERENCES coconut_credentials (id),
-    gateway_id_bs58 TEXT    NOT NULL,
-
--     no matter credential type, we can't spend the same credential with the same gateway multiple times
-    UNIQUE (credential_id, gateway_id_bs58)
-);
-
-INSERT INTO coconut_credentials
-SELECT *
-FROM old_coconut_credentials;
-
-
-INSERT INTO credential_usage
-SELECT *
-FROM old_credential_usage;
-
-DROP TABLE old_coconut_credentials;
-DROP TABLE old_credential_usage;
@@ -1,25 +0,0 @@
-/*
- * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-CREATE TABLE coin_indices_signatures
-(
-    epoch_id                TEXT NOT NULL PRIMARY KEY,
-    signatures              TEXT NOT NULL
-);
-
-CREATE TABLE ecash_credentials
-(
-    id                     INTEGER                                                                  NOT NULL PRIMARY KEY AUTOINCREMENT,
-
--     introduce a way for us to introduce breaking changes in serialization
-serialization_revision INTEGER                                                                      NOT NULL,
-
--     the best we can do without enums
-    credential_type        TEXT CHECK ( credential_type IN ('TicketBook', 'FreeBandwidthPass') )    NOT NULL,
-    credential_data        BLOB                                                                     NOT NULL UNIQUE,
-    epoch_id               INTEGER                                                                  NOT NULL,
-    expired                BOOLEAN                                                                  NOT NULL,
-    consumed               BOOLEAN                                                                  NOT NULL
-);
@@ -1,20 +1,19 @@
 // Copyright 2023-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::models::CoinIndicesSignature;
-use crate::models::StoredIssuedCredential;
+use crate::models::{CredentialUsage, StoredIssuedCredential};
 use std::sync::Arc;
 use tokio::sync::RwLock;

 #[derive(Clone)]
 pub struct CoconutCredentialManager {
    inner: Arc<RwLock<CoconutCredentialManagerInner>>,
-    coin_indices_sig: Arc<RwLock<Vec<CoinIndicesSignature>>>,
 }

 #[derive(Default)]
 struct CoconutCredentialManagerInner {
    credentials: Vec<StoredIssuedCredential>,
+    credential_usage: Vec<CredentialUsage>,
    _next_id: i64,
 }

@@ -31,7 +30,6 @@ impl CoconutCredentialManager {
    pub fn new() -> Self {
        CoconutCredentialManager {
            inner: Default::default(),
-            coin_indices_sig: Default::default(),
        }
    }

@@ -51,33 +49,56 @@ impl CoconutCredentialManager {
            credential_type,
            epoch_id,
            expired: false,
-            consumed: false,
        })
    }

+    async fn bandwidth_voucher_spent(&self, id: i64) -> bool {
+        self.inner
+            .read()
+            .await
+            .credential_usage
+            .iter()
+            .any(|c| c.credential_id == id)
+    }
+
+    async fn freepass_spent(&self, id: i64, gateway_id: &str) -> bool {
+        self.inner
+            .read()
+            .await
+            .credential_usage
+            .iter()
+            .any(|c| c.credential_id == id && c.gateway_id_bs58 == gateway_id)
+    }
+
    /// Tries to retrieve one of the stored, unused credentials.
-    pub async fn get_next_unspent_ticketbook(&self) -> Option<StoredIssuedCredential> {
+    pub async fn get_next_unspect_bandwidth_voucher(&self) -> Option<StoredIssuedCredential> {
        let guard = self.inner.read().await;
        for credential in guard
            .credentials
            .iter()
-            .filter(|c| c.credential_type == "TicketBook")
+            .filter(|c| c.credential_type == "BandwidthVoucher")
        {
-            if !credential.consumed && !credential.expired {
+            if !self.bandwidth_voucher_spent(credential.id).await {
                return Some(credential.clone());
            }
        }
        None
    }

-    pub async fn get_next_unspent_freepass(&self) -> Option<StoredIssuedCredential> {
+    pub async fn get_next_unspect_freepass(
+        &self,
+        gateway_id: &str,
+    ) -> Option<StoredIssuedCredential> {
        let guard = self.inner.read().await;
        for credential in guard
            .credentials
            .iter()
            .filter(|c| c.credential_type == "FreeBandwidthPass")
        {
-            if !credential.consumed && !credential.expired {
+            if credential.expired {
+                continue;
+            }
+            if !self.freepass_spent(credential.id, gateway_id).await {
                return Some(credential.clone());
            }
        }
@@ -89,55 +110,14 @@ impl CoconutCredentialManager {
    /// # Arguments
    ///
    /// * `id`: Database id.
-    pub async fn consume_coconut_credential(&self, id: i64) {
+    pub async fn consume_coconut_credential(&self, id: i64, gateway_id: &str) {
        let mut guard = self.inner.write().await;
-        if let Some(cred) = guard.credentials.get_mut(id as usize) {
-            cred.consumed = true;
-        }
-    }
-
-    pub async fn update_issued_credential(&self, credential_data: &[u8], id: i64, consumed: bool) {
-        let mut guard = self.inner.write().await;
-        if let Some(cred) = guard.credentials.get_mut(id as usize) {
-            cred.credential_data = credential_data.to_vec();
-            cred.consumed = consumed;
-        }
-    }
-
-    /// Inserts provided coin_indices_signatures into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    /// * `coin_indices_signatures` : The coin indices signatures for the epoch
-    pub async fn insert_coin_indices_sig(&self, epoch_id: String, coin_indices_sig: String) {
-        let mut signatures = self.coin_indices_sig.write().await;
-        signatures.push(CoinIndicesSignature {
-            epoch_id,
-            signatures: coin_indices_sig,
+        guard.credential_usage.push(CredentialUsage {
+            credential_id: id,
+            gateway_id_bs58: gateway_id.to_string(),
        });
    }

-    /// Check if coin indices signatures are present for a given epoch
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    pub async fn is_coin_indices_sig_present(&self, epoch_id: String) -> bool {
-        let sigs = self.coin_indices_sig.read().await;
-        sigs.iter().any(|s| s.epoch_id == epoch_id)
-    }
-
-    /// Get coin_indices_signatures of a given epoch.
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    pub async fn get_coin_indices_sig(&self, epoch_id: String) -> Option<CoinIndicesSignature> {
-        let sigs = self.coin_indices_sig.read().await;
-        sigs.iter().find(|s| s.epoch_id == epoch_id).cloned()
-    }
-
    /// Marks the specified credential as expired
    ///
    /// # Arguments
@@ -1,7 +1,6 @@
 // Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::models::CoinIndicesSignature;
 use crate::models::StoredIssuedCredential;

 #[derive(Clone)]
@@ -28,45 +27,50 @@ impl CoconutCredentialManager {
    ) -> Result<(), sqlx::Error> {
        sqlx::query!(
            r#"
-                INSERT INTO ecash_credentials(serialization_revision, credential_type, credential_data, epoch_id, expired, consumed)
-                VALUES (?, ?, ?, ?, false, false)
+                INSERT INTO coconut_credentials(serialization_revision, credential_type, credential_data, epoch_id, expired)
+                VALUES (?, ?, ?, ?, false)
            "#,
            serialization_revision, credential_type, credential_data, epoch_id
        ).execute(&self.connection_pool).await?;
        Ok(())
    }

-    pub async fn get_next_unspent_freepass(
+    pub async fn get_next_unspect_freepass(
        &self,
+        gateway_id: &str,
    ) -> Result<Option<StoredIssuedCredential>, sqlx::Error> {
-        // get a credential of freepass type
+        // get a credential of freepass type that doesn't appear in `credential_usage` for the provided gateway_id
        sqlx::query_as(
            r#"
                SELECT * 
-                FROM ecash_credentials
-                WHERE credential_type == "FreeBandwidthPass" 
-                AND expired = false
-                AND consumed = false
-                ORDER BY id ASC
+                FROM coconut_credentials
+                WHERE coconut_credentials.credential_type == "FreeBandwidthPass"
+                      AND NOT EXISTS (SELECT 1
+                                      FROM   credential_usage
+                                      WHERE  credential_usage.credential_id = coconut_credentials.id
+                                             AND credential_usage.gateway_id_bs58 == ?)
+                ORDER BY coconut_credentials.id
                LIMIT 1
            "#,
        )
+        .bind(gateway_id)
        .fetch_optional(&self.connection_pool)
        .await
    }

-    pub async fn get_next_unspent_ticketbook(
+    pub async fn get_next_unspect_bandwidth_voucher(
        &self,
    ) -> Result<Option<StoredIssuedCredential>, sqlx::Error> {
-        // get a credential of bandwidth voucher type
+        // get a credential of bandwidth voucher type that doesn't appear in `credential_usage` for any gateway_id
        sqlx::query_as(
            r#"
                SELECT * 
-                FROM ecash_credentials
-                WHERE credential_type == "TicketBook"
-                AND expired = false
-                AND consumed = false
-                ORDER BY id ASC
+                FROM coconut_credentials
+                WHERE coconut_credentials.credential_type == "BandwidthVoucher"
+                      AND NOT EXISTS (SELECT 1
+                                      FROM   credential_usage
+                                      WHERE  credential_usage.credential_id = coconut_credentials.id)
+                ORDER BY coconut_credentials.id
                LIMIT 1
            "#,
        )
@@ -80,32 +84,21 @@ impl CoconutCredentialManager {
    ///
    /// * `id`: Database id.
    /// * `gateway_id`: id of the gateway that received the credential
-    pub async fn consume_coconut_credential(&self, id: i64) -> Result<(), sqlx::Error> {
+    pub async fn consume_coconut_credential(
+        &self,
+        id: i64,
+        gateway_id: &str,
+    ) -> Result<(), sqlx::Error> {
        sqlx::query!(
-            "UPDATE ecash_credentials SET consumed = TRUE WHERE id = ?",
-            id
+            "INSERT INTO credential_usage (credential_id, gateway_id_bs58) VALUES (?, ?)",
+            id,
+            gateway_id
        )
        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }

-    pub async fn update_issued_credential(
-        &self,
-        credential_data: &[u8],
-        id: i64,
-        consumed: bool,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            "UPDATE ecash_credentials SET credential_data = ?, consumed = ? WHERE id = ?",
-            credential_data,
-            consumed,
-            id
-        )
-        .execute(&self.connection_pool)
-        .await?;
-        Ok(())
-    }
    /// Marks the specified credential as expired
    ///
    /// # Arguments
@@ -113,65 +106,11 @@ impl CoconutCredentialManager {
    /// * `id`: Id of the credential to mark as expired.
    pub async fn mark_expired(&self, id: i64) -> Result<(), sqlx::Error> {
        sqlx::query!(
-            "UPDATE ecash_credentials SET expired = TRUE WHERE id = ?",
+            "UPDATE coconut_credentials SET expired = TRUE WHERE id = ?",
            id
        )
        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }
-
-    /// Inserts provided coin_indices_signatures into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    /// * `coin_indices_signatures` : The coin indices signatures for the epoch
-    pub async fn insert_coin_indices_sig(
-        &self,
-        epoch_id: String,
-        coin_indices_sig: String,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            "INSERT INTO coin_indices_signatures(epoch_id, signatures) VALUES (?, ?)",
-            epoch_id,
-            coin_indices_sig
-        )
-        .execute(&self.connection_pool)
-        .await?;
-        Ok(())
-    }
-
-    /// Check if coin indices signatures are present for a given epoch
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    pub async fn is_coin_indices_sig_present(&self, epoch_id: String) -> Result<bool, sqlx::Error> {
-        sqlx::query!(
-            "SELECT epoch_id FROM coin_indices_signatures WHERE epoch_id = ?",
-            epoch_id
-        )
-        .fetch_optional(&self.connection_pool)
-        .await
-        .map(|r| r.is_some())
-    }
-
-    /// Get coin_indices_signatures of a given epoch.
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    pub async fn get_coin_indices_sig(
-        &self,
-        epoch_id: String,
-    ) -> Result<Option<CoinIndicesSignature>, sqlx::Error> {
-        sqlx::query_as!(
-            CoinIndicesSignature,
-            "SELECT * FROM coin_indices_signatures WHERE epoch_id = ?",
-            epoch_id
-        )
-        .fetch_optional(&self.connection_pool)
-        .await
-    }
 }
@@ -5,7 +5,6 @@ use std::fmt::{self, Debug, Formatter};

 use crate::backends::memory::CoconutCredentialManager;
 use crate::error::StorageError;
-use crate::models::CoinIndicesSignature;
 use crate::models::{StorableIssuedCredential, StoredIssuedCredential};
 use crate::storage::Storage;
 use async_trait::async_trait;
@@ -53,11 +52,12 @@ impl Storage for EphemeralStorage {

    async fn get_next_unspent_credential(
        &self,
+        gateway_id: &str,
    ) -> Result<Option<StoredIssuedCredential>, Self::StorageError> {
        // first try to get a free pass if available, otherwise fallback to bandwidth voucher
        let maybe_freepass = self
            .coconut_credential_manager
-            .get_next_unspent_freepass()
+            .get_next_unspect_freepass(gateway_id)
            .await;
        if maybe_freepass.is_some() {
            return Ok(maybe_freepass);
@@ -65,58 +65,22 @@ impl Storage for EphemeralStorage {

        Ok(self
            .coconut_credential_manager
-            .get_next_unspent_ticketbook()
+            .get_next_unspect_bandwidth_voucher()
            .await)
    }

-    async fn consume_coconut_credential(&self, id: i64) -> Result<(), StorageError> {
-        self.coconut_credential_manager
-            .consume_coconut_credential(id)
-            .await;
-
-        Ok(())
-    }
-
-    async fn update_issued_credential<'a>(
+    async fn consume_coconut_credential(
        &self,
-        bandwidth_credential: StorableIssuedCredential<'a>,
        id: i64,
-        consumed: bool,
+        gateway_id: &str,
    ) -> Result<(), StorageError> {
        self.coconut_credential_manager
-            .update_issued_credential(bandwidth_credential.credential_data, id, consumed)
+            .consume_coconut_credential(id, gateway_id)
            .await;
+
        Ok(())
    }

-    async fn insert_coin_indices_sig(
-        &self,
-        epoch_id: String,
-        coin_indices_sig: String,
-    ) -> Result<(), StorageError> {
-        self.coconut_credential_manager
-            .insert_coin_indices_sig(epoch_id, coin_indices_sig)
-            .await;
-        Ok(())
-    }
-
-    async fn is_coin_indices_sig_present(&self, epoch_id: String) -> Result<bool, StorageError> {
-        Ok(self
-            .coconut_credential_manager
-            .is_coin_indices_sig_present(epoch_id)
-            .await)
-    }
-
-    async fn get_coin_indices_sig(
-        &self,
-        epoch_id: String,
-    ) -> Result<CoinIndicesSignature, StorageError> {
-        self.coconut_credential_manager
-            .get_coin_indices_sig(epoch_id)
-            .await
-            .ok_or(StorageError::NoSignatures)
-    }
-
    async fn mark_expired(&self, id: i64) -> Result<(), Self::StorageError> {
        self.coconut_credential_manager.mark_expired(id).await;

@@ -18,7 +18,4 @@ pub enum StorageError {

    #[error("No unused credential in database. You need to buy at least one")]
    NoCredential,
-
-    #[error("No signatures for that epoch in the database")]
-    NoSignatures,
 }
@@ -27,7 +27,6 @@ pub struct StoredIssuedCredential {

    pub epoch_id: u32,
    pub expired: bool,
-    pub consumed: bool,
 }

 pub struct StorableIssuedCredential<'a> {
@@ -43,9 +42,3 @@ pub struct CredentialUsage {
    pub credential_id: i64,
    pub gateway_id_bs58: String,
 }
-
-#[derive(Clone)]
-pub struct CoinIndicesSignature {
-    pub epoch_id: String,
-    pub signatures: String,
-}
@@ -5,7 +5,6 @@ use crate::backends::sqlite::CoconutCredentialManager;
 use crate::error::StorageError;
 use crate::storage::Storage;

-use crate::models::CoinIndicesSignature;
 use crate::models::{StorableIssuedCredential, StoredIssuedCredential};
 use async_trait::async_trait;
 use log::{debug, error};
@@ -77,11 +76,12 @@ impl Storage for PersistentStorage {

    async fn get_next_unspent_credential(
        &self,
+        gateway_id: &str,
    ) -> Result<Option<StoredIssuedCredential>, Self::StorageError> {
        // first try to get a free pass if available, otherwise fallback to bandwidth voucher
        let maybe_freepass = self
            .coconut_credential_manager
-            .get_next_unspent_freepass()
+            .get_next_unspect_freepass(gateway_id)
            .await?;
        if maybe_freepass.is_some() {
            return Ok(maybe_freepass);
@@ -89,62 +89,22 @@ impl Storage for PersistentStorage {

        Ok(self
            .coconut_credential_manager
-            .get_next_unspent_ticketbook()
+            .get_next_unspect_bandwidth_voucher()
            .await?)
    }

-    async fn consume_coconut_credential(&self, id: i64) -> Result<(), StorageError> {
-        self.coconut_credential_manager
-            .consume_coconut_credential(id)
-            .await?;
-
-        Ok(())
-    }
-
-    async fn update_issued_credential<'a>(
+    async fn consume_coconut_credential(
        &self,
-        bandwidth_credential: StorableIssuedCredential<'a>,
        id: i64,
-        consumed: bool,
-    ) -> Result<(), Self::StorageError> {
-        self.coconut_credential_manager
-            .update_issued_credential(bandwidth_credential.credential_data, id, consumed)
-            .await?;
-
-        Ok(())
-    }
-
-    async fn insert_coin_indices_sig(
-        &self,
-        epoch_id: String,
-        coin_indices_sig: String,
+        gateway_id: &str,
    ) -> Result<(), StorageError> {
        self.coconut_credential_manager
-            .insert_coin_indices_sig(epoch_id, coin_indices_sig)
+            .consume_coconut_credential(id, gateway_id)
            .await?;
+
        Ok(())
    }

-    async fn is_coin_indices_sig_present(
-        &self,
-        epoch_id: String,
-    ) -> Result<bool, Self::StorageError> {
-        Ok(self
-            .coconut_credential_manager
-            .is_coin_indices_sig_present(epoch_id)
-            .await?)
-    }
-
-    async fn get_coin_indices_sig(
-        &self,
-        epoch_id: String,
-    ) -> Result<CoinIndicesSignature, StorageError> {
-        self.coconut_credential_manager
-            .get_coin_indices_sig(epoch_id)
-            .await?
-            .ok_or(StorageError::NoSignatures)
-    }
-
    async fn mark_expired(&self, id: i64) -> Result<(), Self::StorageError> {
        self.coconut_credential_manager.mark_expired(id).await?;

@@ -1,7 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::models::CoinIndicesSignature;
 use crate::models::{StorableIssuedCredential, StoredIssuedCredential};
 use async_trait::async_trait;
 use std::error::Error;
@@ -19,6 +18,7 @@ pub trait Storage: Send + Sync {
    /// that is also not marked as expired
    async fn get_next_unspent_credential(
        &self,
+        gateway_id: &str,
    ) -> Result<Option<StoredIssuedCredential>, Self::StorageError>;

    /// Marks as consumed in the database the specified credential.
@@ -26,54 +26,13 @@ pub trait Storage: Send + Sync {
    /// # Arguments
    ///
    /// * `id`: Id of the credential to be consumed.
-    async fn consume_coconut_credential(&self, id: i64) -> Result<(), Self::StorageError>;
-
-    /// Update in the database the specified credential.
-    ///
-    /// # Arguments
-    ///
-    /// * `bandwidth_credential` : New credential
-    /// * `id`: Id of the credential to be updated.
-    /// * `consumed`: if the credential is consumed or not
-    ///
-    async fn update_issued_credential<'a>(
+    /// * `gateway_id`: id of the gateway that received the credential.
+    async fn consume_coconut_credential(
        &self,
-        bandwidth_credential: StorableIssuedCredential<'a>,
        id: i64,
-        consumed: bool,
+        gateway_id: &str,
    ) -> Result<(), Self::StorageError>;

-    /// Inserts provided coin_indices_signatures into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    /// * `coin_indices_signatures` : The coin indices signatures for the epoch
-    async fn insert_coin_indices_sig(
-        &self,
-        epoch_id: String,
-        coin_indices_sig: String,
-    ) -> Result<(), Self::StorageError>;
-
-    /// Check if coin indices signatures are present for a given epoch
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    async fn is_coin_indices_sig_present(
-        &self,
-        epoch_id: String,
-    ) -> Result<bool, Self::StorageError>;
-
-    /// Get coin_indices_signatures of a given epoch.
-    ///
-    /// # Arguments
-    ///
-    /// * `epoch_id`: Id of the epoch.
-    async fn get_coin_indices_sig(
-        &self,
-        epoch_id: String,
-    ) -> Result<CoinIndicesSignature, Self::StorageError>;
    /// Marks the specified credential as expired
    ///
    /// # Arguments
@@ -18,4 +18,3 @@ nym-credential-storage = { path = "../../common/credential-storage" }
 nym-validator-client = { path = "../../common/client-libs/validator-client" }
 nym-config = { path = "../../common/config" }
 nym-client-core = { path = "../../common/client-core" }
-nym-compact-ecash = { path = "../../common/nym_offline_compact_ecash" }
@@ -53,7 +53,7 @@ impl RecoveryStorage {

    pub fn voucher_filename(voucher: &IssuanceBandwidthCredential) -> String {
        let prefix = voucher.typ().to_string();
-        let suffix = voucher.ecash_pubkey_bs58();
+        let suffix = voucher.blinded_serial_number_bs58();
        format!("{prefix}-{suffix}.{DUMPED_VOUCHER_EXTENSION}")
    }

@@ -7,8 +7,9 @@ use nym_config::DEFAULT_DATA_DIR;
 use nym_credential_storage::persistent_storage::PersistentStorage;
 use nym_credentials::coconut::bandwidth::CredentialType;
 use nym_validator_client::nyxd::contract_traits::{
-    dkg_query_client::EpochState, DkgQueryClient, EcashSigningClient,
+    dkg_query_client::EpochState, CoconutBandwidthSigningClient, DkgQueryClient,
 };
+use nym_validator_client::nyxd::Coin;
 use std::path::PathBuf;
 use std::process::exit;
 use std::time::{Duration, SystemTime};
@@ -17,12 +18,12 @@ const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute

 pub async fn issue_credential<C>(
    client: &C,
-    client_id: &[u8],
+    amount: Coin,
    persistent_storage: &PersistentStorage,
    recovery_storage_path: PathBuf,
 ) -> Result<()>
 where
-    C: DkgQueryClient + EcashSigningClient + Send + Sync,
+    C: DkgQueryClient + CoconutBandwidthSigningClient + Send + Sync,
 {
    let recovery_storage = setup_recovery_storage(recovery_storage_path).await;

@@ -41,8 +42,7 @@ where
        }
    };

-    let state = nym_bandwidth_controller::acquire::deposit(client, client_id).await?;
-    info!("Deposit done");
+    let state = nym_bandwidth_controller::acquire::deposit(client, amount.clone()).await?;

    if nym_bandwidth_controller::acquire::get_bandwidth_voucher(&state, client, persistent_storage)
        .await
@@ -63,7 +63,7 @@ where
        ));
    }

-    info!("Succeeded adding a ticketbook credential");
+    info!("Succeeded adding a credential with amount {amount}");

    Ok(())
 }
@@ -130,25 +130,15 @@ where
    let mut recovered_amount: u128 = 0;
    for voucher in recovery_storage.unconsumed_vouchers()? {
        let voucher_value = match voucher.typ() {
-            CredentialType::TicketBook => voucher.value(),
-            CredentialType::Voucher => {
-                error!("Impossible to recover old coconut voucher");
-                continue;
-            }
+            CredentialType::Voucher => voucher.get_bandwidth_attribute(),
            CredentialType::FreePass => {
                error!("unimplemented recovery of free pass credentials");
                continue;
            }
        };
-        recovered_amount += voucher_value;
+        recovered_amount += voucher_value.parse::<u128>()?;

        let voucher_name = RecoveryStorage::voucher_filename(&voucher);
-
-        if voucher.check_expiration_date() {
-            //We did change the expiration
-            warn!("Deposit {} was made with a different expiration date, it's validity will be shorter than the max one", voucher_name);
-        }
-
        let state = State::new(voucher);

        if let Err(e) =
@@ -15,5 +15,4 @@ bls12_381 = { workspace = true, default-features = false }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }

-nym-compact-ecash = { path = "../nym_offline_compact_ecash" }
 nym-coconut = { path = "../nymcoconut" }
@@ -1,28 +1,21 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use bls12_381::Scalar;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 use std::str::FromStr;
 use thiserror::Error;

-pub use nym_compact_ecash::{
-    aggregate_verification_keys, aggregate_wallets, constants, error::CompactEcashError,
-    generate_keypair_user, generate_keypair_user_from_seed, issue_verify,
-    scheme::expiration_date_signatures::aggregate_expiration_signatures,
-    scheme::expiration_date_signatures::date_scalar,
-    scheme::expiration_date_signatures::ExpirationDateSignature,
-    scheme::expiration_date_signatures::PartialExpirationDateSignature,
-    scheme::keygen::KeyPairUser, scheme::setup::aggregate_indices_signatures,
-    scheme::setup::CoinIndexSignature, scheme::setup::PartialCoinIndexSignature,
-    scheme::withdrawal::RequestInfo, scheme::Payment, scheme::Wallet, setup::setup,
-    setup::Parameters, utils::BlindedSignature, withdrawal_request, Base58, Bytable,
-    GroupParameters, PartialWallet, PayInfo, PublicKeyUser, SecretKeyUser, VerificationKeyAuth,
-    WithdrawalRequest,
+pub use nym_coconut::{
+    aggregate_signature_shares, aggregate_verification_keys, blind_sign, hash_to_scalar, keygen,
+    prepare_blind_sign, prove_bandwidth_credential, verify_credential, Attribute, Base58,
+    BlindSignRequest, BlindedSerialNumber, BlindedSignature, Bytable, CoconutError, KeyPair,
+    Parameters, PrivateAttribute, PublicAttribute, SecretKey, Signature, SignatureShare,
+    VerificationKey, VerifyCredentialRequest,
 };

 pub const VOUCHER_INFO_TYPE: &str = "BandwidthVoucher";
-pub const ECASH_INFO_TYPE: &str = "TicketBook";
 pub const FREE_PASS_INFO_TYPE: &str = "FreeBandwidthPass";

 // pub trait NymCredential {
@@ -36,7 +29,6 @@ pub struct UnknownCredentialType(String);
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub enum CredentialType {
    Voucher,
-    TicketBook,
    FreePass,
 }

@@ -44,12 +36,10 @@ impl FromStr for CredentialType {
    type Err = UnknownCredentialType;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s == ECASH_INFO_TYPE {
-            Ok(CredentialType::TicketBook)
+        if s == VOUCHER_INFO_TYPE {
+            Ok(CredentialType::Voucher)
        } else if s == FREE_PASS_INFO_TYPE {
            Ok(CredentialType::FreePass)
-        } else if s == VOUCHER_INFO_TYPE {
-            Ok(CredentialType::Voucher)
        } else {
            Err(UnknownCredentialType(s.to_string()))
        }
@@ -59,7 +49,6 @@ impl FromStr for CredentialType {
 impl CredentialType {
    pub fn validate(&self, type_plain: &str) -> bool {
        match self {
-            CredentialType::TicketBook => type_plain == ECASH_INFO_TYPE,
            CredentialType::Voucher => type_plain == VOUCHER_INFO_TYPE,
            CredentialType::FreePass => type_plain == FREE_PASS_INFO_TYPE,
        }
@@ -69,10 +58,6 @@ impl CredentialType {
        matches!(self, CredentialType::FreePass)
    }

-    pub fn is_ticketbook(&self) -> bool {
-        matches!(self, CredentialType::TicketBook)
-    }
-
    pub fn is_voucher(&self) -> bool {
        matches!(self, CredentialType::Voucher)
    }
@@ -81,7 +66,6 @@ impl CredentialType {
 impl Display for CredentialType {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
-            CredentialType::TicketBook => ECASH_INFO_TYPE.fmt(f),
            CredentialType::Voucher => VOUCHER_INFO_TYPE.fmt(f),
            CredentialType::FreePass => FREE_PASS_INFO_TYPE.fmt(f),
        }
@@ -90,168 +74,17 @@ impl Display for CredentialType {

 #[derive(Debug, Clone)]
 pub struct CredentialSigningData {
-    pub withdrawal_request: WithdrawalRequest,
+    pub pedersen_commitments_openings: Vec<Scalar>,

-    pub request_info: RequestInfo,
+    pub blind_sign_request: BlindSignRequest,

-    pub ecash_pub_key: PublicKeyUser,
-
-    pub expiration_date: u64,
+    pub public_attributes_plain: Vec<String>,

    pub typ: CredentialType,
 }

-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-pub struct CredentialSpendingData {
-    pub payment: Payment,
-
-    pub pay_info: PayInfo,
-
-    pub spend_date: u64,
-
-    pub value: u64,
-
-    pub typ: CredentialType,
-
-    /// The (DKG) epoch id under which the credential has been issued so that the verifier could use correct verification key for validation.
-    pub epoch_id: u64,
-}
-
-impl CredentialSpendingData {
-    pub fn verify(
-        &self,
-        params: &Parameters,
-        verification_key: &VerificationKeyAuth,
-    ) -> Result<bool, CompactEcashError> {
-        self.payment.spend_verify(
-            params,
-            verification_key,
-            &self.pay_info,
-            date_scalar(self.spend_date),
-        )
-    }
-
-    pub fn serial_number_b58(&self) -> String {
-        self.payment.serial_number_bs58()
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        // simple length prefixed serialization
-        // TODO: change it to a standard format instead
-        let mut bytes = Vec::new();
-        let payment_bytes = self.payment.to_bytes();
-        let typ = self.typ.to_string();
-        let typ_bytes = typ.as_bytes();
-
-        bytes.extend_from_slice(&(payment_bytes.len() as u32).to_be_bytes());
-        bytes.extend_from_slice(&payment_bytes);
-        bytes.extend_from_slice(&self.pay_info.pay_info_bytes); //this is 72 bytes long
-        bytes.extend_from_slice(&self.spend_date.to_be_bytes());
-        bytes.extend_from_slice(&self.value.to_be_bytes());
-        bytes.extend_from_slice(&(typ_bytes.len() as u32).to_be_bytes());
-        bytes.extend_from_slice(typ_bytes);
-        bytes.extend_from_slice(&self.epoch_id.to_be_bytes());
-
-        bytes
-    }
-
-    pub fn try_from_bytes(raw: &[u8]) -> Result<Self, CompactEcashError> {
-        if raw.len() < 72 + 8 + 8 + 8 + 4 + 4 {
-            return Err(CompactEcashError::Deserialization(
-                "Invalid byte array for EcashCredential deserialization".to_string(),
-            ));
-        }
-        let mut index = 0;
-        //SAFETY : casting a slice of lenght 4 into an array of size 4
-        let payment_len = u32::from_be_bytes(raw[index..index + 4].try_into().unwrap()) as usize;
-        index += 4;
-
-        if raw[index..].len() < payment_len {
-            return Err(CompactEcashError::Deserialization(
-                "Invalid byte array for EcashCredential deserialization".to_string(),
-            ));
-        }
-        let payment = Payment::try_from(&raw[index..index + payment_len])?;
-        index += payment_len;
-
-        if raw[index..].len() < 72 + 8 + 8 + 8 + 4 {
-            return Err(CompactEcashError::Deserialization(
-                "Invalid byte array for EcashCredential deserialization".to_string(),
-            ));
-        }
-
-        let pay_info = PayInfo {
-            //SAFETY : casting a slice of lenght 72 into an array of size 72
-            pay_info_bytes: raw[index..index + 72].try_into().unwrap(),
-        };
-        index += 72;
-
-        //SAFETY : casting a slice of lenght 8 into an array of size 8
-        let spend_date = u64::from_be_bytes(raw[index..index + 8].try_into().unwrap());
-        index += 8;
-
-        //SAFETY : casting a slice of lenght 8 into an array of size 8
-        let value = u64::from_be_bytes(raw[index..index + 8].try_into().unwrap());
-        index += 8;
-
-        //SAFETY : casting a slice of lenght 4 into an array of size 4
-        let typ_len = u32::from_be_bytes(raw[index..index + 4].try_into().unwrap()) as usize;
-        index += 4;
-
-        if raw[index..].len() != typ_len + 8 {
-            return Err(CompactEcashError::Deserialization(
-                "Invalid byte array for EcashCredential deserialization".to_string(),
-            ));
-        }
-
-        let raw_typ = String::from_utf8(raw[index..index + typ_len].to_vec()).map_err(|_| {
-            CompactEcashError::Deserialization("Failed to deserialize type".to_string())
-        })?;
-        let typ = raw_typ.parse().map_err(|_| {
-            CompactEcashError::Deserialization("Failed to deserialize type".to_string())
-        })?;
-        index += typ_len;
-
-        //SAFETY : casting a slice of lenght 8 into an array of size 8
-        let epoch_id = u64::from_be_bytes(raw[index..index + 8].try_into().unwrap());
-
-        Ok(CredentialSpendingData {
-            payment,
-            pay_info,
-            spend_date,
-            value,
-            typ,
-            epoch_id,
-        })
-    }
-}
-
-impl Bytable for CredentialSpendingData {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self, CompactEcashError> {
-        Self::try_from_bytes(slice)
-    }
-}
-
-impl Base58 for CredentialSpendingData {}
-
-pub use nym_coconut::{
-    hash_to_scalar, keygen as coconut_keygen, prove_bandwidth_credential, verify_credential,
-    Attribute, Base58 as CoconutBase58, BlindedSerialNumber, CoconutError,
-    Parameters as CoconutParameters, Signature as CoconutSignature, VerificationKey,
-    VerifyCredentialRequest,
-};
-
-//SW NOTE: for coconut compatibility
-pub fn to_coconut(verification_key: &VerificationKeyAuth) -> Result<VerificationKey, CoconutError> {
-    VerificationKey::from_bytes(&verification_key.to_bytes())
-}
-
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
-pub struct OldCredentialSpendingData {
+pub struct CredentialSpendingData {
    pub embedded_private_attributes: usize,

    pub verify_credential_request: VerifyCredentialRequest,
@@ -264,8 +97,8 @@ pub struct OldCredentialSpendingData {
    pub epoch_id: u64,
 }

-impl OldCredentialSpendingData {
-    pub fn verify(&self, params: &CoconutParameters, verification_key: &VerificationKey) -> bool {
+impl CredentialSpendingData {
+    pub fn verify(&self, params: &Parameters, verification_key: &VerificationKey) -> bool {
        let hashed_public_attributes = self
            .public_attributes_plain
            .iter()
@@ -18,11 +18,9 @@ zeroize = { workspace = true }

 # I guess temporarily until we get serde support in coconut up and running
 nym-credentials-interface = { path = "../credentials-interface" }
-chrono = "0.4.38"
-nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "hashing"] }
+nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "serde"] }
 nym-api-requests = { path = "../../nym-api/nym-api-requests" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
-nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }

 [dev-dependencies]
 rand = "0.7.3"
@@ -1,20 +1,97 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::coconut::utils::scalar_serde_helper;
 use crate::error::Error;
 use nym_api_requests::coconut::FreePassRequest;
-use nym_credentials_interface::{BlindedSignature, CredentialSigningData};
+use nym_credentials_interface::{
+    hash_to_scalar, Attribute, BlindedSignature, CredentialSigningData, PublicAttribute,
+};
 use nym_validator_client::signing::AccountData;
 use serde::{Deserialize, Serialize};
+use time::{Duration, OffsetDateTime, Time};
 use zeroize::{Zeroize, ZeroizeOnDrop};

-#[derive(Debug, Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
-pub struct FreePassIssuedData {}
+pub const MAX_FREE_PASS_VALIDITY: Duration = Duration::WEEK; // 1 week

-pub struct FreePassIssuanceData {}
+#[derive(Debug, Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
+pub struct FreePassIssuedData {
+    /// the plain validity value of this credential expressed as unix timestamp
+    #[zeroize(skip)]
+    expiry_date: OffsetDateTime,
+}
+
+impl<'a> From<&'a FreePassIssuanceData> for FreePassIssuedData {
+    fn from(value: &'a FreePassIssuanceData) -> Self {
+        FreePassIssuedData {
+            expiry_date: value.expiry_date,
+        }
+    }
+}
+
+impl FreePassIssuedData {
+    pub fn expired(&self) -> bool {
+        self.expiry_date <= OffsetDateTime::now_utc()
+    }
+
+    pub fn expiry_date(&self) -> OffsetDateTime {
+        self.expiry_date
+    }
+
+    pub fn expiry_date_plain(&self) -> String {
+        self.expiry_date.unix_timestamp().to_string()
+    }
+}
+
+#[derive(Zeroize, Serialize, Deserialize)]
+pub struct FreePassIssuanceData {
+    /// the plain validity value of this credential expressed as unix timestamp
+    #[zeroize(skip)]
+    expiry_date: OffsetDateTime,
+
+    // the expiry date, as unix timestamp, hashed into a scalar
+    #[serde(with = "scalar_serde_helper")]
+    expiry_date_prehashed: PublicAttribute,
+}

 impl FreePassIssuanceData {
+    pub fn new(expiry_date: Option<OffsetDateTime>) -> Self {
+        // ideally we should have implemented a proper error handling here, sure.
+        // but given it's meant to only be used by nym, imo it's fine to just panic here in case of invalid arguments
+        let expiry_date = if let Some(provided) = expiry_date {
+            if provided - OffsetDateTime::now_utc() > MAX_FREE_PASS_VALIDITY {
+                panic!("the provided expiry date is bigger than the maximum value of {MAX_FREE_PASS_VALIDITY}");
+            }
+
+            provided
+        } else {
+            Self::default_expiry_date()
+        };
+
+        let expiry_date_prehashed = hash_to_scalar(expiry_date.unix_timestamp().to_string());
+
+        FreePassIssuanceData {
+            expiry_date,
+            expiry_date_prehashed,
+        }
+    }
+
+    pub fn default_expiry_date() -> OffsetDateTime {
+        // set it to furthest midnight in the future such as it's no more than a week away,
+        // i.e. if it's currently for example 9:43 on 2nd March 2024, it will set it to 0:00 on 9th March 2024
+        (OffsetDateTime::now_utc() + MAX_FREE_PASS_VALIDITY).replace_time(Time::MIDNIGHT)
+    }
+
+    pub fn expiry_date_attribute(&self) -> &Attribute {
+        &self.expiry_date_prehashed
+    }
+
+    pub fn expiry_date_plain(&self) -> String {
+        self.expiry_date.unix_timestamp().to_string()
+    }
+
    pub async fn obtain_free_pass_nonce(
+        &self,
        client: &nym_validator_client::client::NymApiClient,
    ) -> Result<[u8; 16], Error> {
        let server_response = client.free_pass_nonce().await?;
@@ -22,6 +99,7 @@ impl FreePassIssuanceData {
    }

    pub fn create_free_pass_request(
+        &self,
        signing_request: &CredentialSigningData,
        account_data: &AccountData,
        issuer_nonce: [u8; 16],
@@ -33,15 +111,15 @@ impl FreePassIssuanceData {

        Ok(FreePassRequest {
            cosmos_pubkey: account_data.public_key(),
-            inner_sign_request: signing_request.withdrawal_request.clone(),
+            inner_sign_request: signing_request.blind_sign_request.clone(),
            used_nonce: issuer_nonce,
            nonce_signature,
-            ecash_pubkey: signing_request.ecash_pub_key.clone(),
-            expiration_date: signing_request.expiration_date,
+            public_attributes_plain: signing_request.public_attributes_plain.clone(),
        })
    }

    pub async fn obtain_blinded_credential(
+        &self,
        client: &nym_validator_client::client::NymApiClient,
        request: &FreePassRequest,
    ) -> Result<BlindedSignature, Error> {
@@ -50,12 +128,14 @@ impl FreePassIssuanceData {
    }

    pub async fn request_blinded_credential(
+        &self,
        signing_request: &CredentialSigningData,
        account_data: &AccountData,
        client: &nym_validator_client::client::NymApiClient,
    ) -> Result<BlindedSignature, Error> {
-        let signing_nonce = Self::obtain_free_pass_nonce(client).await?;
-        let request = Self::create_free_pass_request(signing_request, account_data, signing_nonce)?;
-        Self::obtain_blinded_credential(client, &request).await
+        let signing_nonce = self.obtain_free_pass_nonce(client).await?;
+        let request =
+            self.create_free_pass_request(signing_request, account_data, signing_nonce)?;
+        self.obtain_blinded_credential(client, &request).await
    }
 }
@@ -7,44 +7,70 @@ use crate::coconut::bandwidth::voucher::BandwidthVoucherIssuanceData;
 use crate::coconut::bandwidth::{
    bandwidth_credential_params, CredentialSigningData, CredentialType,
 };
-use crate::coconut::utils::{cred_exp_date_timestamp, freepass_exp_date_timestamp};
+use crate::coconut::utils::scalar_serde_helper;
 use crate::error::Error;
-use log::error;
 use nym_credentials_interface::{
-    aggregate_wallets, constants, generate_keypair_user, generate_keypair_user_from_seed,
-    issue_verify, setup, withdrawal_request, BlindedSignature, ExpirationDateSignature,
-    KeyPairUser, Parameters, PartialWallet, VerificationKeyAuth, Wallet,
+    aggregate_signature_shares, hash_to_scalar, prepare_blind_sign, Attribute, BlindedSerialNumber,
+    BlindedSignature, Parameters, PrivateAttribute, PublicAttribute, Signature, SignatureShare,
+    VerificationKey,
 };
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_validator_client::nym_api::EpochId;
-use nym_validator_client::nyxd::Hash;
+use nym_validator_client::nyxd::{Coin, Hash};
 use nym_validator_client::signing::AccountData;
 use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
 use zeroize::{Zeroize, ZeroizeOnDrop};

 #[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
 pub enum BandwidthCredentialIssuanceDataVariant {
-    TicketBook(BandwidthVoucherIssuanceData),
-    FreePass,
+    Voucher(BandwidthVoucherIssuanceData),
+    FreePass(FreePassIssuanceData),
+}
+
+impl From<FreePassIssuanceData> for BandwidthCredentialIssuanceDataVariant {
+    fn from(value: FreePassIssuanceData) -> Self {
+        BandwidthCredentialIssuanceDataVariant::FreePass(value)
+    }
 }

 impl From<BandwidthVoucherIssuanceData> for BandwidthCredentialIssuanceDataVariant {
    fn from(value: BandwidthVoucherIssuanceData) -> Self {
-        BandwidthCredentialIssuanceDataVariant::TicketBook(value)
+        BandwidthCredentialIssuanceDataVariant::Voucher(value)
    }
 }

 impl BandwidthCredentialIssuanceDataVariant {
    pub fn info(&self) -> CredentialType {
        match self {
-            BandwidthCredentialIssuanceDataVariant::TicketBook(..) => CredentialType::TicketBook,
-            BandwidthCredentialIssuanceDataVariant::FreePass => CredentialType::FreePass,
+            BandwidthCredentialIssuanceDataVariant::Voucher(..) => CredentialType::Voucher,
+            BandwidthCredentialIssuanceDataVariant::FreePass(..) => CredentialType::FreePass,
+        }
+    }
+
+    // currently this works under the assumption of there being a single unique public attribute for given variant
+    pub fn public_value(&self) -> &Attribute {
+        match self {
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => voucher.value_attribute(),
+            BandwidthCredentialIssuanceDataVariant::FreePass(freepass) => {
+                freepass.expiry_date_attribute()
+            }
+        }
+    }
+
+    // currently this works under the assumption of there being a single unique public attribute for given variant
+    pub fn public_value_plain(&self) -> String {
+        match self {
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => voucher.value_plain(),
+            BandwidthCredentialIssuanceDataVariant::FreePass(freepass) => {
+                freepass.expiry_date_plain()
+            }
        }
    }

    pub fn voucher_data(&self) -> Option<&BandwidthVoucherIssuanceData> {
        match self {
-            BandwidthCredentialIssuanceDataVariant::TicketBook(voucher) => Some(voucher),
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => Some(voucher),
            _ => None,
        }
    }
@@ -53,103 +79,102 @@ impl BandwidthCredentialIssuanceDataVariant {
 // all types of bandwidth credentials contain serial number and binding number
 #[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
 pub struct IssuanceBandwidthCredential {
+    // private attributes
+    /// a random secret value generated by the client used for double-spending detection
+    #[serde(with = "scalar_serde_helper")]
+    serial_number: PrivateAttribute,
+
+    /// a random secret value generated by the client used to bind multiple credentials together
+    #[serde(with = "scalar_serde_helper")]
+    binding_number: PrivateAttribute,
+
    /// data specific to given bandwidth credential, for example a value for bandwidth voucher and expiry date for the free pass
    variant_data: BandwidthCredentialIssuanceDataVariant,

-    ///ecash keypair related to the credential
-    ecash_keypair: KeyPairUser,
-
-    ///expiration_date of that credential
-    expiration_date: u64,
+    /// type of the bandwdith credential hashed onto a scalar
+    #[serde(with = "scalar_serde_helper")]
+    type_prehashed: PublicAttribute,
 }

 impl IssuanceBandwidthCredential {
+    pub const PUBLIC_ATTRIBUTES: u32 = 2;
+    pub const PRIVATE_ATTRIBUTES: u32 = 2;
+    pub const ENCODED_ATTRIBUTES: u32 = Self::PUBLIC_ATTRIBUTES + Self::PRIVATE_ATTRIBUTES;
+
    pub fn default_parameters() -> Parameters {
-        setup(constants::NB_TICKETS)
+        // safety: the unwrap is fine here as Self::ENCODED_ATTRIBUTES is non-zero
+        Parameters::new(Self::ENCODED_ATTRIBUTES).unwrap()
    }

-    pub fn new<B: Into<BandwidthCredentialIssuanceDataVariant>>(
-        variant_data: B,
-        identifier: Option<&[u8]>,
-        expiration_date: u64,
-    ) -> Self {
+    pub fn new<B: Into<BandwidthCredentialIssuanceDataVariant>>(variant_data: B) -> Self {
        let variant_data = variant_data.into();
-        let params = bandwidth_credential_params().grp();
-        let ecash_keypair = if let Some(id) = identifier {
-            generate_keypair_user_from_seed(params, id)
-        } else {
-            generate_keypair_user(params)
-        };
+        let type_prehashed = hash_to_scalar(variant_data.info().to_string());
+
+        let params = bandwidth_credential_params();
+        let serial_number = params.random_scalar();
+        let binding_number = params.random_scalar();

        IssuanceBandwidthCredential {
+            serial_number,
+            binding_number,
            variant_data,
-            ecash_keypair,
-            expiration_date,
+            type_prehashed,
        }
    }

    pub fn new_voucher(
+        value: impl Into<Coin>,
        deposit_tx_hash: Hash,
-        identifier: &[u8],
        signing_key: identity::PrivateKey,
        unused_ed25519: encryption::PrivateKey,
    ) -> Self {
-        Self::new(
-            BandwidthVoucherIssuanceData::new(deposit_tx_hash, signing_key, unused_ed25519),
-            Some(identifier),
-            cred_exp_date_timestamp(),
-        )
+        Self::new(BandwidthVoucherIssuanceData::new(
+            value,
+            deposit_tx_hash,
+            signing_key,
+            unused_ed25519,
+        ))
    }

-    pub fn new_freepass(timestamp: u64) -> Self {
-        let exp_timestamp = if timestamp > freepass_exp_date_timestamp() {
-            error!(
-                "the provided free pass request has too long expiry, setting it to max possible"
-            );
-            freepass_exp_date_timestamp()
-        } else {
-            timestamp
-        };
-        Self::new(
-            BandwidthCredentialIssuanceDataVariant::FreePass,
-            None,
-            exp_timestamp,
-        )
+    pub fn new_freepass(expiry_date: Option<OffsetDateTime>) -> Self {
+        Self::new(FreePassIssuanceData::new(expiry_date))
    }

-    pub fn ecash_pubkey_bs58(&self) -> String {
+    pub fn blind_serial_number(&self) -> BlindedSerialNumber {
+        (bandwidth_credential_params().gen2() * self.serial_number).into()
+    }
+
+    pub fn blinded_serial_number_bs58(&self) -> String {
        use nym_credentials_interface::Base58;

-        self.ecash_keypair.public_key().to_bs58()
+        self.blind_serial_number().to_bs58()
    }

    pub fn typ(&self) -> CredentialType {
        self.variant_data.info()
    }

-    pub fn expiration_date(&self) -> u64 {
-        self.expiration_date
+    pub fn get_private_attributes(&self) -> Vec<&PrivateAttribute> {
+        vec![&self.serial_number, &self.binding_number]
+    }
+
+    pub fn get_public_attributes(&self) -> Vec<&PublicAttribute> {
+        vec![self.variant_data.public_value(), &self.type_prehashed]
+    }
+
+    pub fn get_plain_public_attributes(&self) -> Vec<String> {
+        vec![
+            self.variant_data.public_value_plain(),
+            self.typ().to_string(),
+        ]
    }

    pub fn get_variant_data(&self) -> &BandwidthCredentialIssuanceDataVariant {
        &self.variant_data
    }

-    pub fn value(&self) -> u128 {
-        if let BandwidthCredentialIssuanceDataVariant::TicketBook(data) = &self.variant_data {
-            data.value()
-        } else {
-            0_u128
-        }
-    }
-
-    pub fn check_expiration_date(&self) -> bool {
-        let old_expiration_date = self.expiration_date;
-        let new_expiration_date = match self.get_variant_data() {
-            BandwidthCredentialIssuanceDataVariant::TicketBook(_) => cred_exp_date_timestamp(),
-            BandwidthCredentialIssuanceDataVariant::FreePass => freepass_exp_date_timestamp(),
-        };
-        old_expiration_date != new_expiration_date
+    pub fn get_bandwidth_attribute(&self) -> String {
+        self.variant_data.public_value_plain()
    }

    pub fn prepare_for_signing(&self) -> CredentialSigningData {
@@ -157,37 +182,38 @@ impl IssuanceBandwidthCredential {

        // safety: the creation of the request can only fail if one provided invalid parameters
        // and we created then specific to this type of the credential so the unwrap is fine
-        let (withdrawal_request, request_info) = withdrawal_request(
-            params.grp(),
-            &self.ecash_keypair.secret_key(),
-            self.expiration_date,
+        let (pedersen_commitments_openings, blind_sign_request) = prepare_blind_sign(
+            params,
+            &[&self.serial_number, &self.binding_number],
+            &self.get_public_attributes(),
        )
        .unwrap();

        CredentialSigningData {
-            withdrawal_request,
-            request_info,
-            ecash_pub_key: self.ecash_keypair.public_key(),
+            pedersen_commitments_openings,
+            blind_sign_request,
+            public_attributes_plain: self.get_plain_public_attributes(),
            typ: self.typ(),
-            expiration_date: self.expiration_date,
        }
    }

    pub fn unblind_signature(
        &self,
-        validator_vk: &VerificationKeyAuth,
+        validator_vk: &VerificationKey,
        signing_data: &CredentialSigningData,
        blinded_signature: BlindedSignature,
-        signer_index: u64,
-    ) -> Result<PartialWallet, Error> {
-        let params = bandwidth_credential_params().grp();
-        let unblinded_signature = issue_verify(
+    ) -> Result<Signature, Error> {
+        let public_attributes = self.get_public_attributes();
+        let private_attributes = self.get_private_attributes();
+
+        let params = bandwidth_credential_params();
+        let unblinded_signature = blinded_signature.unblind_and_verify(
            params,
            validator_vk,
-            &self.ecash_keypair.secret_key(),
-            &blinded_signature,
-            &signing_data.request_info,
-            signer_index,
+            &private_attributes,
+            &public_attributes,
+            &signing_data.blind_sign_request.get_commitment_hash(),
+            &signing_data.pedersen_commitments_openings,
        )?;

        Ok(unblinded_signature)
@@ -196,88 +222,88 @@ impl IssuanceBandwidthCredential {
    pub async fn obtain_partial_freepass_credential(
        &self,
        client: &nym_validator_client::client::NymApiClient,
-        signer_index: u64,
        account_data: &AccountData,
-        validator_vk: &VerificationKeyAuth,
-        signing_data: CredentialSigningData,
-    ) -> Result<PartialWallet, Error> {
-        // We need signing data, because they will be use at the aggregation step
+        validator_vk: &VerificationKey,
+        signing_data: impl Into<Option<CredentialSigningData>>,
+    ) -> Result<Signature, Error> {
+        // if we provided signing data, do use them, otherwise generate fresh data
+        let signing_data = signing_data
+            .into()
+            .unwrap_or_else(|| self.prepare_for_signing());

        let blinded_signature = match &self.variant_data {
-            BandwidthCredentialIssuanceDataVariant::FreePass => {
-                FreePassIssuanceData::request_blinded_credential(
-                    &signing_data,
-                    account_data,
-                    client,
-                )
-                .await?
+            BandwidthCredentialIssuanceDataVariant::FreePass(freepass) => {
+                freepass
+                    .request_blinded_credential(&signing_data, account_data, client)
+                    .await?
            }
            _ => return Err(Error::NotAFreePass),
        };
-        self.unblind_signature(validator_vk, &signing_data, blinded_signature, signer_index)
+        self.unblind_signature(validator_vk, &signing_data, blinded_signature)
    }

    // ideally this would have been generic over credential type, but we really don't need secp256k1 keys for bandwidth vouchers
    pub async fn obtain_partial_bandwidth_voucher_credential(
        &self,
        client: &nym_validator_client::client::NymApiClient,
-        signer_index: u64,
-        validator_vk: &VerificationKeyAuth,
-        signing_data: CredentialSigningData,
-    ) -> Result<PartialWallet, Error> {
-        // We need signing data, because they will be use at the aggregation step
+        validator_vk: &VerificationKey,
+        signing_data: impl Into<Option<CredentialSigningData>>,
+    ) -> Result<Signature, Error> {
+        // if we provided signing data, do use them, otherwise generate fresh data
+        let signing_data = signing_data
+            .into()
+            .unwrap_or_else(|| self.prepare_for_signing());

        let blinded_signature = match &self.variant_data {
-            BandwidthCredentialIssuanceDataVariant::TicketBook(voucher) => {
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => {
                // TODO: the request can be re-used between different apis
                let request = voucher.create_blind_sign_request_body(&signing_data);
                voucher.obtain_blinded_credential(client, &request).await?
            }
            _ => return Err(Error::NotABandwdithVoucher),
        };
-        self.unblind_signature(validator_vk, &signing_data, blinded_signature, signer_index)
+        self.unblind_signature(validator_vk, &signing_data, blinded_signature)
    }

    pub fn aggregate_signature_shares(
        &self,
-        verification_key: &VerificationKeyAuth,
-        shares: &[PartialWallet],
-        signing_data: CredentialSigningData,
-    ) -> Result<Wallet, Error> {
-        let params = bandwidth_credential_params().grp();
-        aggregate_wallets(
-            params,
-            verification_key,
-            &self.ecash_keypair.secret_key(),
-            shares,
-            &signing_data.request_info,
-        )
-        .map_err(Error::SignatureAggregationError)
+        verification_key: &VerificationKey,
+        shares: &[SignatureShare],
+    ) -> Result<Signature, Error> {
+        let public_attributes = self.get_public_attributes();
+        let private_attributes = self.get_private_attributes();
+
+        let params = bandwidth_credential_params();
+
+        let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
+        attributes.extend_from_slice(&private_attributes);
+        attributes.extend_from_slice(&public_attributes);
+
+        aggregate_signature_shares(params, verification_key, &attributes, shares)
+            .map_err(Error::SignatureAggregationError)
    }

    // also drops self after the conversion
    pub fn into_issued_credential(
        self,
-        wallet: Wallet,
-        exp_date_signatures: Vec<ExpirationDateSignature>,
+        aggregate_signature: Signature,
        epoch_id: EpochId,
    ) -> IssuedBandwidthCredential {
-        self.to_issued_credential(wallet, exp_date_signatures, epoch_id)
+        self.to_issued_credential(aggregate_signature, epoch_id)
    }

    pub fn to_issued_credential(
        &self,
-        wallet: Wallet,
-        exp_date_signatures: Vec<ExpirationDateSignature>,
+        aggregate_signature: Signature,
        epoch_id: EpochId,
    ) -> IssuedBandwidthCredential {
        IssuedBandwidthCredential::new(
-            wallet,
+            self.serial_number,
+            self.binding_number,
+            aggregate_signature,
            (&self.variant_data).into(),
+            self.type_prehashed,
            epoch_id,
-            self.ecash_keypair.secret_key(),
-            exp_date_signatures,
-            self.expiration_date,
        )
    }

@@ -2,54 +2,70 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::coconut::bandwidth::bandwidth_credential_params;
+use crate::coconut::bandwidth::freepass::FreePassIssuedData;
 use crate::coconut::bandwidth::issuance::{
    BandwidthCredentialIssuanceDataVariant, IssuanceBandwidthCredential,
 };
 use crate::coconut::bandwidth::voucher::BandwidthVoucherIssuedData;
 use crate::coconut::bandwidth::{CredentialSpendingData, CredentialType};
-use crate::coconut::utils::today_timestamp;
+use crate::coconut::utils::scalar_serde_helper;
 use crate::error::Error;
+use nym_credentials_interface::prove_bandwidth_credential;
 use nym_credentials_interface::{
-    constants, date_scalar, CoinIndexSignature, ExpirationDateSignature, Parameters, PayInfo,
-    SecretKeyUser, VerificationKeyAuth, Wallet,
+    Parameters, PrivateAttribute, PublicAttribute, Signature, VerificationKey,
 };
 use nym_validator_client::nym_api::EpochId;
 use serde::{Deserialize, Serialize};
-use time::OffsetDateTime;
 use zeroize::{Zeroize, ZeroizeOnDrop};

 pub const CURRENT_SERIALIZATION_REVISION: u8 = 1;

 #[derive(Debug, Zeroize, Serialize, Deserialize)]
 pub enum BandwidthCredentialIssuedDataVariant {
-    TicketBook(BandwidthVoucherIssuedData),
-    FreePass,
+    Voucher(BandwidthVoucherIssuedData),
+    FreePass(FreePassIssuedData),
 }

 impl<'a> From<&'a BandwidthCredentialIssuanceDataVariant> for BandwidthCredentialIssuedDataVariant {
    fn from(value: &'a BandwidthCredentialIssuanceDataVariant) -> Self {
        match value {
-            BandwidthCredentialIssuanceDataVariant::TicketBook(voucher) => {
-                BandwidthCredentialIssuedDataVariant::TicketBook(voucher.into())
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => {
+                BandwidthCredentialIssuedDataVariant::Voucher(voucher.into())
            }
-            BandwidthCredentialIssuanceDataVariant::FreePass => {
-                BandwidthCredentialIssuedDataVariant::FreePass
+            BandwidthCredentialIssuanceDataVariant::FreePass(freepass) => {
+                BandwidthCredentialIssuedDataVariant::FreePass(freepass.into())
            }
        }
    }
 }

+impl From<FreePassIssuedData> for BandwidthCredentialIssuedDataVariant {
+    fn from(value: FreePassIssuedData) -> Self {
+        BandwidthCredentialIssuedDataVariant::FreePass(value)
+    }
+}
+
 impl From<BandwidthVoucherIssuedData> for BandwidthCredentialIssuedDataVariant {
    fn from(value: BandwidthVoucherIssuedData) -> Self {
-        BandwidthCredentialIssuedDataVariant::TicketBook(value)
+        BandwidthCredentialIssuedDataVariant::Voucher(value)
    }
 }

 impl BandwidthCredentialIssuedDataVariant {
    pub fn info(&self) -> CredentialType {
        match self {
-            BandwidthCredentialIssuedDataVariant::TicketBook(..) => CredentialType::TicketBook,
-            BandwidthCredentialIssuedDataVariant::FreePass => CredentialType::FreePass,
+            BandwidthCredentialIssuedDataVariant::Voucher(..) => CredentialType::Voucher,
+            BandwidthCredentialIssuedDataVariant::FreePass(..) => CredentialType::FreePass,
+        }
+    }
+
+    // currently this works under the assumption of there being a single unique public attribute for given variant
+    pub fn public_value_plain(&self) -> String {
+        match self {
+            BandwidthCredentialIssuedDataVariant::Voucher(voucher) => voucher.value_plain(),
+            BandwidthCredentialIssuedDataVariant::FreePass(freepass) => {
+                freepass.expiry_date_plain()
+            }
        }
    }
 }
@@ -57,42 +73,46 @@ impl BandwidthCredentialIssuedDataVariant {
 // the only important thing to zeroize here are the private attributes, the rest can be made fully public for what we're concerned
 #[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
 pub struct IssuedBandwidthCredential {
-    /// the underlying wallet
-    wallet: Wallet,
+    // private attributes
+    /// a random secret value generated by the client used for double-spending detection
+    #[serde(with = "scalar_serde_helper")]
+    serial_number: PrivateAttribute,
+
+    /// a random secret value generated by the client used to bind multiple credentials together
+    #[serde(with = "scalar_serde_helper")]
+    binding_number: PrivateAttribute,
+
+    /// the underlying aggregated signature on the attributes
+    #[zeroize(skip)]
+    signature: Signature,

    /// data specific to given bandwidth credential, for example a value for bandwidth voucher and expiry date for the free pass
-    variant_data: BandwidthCredentialIssuedDataVariant, //SW NOTE: freepass has no info, maybe put value directly here
+    variant_data: BandwidthCredentialIssuedDataVariant,
+
+    /// type of the bandwdith credential hashed onto a scalar
+    #[serde(with = "scalar_serde_helper")]
+    type_prehashed: PublicAttribute,

    /// Specifies the (DKG) epoch id when this credential has been issued
    epoch_id: EpochId,
-
-    ///secret ecash key used to generate this wallet
-    ecash_secret_key: SecretKeyUser,
-
-    ///signatures on expiration dates used to spend tickets
-    #[zeroize(skip)]
-    exp_date_signatures: Vec<ExpirationDateSignature>,
-
-    ///expiration_date for easier discarding
-    expiration_date: u64,
 }

 impl IssuedBandwidthCredential {
    pub fn new(
-        wallet: Wallet,
+        serial_number: PrivateAttribute,
+        binding_number: PrivateAttribute,
+        signature: Signature,
        variant_data: BandwidthCredentialIssuedDataVariant,
+        type_prehashed: PublicAttribute,
        epoch_id: EpochId,
-        ecash_secret_key: SecretKeyUser,
-        exp_date_signatures: Vec<ExpirationDateSignature>,
-        expiration_date: u64,
    ) -> Self {
        IssuedBandwidthCredential {
-            wallet,
+            serial_number,
+            binding_number,
+            signature,
            variant_data,
+            type_prehashed,
            epoch_id,
-            ecash_secret_key,
-            exp_date_signatures,
-            expiration_date,
        }
    }

@@ -117,27 +137,6 @@ impl IssuedBandwidthCredential {
        CURRENT_SERIALIZATION_REVISION
    }

-    pub fn expiration_date(&self) -> u64 {
-        self.expiration_date
-    }
-
-    pub fn expiration_date_formatted(&self) -> OffsetDateTime {
-        //SAFETY : expiration date is encoded as a u64 but it is a unix timestamp. The unwrap is guaranteed to succeed for at least 290 million more years
-        OffsetDateTime::from_unix_timestamp(self.expiration_date.try_into().unwrap()).unwrap()
-    }
-
-    pub fn expired(&self) -> bool {
-        self.expiration_date < today_timestamp()
-    }
-
-    pub fn exp_date_sigs(&self) -> Vec<ExpirationDateSignature> {
-        self.exp_date_signatures.clone()
-    }
-
-    pub fn wallet(&self) -> &Wallet {
-        &self.wallet
-    }
-
    /// Pack (serialize) this credential data into a stream of bytes using v1 serializer.
    pub fn pack_v1(&self) -> Vec<u8> {
        use bincode::Options;
@@ -156,6 +155,11 @@ impl IssuedBandwidthCredential {
            })
    }

+    pub fn randomise_signature(&mut self) {
+        let signature_prime = self.signature.randomise(bandwidth_credential_params());
+        self.signature = signature_prime.0
+    }
+
    pub fn default_parameters() -> Parameters {
        IssuanceBandwidthCredential::default_parameters()
    }
@@ -164,38 +168,31 @@ impl IssuedBandwidthCredential {
        self.variant_data.info()
    }

+    pub fn get_plain_public_attributes(&self) -> Vec<String> {
+        vec![
+            self.variant_data.public_value_plain(),
+            self.typ().to_string(),
+        ]
+    }
+
    pub fn prepare_for_spending(
        &self,
-        verification_key: &VerificationKeyAuth,
-        pay_info: PayInfo,
-        coin_indices_signatures: Vec<CoinIndexSignature>,
+        verification_key: &VerificationKey,
    ) -> Result<CredentialSpendingData, Error> {
        let params = bandwidth_credential_params();
-        let spend_date = today_timestamp();
-        let (payment, _) = self.wallet.spend(
+
+        let verify_credential_request = prove_bandwidth_credential(
            params,
            verification_key,
-            &self.ecash_secret_key,
-            &pay_info,
-            false,
-            constants::SPEND_TICKETS,
-            self.exp_date_sigs(),
-            coin_indices_signatures,
-            date_scalar(spend_date),
+            &self.signature,
+            &self.serial_number,
+            &self.binding_number,
        )?;

-        let value = match &self.variant_data {
-            BandwidthCredentialIssuedDataVariant::FreePass => 0u64,
-            BandwidthCredentialIssuedDataVariant::TicketBook(voucher) => {
-                constants::SPEND_TICKETS * voucher.value() as u64 / params.get_total_coins()
-            }
-        };
-
        Ok(CredentialSpendingData {
-            payment,
-            pay_info,
-            spend_date,
-            value,
+            embedded_private_attributes: IssuanceBandwidthCredential::PRIVATE_ATTRIBUTES as usize,
+            verify_credential_request,
+            public_attributes_plain: self.get_plain_public_attributes(),
            typ: self.typ(),
            epoch_id: self.epoch_id,
        })
@@ -15,6 +15,7 @@ pub mod issuance;
 pub mod issued;
 pub mod voucher;

+// works under the assumption of having 4 attributes in the underlying credential(s)
 pub fn bandwidth_credential_params() -> &'static Parameters {
    static BANDWIDTH_CREDENTIAL_PARAMS: OnceLock<Parameters> = OnceLock::new();
    BANDWIDTH_CREDENTIAL_PARAMS.get_or_init(IssuanceBandwidthCredential::default_parameters)
@@ -2,12 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::coconut::bandwidth::CredentialSigningData;
+use crate::coconut::utils::scalar_serde_helper;
 use crate::error::Error;
 use nym_api_requests::coconut::BlindSignRequestBody;
-use nym_credentials_interface::{BlindedSignature, WithdrawalRequest};
+use nym_credentials_interface::{
+    hash_to_scalar, Attribute, BlindSignRequest, BlindedSignature, PublicAttribute,
+};
 use nym_crypto::asymmetric::{encryption, identity};
-use nym_ecash_contract_common::events::TICKET_BOOK_VALUE;
-use nym_validator_client::nyxd::Hash;
+use nym_validator_client::nyxd::{Coin, Hash};
 use serde::{Deserialize, Serialize};
 use zeroize::{Zeroize, ZeroizeOnDrop};

@@ -16,24 +18,24 @@ pub struct BandwidthVoucherIssuedData {
    /// the plain value (e.g., bandwidth) encoded in this voucher
    // note: for legacy reasons we're only using the value of the coin and ignoring the denom
    #[zeroize(skip)]
-    value: u128,
+    value: Coin,
 }

 impl<'a> From<&'a BandwidthVoucherIssuanceData> for BandwidthVoucherIssuedData {
    fn from(value: &'a BandwidthVoucherIssuanceData) -> Self {
        BandwidthVoucherIssuedData {
-            value: value.value(),
+            value: value.value.clone(),
        }
    }
 }

 impl BandwidthVoucherIssuedData {
-    pub fn value(&self) -> u128 {
-        self.value
+    pub fn value(&self) -> &Coin {
+        &self.value
    }

    pub fn value_plain(&self) -> String {
-        self.value.to_string()
+        self.value.amount.to_string()
    }
 }

@@ -42,7 +44,11 @@ pub struct BandwidthVoucherIssuanceData {
    /// the plain value (e.g., bandwidth) encoded in this voucher
    // note: for legacy reasons we're only using the value of the coin and ignoring the denom
    #[zeroize(skip)]
-    value: u128,
+    value: Coin,
+
+    // note: as mentioned above, we're only hashing the value of the coin!
+    #[serde(with = "scalar_serde_helper")]
+    value_prehashed: PublicAttribute,

    /// the hash of the deposit transaction
    #[zeroize(skip)]
@@ -57,21 +63,24 @@ pub struct BandwidthVoucherIssuanceData {

 impl BandwidthVoucherIssuanceData {
    pub fn new(
+        value: impl Into<Coin>,
        deposit_tx_hash: Hash,
        signing_key: identity::PrivateKey,
        unused_ed25519: encryption::PrivateKey,
    ) -> Self {
-        let value = TICKET_BOOK_VALUE;
+        let value = value.into();
+        let value_prehashed = hash_to_scalar(value.amount.to_string());

        BandwidthVoucherIssuanceData {
            value,
+            value_prehashed,
            deposit_tx_hash,
            signing_key,
            unused_ed25519,
        }
    }

-    pub fn request_plaintext(request: &WithdrawalRequest, tx_hash: Hash) -> Vec<u8> {
+    pub fn request_plaintext(request: &BlindSignRequest, tx_hash: Hash) -> Vec<u8> {
        let mut message = request.to_bytes();
        message.extend_from_slice(tx_hash.as_bytes());
        message
@@ -79,7 +88,7 @@ impl BandwidthVoucherIssuanceData {

    fn request_signature(&self, signing_request: &CredentialSigningData) -> identity::Signature {
        let message =
-            Self::request_plaintext(&signing_request.withdrawal_request, self.deposit_tx_hash);
+            Self::request_plaintext(&signing_request.blind_sign_request, self.deposit_tx_hash);
        self.signing_key.sign(message)
    }

@@ -90,11 +99,10 @@ impl BandwidthVoucherIssuanceData {
        let request_signature = self.request_signature(signing_request);

        BlindSignRequestBody::new(
-            signing_request.withdrawal_request.clone(),
+            signing_request.blind_sign_request.clone(),
            self.deposit_tx_hash,
            request_signature,
-            signing_request.ecash_pub_key.clone(),
-            signing_request.expiration_date,
+            signing_request.public_attributes_plain.clone(),
        )
    }

@@ -107,8 +115,12 @@ impl BandwidthVoucherIssuanceData {
        Ok(server_response.blinded_signature)
    }

-    pub fn value(&self) -> u128 {
-        self.value
+    pub fn value_plain(&self) -> String {
+        self.value.amount.to_string()
+    }
+
+    pub fn value_attribute(&self) -> &Attribute {
+        &self.value_prehashed
    }

    pub fn tx_hash(&self) -> Hash {
@@ -3,35 +3,15 @@

 use crate::coconut::bandwidth::IssuanceBandwidthCredential;
 use crate::error::Error;
-use chrono::{Duration, Timelike, Utc};
 use log::{debug, warn};
 use nym_credentials_interface::{
-    aggregate_expiration_signatures, aggregate_indices_signatures, aggregate_verification_keys,
-    constants, setup, Base58, CoinIndexSignature, ExpirationDateSignature,
-    PartialCoinIndexSignature, PartialExpirationDateSignature, VerificationKeyAuth, Wallet,
+    aggregate_verification_keys, Signature, SignatureShare, VerificationKey,
 };
 use nym_validator_client::client::CoconutApiClient;

-pub fn today_timestamp() -> u64 {
-    let now_utc = Utc::now();
-    (now_utc.timestamp() - now_utc.num_seconds_from_midnight() as i64) as u64
-}
-
-pub fn cred_exp_date_timestamp() -> u64 {
-    today_timestamp()
-        + Duration::days(constants::CRED_VALIDITY_PERIOD as i64 - 1).num_seconds() as u64
-    //count today as well
-}
-
-pub fn freepass_exp_date_timestamp() -> u64 {
-    today_timestamp()
-        + Duration::days(constants::FREEPASS_VALIDITY_PERIOD as i64 - 1).num_seconds() as u64
-    //count today as well
-}
-
 pub fn obtain_aggregate_verification_key(
    api_clients: &[CoconutApiClient],
-) -> Result<VerificationKeyAuth, Error> {
+) -> Result<VerificationKey, Error> {
    if api_clients.is_empty() {
        return Err(Error::NoValidatorsAvailable);
    }
@@ -48,157 +28,70 @@ pub fn obtain_aggregate_verification_key(
    Ok(aggregate_verification_keys(&shares, Some(&indices))?)
 }

-pub async fn obtain_expiration_date_signatures(
-    ecash_api_clients: &[CoconutApiClient],
-    verification_key: &VerificationKeyAuth,
-    threshold: u64,
-) -> Result<Vec<ExpirationDateSignature>, Error> {
-    if ecash_api_clients.is_empty() {
-        return Err(Error::NoValidatorsAvailable);
-    }
-
-    let mut signatures: Vec<(
-        u64,
-        VerificationKeyAuth,
-        Vec<PartialExpirationDateSignature>,
-    )> = Vec::with_capacity(ecash_api_clients.len());
-
-    let ecash_params = setup(constants::NB_TICKETS);
-    let expiration_date = cred_exp_date_timestamp();
-    for ecash_api_client in ecash_api_clients.iter() {
-        match ecash_api_client
-            .api_client
-            .expiration_date_signatures()
-            .await
-        {
-            Ok(signature) => {
-                let index = ecash_api_client.node_id;
-                let share = ecash_api_client.verification_key.clone();
-                signatures.push((index, share, signature.signs));
-            }
-            Err(err) => {
-                warn!(
-                    "failed to obtain expiration date signature from {}: {err}",
-                    ecash_api_client.api_client.api_url()
-                );
-            }
-        }
-    }
-
-    if signatures.len() < threshold as usize {
-        return Err(Error::NotEnoughShares);
-    }
-
-    //this already takes care of partial signatures validation
-    aggregate_expiration_signatures(
-        &ecash_params,
-        verification_key,
-        expiration_date,
-        &signatures,
-    )
-    .map_err(Error::CompactEcashError)
-}
-
-pub async fn obtain_coin_indices_signatures(
-    ecash_api_clients: &[CoconutApiClient],
-    verification_key: &VerificationKeyAuth,
-    threshold: u64,
-) -> Result<Vec<CoinIndexSignature>, Error> {
-    if ecash_api_clients.is_empty() {
-        return Err(Error::NoValidatorsAvailable);
-    }
-
-    let mut signatures: Vec<(u64, VerificationKeyAuth, Vec<PartialCoinIndexSignature>)> =
-        Vec::with_capacity(ecash_api_clients.len());
-
-    let ecash_params = setup(constants::NB_TICKETS);
-    for ecash_api_client in ecash_api_clients.iter() {
-        match ecash_api_client.api_client.coin_indices_signatures().await {
-            Ok(signature) => {
-                let index = ecash_api_client.node_id;
-                let share = ecash_api_client.verification_key.clone();
-                signatures.push((index, share, signature.signs));
-            }
-            Err(err) => {
-                warn!(
-                    "failed to obtain expiration date signature from {}: {err}",
-                    ecash_api_client.api_client.api_url()
-                );
-            }
-        }
-    }
-
-    if signatures.len() < threshold as usize {
-        return Err(Error::NotEnoughShares);
-    }
-
-    //this takes care of validating partial signatures
-    aggregate_indices_signatures(&ecash_params, verification_key, &signatures)
-        .map_err(Error::CompactEcashError)
-}
-
 pub async fn obtain_aggregate_signature(
    voucher: &IssuanceBandwidthCredential,
-    ecash_api_clients: &[CoconutApiClient],
+    coconut_api_clients: &[CoconutApiClient],
    threshold: u64,
-) -> Result<Wallet, Error> {
-    if ecash_api_clients.is_empty() {
+) -> Result<Signature, Error> {
+    if coconut_api_clients.is_empty() {
        return Err(Error::NoValidatorsAvailable);
    }
-    let verification_key = obtain_aggregate_verification_key(ecash_api_clients)?;
+    let mut shares = Vec::with_capacity(coconut_api_clients.len());
+    let verification_key = obtain_aggregate_verification_key(coconut_api_clients)?;

    let request = voucher.prepare_for_signing();

-    let mut wallets = Vec::with_capacity(ecash_api_clients.len());
-
-    for ecash_api_client in ecash_api_clients.iter() {
+    for coconut_api_client in coconut_api_clients.iter() {
        debug!(
            "attempting to obtain partial credential from {}",
-            ecash_api_client.api_client.api_url()
+            coconut_api_client.api_client.api_url()
        );

        match voucher
            .obtain_partial_bandwidth_voucher_credential(
-                &ecash_api_client.api_client,
-                ecash_api_client.node_id,
-                &ecash_api_client.verification_key,
-                request.clone(),
+                &coconut_api_client.api_client,
+                &coconut_api_client.verification_key,
+                Some(request.clone()),
            )
            .await
        {
-            Ok(wallet) => wallets.push(wallet),
+            Ok(signature) => {
+                let share = SignatureShare::new(signature, coconut_api_client.node_id);
+                shares.push(share)
+            }
            Err(err) => {
                warn!(
                    "failed to obtain partial credential from {}: {err}",
-                    ecash_api_client.api_client.api_url()
+                    coconut_api_client.api_client.api_url()
                );
            }
        };
    }
-    if wallets.len() < threshold as usize {
+    if shares.len() < threshold as usize {
        return Err(Error::NotEnoughShares);
    }

-    voucher.aggregate_signature_shares(&verification_key, &wallets, request)
+    voucher.aggregate_signature_shares(&verification_key, &shares)
 }

-pub fn signatures_to_string<B>(sigs: &[B]) -> String
-where
-    B: Base58,
-{
-    sigs.iter()
-        .map(|sig| sig.to_bs58())
-        .collect::<Vec<_>>()
-        .join(",")
-}
+pub(crate) mod scalar_serde_helper {
+    use bls12_381::Scalar;
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+    use zeroize::Zeroizing;

-pub fn signatures_from_string<B>(bs58_sigs: String) -> Result<Vec<B>, Error>
-where
-    B: Base58,
-{
-    bs58_sigs
-        .split(',')
-        .map(B::try_from_bs58)
-        .collect::<Result<Vec<_>, _>>()
-        .map_err(Error::CompactEcashError)
+    pub fn serialize<S: Serializer>(scalar: &Scalar, serializer: S) -> Result<S::Ok, S::Error> {
+        scalar.to_bytes().serialize(serializer)
+    }
+
+    pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Scalar, D::Error> {
+        let b = <[u8; 32]>::deserialize(deserializer)?;
+
+        // make sure the bytes get zeroed
+        let bytes = Zeroizing::new(b);
+
+        let maybe_scalar: Option<Scalar> = Scalar::from_bytes(&bytes).into();
+        maybe_scalar.ok_or(serde::de::Error::custom(
+            "did not construct a valid bls12-381 scalar out of the provided bytes",
+        ))
+    }
 }
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_credentials_interface::CompactEcashError;
+use nym_credentials_interface::CoconutError;
 use nym_crypto::asymmetric::encryption::KeyRecoveryError;
 use nym_validator_client::ValidatorClientError;

@@ -32,8 +32,8 @@ pub enum Error {
    #[error("Could not contact any validator")]
    NoValidatorsAvailable,

-    #[error("Ran into a Compact ecash error - {0}")]
-    CompactEcashError(#[from] CompactEcashError),
+    #[error("Ran into a coconut error - {0}")]
+    CoconutError(#[from] CoconutError),

    #[error("Ran into a validator client error - {0}")]
    ValidatorClientError(#[from] ValidatorClientError),
@@ -51,7 +51,7 @@ pub enum Error {
    NotEnoughShares,

    #[error("Could not aggregate signature shares - {0}. Try again using the recovery command")]
-    SignatureAggregationError(CompactEcashError),
+    SignatureAggregationError(CoconutError),

    #[error("Could not deserialize bandwidth voucher - {0}")]
    BandwidthVoucherDeserializationError(String),
@@ -10,9 +10,6 @@ use std::str::FromStr;
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop};

-#[cfg(feature = "serde")]
-pub mod serde_helpers;
-
 #[cfg(feature = "sphinx")]
 use nym_sphinx_types::{DestinationAddressBytes, DESTINATION_ADDRESS_LENGTH};

@@ -1,18 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::PublicKey;
-
-pub mod bs58_pubkey {
-    use super::*;
-    use serde_crate::{Deserialize, Deserializer, Serializer};
-
-    pub fn serialize<S: Serializer>(key: &PublicKey, serializer: S) -> Result<S::Ok, S::Error> {
-        serializer.serialize_str(&key.to_base58_string())
-    }
-
-    pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<PublicKey, D::Error> {
-        let s = String::deserialize(deserializer)?;
-        PublicKey::from_base58_string(s).map_err(serde::de::Error::custom)
-    }
-}
@@ -3,6 +3,3 @@

 pub mod encryption;
 pub mod identity;
-
-pub use encryption as x25519;
-pub use identity as ed25519;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jon Häggblad	7a9f13c08d	Rename to set_active_gateway_if_previously_registered	2024-04-05 13:21:46 +02:00
Jon Häggblad	6b1b04f53c	Revert set_active_gateway in base_client	2024-04-05 13:21:31 +02:00
Jon Häggblad	6723690584	Downgrade log statement to debug	2024-04-04 23:14:13 +02:00
Jon Häggblad	c4d7c9eb16	Make create_bandwidth_client pub	2024-04-04 23:07:18 +02:00
Jon Häggblad	afa2f07636	Remove pseudo builder methods	2024-04-04 22:38:23 +02:00
Jon Häggblad	5dd2acfcac	Remove pub from internal setters	2024-04-04 22:38:23 +02:00
Jon Häggblad	03c702d498	Remove unused KeyMode type	2024-04-04 22:38:23 +02:00
Jon Häggblad	c7dbcc097d	Rework gateway setup in rust sdk mixnet client	2024-04-04 22:38:23 +02:00
Jon Häggblad	80f6c2c32a	Add debug implementations for some gateway setup types	2024-04-04 22:38:23 +02:00
Jon Häggblad	c9a36a21a1	Elevate log statements in gateway setup	2024-04-04 21:52:41 +02:00
Jon Häggblad	9eb4ca3aad	Set active gateway after setting up gateway in base client	2024-04-04 21:51:51 +02:00