Rebase, clippy, fmt

generate ecash key on client upgrade
add config migration for clients
2023-12-07 10:43:03 +01:00 · 2023-12-07 09:49:27 +01:00 · 2023-12-07 09:49:27 +01:00 · 2023-12-07 09:49:27 +01:00 · 2023-12-07 09:49:27 +01:00 · 2023-12-07 09:49:27 +01:00
968 changed files with 32316 additions and 25710 deletions
@@ -4,18 +4,18 @@ on:
  workflow_dispatch:
  pull_request:
    paths:
-      - "clients/**"
-      - "common/**"
-      - "explorer-api/**"
-      - "gateway/**"
-      - "integrations/**"
-      - "mixnode/**"
-      - "sdk/rust/nym-sdk/**"
-      - "service-providers/**"
-      - "nym-api/**"
-      - "nym-outfox/**"
-      - "tools/nym-cli/**"
-      - "tools/ts-rs-cli/**"
+      - 'clients/**'
+      - 'common/**'
+      - 'explorer-api/**'
+      - 'gateway/**'
+      - 'integrations/**'
+      - 'mixnode/**'
+      - 'sdk/rust/nym-sdk/**'
+      - 'service-providers/**'
+      - 'nym-api/**'
+      - 'nym-outfox/**'
+      - 'tools/nym-cli/**'
+      - 'tools/ts-rs-cli/**'

 jobs:
  publish-nym:
@@ -53,16 +53,6 @@ jobs:
          command: build
          args: --workspace --release

-      - name: Install cargo-deb
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-deb
-
-      - name: Build deb packages
-        shell: bash
-        run: scripts/ppa.sh ${{ secrets.PPA_SIGNING_KEY }}
-
      - name: Prepare build output
        shell: bash
        env:
@@ -77,7 +67,6 @@ jobs:
          cp target/release/nym-network-statistics $OUTPUT_DIR
          cp target/release/nym-cli $OUTPUT_DIR
          cp target/release/explorer-api $OUTPUT_DIR
-          cp ppa/debian/* $OUTPUT_DIR

      - name: Deploy branch to CI www
        continue-on-error: true
@@ -1,21 +0,0 @@
-name: ci-cargo-deny
-on: [workflow_dispatch]
-jobs:
-  cargo-deny:
-    runs-on: ubuntu-22.04
-    strategy:
-      matrix:
-        checks:
-          # - advisories
-          - licenses
-          - bans sources
-
-    continue-on-error: ${{ matrix.checks == 'licenses' }}
-
-    steps:
-    - uses: actions/checkout@v3
-    - uses: EmbarkStudios/cargo-deny-action@v1
-      with:
-        log-level: warn
-        command: check ${{ matrix.checks }}
-        argument: --all-features
@@ -17,9 +17,6 @@ jobs:
    steps:
      - uses: actions/checkout@v2

-      - name: install yarn in root
-        run: cd ../.. yarn install
-
      - name: Install npm
        run: npm install

@@ -0,0 +1,40 @@
+name: ci-nym-vpn-ui-js
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - 'nym-vpn/ui/src/**'
+      - 'nym-vpn/ui/package.json'
+      - 'nym-vpn/ui/index.html'
+
+jobs:
+  check:
+    runs-on: custom-linux
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Install Yarn
+        run: npm install -g yarn
+      - name: Install dependencies
+        working-directory: nym-vpn/ui
+        run: yarn
+      - name: Type-check
+        working-directory: nym-vpn/ui
+        run: yarn typecheck
+      - name: Check lint
+        working-directory: nym-vpn/ui
+        run: yarn lint
+      - name: Check formatting
+        working-directory: nym-vpn/ui
+        run: yarn fmt:check
+#      - name: Run tests
+#        working-directory: nym-vpn/ui
+#        run: yarn test
+      - name: Check build
+        working-directory: nym-vpn/ui
+        run: yarn build
@@ -0,0 +1,63 @@
+name: ci-nym-vpn-ui-rust
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - 'nym-vpn/ui/src-tauri/**'
+
+jobs:
+  build:
+    runs-on: custom-linux
+    env:
+      CARGO_TERM_COLOR: always
+      CARGOTOML_PATH: ./nym-vpn/ui/src-tauri/Cargo.toml
+    steps:
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools libayatana-appindicator3-dev
+        continue-on-error: true
+
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Prepare build
+        run: mkdir nym-vpn/ui/dist
+
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --features custom-protocol
+
+#      - name: Run all tests
+#        uses: actions-rs/cargo@v1
+#        with:
+#          command: test
+#          args: --manifest-path ${{ env.CARGOTOML_PATH }}
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --all -- --check
+
+      - name: Annotate with clippy checks
+        uses: actions-rs/clippy-check@v1
+        continue-on-error: true
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --all-features
+
+      - name: Clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --all-features --all-targets -- -D warnings
@@ -9,7 +9,6 @@
 target
 .env
 .env.dev
-envs/devnet.env
 /.vscode/settings.json
 validator/.vscode
 sample-configs/validator-config.toml
@@ -56,6 +56,9 @@ members = [
    "common/node-tester-utils",
    "common/nonexhaustive-delayqueue",
    "common/nymcoconut",
+    "common/nym_offline_compact_ecash",
+    "common/nym_offline_divisible_ecash",
+    "common/nym_online_divisible_ecash",
    "common/nymsphinx",
    "common/nymsphinx/acknowledgements",
    "common/nymsphinx/addressing",
@@ -67,7 +70,6 @@ members = [
    "common/nymsphinx/params",
    "common/nymsphinx/routing",
    "common/nymsphinx/types",
-    "common/nyxd-scraper",
    "common/pemstore",
    "common/socks5-client-core",
    "common/socks5/proxy-helpers",
@@ -102,7 +104,6 @@ members = [
    "nym-node",
    "nym-node/nym-node-requests",
    "nym-outfox",
-    "nym-validator-rewarder",
    "tools/internal/ssl-inject",
    "tools/internal/sdk-version-bump",
    "tools/nym-cli",
@@ -110,7 +111,7 @@ members = [
    "tools/nymvisor",
    "tools/ts-rs-cli",
    "wasm/client",
-#    "wasm/full-nym-wasm",
+    #    "wasm/full-nym-wasm",
    "wasm/mix-fetch",
    "wasm/node-tester",
 ]
@@ -125,10 +126,17 @@ default-members = [
    "nym-api",
    "tools/nymvisor",
    "explorer-api",
-    "nym-validator-rewarder",
 ]

-exclude = ["explorer", "contracts", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop", "nym-vpn/ui/src-tauri", "cpu-cycles", "sdk/ffi/cpp"]
+exclude = [
+    "explorer",
+    "contracts",
+    "nym-wallet",
+    "nym-connect/mobile/src-tauri",
+    "nym-connect/desktop",
+    "nym-vpn/ui/src-tauri",
+    "cpu-cycles",
+]

 [workspace.package]
 authors = ["Nym Technologies SA"]
@@ -162,12 +170,10 @@ reqwest = "0.11.22"
 schemars = "0.8.1"
 serde = "1.0.152"
 serde_json = "1.0.91"
-sqlx = "0.6.3"
 tap = "1.0.1"
 time = "0.3.30"
 thiserror = "1.0.48"
-tokio = "1.33.0"
-tokio-util = "0.7.10"
+tokio = "1.24.1"
 tokio-tungstenite = "0.20.1"
 tracing = "0.1.37"
 tungstenite = { version = "0.20.1", default-features = false }
@@ -177,14 +183,6 @@ utoipa-swagger-ui = "3.1.5"
 url = "2.4"
 zeroize = "1.6.0"

-# coconut/DKG related
-# unfortunately until https://github.com/zkcrypto/bls12_381/issues/10 is resolved, we have to rely on the fork
-# as we need to be able to serialize Gt so that we could create the lookup table for baby-step-giant-step algorithm
-bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", branch ="feature/gt-serialization-0.8.0" }
-group = "0.13.0"
-ff = "0.13.0"
-
-
 # cosmwasm-related
 cosmwasm-derive = "=1.3.0"
 cosmwasm-schema = "=1.3.0"
@@ -203,11 +201,7 @@ cw-controllers = { version = "=1.1.0" }

 # cosmrs-related
 bip32 = "0.5.1"
-
-# temporarily using a fork again (yay.) because we need staking and slashing support
-cosmrs = { git = "https://github.com/jstuczyn/cosmos-rust", branch ="nym-temp/all-validator-features" }
-#cosmrs = {  git = "https://github.com/jstuczyn/cosmos-rust", branch = "nym-temp/all-validator-features" } # unfortuntely we need a fork by yours truly to get the staking support
-tendermint = "0.34" # same version as used by cosmrs
+cosmrs = "=0.15.0"
 tendermint-rpc = "0.34" # same version as used by cosmrs
 prost = "0.12"

@@ -221,6 +215,15 @@ wasm-bindgen-futures = "0.4.37"
 wasmtimer = "0.2.0"
 web-sys = "0.3.63"

+bls12_381 = { path = "/Users/drazen/nym/bls12_381", default-features = false, features = [
+    "alloc",
+    "pairings",
+    "experimental",
+    "zeroize",
+] }
+ff = { version = "0.13", default-features = false }
+group = { version = "0.13", default-features = false }
+
 # Profile settings for individual crates

 [profile.release.package.nym-socks5-listener]
@@ -12,7 +12,6 @@ help:
 	@echo "  clippy: run clippy for all workspaces"
 	@echo "  test: run clippy, unit tests, and formatting."
 	@echo "  test-all: like test, but also includes the expensive tests"
-	@echo "  ppa: build debian package and generate files required for PPA update"

 # -----------------------------------------------------------------------------
 # Meta targets
@@ -158,12 +157,6 @@ build-explorer-api:
 build-nym-cli:
 	cargo build -p nym-cli --release

-build-nym-gateway:
-	cargo build -p nym-gateway --release
-
-build-nym-mixnode:
-	cargo build -p nym-mixnode --release
-
 # -----------------------------------------------------------------------------
 # Misc
 # -----------------------------------------------------------------------------
@@ -177,5 +170,5 @@ run-api-tests:

 # Build debian package, and update PPA
 # Requires base64 encode GPG key to be set up in environment PPA_SIGNING_KEY
-# ppa: build-nym-mixnode build-nym-gateway
-# 	scripts/ppa.sh
+deb:
+	scripts/ppa.sh
@@ -1,70 +0,0 @@
-<html>
-
-<head>
-    <style>
-        @media (prefers-color-scheme: dark) {
-            body {
-                background: #333;
-                color: white;
-            }
-            a {
-                color: skyblue;
-            }
-        }
-        .container {
-            font-family: sans-serif;
-            max-width: 800px;
-            margin: 0 auto;
-        }
-        .intro {
-            text-align: center;
-        }
-        .licenses-list {
-            list-style-type: none;
-            margin: 0;
-            padding: 0;
-        }
-        .license-used-by {
-            margin-top: -10px;
-        }
-        .license-text {
-            max-height: 200px;
-            overflow-y: scroll;
-            white-space: pre-wrap;
-        }
-    </style>
-</head>
-
-<body>
-    <main class="container">
-        <div class="intro">
-            <h1>Third Party Licenses</h1>
-            <p>This page lists the licenses of the projects used in cargo-about.</p>
-        </div>
-    
-        <h2>Overview of licenses:</h2>
-        <ul class="licenses-overview">
-            {{#each overview}}
-            <li><a href="#{{id}}">{{name}}</a> ({{count}})</li>
-            {{/each}}
-        </ul>
-
-        <h2>All license text:</h2>
-        <ul class="licenses-list">
-            {{#each licenses}}
-            <li class="license">
-                <h3 id="{{id}}">{{name}}</h3>
-                <h4>Used by:</h4>
-                <ul class="license-used-by">
-                    {{#each used_by}}
-                    <li><a href="{{#if crate.repository}} {{crate.repository}} {{else}} https://crates.io/crates/{{crate.name}} {{/if}}">{{crate.name}} {{crate.version}}</a></li>
-                    {{/each}}
-                </ul>
-                <pre class="license-text">{{text}}</pre>
-            </li>
-            {{/each}}
-        </ul>
-    </main>
-</body>
-
-</html>
@@ -1,19 +0,0 @@
-private = { ignore = true }
-
-accepted = [
-    "0BSD",
-    "Apache-2.0",
-    "BSD-2-Clause",
-    "BSD-3-Clause",
-    "CC0-1.0",
-    "ISC",
-    "MIT",
-    "MPL-2.0",
-    "Unicode-DFS-2016",
-    "OpenSSL",
-]
-
-workarounds = [
-    "ring",
-    "rustls",
-]
@@ -5,7 +5,6 @@ authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej St
 description = "Implementation of the Nym Client"
 edition = "2021"
 rust-version = "1.65"
-license.workspace = true

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -39,6 +38,7 @@ nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
 nym-client-core = { path = "../../common/client-core", features = ["fs-surb-storage", "cli"] }
 nym-coconut-interface = { path = "../../common/coconut-interface" }
+nym-compact-ecash = { path = "../../common/nym_offline_compact_ecash" }
 nym-config = { path = "../../common/config" }
 nym-credential-storage = { path = "../../common/credential-storage" }
 nym-credentials = { path = "../../common/credentials" }
@@ -1667,9 +1667,9 @@
      }
    },
    "node_modules/follow-redirects": {
-      "version": "1.15.4",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
-      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
+      "version": "1.14.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.9.tgz",
+      "integrity": "sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==",
      "dev": true,
      "funding": [
        {
@@ -5800,9 +5800,9 @@
      }
    },
    "follow-redirects": {
-      "version": "1.15.4",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
-      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
+      "version": "1.14.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.9.tgz",
+      "integrity": "sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==",
      "dev": true
    },
    "forwarded": {
@@ -5,8 +5,9 @@ use crate::client::config::old_config_v1_1_20_2::{
    ClientPathsV1_1_20_2, ConfigV1_1_20_2, SocketTypeV1_1_20_2, SocketV1_1_20_2,
 };
 use nym_bin_common::logging::LoggingSettings;
-use nym_client_core::config::disk_persistence::keys_paths::ClientKeysPaths;
-use nym_client_core::config::disk_persistence::old_v1_1_20_2::CommonClientPathsV1_1_20_2;
+use nym_client_core::config::disk_persistence::old_v1_1_20_2::{
+    ClientKeysPathsV1_1_20_2, CommonClientPathsV1_1_20_2,
+};
 use nym_client_core::config::old_config_v1_1_20::ConfigV1_1_20 as BaseConfigV1_1_20;
 use nym_client_core::config::old_config_v1_1_20_2::{
    ClientV1_1_20_2, ConfigV1_1_20_2 as BaseConfigV1_1_20_2,
@@ -60,7 +61,7 @@ impl From<ConfigV1_1_20> for ConfigV1_1_20_2 {
            socket: value.socket.into(),
            storage_paths: ClientPathsV1_1_20_2 {
                common_paths: CommonClientPathsV1_1_20_2 {
-                    keys: ClientKeysPaths {
+                    keys: ClientKeysPathsV1_1_20_2 {
                        private_identity_key_file: value.base.client.private_identity_key_file,
                        public_identity_key_file: value.base.client.public_identity_key_file,
                        private_encryption_key_file: value.base.client.private_encryption_key_file,
@@ -50,6 +50,12 @@ keys.private_encryption_key_file = '{{ storage_paths.keys.private_encryption_key
 # Path to file containing public encryption key.
 keys.public_encryption_key_file = '{{ storage_paths.keys.public_encryption_key_file }}'

+# Path to file containing private ecash key.
+keys.private_ecash_key_file = '{{ storage_paths.keys.private_ecash_key_file }}'
+
+# Path to file containing public ecash key.
+keys.public_ecash_key_file = '{{ storage_paths.keys.public_ecash_key_file }}'
+
 # A gateway specific, optional, base58 stringified shared key used for
 # communication with particular gateway.
 keys.gateway_shared_key_file = '{{ storage_paths.keys.gateway_shared_key_file }}'
@@ -51,7 +51,7 @@ impl InitialisableClient for NativeClientInit {
    }
 }

-#[derive(Args, Clone, Debug)]
+#[derive(Args, Clone)]
 pub(crate) struct Init {
    #[command(flatten)]
    common_args: CommonClientInitArgs,
@@ -18,6 +18,7 @@ use nym_client_core::client::base_client::storage::gateway_details::{
 use nym_client_core::client::key_manager::persistence::OnDiskKeys;
 use nym_client_core::config::GatewayEndpointConfig;
 use nym_client_core::error::ClientCoreError;
+use nym_compact_ecash::{generate_keypair_user, setup::GroupParameters};
 use nym_config::OptionalSet;
 use std::error::Error;
 use std::net::IpAddr;
@@ -121,6 +122,28 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
        )
 }

+fn init_ecash_keypair(config: &Config) -> Result<(), ClientError> {
+    let kp = generate_keypair_user(&GroupParameters::new().unwrap());
+    nym_pemstore::store_keypair(
+        &kp,
+        &nym_pemstore::KeyPairPath::new(
+            config
+                .storage_paths
+                .common_paths
+                .keys
+                .private_ecash_key_file
+                .clone(),
+            config
+                .storage_paths
+                .common_paths
+                .keys
+                .public_ecash_key_file
+                .clone(),
+        ),
+    )?;
+    Ok(())
+}
+
 fn persist_gateway_details(
    config: &Config,
    details: GatewayEndpointConfig,
@@ -159,6 +182,7 @@ fn try_upgrade_v1_1_13_config(id: &str) -> Result<bool, ClientError> {
    let updated_step2: ConfigV1_1_20_2 = updated_step1.into();
    let (updated, gateway_config) = updated_step2.upgrade()?;
    persist_gateway_details(&updated, gateway_config)?;
+    init_ecash_keypair(&updated)?; //SW does that belong here?

    updated.save_to_default_location()?;
    Ok(true)
@@ -179,6 +203,7 @@ fn try_upgrade_v1_1_20_config(id: &str) -> Result<bool, ClientError> {
    let updated_step1: ConfigV1_1_20_2 = old_config.into();
    let (updated, gateway_config) = updated_step1.upgrade()?;
    persist_gateway_details(&updated, gateway_config)?;
+    init_ecash_keypair(&updated)?; //SW does that belong here?

    updated.save_to_default_location()?;
    Ok(true)
@@ -196,6 +221,7 @@ fn try_upgrade_v1_1_20_2_config(id: &str) -> Result<bool, ClientError> {

    let (updated, gateway_config) = old_config.upgrade()?;
    persist_gateway_details(&updated, gateway_config)?;
+    init_ecash_keypair(&updated)?; //SW does that belong here?

    updated.save_to_default_location()?;
    Ok(true)
@@ -3,7 +3,6 @@ name = "nym-client-websocket-requests"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -5,7 +5,6 @@ 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"
 rust-version = "1.56"
-license.workspace = true

 [dependencies]
 clap = { workspace = true, features = ["cargo", "derive"] }
@@ -51,7 +51,7 @@ impl InitialisableClient for Socks5ClientInit {
    }
 }

-#[derive(Args, Clone, Debug)]
+#[derive(Args, Clone)]
 pub(crate) struct Init {
    #[command(flatten)]
    common_args: CommonClientInitArgs,
@@ -5,8 +5,9 @@ use crate::config::old_config_v1_1_20_2::{
    ConfigV1_1_20_2, CoreConfigV1_1_20_2, SocksClientPathsV1_1_20_2,
 };
 use nym_bin_common::logging::LoggingSettings;
-use nym_client_core::config::disk_persistence::keys_paths::ClientKeysPaths;
-use nym_client_core::config::disk_persistence::old_v1_1_20_2::CommonClientPathsV1_1_20_2;
+use nym_client_core::config::disk_persistence::old_v1_1_20_2::{
+    ClientKeysPathsV1_1_20_2, CommonClientPathsV1_1_20_2,
+};
 use nym_client_core::config::old_config_v1_1_20::ConfigV1_1_20 as BaseConfigV1_1_20;
 use nym_client_core::config::old_config_v1_1_20_2::ClientV1_1_20_2;
 use nym_config::legacy_helpers::nym_config::MigrationNymConfig;
@@ -50,7 +51,7 @@ impl From<ConfigV1_1_20> for ConfigV1_1_20_2 {
            },
            storage_paths: SocksClientPathsV1_1_20_2 {
                common_paths: CommonClientPathsV1_1_20_2 {
-                    keys: ClientKeysPaths {
+                    keys: ClientKeysPathsV1_1_20_2 {
                        private_identity_key_file: value.base.client.private_identity_key_file,
                        public_identity_key_file: value.base.client.public_identity_key_file,
                        private_encryption_key_file: value.base.client.private_encryption_key_file,
@@ -50,6 +50,12 @@ keys.private_encryption_key_file = '{{ storage_paths.keys.private_encryption_key
 # Path to file containing public encryption key.
 keys.public_encryption_key_file = '{{ storage_paths.keys.public_encryption_key_file }}'

+# Path to file containing private ecash key.
+keys.private_ecash_key_file = '{{ storage_paths.keys.private_ecash_key_file }}'
+
+# Path to file containing public ecash key.
+keys.public_ecash_key_file = '{{ storage_paths.keys.public_ecash_key_file }}'
+
 # A gateway specific, optional, base58 stringified shared key used for
 # communication with particular gateway.
 keys.gateway_shared_key_file = '{{ storage_paths.keys.gateway_shared_key_file }}'
@@ -1,4 +0,0 @@
-module.exports = {
-    ConfigHandler: require('./config/configHandler.ts'),
-    RestClient: require('./restClient/RestClient.ts')
-  };
@@ -2,7 +2,6 @@
 name = "async-file-watcher"
 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

@@ -2,7 +2,6 @@
 name = "nym-bandwidth-controller"
 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

@@ -11,9 +10,9 @@ bip39 = { workspace = true }
 rand = "0.7.3"
 thiserror = { workspace = true }
 url = { workspace = true }
-zeroize = { workspace = true }

 nym-coconut-interface = { path = "../coconut-interface" }
+nym-compact-ecash = { path = "../nym_offline_compact_ecash" }
 nym-credential-storage = { path = "../credential-storage" }
 nym-credentials = { path = "../credentials" }
 nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
@@ -2,49 +2,59 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::BandwidthControllerError;
-use nym_coconut_interface::Base58;
+use nym_compact_ecash::scheme::keygen::KeyPairUser;
+use nym_compact_ecash::setup::GroupParameters;
+use nym_compact_ecash::Base58;
 use nym_credential_storage::storage::Storage;
 use nym_credentials::coconut::bandwidth::BandwidthVoucher;
 use nym_credentials::coconut::utils::obtain_aggregate_signature;
 use nym_crypto::asymmetric::{encryption, identity};
-use nym_network_defaults::VOUCHER_INFO;
-use nym_validator_client::coconut::all_coconut_api_clients;
+use nym_network_defaults::ECASH_INFO;
+use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nyxd::contract_traits::CoconutBandwidthSigningClient;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use nym_validator_client::nyxd::Coin;
+use nym_validator_client::nyxd::Hash;
 use rand::rngs::OsRng;
-use state::State;
+use state::{KeyPair, State};
+use std::str::FromStr;

 pub mod state;

-pub async fn deposit<C>(client: &C, amount: Coin) -> Result<State, BandwidthControllerError>
+pub async fn deposit<C>(
+    client: &C,
+    amount: Coin,
+    ecash_keypair: KeyPairUser,
+) -> Result<State, BandwidthControllerError>
 where
    C: CoconutBandwidthSigningClient + Sync,
 {
    let mut rng = OsRng;
-    let signing_key = identity::PrivateKey::new(&mut rng);
-    let encryption_key = encryption::PrivateKey::new(&mut rng);
-    let params = BandwidthVoucher::default_parameters();
+    let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
+    let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));
+    let params = GroupParameters::new().unwrap();
    let voucher_value = amount.amount.to_string();

    let tx_hash = client
        .deposit(
            amount,
-            String::from(VOUCHER_INFO),
-            signing_key.public_key().to_base58_string(),
-            encryption_key.public_key().to_base58_string(),
+            String::from(ECASH_INFO),
+            signing_keypair.public_key.clone(),
+            encryption_keypair.public_key.clone(),
            None,
        )
        .await?
-        .transaction_hash;
+        .transaction_hash
+        .to_string();

    let voucher = BandwidthVoucher::new(
        &params,
        voucher_value,
-        VOUCHER_INFO.to_string(),
-        tx_hash,
-        signing_key,
-        encryption_key,
+        ECASH_INFO.to_string(),
+        Hash::from_str(&tx_hash).map_err(|_| BandwidthControllerError::InvalidTxHash)?,
+        identity::PrivateKey::from_base58_string(&signing_keypair.private_key)?,
+        encryption::PrivateKey::from_base58_string(&encryption_keypair.private_key)?,
+        ecash_keypair,
    );

    let state = State { voucher, params };
@@ -68,22 +78,16 @@ where
        .await?
        .ok_or(BandwidthControllerError::NoThreshold)?;

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

-    let signature = obtain_aggregate_signature(
-        &state.params,
-        &state.voucher,
-        &coconut_api_clients,
-        threshold,
-    )
-    .await?;
+    let wallet =
+        obtain_aggregate_signature(&state.params, &state.voucher, &ecash_api_clients, threshold)
+            .await?;
    storage
-        .insert_coconut_credential(
+        .insert_ecash_wallet(
+            ECASH_INFO.to_string(),
+            wallet.to_bs58(),
            state.voucher.get_voucher_value(),
-            VOUCHER_INFO.to_string(),
-            state.voucher.get_private_attributes()[0].to_bs58(),
-            state.voucher.get_private_attributes()[1].to_bs58(),
-            signature.to_bs58(),
            epoch_id.to_string(),
        )
        .await
@@ -1,19 +1,44 @@
 // Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_coconut_interface::Parameters;
+use nym_compact_ecash::setup::GroupParameters;
 use nym_credentials::coconut::bandwidth::BandwidthVoucher;

+use nym_crypto::asymmetric::{encryption, identity};
+
+pub(crate) struct KeyPair {
+    pub public_key: String,
+    pub private_key: String,
+}
+
+impl From<identity::KeyPair> for KeyPair {
+    fn from(kp: identity::KeyPair) -> Self {
+        Self {
+            public_key: kp.public_key().to_base58_string(),
+            private_key: kp.private_key().to_base58_string(),
+        }
+    }
+}
+
+impl From<encryption::KeyPair> for KeyPair {
+    fn from(kp: encryption::KeyPair) -> Self {
+        Self {
+            public_key: kp.public_key().to_base58_string(),
+            private_key: kp.private_key().to_base58_string(),
+        }
+    }
+}
+
 pub struct State {
    pub voucher: BandwidthVoucher,
-    pub params: Parameters,
+    pub params: GroupParameters,
 }

 impl State {
    pub fn new(voucher: BandwidthVoucher) -> Self {
        State {
            voucher,
-            params: BandwidthVoucher::default_parameters(),
+            params: GroupParameters::new().unwrap(),
        }
    }
 }
@@ -1,7 +1,7 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_coconut_interface::CoconutError;
+use nym_compact_ecash::error::CompactEcashError;
 use nym_credential_storage::error::StorageError;
 use nym_credentials::error::Error as CredentialsError;
 use nym_crypto::asymmetric::encryption::KeyRecoveryError;
@@ -25,8 +25,8 @@ pub enum BandwidthControllerError {
    #[error(transparent)]
    StorageError(#[from] StorageError),

-    #[error("Coconut error - {0}")]
-    CoconutError(#[from] CoconutError),
+    #[error("Ecash error - {0}")]
+    EcashError(#[from] CompactEcashError),

    #[error("Validator client error - {0}")]
    ValidatorError(#[from] ValidatorClientError),
@@ -2,18 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::BandwidthControllerError;
+use nym_compact_ecash::scheme::keygen::KeyPairUser;
+use nym_compact_ecash::scheme::{EcashCredential, Wallet};
+use nym_compact_ecash::setup::{setup, Parameters};
+use nym_compact_ecash::{Base58, PayInfo};
 use nym_credential_storage::error::StorageError;
 use nym_credential_storage::storage::Storage;
-use nym_validator_client::coconut::all_coconut_api_clients;
+use nym_credentials::obtain_aggregate_verification_key;
+use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use std::str::FromStr;
-use zeroize::Zeroizing;
-use {
-    nym_coconut_interface::Base58,
-    nym_credentials::coconut::{
-        bandwidth::prepare_for_spending, utils::obtain_aggregate_verification_key,
-    },
-};

 pub mod acquire;
 pub mod error;
@@ -21,70 +19,89 @@ pub mod error;
 pub struct BandwidthController<C, St> {
    storage: St,
    client: C,
+    ecash_keypair: KeyPairUser,
+    ecash_params: Parameters,
 }

 impl<C, St: Storage> BandwidthController<C, St> {
-    pub fn new(storage: St, client: C) -> Self {
-        BandwidthController { storage, client }
+    pub fn new(
+        storage: St,
+        client: C,
+        ecash_keypair: KeyPairUser,
+        ecash_params: Parameters,
+    ) -> Self {
+        BandwidthController {
+            storage,
+            client,
+            ecash_keypair,
+            ecash_params,
+        }
    }

    pub fn storage(&self) -> &St {
        &self.storage
    }

-    pub async fn prepare_coconut_credential(
+    pub async fn prepare_ecash_credential(
        &self,
-    ) -> Result<(nym_coconut_interface::Credential, i64), BandwidthControllerError>
+        provider_pk: [u8; 32],
+    ) -> Result<(EcashCredential, Wallet, i64), BandwidthControllerError>
    where
        C: DkgQueryClient + Sync + Send,
        <St as Storage>::StorageError: Send + Sync + 'static,
    {
-        let bandwidth_credential = self
+        let ecash_wallet = self
            .storage
-            .get_next_coconut_credential()
+            .get_next_ecash_wallet()
            .await
            .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))?;
-        let voucher_value = u64::from_str(&bandwidth_credential.voucher_value)
-            .map_err(|_| StorageError::InconsistentData)?;
-        let voucher_info = bandwidth_credential.voucher_info.clone();
-        let serial_number = Zeroizing::new(nym_coconut_interface::Attribute::try_from_bs58(
-            bandwidth_credential.serial_number,
-        )?);
-        let binding_number = Zeroizing::new(nym_coconut_interface::Attribute::try_from_bs58(
-            bandwidth_credential.binding_number,
-        )?);
-        let signature =
-            nym_coconut_interface::Signature::try_from_bs58(bandwidth_credential.signature)?;
-        let epoch_id = u64::from_str(&bandwidth_credential.epoch_id)
-            .map_err(|_| StorageError::InconsistentData)?;

-        let coconut_api_clients = all_coconut_api_clients(&self.client, epoch_id).await?;
+        let wallet = Wallet::try_from_bs58(ecash_wallet.wallet)?;
+        let epoch_id =
+            u64::from_str(&ecash_wallet.epoch_id).map_err(|_| StorageError::InconsistentData)?;

-        let verification_key = obtain_aggregate_verification_key(&coconut_api_clients).await?;
+        let ecash_api_clients = all_ecash_api_clients(&self.client, epoch_id).await?;
+
+        let verification_key = obtain_aggregate_verification_key(&ecash_api_clients).await?;
+
+        let sk_user = self.ecash_keypair.secret_key();
+        let pay_info = PayInfo::generate_payinfo(provider_pk);
+        let nb_tickets = 1u64; //SW: TEMPORARY VALUE, what should we put there?
+        let wallet_value = u64::from_str(&ecash_wallet.value)
+            .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))?;
+        let credential_value = nb_tickets * wallet_value / (self.ecash_params.ll());

        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
-        Ok((
-            prepare_for_spending(
-                voucher_value,
-                voucher_info,
-                &serial_number,
-                &binding_number,
-                epoch_id,
-                &signature,
-                &verification_key,
-            )?,
-            bandwidth_credential.id,
-        ))
+
+        let (payment, _) = wallet.spend(
+            &self.ecash_params,
+            &verification_key,
+            &sk_user,
+            &pay_info,
+            false,
+            nb_tickets,
+        )?;
+
+        let credential = EcashCredential::new(payment, credential_value, pay_info, epoch_id);
+
+        Ok((credential, wallet, ecash_wallet.id))
    }

-    pub async fn consume_credential(&self, id: i64) -> Result<(), BandwidthControllerError>
+    pub async fn update_ecash_wallet(
+        &self,
+        wallet: Wallet,
+        id: i64,
+    ) -> 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 = wallet.l() >= setup(100).ll(); //temporary, depends on parameters distribution
+        let wallet_string = wallet.to_bs58();
+
        self.storage
-            .consume_coconut_credential(id)
+            .update_ecash_wallet(wallet_string, id, consumed)
            .await
            .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))
    }
@@ -99,6 +116,8 @@ where
        BandwidthController {
            storage: self.storage.clone(),
            client: self.client.clone(),
+            ecash_keypair: self.ecash_keypair.clone(),
+            ecash_params: self.ecash_params.clone(),
        }
    }
 }
@@ -9,7 +9,6 @@ repository = { workspace = true }

 [dependencies]
 atty = "0.2"
-const-str = "0.5.6"
 clap = { workspace = true, features = ["derive"] }
 clap_complete = "4.0"
 clap_complete_fig = "4.0"
@@ -36,10 +35,9 @@ opentelemetry = { version = "0.19.0", optional = true, features = ["rt-tokio"] }


 [build-dependencies]
-vergen = { version = "=8.2.6", default-features = false, features = [
+vergen = { version = "=7.4.3", default-features = false, features = [
    "build",
    "git",
-    "gitcl",
    "rustc",
    "cargo",
 ] }
@@ -1,14 +1,13 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use vergen::EmitBuilder;
+use vergen::{vergen, Config};

 fn main() {
-    EmitBuilder::builder()
-        .all_build()
-        .all_git()
-        .all_rustc()
-        .all_cargo()
-        .emit()
-        .expect("failed to extract build metadata");
+    let mut config = Config::default();
+    if std::env::var("DOCS_RS").is_ok() {
+        // If we don't have access to git information, such as in a docs.rs build, don't error
+        *config.git_mut().skip_if_error_mut() = true;
+    }
+    vergen(config).expect("failed to extract build metadata");
 }
@@ -40,22 +40,14 @@ pub struct BinaryBuildInformation {
    /// Provides the rustc channel that was used for the build, for example `nightly`.
    pub rustc_channel: &'static str,

-    // VERGEN_CARGO_DEBUG
-    /// Provides the cargo debug mode that was used for the build.
-    // NOTE: keep the old name cargo_profile instead of cargo_debug for backwards compatibility
+    // VERGEN_CARGO_PROFILE
+    /// Provides the cargo profile that was used for the build, for example `debug`.
    pub cargo_profile: &'static str,
 }

 impl BinaryBuildInformation {
    // explicitly require the build_version to be passed as it's binary specific
    pub const fn new(binary_name: &'static str, build_version: &'static str) -> Self {
-        let cargo_debug = env!("VERGEN_CARGO_DEBUG");
-        let cargo_profile = if const_str::equal!(cargo_debug, "true") {
-            "debug"
-        } else {
-            "release"
-        };
-
        BinaryBuildInformation {
            binary_name,
            build_timestamp: env!("VERGEN_BUILD_TIMESTAMP"),
@@ -65,7 +57,7 @@ impl BinaryBuildInformation {
            commit_branch: env!("VERGEN_GIT_BRANCH"),
            rustc_version: env!("VERGEN_RUSTC_SEMVER"),
            rustc_channel: env!("VERGEN_RUSTC_CHANNEL"),
-            cargo_profile,
+            cargo_profile: env!("VERGEN_CARGO_PROFILE"),
        }
    }

@@ -123,9 +115,8 @@ pub struct BinaryBuildInformationOwned {
    /// Provides the rustc channel that was used for the build, for example `nightly`.
    pub rustc_channel: String,

-    // VERGEN_CARGO_DEBUG
-    /// Provides the cargo debug mode that was used for the build.
-    // NOTE: keep the old name cargo_profile instead of cargo_debug for backwards compatibility
+    // VERGEN_CARGO_PROFILE
+    /// Provides the cargo profile that was used for the build, for example `debug`.
    pub cargo_profile: String,
 }

@@ -4,7 +4,6 @@ version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
-license.workspace = true

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -35,6 +34,7 @@ zeroize = { workspace = true }
 nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-config = { path = "../config" }
 nym-crypto = { path = "../crypto" }
+nym-compact-ecash = { path = "../nym_offline_compact_ecash" }
 nym-explorer-client = { path = "../../explorer-api/explorer-client" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 nym-gateway-requests = { path = "../../gateway/gateway-requests" }
@@ -46,7 +46,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" }
-si-scale = "0.2.2"

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
 version = "0.1.11"
@@ -60,7 +59,7 @@ features = ["time"]
 version = "0.20.1"

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
-workspace = true
+version = "0.6.2"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
 optional = true

@@ -91,7 +90,7 @@ tempfile = "3.1.0"

 [build-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
-sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
+sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }

 [features]
 default = []
@@ -109,8 +109,6 @@ pub async fn initialise_client<C>(
 ) -> Result<InitResultsWithConfig<C::Config>, C::Error>
 where
    C: InitialisableClient,
-    <C as InitialisableClient>::Config: std::fmt::Debug,
-    <C as InitialisableClient>::InitArgs: std::fmt::Debug,
 {
    info!("initialising {} client", C::NAME);

@@ -142,32 +140,17 @@ where

    // Attempt to use a user-provided gateway, if possible
    let user_chosen_gateway_id = common_args.gateway;
-    log::debug!("User chosen gateway id: {user_chosen_gateway_id:?}");
-
    let selection_spec = GatewaySelectionSpecification::new(
        user_chosen_gateway_id.map(|id| id.to_base58_string()),
        Some(common_args.latency_based_selection),
        false,
    );
-    log::debug!("Gateway selection specification: {selection_spec:?}");

    // Load and potentially override config
-    log::debug!("Init arguments: {init_args:#?}");
    let config = C::construct_config(&init_args);
-    log::debug!("Constructed config: {config:#?}");
    let paths = config.common_paths();
    let core = config.core_config();

-    log::info!(
-        "Using nym-api: {}",
-        core.client
-            .nym_api_urls
-            .iter()
-            .map(|url| url.as_str())
-            .collect::<Vec<&str>>()
-            .join(",")
-    );
-
    // Setup gateway by either registering a new one, or creating a new config from the selected
    // one but with keys kept, or reusing the gateway configuration.
    let key_store = OnDiskKeys::new(paths.keys.clone());
@@ -1,7 +1,6 @@
 // Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use super::packet_statistics_control::PacketStatisticsReporter;
 use super::received_buffer::ReceivedBufferMessage;
 use super::topology_control::geo_aware_provider::GeoAwareTopologyProvider;
 use crate::client::base_client::storage::gateway_details::GatewayDetailsStore;
@@ -11,7 +10,6 @@ use crate::client::inbound_messages::{InputMessage, InputMessageReceiver, InputM
 use crate::client::key_manager::persistence::KeyStore;
 use crate::client::mix_traffic::transceiver::{GatewayReceiver, GatewayTransceiver, RemoteGateway};
 use crate::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
-use crate::client::packet_statistics_control::PacketStatisticsControl;
 use crate::client::real_messages_control;
 use crate::client::real_messages_control::RealMessagesController;
 use crate::client::received_buffer::{
@@ -36,6 +34,7 @@ use crate::{config, spawn_future};
 use futures::channel::mpsc;
 use log::{debug, error, info};
 use nym_bandwidth_controller::BandwidthController;
+use nym_compact_ecash::setup::Parameters;
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_crypto::asymmetric::encryption;
 use nym_gateway_client::{
@@ -51,7 +50,10 @@ use nym_task::{TaskClient, TaskHandle};
 use nym_topology::provider_trait::TopologyProvider;
 use nym_topology::HardcodedTopologyProvider;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
 use std::fmt::Debug;
+use std::ops::Deref;
 use std::path::Path;
 use std::sync::Arc;
 use url::Url;
@@ -256,7 +258,6 @@ where
        self_address: Recipient,
        topology_accessor: TopologyAccessor,
        mix_tx: BatchMixMessageSender,
-        stats_tx: PacketStatisticsReporter,
        shutdown: TaskClient,
    ) {
        info!("Starting loop cover traffic stream...");
@@ -269,7 +270,6 @@ where
            topology_accessor,
            debug_config.traffic,
            debug_config.cover_traffic,
-            stats_tx,
        );

        stream.start_with_shutdown(shutdown);
@@ -289,7 +289,6 @@ where
        client_connection_rx: ConnectionCommandReceiver,
        shutdown: TaskClient,
        packet_type: PacketType,
-        stats_tx: PacketStatisticsReporter,
    ) {
        info!("Starting real traffic stream...");

@@ -304,7 +303,6 @@ where
            reply_controller_receiver,
            lane_queue_lengths,
            client_connection_rx,
-            stats_tx,
        )
        .start_with_shutdown(shutdown, packet_type);
    }
@@ -318,7 +316,6 @@ where
        reply_key_storage: SentReplyKeys,
        reply_controller_sender: ReplyControllerSender,
        shutdown: TaskClient,
-        packet_statistics_control: PacketStatisticsReporter,
    ) {
        info!("Starting received messages buffer controller...");
        let controller: ReceivedMessagesBufferController<SphinxMessageReceiver> =
@@ -328,7 +325,6 @@ where
                mixnet_receiver,
                reply_key_storage,
                reply_controller_sender,
-                packet_statistics_control,
            );
        controller.start_with_shutdown(shutdown)
    }
@@ -514,13 +510,6 @@ where
        Ok(())
    }

-    fn start_packet_statistics_control(shutdown: TaskClient) -> PacketStatisticsReporter {
-        info!("Starting packet statistics control...");
-        let (packet_statistics_control, packet_stats_reporter) = PacketStatisticsControl::new();
-        packet_statistics_control.start_with_shutdown(shutdown);
-        packet_stats_reporter
-    }
-
    fn start_mix_traffic_controller(
        gateway_transceiver: Box<dyn GatewayTransceiver + Send>,
        shutdown: TaskClient,
@@ -571,6 +560,23 @@ where
        setup_gateway(setup_method, key_store, details_store).await
    }

+    async fn get_ecash_parameters(nym_api_urls: Vec<Url>) -> Result<Parameters, ClientCoreError> {
+        let nym_api = nym_api_urls
+            .choose(&mut thread_rng())
+            .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
+
+        let validator_client = nym_validator_client::NymApiClient::new(nym_api.clone());
+        match validator_client.ecash_parameters().await {
+            Err(err) => {
+                error!(
+                    "Failed to grab ecash parameters - {err}\n Plesae try again in a few minutes"
+                );
+                Err(ClientCoreError::ValidatorClientError(err))
+            }
+            Ok(response) => Ok(response.params),
+        }
+    }
+
    pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>
    where
        S::ReplyStore: Send + Sync,
@@ -627,9 +633,16 @@ where

        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
-        let bandwidth_controller = self
-            .dkg_query_client
-            .map(|client| BandwidthController::new(credential_store, client));
+        let ecash_parameters =
+            Self::get_ecash_parameters(self.config.get_nym_api_endpoints()).await?;
+        let bandwidth_controller = self.dkg_query_client.map(|client| {
+            BandwidthController::new(
+                credential_store,
+                client,
+                init_res.managed_keys.ecash_keypair().deref().clone(),
+                ecash_parameters,
+            )
+        });

        let topology_provider = Self::setup_topology_provider(
            self.custom_topology_provider.take(),
@@ -648,9 +661,6 @@ where
        )
        .await?;

-        let packet_stats_reporter =
-            Self::start_packet_statistics_control(shutdown.fork("packet_statistics_control"));
-
        let gateway_packet_router = PacketRouter::new(
            ack_sender,
            mixnet_messages_sender,
@@ -680,7 +690,6 @@ where
            reply_storage.key_storage(),
            reply_controller_sender.clone(),
            shutdown.fork("received_messages_buffer"),
-            packet_stats_reporter.clone(),
        );

        // The message_sender is the transmitter for any component generating sphinx packets
@@ -719,7 +728,6 @@ where
            client_connection_rx,
            shutdown.fork("real_traffic_controller"),
            self.config.debug.traffic.packet_type,
-            packet_stats_reporter.clone(),
        );

        if !self
@@ -734,7 +742,6 @@ where
                self_address,
                shared_topology_accessor.clone(),
                message_sender,
-                packet_stats_reporter,
                shutdown.fork("cover_traffic_stream"),
            );
        }
@@ -9,6 +9,8 @@ use crate::config::Config;
 use crate::error::ClientCoreError;
 use log::{error, info};
 use nym_bandwidth_controller::BandwidthController;
+use nym_compact_ecash::scheme::keygen::KeyPairUser;
+use nym_compact_ecash::setup::Parameters;
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_validator_client::nyxd;
 use nym_validator_client::QueryHttpRpcNyxdClient;
@@ -101,25 +103,30 @@ pub async fn setup_fs_reply_surb_backend<P: AsRef<Path>>(
    }
 }

+//SW Is this used anywhere?
 pub fn create_bandwidth_controller<St: CredentialStorage>(
    config: &Config,
    storage: St,
+    ecash_keypair: KeyPairUser,
+    ecash_params: Parameters,
 ) -> BandwidthController<QueryHttpRpcNyxdClient, St> {
    let nyxd_url = config
        .get_validator_endpoints()
        .pop()
        .expect("No nyxd validator endpoint provided");

-    create_bandwidth_controller_with_urls(nyxd_url, storage)
+    create_bandwidth_controller_with_urls(nyxd_url, storage, ecash_keypair, ecash_params)
 }

 pub fn create_bandwidth_controller_with_urls<St: CredentialStorage>(
    nyxd_url: Url,
    storage: St,
+    ecash_keypair: KeyPairUser,
+    ecash_params: Parameters,
 ) -> BandwidthController<QueryHttpRpcNyxdClient, St> {
    let client = default_query_dkg_client(nyxd_url);

-    BandwidthController::new(storage, client)
+    BandwidthController::new(storage, client, ecash_keypair, ecash_params)
 }

 pub fn default_query_dkg_client_from_config(config: &Config) -> QueryHttpRpcNyxdClient {
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::mix_traffic::BatchMixMessageSender;
-use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
 use crate::client::topology_control::TopologyAccessor;
 use crate::{config, spawn_future};
 use futures::task::{Context, Poll};
@@ -62,8 +61,6 @@ where
    secondary_packet_size: Option<PacketSize>,

    packet_type: PacketType,
-
-    stats_tx: PacketStatisticsReporter,
 }

 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -100,8 +97,7 @@ where
 // obviously when we finally make shared rng that is on 'higher' level, this should become
 // generic `R`
 impl LoopCoverTrafficStream<OsRng> {
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn new(
+    pub fn new(
        ack_key: Arc<AckKey>,
        average_ack_delay: Duration,
        mix_tx: BatchMixMessageSender,
@@ -109,7 +105,6 @@ impl LoopCoverTrafficStream<OsRng> {
        topology_access: TopologyAccessor,
        traffic_config: config::Traffic,
        cover_config: config::CoverTraffic,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        let rng = OsRng;

@@ -127,7 +122,6 @@ impl LoopCoverTrafficStream<OsRng> {
            primary_packet_size: traffic_config.primary_packet_size,
            secondary_packet_size: traffic_config.secondary_packet_size,
            packet_type: traffic_config.packet_type,
-            stats_tx,
        }
    }

@@ -197,10 +191,6 @@ impl LoopCoverTrafficStream<OsRng> {
                    log::warn!("Failed to send cover message - channel closed");
                }
            }
-        } else {
-            self.stats_tx.report(PacketStatisticsEvent::CoverPacketSent(
-                cover_traffic_packet_size.size(),
-            ));
        }

        // TODO: I'm not entirely sure whether this is really required, because I'm not 100%
@@ -1,8 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-#![allow(unused_imports)]
-
 use std::time::Duration;

 pub use wasmtimer::{std::Instant, tokio::*};
@@ -2,6 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::key_manager::persistence::KeyStore;
+use nym_compact_ecash::scheme::keygen::KeyPairUser;
+use nym_compact_ecash::setup::GroupParameters;
+use nym_compact_ecash::{generate_keypair_user, PublicKeyUser};
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_gateway_requests::registration::handshake::SharedKeys;
 use nym_sphinx::acknowledgements::AckKey;
@@ -87,6 +90,14 @@ impl ManagedKeys {
        }
    }

+    pub fn ecash_keypair(&self) -> Arc<KeyPairUser> {
+        match self {
+            ManagedKeys::Initial(keys) => keys.ecash_keypair(),
+            ManagedKeys::FullyDerived(keys) => keys.ecash_keypair(),
+            ManagedKeys::Invalidated => unreachable!("the managed keys got invalidated"),
+        }
+    }
+
    pub fn ack_key(&self) -> Arc<AckKey> {
        match self {
            ManagedKeys::Initial(keys) => keys.ack_key(),
@@ -124,6 +135,14 @@ impl ManagedKeys {
        }
    }

+    pub fn ecash_public_key(&self) -> PublicKeyUser {
+        match self {
+            ManagedKeys::Initial(keys) => keys.ecash_keypair().public_key(),
+            ManagedKeys::FullyDerived(keys) => keys.ecash_keypair().public_key(),
+            ManagedKeys::Invalidated => unreachable!("the managed keys got invalidated"),
+        }
+    }
+
    pub fn ensure_gateway_key(&self, gateway_shared_key: Option<Arc<SharedKeys>>) {
        if let ManagedKeys::FullyDerived(key_manager) = &self {
            if self.gateway_shared_key().is_none() && gateway_shared_key.is_none() {
@@ -185,6 +204,9 @@ pub struct KeyManagerBuilder {

    /// key used for producing and processing acknowledgement packets.
    ack_key: Arc<AckKey>,
+
+    /// key used for ecash wallet
+    ecash_keypair: Arc<KeyPairUser>,
 }

 impl KeyManagerBuilder {
@@ -197,6 +219,7 @@ impl KeyManagerBuilder {
            identity_keypair: Arc::new(identity::KeyPair::new(rng)),
            encryption_keypair: Arc::new(encryption::KeyPair::new(rng)),
            ack_key: Arc::new(AckKey::new(rng)),
+            ecash_keypair: Arc::new(generate_keypair_user(&GroupParameters::new().unwrap())),
        }
    }

@@ -207,6 +230,7 @@ impl KeyManagerBuilder {
        KeyManager {
            identity_keypair: self.identity_keypair,
            encryption_keypair: self.encryption_keypair,
+            ecash_keypair: self.ecash_keypair,
            gateway_shared_key,
            ack_key: self.ack_key,
        }
@@ -220,6 +244,10 @@ impl KeyManagerBuilder {
        Arc::clone(&self.encryption_keypair)
    }

+    pub fn ecash_keypair(&self) -> Arc<KeyPairUser> {
+        Arc::clone(&self.ecash_keypair)
+    }
+
    pub fn ack_key(&self) -> Arc<AckKey> {
        Arc::clone(&self.ack_key)
    }
@@ -240,6 +268,9 @@ pub struct KeyManager {
    /// encryption key associated with the client instance.
    encryption_keypair: Arc<encryption::KeyPair>,

+    /// ecash key associated with the client instance
+    ecash_keypair: Arc<KeyPairUser>,
+
    /// shared key derived with the gateway during "registration handshake"
    // I'm not a fan of how we broke the nice transition of `KeyManagerBuilder` -> `KeyManager`
    // by making this field optional.
@@ -255,12 +286,14 @@ impl KeyManager {
    pub fn from_keys(
        id_keypair: identity::KeyPair,
        enc_keypair: encryption::KeyPair,
+        ecash_keypair: KeyPairUser,
        gateway_shared_key: Option<SharedKeys>,
        ack_key: AckKey,
    ) -> Self {
        Self {
            identity_keypair: Arc::new(id_keypair),
            encryption_keypair: Arc::new(enc_keypair),
+            ecash_keypair: Arc::new(ecash_keypair),
            gateway_shared_key: gateway_shared_key.map(Arc::new),
            ack_key: Arc::new(ack_key),
        }
@@ -283,6 +316,12 @@ impl KeyManager {
    pub fn encryption_keypair(&self) -> Arc<encryption::KeyPair> {
        Arc::clone(&self.encryption_keypair)
    }
+
+    /// Gets an atomically reference counted pointer to [`encryption::KeyPair`].
+    pub fn ecash_keypair(&self) -> Arc<KeyPairUser> {
+        Arc::clone(&self.ecash_keypair)
+    }
+
    /// Gets an atomically reference counted pointer to [`AckKey`].
    pub fn ack_key(&self) -> Arc<AckKey> {
        Arc::clone(&self.ack_key)
@@ -310,6 +349,7 @@ impl KeyManager {
        KeyManagerBuilder {
            identity_keypair: self.identity_keypair,
            encryption_keypair: self.encryption_keypair,
+            ecash_keypair: self.ecash_keypair,
            ack_key: self.ack_key,
        }
    }
@@ -320,6 +360,7 @@ fn _assert_keys_zeroize_on_drop() {

    _assert_zeroize_on_drop::<identity::KeyPair>();
    _assert_zeroize_on_drop::<encryption::KeyPair>();
+    _assert_zeroize_on_drop::<KeyPairUser>();
    _assert_zeroize_on_drop::<AckKey>();
    _assert_zeroize_on_drop::<SharedKeys>();
 }
@@ -3,6 +3,7 @@

 use crate::client::key_manager::KeyManager;
 use async_trait::async_trait;
+use nym_compact_ecash::scheme::keygen::KeyPairUser;
 use std::error::Error;
 use tokio::sync::Mutex;

@@ -104,6 +105,12 @@ impl OnDiskKeys {
        self.load_keypair(identity_paths, "identity")
    }

+    #[doc(hidden)]
+    pub fn load_ecash_keypair(&self) -> Result<KeyPairUser, OnDiskKeysError> {
+        let ecash_paths = self.paths.ecash_key_pair_path();
+        self.load_keypair(ecash_paths, "ecash")
+    }
+
    fn load_key<T: PemStorableKey>(
        &self,
        path: &std::path::Path,
@@ -159,6 +166,7 @@ impl OnDiskKeys {
    fn load_keys(&self) -> Result<KeyManager, OnDiskKeysError> {
        let identity_keypair = self.load_identity_keypair()?;
        let encryption_keypair = self.load_encryption_keypair()?;
+        let ecash_keypair = self.load_ecash_keypair()?;

        let ack_key: AckKey = self.load_key(self.paths.ack_key(), "ack key")?;
        let gateway_shared_key: Option<SharedKeys> = self
@@ -168,6 +176,7 @@ impl OnDiskKeys {
        Ok(KeyManager::from_keys(
            identity_keypair,
            encryption_keypair,
+            ecash_keypair,
            gateway_shared_key,
            ack_key,
        ))
@@ -178,6 +187,7 @@ impl OnDiskKeys {

        let identity_paths = self.paths.identity_key_pair_path();
        let encryption_paths = self.paths.encryption_key_pair_path();
+        let ecash_paths = self.paths.ecash_key_pair_path();

        self.store_keypair(
            keys.identity_keypair.as_ref(),
@@ -189,6 +199,7 @@ impl OnDiskKeys {
            encryption_paths,
            "encryption keys",
        )?;
+        self.store_keypair(keys.ecash_keypair.as_ref(), ecash_paths, "ecash keys")?;

        self.store_key(keys.ack_key.as_ref(), self.paths.ack_key(), "ack key")?;

@@ -7,7 +7,6 @@ pub(crate) mod helpers;
 pub mod inbound_messages;
 pub mod key_manager;
 pub mod mix_traffic;
-pub(crate) mod packet_statistics_control;
 pub mod real_messages_control;
 pub mod received_buffer;
 pub mod replies;
@@ -1,498 +0,0 @@
-use std::{
-    collections::VecDeque,
-    time::{Duration, Instant},
-};
-
-use si_scale::helpers::bibytes2;
-
-use crate::spawn_future;
-
-// Time interval between reporting packet statistics
-const PACKET_REPORT_INTERVAL_SECS: u64 = 2;
-// Interval for taking snapshots of the packet statistics
-const SNAPSHOT_INTERVAL_MS: u64 = 500;
-// When computing rates, we include snapshots that are up to this old. We set it to some odd number
-// a tad larger than an integer number of snapshot intervals, so that we don't have to worry about
-// threshold effects.
-// Also, set it larger than the packet report interval so that we don't miss notable singular events
-const RECORDING_WINDOW_MS: u64 = 2300;
-
-#[derive(Default, Debug, Clone)]
-struct PacketStatistics {
-    // Sent
-    real_packets_sent: u64,
-    real_packets_sent_size: usize,
-    cover_packets_sent: u64,
-    cover_packets_sent_size: usize,
-
-    // Received
-    real_packets_received: u64,
-    real_packets_received_size: usize,
-    cover_packets_received: u64,
-    cover_packets_received_size: usize,
-
-    // Acks
-    total_acks_received: u64,
-    total_acks_received_size: usize,
-    real_acks_received: u64,
-    real_acks_received_size: usize,
-    cover_acks_received: u64,
-    cover_acks_received_size: usize,
-
-    // Types of packets queued
-    // TODO: track the type sent instead
-    real_packets_queued: u64,
-    retransmissions_queued: u64,
-    reply_surbs_queued: u64,
-    additional_reply_surbs_queued: u64,
-}
-
-impl PacketStatistics {
-    fn handle_event(&mut self, event: PacketStatisticsEvent) {
-        match event {
-            PacketStatisticsEvent::RealPacketSent(packet_size) => {
-                self.real_packets_sent += 1;
-                self.real_packets_sent_size += packet_size;
-            }
-            PacketStatisticsEvent::CoverPacketSent(packet_size) => {
-                self.cover_packets_sent += 1;
-                self.cover_packets_sent_size += packet_size;
-            }
-            PacketStatisticsEvent::RealPacketReceived(packet_size) => {
-                self.real_packets_received += 1;
-                self.real_packets_received_size += packet_size;
-            }
-            PacketStatisticsEvent::CoverPacketReceived(packet_size) => {
-                self.cover_packets_received += 1;
-                self.cover_packets_received_size += packet_size;
-            }
-            PacketStatisticsEvent::AckReceived(packet_size) => {
-                self.total_acks_received += 1;
-                self.total_acks_received_size += packet_size;
-            }
-            PacketStatisticsEvent::RealAckReceived(packet_size) => {
-                self.real_acks_received += 1;
-                self.real_acks_received_size += packet_size;
-            }
-            PacketStatisticsEvent::CoverAckReceived(packet_size) => {
-                self.cover_acks_received += 1;
-                self.cover_acks_received_size += packet_size;
-            }
-            PacketStatisticsEvent::RealPacketQueued => {
-                self.real_packets_queued += 1;
-            }
-            PacketStatisticsEvent::RetransmissionQueued => {
-                self.retransmissions_queued += 1;
-            }
-            PacketStatisticsEvent::ReplySurbRequestQueued => {
-                self.reply_surbs_queued += 1;
-            }
-            PacketStatisticsEvent::AdditionalReplySurbRequestQueued => {
-                self.additional_reply_surbs_queued += 1;
-            }
-        }
-    }
-
-    fn summary(&self) -> (String, String) {
-        (
-            format!(
-                "packets sent: {} (real: {}, cover: {}, retransmissions: {})",
-                self.real_packets_sent + self.cover_packets_sent,
-                self.real_packets_sent,
-                self.cover_packets_sent,
-                self.retransmissions_queued,
-            ),
-            format!(
-                "packets received: {}, (real: {}, cover: {}, acks: {}, acks for cover: {})",
-                self.real_packets_received + self.cover_packets_received,
-                self.real_packets_received,
-                self.cover_packets_received,
-                self.real_acks_received,
-                self.cover_acks_received,
-            ),
-        )
-    }
-}
-
-impl std::ops::Sub for PacketStatistics {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self {
-            real_packets_sent: self.real_packets_sent - rhs.real_packets_sent,
-            real_packets_sent_size: self.real_packets_sent_size - rhs.real_packets_sent_size,
-            cover_packets_sent: self.cover_packets_sent - rhs.cover_packets_sent,
-            cover_packets_sent_size: self.cover_packets_sent_size - rhs.cover_packets_sent_size,
-
-            real_packets_received: self.real_packets_received - rhs.real_packets_received,
-            real_packets_received_size: self.real_packets_received_size
-                - rhs.real_packets_received_size,
-            cover_packets_received: self.cover_packets_received - rhs.cover_packets_received,
-            cover_packets_received_size: self.cover_packets_received_size
-                - rhs.cover_packets_received_size,
-
-            total_acks_received: self.total_acks_received - rhs.total_acks_received,
-            total_acks_received_size: self.total_acks_received_size - rhs.total_acks_received_size,
-            real_acks_received: self.real_acks_received - rhs.real_acks_received,
-            real_acks_received_size: self.real_acks_received_size - rhs.real_acks_received_size,
-            cover_acks_received: self.cover_acks_received - rhs.cover_acks_received,
-            cover_acks_received_size: self.cover_acks_received_size - rhs.cover_acks_received_size,
-
-            real_packets_queued: self.real_packets_queued - rhs.real_packets_queued,
-            retransmissions_queued: self.retransmissions_queued - rhs.retransmissions_queued,
-            reply_surbs_queued: self.reply_surbs_queued - rhs.reply_surbs_queued,
-            additional_reply_surbs_queued: self.additional_reply_surbs_queued
-                - rhs.additional_reply_surbs_queued,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-struct PacketRates {
-    real_packets_sent: f64,
-    real_packets_sent_size: f64,
-    cover_packets_sent: f64,
-    cover_packets_sent_size: f64,
-
-    real_packets_received: f64,
-    real_packets_received_size: f64,
-    cover_packets_received: f64,
-    cover_packets_received_size: f64,
-
-    total_acks_received: f64,
-    total_acks_received_size: f64,
-    real_acks_received: f64,
-    real_acks_received_size: f64,
-    cover_acks_received: f64,
-    cover_acks_received_size: f64,
-
-    real_packets_queued: f64,
-    retransmissions_queued: f64,
-    reply_surbs_queued: f64,
-    additional_reply_surbs_queued: f64,
-}
-
-impl From<PacketStatistics> for PacketRates {
-    fn from(stats: PacketStatistics) -> Self {
-        Self {
-            real_packets_sent: stats.real_packets_sent as f64,
-            real_packets_sent_size: stats.real_packets_sent_size as f64,
-            cover_packets_sent: stats.cover_packets_sent as f64,
-            cover_packets_sent_size: stats.cover_packets_sent_size as f64,
-
-            real_packets_received: stats.real_packets_received as f64,
-            real_packets_received_size: stats.real_packets_received_size as f64,
-            cover_packets_received: stats.cover_packets_received as f64,
-            cover_packets_received_size: stats.cover_packets_received_size as f64,
-
-            total_acks_received: stats.total_acks_received as f64,
-            total_acks_received_size: stats.total_acks_received_size as f64,
-            real_acks_received: stats.real_acks_received as f64,
-            real_acks_received_size: stats.real_acks_received_size as f64,
-            cover_acks_received: stats.cover_acks_received as f64,
-            cover_acks_received_size: stats.cover_acks_received_size as f64,
-
-            real_packets_queued: stats.real_packets_queued as f64,
-            retransmissions_queued: stats.retransmissions_queued as f64,
-            reply_surbs_queued: stats.reply_surbs_queued as f64,
-            additional_reply_surbs_queued: stats.additional_reply_surbs_queued as f64,
-        }
-    }
-}
-
-impl std::ops::Sub for PacketRates {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self {
-            real_packets_sent: self.real_packets_sent - rhs.real_packets_sent,
-            real_packets_sent_size: self.real_packets_sent_size - rhs.real_packets_sent_size,
-            cover_packets_sent: self.cover_packets_sent - rhs.cover_packets_sent,
-            cover_packets_sent_size: self.cover_packets_sent_size - rhs.cover_packets_sent_size,
-
-            real_packets_received: self.real_packets_received - rhs.real_packets_received,
-            real_packets_received_size: self.real_packets_received_size
-                - rhs.real_packets_received_size,
-            cover_packets_received: self.cover_packets_received - rhs.cover_packets_received,
-            cover_packets_received_size: self.cover_packets_received_size
-                - rhs.cover_packets_received_size,
-
-            total_acks_received: self.total_acks_received - rhs.total_acks_received,
-            total_acks_received_size: self.total_acks_received_size - rhs.total_acks_received_size,
-            real_acks_received: self.real_acks_received - rhs.real_acks_received,
-            real_acks_received_size: self.real_acks_received_size - rhs.real_acks_received_size,
-            cover_acks_received: self.cover_acks_received - rhs.cover_acks_received,
-            cover_acks_received_size: self.cover_acks_received_size - rhs.cover_acks_received_size,
-
-            real_packets_queued: self.real_packets_queued - rhs.real_packets_queued,
-            retransmissions_queued: self.retransmissions_queued - rhs.retransmissions_queued,
-            reply_surbs_queued: self.reply_surbs_queued - rhs.reply_surbs_queued,
-            additional_reply_surbs_queued: self.additional_reply_surbs_queued
-                - rhs.additional_reply_surbs_queued,
-        }
-    }
-}
-
-impl std::ops::Div<f64> for PacketRates {
-    type Output = Self;
-
-    fn div(self, rhs: f64) -> Self::Output {
-        Self {
-            real_packets_sent: self.real_packets_sent / rhs,
-            real_packets_sent_size: self.real_packets_sent_size / rhs,
-            cover_packets_sent: self.cover_packets_sent / rhs,
-            cover_packets_sent_size: self.cover_packets_sent_size / rhs,
-
-            real_packets_received: self.real_packets_received / rhs,
-            real_packets_received_size: self.real_packets_received_size / rhs,
-            cover_packets_received: self.cover_packets_received / rhs,
-            cover_packets_received_size: self.cover_packets_received_size / rhs,
-
-            total_acks_received: self.total_acks_received / rhs,
-            total_acks_received_size: self.total_acks_received_size / rhs,
-            real_acks_received: self.real_acks_received / rhs,
-            real_acks_received_size: self.real_acks_received_size / rhs,
-            cover_acks_received: self.cover_acks_received / rhs,
-            cover_acks_received_size: self.cover_acks_received_size / rhs,
-
-            real_packets_queued: self.real_packets_queued / rhs,
-            retransmissions_queued: self.retransmissions_queued / rhs,
-            reply_surbs_queued: self.reply_surbs_queued / rhs,
-            additional_reply_surbs_queued: self.additional_reply_surbs_queued / rhs,
-        }
-    }
-}
-
-impl PacketRates {
-    fn summary(&self) -> String {
-        format!(
-            "rx: {}/s (real: {}/s), tx: {}/s (real: {}/s)",
-            bibytes2(self.real_packets_received_size + self.cover_packets_received_size),
-            bibytes2(self.real_packets_received_size),
-            bibytes2(self.real_packets_sent_size + self.cover_packets_sent_size),
-            bibytes2(self.real_packets_sent_size),
-        )
-    }
-
-    fn detailed_summary(&self) -> String {
-        format!(
-            "RX: {:.1} mixpkt/s, {}/s (real: {}/s, acks: {}/s), TX: {:.1} mixpkt/s, {}/s (real: {}/s)",
-            self.real_packets_received + self.cover_packets_received,
-            bibytes2(self.real_packets_received_size + self.cover_packets_received_size),
-            bibytes2(self.real_packets_received_size),
-            bibytes2(self.total_acks_received_size),
-            self.real_packets_sent + self.cover_packets_sent,
-            bibytes2(self.real_packets_sent_size + self.cover_packets_sent_size),
-            bibytes2(self.real_packets_sent_size),
-        )
-    }
-}
-
-pub(crate) enum PacketStatisticsEvent {
-    // The real packets sent. Recall that acks are sent by the gateway, so it's not included here.
-    RealPacketSent(usize),
-    // The cover packets sent
-    CoverPacketSent(usize),
-
-    // Real packets received
-    RealPacketReceived(usize),
-    // Cover packets received
-    CoverPacketReceived(usize),
-
-    // Ack of any type received. This is mostly used as a consistency check, and should be the sum
-    // of real and cover acks received.
-    AckReceived(usize),
-    // Out of the total acks received, this is the subset of those that were real
-    RealAckReceived(usize),
-    // Out of the total acks received, this is the subset of those that were for cover traffic
-    CoverAckReceived(usize),
-
-    // Types of packets queued
-    RealPacketQueued,
-    RetransmissionQueued,
-    ReplySurbRequestQueued,
-    AdditionalReplySurbRequestQueued,
-}
-
-type PacketStatisticsReceiver = tokio::sync::mpsc::UnboundedReceiver<PacketStatisticsEvent>;
-
-#[derive(Clone)]
-pub(crate) struct PacketStatisticsReporter {
-    stats_tx: tokio::sync::mpsc::UnboundedSender<PacketStatisticsEvent>,
-}
-
-impl PacketStatisticsReporter {
-    pub(crate) fn new(stats_tx: tokio::sync::mpsc::UnboundedSender<PacketStatisticsEvent>) -> Self {
-        Self { stats_tx }
-    }
-
-    pub(crate) fn report(&self, event: PacketStatisticsEvent) {
-        self.stats_tx.send(event).unwrap_or_else(|err| {
-            log::error!("Failed to report packet stat: {:?}", err);
-        });
-    }
-}
-
-pub(crate) struct PacketStatisticsControl {
-    // Incoming packet stats events from other tasks
-    stats_rx: PacketStatisticsReceiver,
-
-    // Keep track of packet statistics over time
-    stats: PacketStatistics,
-
-    // We keep snapshots of the statistics over time so we can compute rates, and also keeping the
-    // full history allows for some more fancy averaging if we want to do that.
-    history: VecDeque<(Instant, PacketStatistics)>,
-
-    // Keep previous rates so that we can detect notable events
-    rates: VecDeque<(Instant, PacketRates)>,
-}
-
-impl PacketStatisticsControl {
-    pub(crate) fn new() -> (Self, PacketStatisticsReporter) {
-        let (stats_tx, stats_rx) = tokio::sync::mpsc::unbounded_channel();
-
-        (
-            Self {
-                stats_rx,
-                stats: PacketStatistics::default(),
-                history: VecDeque::new(),
-                rates: VecDeque::new(),
-            },
-            PacketStatisticsReporter::new(stats_tx),
-        )
-    }
-
-    // Add the current stats to the history, and remove old ones.
-    fn update_history(&mut self) {
-        // Update latest
-        self.history.push_back((Instant::now(), self.stats.clone()));
-
-        // Filter out old ones
-        let recording_window = Instant::now() - Duration::from_millis(RECORDING_WINDOW_MS);
-        while self
-            .history
-            .front()
-            .map_or(false, |&(t, _)| t < recording_window)
-        {
-            self.history.pop_front();
-        }
-    }
-
-    fn compute_rates(&self) -> Option<PacketRates> {
-        // NOTE: consider changing this to compute rates over the history instead of using current
-        // stats. Currently it should not make much of a difference since we call this just after
-        // updating the history, but it seems like it could be more internally consistent to do it
-        // that way.
-
-        // Do basic averaging over the entire history, which just uses the first and last
-        if let Some((start, start_stats)) = self.history.front() {
-            let duration_secs = Instant::now().duration_since(*start).as_secs_f64();
-            let delta = self.stats.clone() - start_stats.clone();
-            let rates = PacketRates::from(delta) / duration_secs;
-            Some(rates)
-        } else {
-            None
-        }
-    }
-
-    fn update_rates(&mut self) {
-        // Update latest
-        if let Some(rates) = self.compute_rates() {
-            self.rates.push_back((Instant::now(), rates));
-        }
-
-        // Filter out old ones
-        let recording_window = Instant::now() - Duration::from_millis(RECORDING_WINDOW_MS);
-        while self
-            .rates
-            .front()
-            .map_or(false, |&(t, _)| t < recording_window)
-        {
-            self.rates.pop_front();
-        }
-    }
-
-    fn report_rates(&self) {
-        if let Some((_, rates)) = self.rates.back() {
-            log::info!("{}", rates.summary());
-            log::debug!("{}", rates.detailed_summary());
-        }
-    }
-
-    fn report_counters(&self) {
-        log::trace!("packet statistics: {:?}", &self.stats);
-        let (summary_sent, summary_recv) = self.stats.summary();
-        log::debug!("{}", summary_sent);
-        log::debug!("{}", summary_recv);
-    }
-
-    fn check_for_notable_events(&self) {
-        let Some((_, latest_rates)) = self.rates.back() else {
-            return;
-        };
-
-        // If we get a burst of retransmissions
-        // TODO: consider making this the number of retransmissions since last report instead.
-        if latest_rates.retransmissions_queued > 0.0 {
-            log::debug!(
-                "retransmissions: {:.2} pkt/s",
-                latest_rates.retransmissions_queued
-            );
-
-            // Check what the number of retransmissions was during the recording window
-            if let Some((_, start_stats)) = self.history.front() {
-                let delta = self.stats.clone() - start_stats.clone();
-                log::info!("retransmissions: {}", delta.retransmissions_queued,);
-            } else {
-                log::warn!("Unable to check retransmissions during recording window");
-            }
-        }
-
-        // IDEA: if there is a burst of acks, that could indicate tokio task starvation.
-    }
-
-    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
-        log::debug!("Started PacketStatisticsControl with graceful shutdown support");
-
-        let report_interval = Duration::from_secs(PACKET_REPORT_INTERVAL_SECS);
-        let mut report_interval = tokio::time::interval(report_interval);
-        let snapshot_interval = Duration::from_millis(SNAPSHOT_INTERVAL_MS);
-        let mut snapshot_interval = tokio::time::interval(snapshot_interval);
-
-        loop {
-            tokio::select! {
-                stats_event = self.stats_rx.recv() => match stats_event {
-                    Some(stats_event) => {
-                        log::trace!("PacketStatisticsControl: Received stats event");
-                        self.stats.handle_event(stats_event);
-                    },
-                    None => {
-                        log::trace!("PacketStatisticsControl: stopping since stats channel was closed");
-                        break;
-                    }
-                },
-                _ = snapshot_interval.tick() => {
-                    self.update_history();
-                    self.update_rates();
-                }
-                _ = report_interval.tick() => {
-                    self.report_rates();
-                    self.check_for_notable_events();
-                    self.report_counters();
-                }
-                _ = shutdown.recv_with_delay() => {
-                    log::trace!("PacketStatisticsControl: Received shutdown");
-                    break;
-                },
-            }
-        }
-        log::debug!("PacketStatisticsControl: Exiting");
-    }
-
-    pub(crate) fn start_with_shutdown(mut self, task_client: nym_task::TaskClient) {
-        spawn_future(async move {
-            self.run_with_shutdown(task_client).await;
-        })
-    }
-}
@@ -1,8 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
-
 use super::action_controller::{AckActionSender, Action};
 use futures::StreamExt;
 use log::*;
@@ -19,7 +17,6 @@ pub(super) struct AcknowledgementListener {
    ack_key: Arc<AckKey>,
    ack_receiver: AcknowledgementReceiver,
    action_sender: AckActionSender,
-    stats_tx: PacketStatisticsReporter,
 }

 impl AcknowledgementListener {
@@ -27,21 +24,16 @@ impl AcknowledgementListener {
        ack_key: Arc<AckKey>,
        ack_receiver: AcknowledgementReceiver,
        action_sender: AckActionSender,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        AcknowledgementListener {
            ack_key,
            ack_receiver,
            action_sender,
-            stats_tx,
        }
    }

    async fn on_ack(&mut self, ack_content: Vec<u8>) {
        trace!("Received an ack");
-        self.stats_tx
-            .report(PacketStatisticsEvent::AckReceived(ack_content.len()));
-
        let frag_id = match recover_identifier(&self.ack_key, &ack_content)
            .map(FragmentIdentifier::try_from_bytes)
        {
@@ -56,14 +48,11 @@ impl AcknowledgementListener {
        // because nothing was inserted in the first place
        if frag_id == COVER_FRAG_ID {
            trace!("Received an ack for a cover message - no need to do anything");
-            self.stats_tx
-                .report(PacketStatisticsEvent::CoverAckReceived(ack_content.len()));
            return;
        }

        trace!("Received {} from the mix network", frag_id);
-        self.stats_tx
-            .report(PacketStatisticsEvent::RealAckReceived(ack_content.len()));
+
        self.action_sender
            .unbounded_send(Action::new_remove(frag_id))
            .unwrap();
@@ -127,9 +127,7 @@ impl ActionController {
                .insert(frag_id, (Arc::new(pending_ack), None))
                .is_some()
            {
-                // This used to be a panic, however since we've seen this actually happen in the
-                // wild, let's not take the whole client (and possibly gateway) down because of it.
-                error!("Tried to insert duplicate pending ack! This should not be possible!")
+                panic!("Tried to insert duplicate pending ack")
            }
        }
    }
@@ -8,7 +8,6 @@ use self::{
    sent_notification_listener::SentNotificationListener,
 };
 use crate::client::inbound_messages::InputMessageReceiver;
-use crate::client::packet_statistics_control::PacketStatisticsReporter;
 use crate::client::real_messages_control::message_handler::MessageHandler;
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use crate::spawn_future;
@@ -209,7 +208,6 @@ where
        connectors: AcknowledgementControllerConnectors,
        message_handler: MessageHandler<R>,
        reply_controller_sender: ReplyControllerSender,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        let (retransmission_tx, retransmission_rx) = mpsc::unbounded();

@@ -226,7 +224,6 @@ where
            Arc::clone(&ack_key),
            connectors.ack_receiver,
            connectors.ack_action_sender.clone(),
-            stats_tx,
        );

        // will listen for any new messages from the client
@@ -35,8 +35,6 @@ use crate::client::replies::reply_controller;
 use crate::config;
 pub(crate) use acknowledgement_control::{AckActionSender, Action};

-use super::packet_statistics_control::PacketStatisticsReporter;
-
 pub(crate) mod acknowledgement_control;
 pub(crate) mod message_handler;
 pub(crate) mod real_traffic_stream;
@@ -145,7 +143,6 @@ impl RealMessagesController<OsRng> {
        reply_controller_receiver: ReplyControllerReceiver,
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        let rng = OsRng;

@@ -184,7 +181,6 @@ impl RealMessagesController<OsRng> {
            ack_controller_connectors,
            message_handler.clone(),
            reply_controller_sender,
-            stats_tx.clone(),
        );

        let reply_control = ReplyController::new(
@@ -203,7 +199,6 @@ impl RealMessagesController<OsRng> {
            topology_access,
            lane_queue_lengths,
            client_connection_rx,
-            stats_tx,
        );

        RealMessagesController {
@@ -3,7 +3,6 @@

 use self::sending_delay_controller::SendingDelayController;
 use crate::client::mix_traffic::BatchMixMessageSender;
-use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
 use crate::client::transmission_buffer::TransmissionBuffer;
@@ -114,9 +113,6 @@ where

    /// Report queue lengths so that upstream can backoff sending data, and keep connections open.
    lane_queue_lengths: LaneQueueLengths,
-
-    /// Channel used for sending statistics events to `PacketStatisticsControl`.
-    stats_tx: PacketStatisticsReporter,
 }

 #[derive(Debug)]
@@ -175,7 +171,6 @@ where
        topology_access: TopologyAccessor,
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        OutQueueControl {
            config,
@@ -189,7 +184,6 @@ where
            transmission_buffer: TransmissionBuffer::new(),
            client_connection_rx,
            lane_queue_lengths,
-            stats_tx,
        }
    }

@@ -220,7 +214,7 @@ where
    async fn on_message(&mut self, next_message: StreamMessage) {
        trace!("created new message");

-        let (next_message, fragment_id, packet_size) = match next_message {
+        let (next_message, fragment_id) = match next_message {
            StreamMessage::Cover => {
                let cover_traffic_packet_size = self.loop_cover_message_size();
                trace!("the next loop cover message will be put in a {cover_traffic_packet_size} packet");
@@ -256,28 +250,15 @@ where
                        "Somehow failed to generate a loop cover message with a valid topology",
                    ),
                    None,
-                    cover_traffic_packet_size.size(),
                )
            }
            StreamMessage::Real(real_message) => {
-                let packet_size = real_message.packet_size();
-                (
-                    real_message.mix_packet,
-                    real_message.fragment_id,
-                    packet_size,
-                )
+                (real_message.mix_packet, real_message.fragment_id)
            }
        };

        if let Err(err) = self.mix_tx.send(vec![next_message]).await {
            log::error!("Failed to send: {err}");
-        } else {
-            let event = if fragment_id.is_some() {
-                PacketStatisticsEvent::RealPacketSent(packet_size)
-            } else {
-                PacketStatisticsEvent::CoverPacketSent(packet_size)
-            };
-            self.stats_tx.report(event);
        }

        // notify ack controller about sending our message only after we actually managed to push it
@@ -359,28 +340,6 @@ where
        let lane_length = self.transmission_buffer.lane_length(&lane);
        self.lane_queue_lengths.set(&lane, lane_length);

-        // This is the last step in the pipeline where we know the type of the message, so
-        // lets count the number of retransmissions and reply surb messages sent here.
-        let stat_event = match lane {
-            TransmissionLane::General => None,
-            TransmissionLane::ConnectionId(_) => None,
-            TransmissionLane::ReplySurbRequest => {
-                Some(PacketStatisticsEvent::ReplySurbRequestQueued)
-            }
-            TransmissionLane::AdditionalReplySurbs => {
-                Some(PacketStatisticsEvent::AdditionalReplySurbRequestQueued)
-            }
-            TransmissionLane::Retransmission => Some(PacketStatisticsEvent::RetransmissionQueued),
-        };
-        if let Some(stat_event) = stat_event {
-            self.stats_tx.report(stat_event);
-        }
-        // To avoid comparing apples to oranges when presenting the fraction of packets that are
-        // retransmissions, we also need to keep track to the total number of real messages queued,
-        // even though we also track the actual number of messages sent later in the pipeline.
-        self.stats_tx
-            .report(PacketStatisticsEvent::RealPacketQueued);
-
        Some(real_next)
    }

@@ -474,13 +433,6 @@ where
            Poll::Ready(Some((real_messages, conn_id))) => {
                log::trace!("handling real_messages: size: {}", real_messages.len());

-                // This is the last step in the pipeline where we know the type of the message, so
-                // lets count the number of retransmissions here.
-                if conn_id == TransmissionLane::Retransmission {
-                    self.stats_tx
-                        .report(PacketStatisticsEvent::RetransmissionQueued);
-                }
-
                // First store what we got for the given connection id
                self.transmission_buffer.store(&conn_id, real_messages);
                let real_next = self.pop_next_message().expect("we just added one");
@@ -519,10 +471,10 @@ where
        let mult = self.sending_delay_controller.current_multiplier();
        let delay = self.current_average_message_sending_delay().as_millis();
        let status_str = if self.config.traffic.disable_main_poisson_packet_distribution {
-            format!("Packet backlog: {backlog:.2} kiB ({packets}), {lanes} lanes, no delay")
+            format!("Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), no delay")
        } else {
            format!(
-                "Packet backlog: {backlog:.2} kiB ({packets}), {lanes} lanes, avg delay: {delay}ms ({mult})"
+                "Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), avg delay: {delay}ms ({mult})"
            )
        };
        if packets > 1000 {
@@ -1,10 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::{
-    packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter},
-    replies::{reply_controller::ReplyControllerSender, reply_storage::SentReplyKeys},
-};
+use crate::client::replies::reply_controller::ReplyControllerSender;
+use crate::client::replies::reply_storage::SentReplyKeys;
 use crate::spawn_future;
 use futures::channel::mpsc;
 use futures::lock::Mutex;
@@ -45,33 +43,15 @@ struct ReceivedMessagesBufferInner<R: MessageReceiver> {
    // but perhaps it should be changed to include timestamps of when the message was reconstructed
    // and every now and then remove ids older than X
    recently_reconstructed: HashSet<i32>,
-
-    stats_tx: PacketStatisticsReporter,
 }

 impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
-    fn recover_from_fragment(
-        &mut self,
-        fragment_data: &[u8],
-        fragment_data_size: usize,
-    ) -> Option<NymMessage> {
+    fn recover_from_fragment(&mut self, fragment_data: &[u8]) -> Option<NymMessage> {
        if nym_sphinx::cover::is_cover(fragment_data) {
            trace!("The message was a loop cover message! Skipping it");
-            // NOTE: it's important to note that there is quite a bit of difference in size of
-            // received and sent packets due to the sphinx layers being removed by the exit gateway
-            // before it reaches the mixnet client.
-            self.stats_tx
-                .report(PacketStatisticsEvent::CoverPacketReceived(
-                    fragment_data_size,
-                ));
            return None;
        }

-        self.stats_tx
-            .report(PacketStatisticsEvent::RealPacketReceived(
-                fragment_data_size,
-            ));
-
        let fragment = match self.message_receiver.recover_fragment(fragment_data) {
            Err(err) => {
                warn!("failed to recover fragment from raw data: {err}. The whole underlying message might be corrupted and unrecoverable!");
@@ -123,17 +103,15 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
        reply_ciphertext: &mut [u8],
        reply_key: SurbEncryptionKey,
    ) -> Result<Option<NymMessage>, MessageRecoveryError> {
-        let reply_ciphertext_size = reply_ciphertext.len();
        // note: this performs decryption IN PLACE without extra allocation
        self.message_receiver
            .recover_plaintext_from_reply(reply_ciphertext, reply_key)?;
        let fragment_data = reply_ciphertext;

-        Ok(self.recover_from_fragment(fragment_data, reply_ciphertext_size))
+        Ok(self.recover_from_fragment(fragment_data))
    }

    fn process_received_regular_packet(&mut self, mut raw_fragment: Vec<u8>) -> Option<NymMessage> {
-        let raw_fragment_size = raw_fragment.len();
        let fragment_data = match self.message_receiver.recover_plaintext_from_regular_packet(
            self.local_encryption_keypair.private_key(),
            &mut raw_fragment,
@@ -145,7 +123,7 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
            Ok(frag_data) => frag_data,
        };

-        self.recover_from_fragment(fragment_data, raw_fragment_size)
+        self.recover_from_fragment(fragment_data)
    }
 }

@@ -163,7 +141,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
        local_encryption_keypair: Arc<encryption::KeyPair>,
        reply_key_storage: SentReplyKeys,
        reply_controller_sender: ReplyControllerSender,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        ReceivedMessagesBuffer {
            inner: Arc::new(Mutex::new(ReceivedMessagesBufferInner {
@@ -172,7 +149,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                message_receiver: R::new(),
                message_sender: None,
                recently_reconstructed: HashSet::new(),
-                stats_tx,
            })),
            reply_key_storage,
            reply_controller_sender,
@@ -377,7 +353,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                };

            if let Some(completed) = completed_message {
-                debug!("received {completed}");
+                info!("received {completed}");
                completed_messages.push(completed)
            }
        }
@@ -504,13 +480,11 @@ impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferControll
        mixnet_packet_receiver: MixnetMessageReceiver,
        reply_key_storage: SentReplyKeys,
        reply_controller_sender: ReplyControllerSender,
-        packet_statistics_reporter: PacketStatisticsReporter,
    ) -> Self {
        let received_buffer = ReceivedMessagesBuffer::new(
            local_encryption_keypair,
            reply_key_storage,
            reply_controller_sender,
-            packet_statistics_reporter,
        );

        ReceivedMessagesBufferController {
@@ -8,6 +8,8 @@ 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_PRIVATE_ECASH_KEY_FILENAME: &str = "private_ecash.pem";
+pub const DEFAULT_PUBLIC_ECASH_KEY_FILENAME: &str = "public_ecash.pem";
 pub const DEFAULT_GATEWAY_SHARED_KEY_FILENAME: &str = "gateway_shared.pem";
 pub const DEFAULT_ACK_KEY_FILENAME: &str = "ack_key.pem";

@@ -25,6 +27,12 @@ pub struct ClientKeysPaths {
    /// Path to file containing public encryption key.
    pub public_encryption_key_file: PathBuf,

+    /// Path to file containing private ecash key.
+    pub private_ecash_key_file: PathBuf,
+
+    /// Path to file containing public ecash key.
+    pub public_ecash_key_file: PathBuf,
+
    /// Path to file containing shared key derived with the specified gateway that is used
    /// for all communication with it.
    pub gateway_shared_key_file: PathBuf,
@@ -43,6 +51,8 @@ impl ClientKeysPaths {
            public_identity_key_file: base_dir.join(DEFAULT_PUBLIC_IDENTITY_KEY_FILENAME),
            private_encryption_key_file: base_dir.join(DEFAULT_PRIVATE_ENCRYPTION_KEY_FILENAME),
            public_encryption_key_file: base_dir.join(DEFAULT_PUBLIC_ENCRYPTION_KEY_FILENAME),
+            private_ecash_key_file: base_dir.join(DEFAULT_PRIVATE_ECASH_KEY_FILENAME),
+            public_ecash_key_file: base_dir.join(DEFAULT_PUBLIC_ECASH_KEY_FILENAME),
            gateway_shared_key_file: base_dir.join(DEFAULT_GATEWAY_SHARED_KEY_FILENAME),
            ack_key_file: base_dir.join(DEFAULT_ACK_KEY_FILENAME),
        }
@@ -62,11 +72,20 @@ impl ClientKeysPaths {
        )
    }

+    pub fn ecash_key_pair_path(&self) -> nym_pemstore::KeyPairPath {
+        nym_pemstore::KeyPairPath::new(
+            self.private_ecash_key().to_path_buf(),
+            self.public_ecash_key().to_path_buf(),
+        )
+    }
+
    pub fn any_file_exists(&self) -> bool {
        matches!(self.public_identity_key_file.try_exists(), Ok(true))
            || matches!(self.private_identity_key_file.try_exists(), Ok(true))
            || matches!(self.public_encryption_key_file.try_exists(), Ok(true))
            || matches!(self.private_encryption_key_file.try_exists(), Ok(true))
+            || matches!(self.public_ecash_key_file.try_exists(), Ok(true))
+            || matches!(self.private_ecash_key_file.try_exists(), Ok(true))
            || matches!(self.gateway_shared_key_file.try_exists(), Ok(true))
            || matches!(self.ack_key_file.try_exists(), Ok(true))
    }
@@ -76,6 +95,8 @@ impl ClientKeysPaths {
            .or_else(|| file_exists(&self.private_identity_key_file))
            .or_else(|| file_exists(&self.public_encryption_key_file))
            .or_else(|| file_exists(&self.private_encryption_key_file))
+            .or_else(|| file_exists(&self.public_ecash_key_file))
+            .or_else(|| file_exists(&self.private_ecash_key_file))
            .or_else(|| file_exists(&self.gateway_shared_key_file))
            .or_else(|| file_exists(&self.ack_key_file))
    }
@@ -100,6 +121,14 @@ impl ClientKeysPaths {
        &self.public_encryption_key_file
    }

+    pub fn private_ecash_key(&self) -> &Path {
+        &self.private_ecash_key_file
+    }
+
+    pub fn public_ecash_key(&self) -> &Path {
+        &self.public_ecash_key_file
+    }
+
    pub fn gateway_shared_key(&self) -> &Path {
        &self.gateway_shared_key_file
    }
@@ -1,7 +1,9 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::config::disk_persistence::keys_paths::ClientKeysPaths;
+use crate::config::disk_persistence::keys_paths::{
+    ClientKeysPaths, DEFAULT_PRIVATE_ECASH_KEY_FILENAME, DEFAULT_PUBLIC_ECASH_KEY_FILENAME,
+};
 use crate::config::disk_persistence::{CommonClientPaths, DEFAULT_GATEWAY_DETAILS_FILENAME};
 use crate::error::ClientCoreError;
 use serde::{Deserialize, Serialize};
@@ -10,7 +12,7 @@ use std::path::PathBuf;
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct CommonClientPathsV1_1_20_2 {
-    pub keys: ClientKeysPaths,
+    pub keys: ClientKeysPathsV1_1_20_2,
    pub credentials_database: PathBuf,
    pub reply_surb_database: PathBuf,
 }
@@ -23,10 +25,53 @@ impl CommonClientPathsV1_1_20_2 {
            }
        })?;
        Ok(CommonClientPaths {
-            keys: self.keys,
+            keys: self.keys.upgrade_default()?,
            gateway_details: data_dir.join(DEFAULT_GATEWAY_DETAILS_FILENAME),
            credentials_database: self.credentials_database,
            reply_surb_database: self.reply_surb_database,
        })
    }
 }
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ClientKeysPathsV1_1_20_2 {
+    /// Path to file containing private identity key.
+    pub private_identity_key_file: PathBuf,
+
+    /// Path to file containing public identity key.
+    pub public_identity_key_file: PathBuf,
+
+    /// Path to file containing private encryption key.
+    pub private_encryption_key_file: PathBuf,
+
+    /// Path to file containing public encryption key.
+    pub public_encryption_key_file: PathBuf,
+
+    /// Path to file containing shared key derived with the specified gateway that is used
+    /// for all communication with it.
+    pub gateway_shared_key_file: PathBuf,
+
+    /// Path to file containing key used for encrypting and decrypting the content of an
+    /// acknowledgement so that nobody besides the client knows which packet it refers to.
+    pub ack_key_file: PathBuf,
+}
+
+impl ClientKeysPathsV1_1_20_2 {
+    pub fn upgrade_default(self) -> Result<ClientKeysPaths, ClientCoreError> {
+        let data_dir = self.gateway_shared_key_file.parent().ok_or_else(|| {
+            ClientCoreError::UnableToUpgradeConfigFile {
+                new_version: "1.1.20-2".to_string(),
+            }
+        })?;
+        Ok(ClientKeysPaths {
+            private_identity_key_file: self.private_identity_key_file,
+            public_identity_key_file: self.public_identity_key_file,
+            private_encryption_key_file: self.private_encryption_key_file,
+            public_encryption_key_file: self.public_encryption_key_file,
+            private_ecash_key_file: data_dir.join(DEFAULT_PRIVATE_ECASH_KEY_FILENAME),
+            public_ecash_key_file: data_dir.join(DEFAULT_PUBLIC_ECASH_KEY_FILENAME),
+            gateway_shared_key_file: self.gateway_shared_key_file,
+            ack_key_file: self.ack_key_file,
+        })
+    }
+}
@@ -65,7 +65,7 @@ pub async fn current_gateways<R: Rng>(
        .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
    let client = nym_validator_client::client::NymApiClient::new(nym_api.clone());

-    log::debug!("Fetching list of gateways from: {nym_api}");
+    log::trace!("Fetching list of gateways from: {nym_api}");

    let gateways = client.get_cached_described_gateways().await?;
    log::debug!("Found {} gateways", gateways.len());
@@ -259,7 +259,6 @@ pub(super) fn get_specified_gateway(
    gateways: &[gateway::Node],
    must_use_tls: bool,
 ) -> Result<gateway::Node, ClientCoreError> {
-    log::debug!("Requesting specified gateway: {}", gateway_identity);
    let user_gateway = identity::PublicKey::from_base58_string(gateway_identity)
        .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;

@@ -212,7 +212,7 @@ where
    D::StorageError: Send + Sync + 'static,
    T: DeserializeOwned + Serialize + Send + Sync,
 {
-    log::debug!("Setting up gateway");
+    log::trace!("Setting up gateway");
    match setup {
        GatewaySetup::MustLoad => use_loaded_gateway_details(key_store, details_store).await,
        GatewaySetup::New {
@@ -178,7 +178,7 @@ impl<T> From<PersistedGatewayDetails<T>> for GatewayDetails<T> {
    }
 }

-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum GatewaySelectionSpecification<T = EmptyCustomDetails> {
    /// Uniformly choose a random remote gateway.
    UniformRemote { must_use_tls: bool },
@@ -3,7 +3,6 @@ name = "nym-gateway-client"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -20,6 +19,7 @@ tokio = { version = "1.24.1", features = ["macros"] }
 # internal
 nym-bandwidth-controller = { path = "../../bandwidth-controller" }
 nym-coconut-interface = { path = "../../coconut-interface" }
+nym-compact-ecash = { path = "../../nym_offline_compact_ecash" }
 nym-credential-storage = { path = "../../credential-storage" }
 nym-crypto = { path = "../../crypto" }
 nym-gateway-requests = { path = "../../../gateway/gateway-requests" }
@@ -12,7 +12,7 @@ use crate::{cleanup_socket_message, try_decrypt_binary_message};
 use futures::{SinkExt, StreamExt};
 use log::*;
 use nym_bandwidth_controller::BandwidthController;
-use nym_coconut_interface::Credential;
+use nym_compact_ecash::scheme::EcashCredential;
 use nym_credential_storage::ephemeral_storage::EphemeralStorage as EphemeralCredentialStorage;
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_crypto::asymmetric::identity;
@@ -513,14 +513,14 @@ impl<C, St> GatewayClient<C, St> {
        }
    }

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

-        let msg = ClientControlRequest::new_enc_coconut_bandwidth_credential(
+        let msg = ClientControlRequest::new_enc_ecash_credential(
            &credential,
            self.shared_key.as_ref().unwrap(),
            iv,
@@ -567,18 +567,18 @@ impl<C, St> GatewayClient<C, St> {
            return self.try_claim_testnet_bandwidth().await;
        }

-        let (credential, credential_id) = self
+        let (credential, new_wallet, wallet_id) = self
            .bandwidth_controller
            .as_ref()
            .unwrap()
-            .prepare_coconut_credential()
+            .prepare_ecash_credential(self.gateway_identity.to_bytes())
            .await?;

-        self.claim_coconut_bandwidth(credential).await?;
+        self.claim_ecash_bandwidth(credential).await?;
        self.bandwidth_controller
            .as_ref()
            .unwrap()
-            .consume_credential(credential_id)
+            .update_ecash_wallet(new_wallet, wallet_id)
            .await?;

        Ok(())
@@ -671,6 +671,7 @@ impl<C, St> GatewayClient<C, St> {
        if !self.authenticated {
            return Err(GatewayClientError::NotAuthenticated);
        }
+        //SW NOTE : Logic to stop sending packet is there already. We only need to update bandwidth_remaining
        if (mix_packet.packet().len() as i64) > self.bandwidth_remaining {
            return Err(GatewayClientError::NotEnoughBandwidth(
                mix_packet.packet().len() as i64,
@@ -792,7 +793,6 @@ pub struct InitOnly;
 impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
    // for initialisation we do not need credential storage. Though it's still a bit weird we have to set the generic...
    pub fn new_init(config: GatewayConfig, local_identity: Arc<identity::KeyPair>) -> Self {
-        log::trace!("Initialising gateway client");
        use futures::channel::mpsc;

        // note: this packet_router is completely invalid in normal circumstances, but "works"
@@ -3,15 +3,14 @@ name = "nym-mixnet-client"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
 futures = { workspace = true }
 log = { workspace = true }
-tokio = { workspace = true, features = ["time", "net", "rt"] }
-tokio-util = { workspace = true, features = ["codec"] }
+tokio = { version = "1.24.1", features = ["time", "net", "rt"] }
+tokio-util = { version = "0.7.4", features = ["codec"] }

 # internal
 nym-sphinx = { path = "../../nymsphinx" }
@@ -4,7 +4,6 @@ version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
 rust-version = "1.56"
-license.workspace = true

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -34,6 +33,7 @@ futures = { workspace = true }
 openssl = { version = "^0.10.55", features = ["vendored"], optional = true }

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

@@ -9,7 +9,8 @@ use crate::{
    ReqwestRpcClient, ValidatorClientError,
 };
 use nym_api_requests::coconut::{
-    BlindSignRequestBody, BlindedSignatureResponse, VerifyCredentialBody, VerifyCredentialResponse,
+    BlindSignRequestBody, BlindedSignatureResponse, EcashParametersResponse,
+    OfflineVerifyCredentialBody, OnlineVerifyCredentialBody, VerifyCredentialResponse,
 };
 use nym_api_requests::models::{DescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::models::{
@@ -42,14 +43,6 @@ pub struct Config {
    nyxd_config: nyxd::Config,
 }

-impl TryFrom<NymNetworkDetails> for Config {
-    type Error = ValidatorClientError;
-
-    fn try_from(value: NymNetworkDetails) -> Result<Self, Self::Error> {
-        Config::try_from_nym_network_details(&value)
-    }
-}
-
 impl Config {
    pub fn try_from_nym_network_details(
        details: &NymNetworkDetails,
@@ -339,13 +332,21 @@ impl NymApiClient {
        Ok(self.nym_api.blind_sign(request_body).await?)
    }

-    pub async fn verify_bandwidth_credential(
+    pub async fn verify_offline_credential(
        &self,
-        request_body: &VerifyCredentialBody,
+        request_body: &OfflineVerifyCredentialBody,
    ) -> Result<VerifyCredentialResponse, ValidatorClientError> {
-        Ok(self
-            .nym_api
-            .verify_bandwidth_credential(request_body)
-            .await?)
+        Ok(self.nym_api.verify_offline_credential(request_body).await?)
+    }
+
+    pub async fn verify_online_credential(
+        &self,
+        request_body: &OnlineVerifyCredentialBody,
+    ) -> Result<VerifyCredentialResponse, ValidatorClientError> {
+        Ok(self.nym_api.verify_online_credential(request_body).await?)
+    }
+
+    pub async fn ecash_parameters(&self) -> Result<EcashParametersResponse, ValidatorClientError> {
+        Ok(self.nym_api.ecash_parameters().await?)
    }
 }
@@ -6,7 +6,8 @@ use crate::nyxd::error::NyxdError;
 use crate::NymApiClient;
 use nym_coconut_dkg_common::types::{EpochId, NodeIndex};
 use nym_coconut_dkg_common::verification_key::ContractVKShare;
-use nym_coconut_interface::{Base58, CoconutError, VerificationKey};
+use nym_compact_ecash::error::CompactEcashError;
+use nym_compact_ecash::{Base58, VerificationKeyAuth};
 use thiserror::Error;
 use url::Url;

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

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

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

-pub async fn all_coconut_api_clients<C>(
+pub async fn all_ecash_api_clients<C>(
    client: &C,
    epoch_id: EpochId,
 ) -> Result<Vec<CoconutApiClient>, CoconutApiError>
@@ -5,24 +5,17 @@ use crate::nym_api::error::NymAPIError;
 use crate::nym_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
 use async_trait::async_trait;
 use http_api_client::{ApiClient, NO_PARAMS};
-pub use nym_api_requests::{
-    coconut::{
-        models::{
-            EpochCredentialsResponse, IssuedCredential, IssuedCredentialBody,
-            IssuedCredentialResponse, IssuedCredentialsResponse,
-        },
-        BlindSignRequestBody, BlindedSignatureResponse, CredentialsRequestBody,
-        VerifyCredentialBody, VerifyCredentialResponse,
-    },
-    models::{
-        ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
-        GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
-        MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
-        MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
-        StakeSaturationResponse, UptimeResponse,
-    },
+use nym_api_requests::coconut::{
+    BlindSignRequestBody, BlindedSignatureResponse, EcashParametersResponse,
+    OfflineVerifyCredentialBody, OnlineVerifyCredentialBody, VerifyCredentialResponse,
+};
+use nym_api_requests::models::{
+    ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
+    GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
+    MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
+    MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
+    StakeSaturationResponse, UptimeResponse,
 };
-pub use nym_coconut_dkg_common::types::EpochId;
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
 use nym_name_service_common::response::NamesListResponse;
@@ -390,16 +383,16 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

-    async fn verify_bandwidth_credential(
+    async fn verify_offline_credential(
        &self,
-        request_body: &VerifyCredentialBody,
+        request_body: &OfflineVerifyCredentialBody,
    ) -> Result<VerifyCredentialResponse, NymAPIError> {
        self.post_json(
            &[
                routes::API_VERSION,
                routes::COCONUT_ROUTES,
                routes::BANDWIDTH,
-                routes::COCONUT_VERIFY_BANDWIDTH_CREDENTIAL,
+                routes::ECASH_VERIFY_OFFLINE_CREDENTIAL,
            ],
            NO_PARAMS,
            request_body,
@@ -407,56 +400,32 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

-    async fn epoch_credentials(
+    async fn verify_online_credential(
        &self,
-        dkg_epoch: EpochId,
-    ) -> Result<EpochCredentialsResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::COCONUT_EPOCH_CREDENTIALS,
-                &dkg_epoch.to_string(),
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    async fn issued_credential(
-        &self,
-        credential_id: i64,
-    ) -> Result<IssuedCredentialResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::COCONUT_ISSUED_CREDENTIAL,
-                &credential_id.to_string(),
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    async fn issued_credentials(
-        &self,
-        credential_ids: Vec<i64>,
-    ) -> Result<IssuedCredentialsResponse, NymAPIError> {
+        request_body: &OnlineVerifyCredentialBody,
+    ) -> Result<VerifyCredentialResponse, NymAPIError> {
        self.post_json(
            &[
                routes::API_VERSION,
                routes::COCONUT_ROUTES,
                routes::BANDWIDTH,
-                routes::COCONUT_ISSUED_CREDENTIALS,
+                routes::ECASH_VERIFY_ONLINE_CREDENTIAL,
+            ],
+            NO_PARAMS,
+            request_body,
+        )
+        .await
+    }
+
+    async fn ecash_parameters(&self) -> Result<EcashParametersResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::ECASH_PARAMETERS,
            ],
            NO_PARAMS,
-            &CredentialsRequestBody {
-                credential_ids,
-                pagination: None,
-            },
        )
        .await
    }
@@ -16,10 +16,9 @@ pub const COCONUT_ROUTES: &str = "coconut";
 pub const BANDWIDTH: &str = "bandwidth";

 pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
-pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";
-pub const COCONUT_EPOCH_CREDENTIALS: &str = "epoch-credentials";
-pub const COCONUT_ISSUED_CREDENTIAL: &str = "issued-credential";
-pub const COCONUT_ISSUED_CREDENTIALS: &str = "issued-credentials";
+pub const ECASH_VERIFY_OFFLINE_CREDENTIAL: &str = "verify-offline-credential";
+pub const ECASH_VERIFY_ONLINE_CREDENTIAL: &str = "verify-online-credential";
+pub const ECASH_PARAMETERS: &str = "ecash-parameters";

 pub const STATUS_ROUTES: &str = "status";
 pub const MIXNODE: &str = "mixnode";
@@ -8,8 +8,6 @@ use cosmwasm_std::{Fraction, Uint128};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::ops::Div;
-use std::str::FromStr;
-use thiserror::Error;

 #[derive(Serialize, Deserialize, Clone, Copy, Default, Debug, PartialEq, Eq)]
 pub struct MismatchedDenoms;
@@ -128,37 +126,6 @@ impl From<CosmWasmCoin> for Coin {
    }
 }

-// unfortunately cosmwasm didn't re-export this correct so we just redefine its
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum CoinFromStrError {
-    #[error("Missing denominator")]
-    MissingDenom,
-    #[error("Missing amount or non-digit characters in amount")]
-    MissingAmount,
-    #[error("Invalid amount: {0}")]
-    InvalidAmount(#[from] std::num::ParseIntError),
-}
-
-impl FromStr for Coin {
-    type Err = CoinFromStrError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let pos = s
-            .find(|c: char| !c.is_ascii_digit())
-            .ok_or(CoinFromStrError::MissingDenom)?;
-        let (amount, denom) = s.split_at(pos);
-
-        if amount.is_empty() {
-            return Err(CoinFromStrError::MissingAmount);
-        }
-
-        Ok(Coin {
-            amount: amount.parse::<u128>()?,
-            denom: denom.to_string(),
-        })
-    }
-}
-
 pub trait CoinConverter {
    type Target;

@@ -32,7 +32,7 @@ pub trait CoconutBandwidthSigningClient {
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NyxdError> {
        let req = CoconutBandwidthExecuteMsg::DepositFunds {
-            data: DepositData::new(info, verification_key, encryption_key),
+            data: DepositData::new(info.to_string(), verification_key, encryption_key),
        };
        self.execute_coconut_bandwidth_contract(
            fee,
@@ -7,12 +7,12 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
-use nym_coconut_dkg_common::{
-    dealer::{ContractDealing, DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse},
-    msg::QueryMsg as DkgQueryMsg,
-    types::{DealerDetails, Epoch, EpochId, InitialReplacementData},
-    verification_key::{ContractVKShare, PagedVKSharesResponse},
+use nym_coconut_dkg_common::dealer::{
+    ContractDealing, DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse,
 };
+use nym_coconut_dkg_common::msg::QueryMsg as DkgQueryMsg;
+use nym_coconut_dkg_common::types::{DealerDetails, Epoch, EpochId, InitialReplacementData};
+use nym_coconut_dkg_common::verification_key::{ContractVKShare, PagedVKSharesResponse};
 use serde::Deserialize;

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -6,8 +6,8 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cw3::{
-    ProposalListResponse, ProposalResponse, VoteListResponse, VoteResponse, VoterDetail,
-    VoterListResponse, VoterResponse,
+    ProposalListResponse, ProposalResponse, VoteListResponse, VoteResponse, VoterListResponse,
+    VoterResponse,
 };
 use cw_utils::ThresholdResponse;
 use nym_multisig_contract_common::msg::QueryMsg as MultisigQueryMsg;
@@ -114,26 +114,6 @@ pub trait PagedMultisigQueryClient: MultisigQueryClient {

        Ok(proposals)
    }
-
-    async fn get_all_voters(&self) -> Result<Vec<VoterDetail>, NyxdError> {
-        let mut voters = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let mut paged_response = self.list_voters(start_after.take(), None).await?;
-
-            let last_voter = paged_response.voters.last().map(|prop| prop.addr.clone());
-            voters.append(&mut paged_response.voters);
-
-            if let Some(start_after_res) = last_voter {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(voters)
-    }
 }

 #[async_trait]
@@ -52,6 +52,10 @@ use wasmtimer::tokio::sleep;
 pub const DEFAULT_BROADCAST_POLLING_RATE: Duration = Duration::from_secs(4);
 pub const DEFAULT_BROADCAST_TIMEOUT: Duration = Duration::from_secs(60);

+#[cfg(feature = "http-client")]
+#[async_trait]
+impl CosmWasmClient for cosmrs::rpc::HttpClient {}
+
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait CosmWasmClient: TendermintRpcClient {
@@ -518,7 +522,3 @@ pub trait CosmWasmClient: TendermintRpcClient {
        res.try_into()
    }
 }
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<T> CosmWasmClient for T where T: TendermintRpcClient {}
@@ -425,7 +425,7 @@ where
                    amount: amount.into_iter().map(Into::into).collect(),
                }
                .to_any()
-                .map_err(|_| NyxdError::SerializationError("MsgSend".to_owned()))
+                .map_err(|_| NyxdError::SerializationError("MsgExecuteContract".to_owned()))
            })
            .collect::<Result<_, _>>()?;

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

-use crate::nyxd::cosmwasm_client::client_traits::SigningCosmWasmClient;
+use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
 use crate::nyxd::error::NyxdError;
 use crate::nyxd::{Config, GasPrice, Hash, Height};
 use crate::rpc::TendermintRpcClient;
@@ -26,7 +26,6 @@ use cosmrs::rpc::{HttpClient, HttpClientUrl};
 pub mod client_traits;
 mod helpers;
 pub mod logs;
-pub mod module_traits;
 pub mod types;

 #[derive(Debug)]
@@ -330,6 +329,14 @@ where
    }
 }

+#[async_trait]
+impl<C, S> CosmWasmClient for MaybeSigningClient<C, S>
+where
+    C: TendermintRpcClient + Send + Sync,
+    S: Send + Sync,
+{
+}
+
 #[async_trait]
 impl<C, S> SigningCosmWasmClient for MaybeSigningClient<C, S>
 where
@@ -1,8 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod slashing;
-pub mod staking;
-
-pub use staking::query::StakingQueryClient;
-// pub use slashing::query
@@ -1,4 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod query;
@@ -1,2 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
@@ -1,8 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod query;
-
-pub use cosmrs::staking::{
-    QueryHistoricalInfoResponse, QueryValidatorResponse, QueryValidatorsResponse, Validator,
-};
@@ -1,78 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::{QueryHistoricalInfoResponse, QueryValidatorResponse, QueryValidatorsResponse};
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::{CosmWasmClient, PageRequest};
-use async_trait::async_trait;
-use cosmrs::proto::cosmos::staking::v1beta1::{
-    QueryHistoricalInfoRequest as ProtoQueryHistoricalInfoRequest,
-    QueryHistoricalInfoResponse as ProtoQueryHistoricalInfoResponse,
-    QueryValidatorRequest as ProtoQueryValidatorRequest,
-    QueryValidatorResponse as ProtoQueryValidatorResponse,
-    QueryValidatorsRequest as ProtoQueryValidatorsRequest,
-    QueryValidatorsResponse as ProtoQueryValidatorsResponse,
-};
-use cosmrs::staking::{QueryHistoricalInfoRequest, QueryValidatorRequest, QueryValidatorsRequest};
-use cosmrs::AccountId;
-
-// TODO: change trait restriction from `CosmWasmClient` to `TendermintRpcClient`
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait StakingQueryClient: CosmWasmClient {
-    async fn historical_info(&self, height: i64) -> Result<QueryHistoricalInfoResponse, NyxdError> {
-        let path = Some("/cosmos.staking.v1beta1.Query/HistoricalInfo".to_owned());
-
-        let req = QueryHistoricalInfoRequest { height };
-
-        let res = self
-            .make_abci_query::<ProtoQueryHistoricalInfoRequest, ProtoQueryHistoricalInfoResponse>(
-                path,
-                req.into(),
-            )
-            .await?;
-
-        Ok(res.try_into()?)
-    }
-
-    async fn validator(
-        &self,
-        validator_addr: AccountId,
-    ) -> Result<QueryValidatorResponse, NyxdError> {
-        let path = Some("/cosmos.staking.v1beta1.Query/Validator".to_owned());
-
-        let req = QueryValidatorRequest { validator_addr };
-
-        let res = self
-            .make_abci_query::<ProtoQueryValidatorRequest, ProtoQueryValidatorResponse>(
-                path,
-                req.into(),
-            )
-            .await?;
-
-        Ok(res.try_into()?)
-    }
-
-    async fn validators(
-        &self,
-        status: String,
-        pagination: Option<PageRequest>,
-    ) -> Result<QueryValidatorsResponse, NyxdError> {
-        let path = Some("/cosmos.staking.v1beta1.Query/Validators".to_owned());
-
-        let req = QueryValidatorsRequest { status, pagination };
-
-        let res = self
-            .make_abci_query::<ProtoQueryValidatorsRequest, ProtoQueryValidatorsResponse>(
-                path,
-                req.into(),
-            )
-            .await?;
-
-        Ok(res.try_into()?)
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<T> StakingQueryClient for T where T: CosmWasmClient {}
@@ -1,13 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nyxd::TxResponse;
-
-pub fn find_tx_attribute(tx: &TxResponse, event_type: &str, attribute_key: &str) -> Option<String> {
-    let event = tx.tx_result.events.iter().find(|e| e.kind == event_type)?;
-    let attribute = event
-        .attributes
-        .iter()
-        .find(|attr| attr.key == attribute_key)?;
-    Some(attribute.value.clone())
-}
@@ -29,41 +29,31 @@ use tendermint_rpc::endpoint::*;
 use tendermint_rpc::{Error as TendermintRpcError, Order};
 use url::Url;

-pub use crate::nyxd::{
-    cosmwasm_client::{
-        client_traits::{CosmWasmClient, SigningCosmWasmClient},
-        module_traits::{self, StakingQueryClient},
-    },
-    fee::Fee,
-};
+pub use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
+pub use crate::nyxd::fee::Fee;
 pub use crate::rpc::TendermintRpcClient;
 pub use coin::Coin;
-pub use cosmrs::{
-    bank::MsgSend,
-    bip32,
-    crypto::PublicKey,
-    query::{PageRequest, PageResponse},
-    tendermint::{
-        abci::{response::DeliverTx, types::ExecTxResult, Event, EventAttribute},
-        block::Height,
-        hash::{self, Algorithm, Hash},
-        validator::Info as TendermintValidatorInfo,
-        Time as TendermintTime,
-    },
-    tx::{self, Msg},
-    AccountId, Any, Coin as CosmosCoin, Denom, Gas,
+pub use cosmrs::bank::MsgSend;
+pub use cosmrs::tendermint::abci::{
+    response::DeliverTx, types::ExecTxResult, Event, EventAttribute,
 };
+pub use cosmrs::tendermint::block::Height;
+pub use cosmrs::tendermint::hash::{self, Algorithm, Hash};
+pub use cosmrs::tendermint::validator::Info as TendermintValidatorInfo;
+pub use cosmrs::tendermint::Time as TendermintTime;
+pub use cosmrs::tx::Msg;
+pub use cosmrs::tx::{self};
+pub use cosmrs::Coin as CosmosCoin;
+pub use cosmrs::Gas;
+pub use cosmrs::{bip32, AccountId, Denom};
 pub use cosmwasm_std::Coin as CosmWasmCoin;
-pub use cw2;
-pub use cw3;
-pub use cw4;
-pub use cw_controllers;
 pub use fee::{gas_price::GasPrice, GasAdjustable, GasAdjustment};
 pub use tendermint_rpc::{
    endpoint::{tx::Response as TxResponse, validators::Response as ValidatorResponse},
    query::Query,
-    Paging, Request, Response, SimpleRequest,
+    Paging,
 };
+pub use tendermint_rpc::{Request, Response, SimpleRequest};

 #[cfg(feature = "http-client")]
 use crate::http_client;
@@ -77,7 +67,6 @@ pub mod contract_traits;
 pub mod cosmwasm_client;
 pub mod error;
 pub mod fee;
-pub mod helpers;

 #[derive(Debug, Clone)]
 pub struct Config {
@@ -103,14 +92,6 @@ impl Config {
    }
 }

-impl TryFrom<NymNetworkDetails> for Config {
-    type Error = NyxdError;
-
-    fn try_from(value: NymNetworkDetails) -> Result<Self, Self::Error> {
-        Config::try_from_nym_network_details(&value)
-    }
-}
-
 #[derive(Debug)]
 pub struct NyxdClient<C, S = NoSigner> {
    client: MaybeSigningClient<C, S>,
@@ -395,11 +376,7 @@ where
        })
    }

-    pub async fn simulate<I, M>(
-        &self,
-        messages: I,
-        memo: impl Into<String> + Send + 'static,
-    ) -> Result<SimulateResponse, NyxdError>
+    pub async fn simulate<I, M>(&self, messages: I) -> Result<SimulateResponse, NyxdError>
    where
        I: IntoIterator<Item = M> + Send,
        M: Msg,
@@ -414,7 +391,7 @@ where
                    .map_err(|_| {
                        NyxdError::SerializationError("custom simulate messages".to_owned())
                    })?,
-                memo,
+                "simulating execution of transactions",
            )
            .await
    }
@@ -742,7 +719,7 @@ where
    where
        H: Into<Height> + Send,
    {
-        TendermintRpcClient::validators(&self.client, height, paging).await
+        self.client.validators(height, paging).await
    }

    async fn latest_consensus_params(
@@ -817,6 +794,14 @@ where
    }
 }

+#[async_trait]
+impl<C, S> CosmWasmClient for NyxdClient<C, S>
+where
+    C: TendermintRpcClient + Send + Sync,
+    S: Send + Sync,
+{
+}
+
 impl<C, S> OfflineSigner for NyxdClient<C, S>
 where
    S: OfflineSigner,
@@ -3,7 +3,6 @@ name = "nym-coconut-interface"
 version = "0.1.0"
 edition = "2021"
 description = "Crutch library until there is proper SerDe support for coconut structs"
-license.workspace = true

 [dependencies]
 bs58 = "0.4.0"
@@ -21,14 +21,10 @@ pub use nym_coconut::{
 pub struct Credential {
    #[getset(get = "pub")]
    n_params: u32,
-
    #[getset(get = "pub")]
    theta: Theta,
-
    voucher_value: u64,
-
    voucher_info: String,
-
    #[getset(get = "pub")]
    epoch_id: u64,
 }
@@ -68,12 +64,14 @@ impl Credential {

    pub fn verify(&self, verification_key: &VerificationKey) -> bool {
        let params = Parameters::new(self.n_params).unwrap();
-
-        let hashed_value = hash_to_scalar(self.voucher_value.to_string());
-        let hashed_info = hash_to_scalar(&self.voucher_info);
-        let public_attributes = &[&hashed_value, &hashed_info];
-
-        nym_coconut::verify_credential(&params, verification_key, &self.theta, public_attributes)
+        let public_attributes = [
+            self.voucher_value.to_string().as_bytes(),
+            self.voucher_info.as_bytes(),
+        ]
+        .iter()
+        .map(hash_to_scalar)
+        .collect::<Vec<Attribute>>();
+        nym_coconut::verify_credential(&params, verification_key, &self.theta, &public_attributes)
    }

    pub fn as_bytes(&self) -> Vec<u8> {
@@ -182,8 +180,8 @@ mod tests {
            &params,
            &verification_key,
            &signature,
-            &serial_number,
-            &binding_number,
+            serial_number,
+            binding_number,
        )
        .unwrap();
        let credential = Credential::new(4, theta, voucher_value, voucher_info, 42);
@@ -3,7 +3,6 @@ name = "nym-cli-commands"
 version = "1.0.0"
 authors.workspace = true
 edition = "2021"
-license.workspace = true

 [dependencies]
 anyhow = { workspace = true }
@@ -26,10 +26,6 @@ pub struct Args {
 }

 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() {
@@ -40,6 +36,14 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
        bail!("the loaded config does not have a credentials store information")
    };

+    let Ok(ecash_key_path) = loaded.try_get_ecash_key() else {
+        bail!("the loaded config does not have an ecash key path information")
+    };
+
+    let Ok(ecash_keypair) = nym_pemstore::load_keypair(&ecash_key_path) else {
+        bail!("invalid secret key in the config path")
+    };
+
    println!(
        "using credentials store at '{}'",
        credentials_store.display()
@@ -49,7 +53,14 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
    let coin = Coin::new(args.amount as u128, denom);

    let persistent_storage = initialise_persistent_storage(credentials_store).await;
-    utils::issue_credential(&client, coin, &persistent_storage, args.recovery_dir).await?;
+    utils::issue_credential(
+        &client,
+        coin,
+        ecash_keypair,
+        &persistent_storage,
+        args.recovery_dir,
+    )
+    .await?;

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

+    pub(crate) fn try_get_ecash_key(&self) -> anyhow::Result<nym_pemstore::KeyPairPath> {
+        match self {
+            CommonConfigsWrapper::NymClients(cfg) => {
+                Ok(cfg.storage_paths.inner.keys.ecash_key_pair_path())
+            }
+            CommonConfigsWrapper::NymApi(cfg) => {
+                Ok(cfg.network_monitor.storage_paths.ecash_keypair_path())
+            }
+            CommonConfigsWrapper::Unknown(cfg) => cfg.try_get_ecash_key(),
+        }
+    }
+
    pub(crate) fn try_get_credentials_store(&self) -> anyhow::Result<PathBuf> {
        match self {
            CommonConfigsWrapper::NymClients(cfg) => {
@@ -159,6 +171,17 @@ struct NymApiConfigNetworkMonitorLight {
 #[derive(Deserialize, Debug)]
 struct NetworkMonitorPaths {
    credentials_database_path: PathBuf,
+    ecash_private_key_path: PathBuf,
+    ecash_public_key_path: PathBuf,
+}
+
+impl NetworkMonitorPaths {
+    fn ecash_keypair_path(&self) -> nym_pemstore::KeyPairPath {
+        nym_pemstore::KeyPairPath::new(
+            self.ecash_private_key_path.clone(),
+            self.ecash_public_key_path.clone(),
+        )
+    }
 }

 // a hacky way of reading common data from client configs (native, socks5, etc.)
@@ -215,6 +238,10 @@ impl UnknownConfigWrapper {
        }
    }

+    pub(crate) fn try_get_ecash_key(&self) -> anyhow::Result<nym_pemstore::KeyPairPath> {
+        todo!()
+    }
+
    pub(crate) fn try_get_credentials_store(&self) -> anyhow::Result<PathBuf> {
        let id_val = self
            .find_value("credentials_database_path")
@@ -3,7 +3,6 @@ name = "nym-config"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -18,4 +17,4 @@ url = { workspace = true }
 nym-network-defaults = { path = "../network-defaults" }

 [features]
-default = ["dirs"]
+default = ["dirs"]
@@ -73,7 +73,7 @@ where
    P: AsRef<Path>,
 {
    let path = path.as_ref();
-    log::info!("saving config file to {}", path.display());
+    log::debug!("trying to save config file to {}", path.display());

    if let Some(parent) = path.parent() {
        create_dir_all(parent)?;
@@ -2,7 +2,6 @@
 name = "nym-coconut-bandwidth-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

@@ -13,4 +12,4 @@ cw2 = { workspace = true, optional = true }
 nym-multisig-contract-common = { path = "../multisig-contract" }

 [features]
-schema = ["cw2"]
+schema = ["cw2"]
@@ -4,9 +4,6 @@
 // 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";
@@ -2,7 +2,6 @@
 name = "nym-coconut-dkg-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

@@ -15,4 +14,4 @@ contracts-common = { path = "../contracts-common", package = "nym-contracts-comm
 nym-multisig-contract-common = { path = "../multisig-contract" }

 [features]
-schema = []
+schema = []
@@ -174,19 +174,17 @@ impl Display for EpochState {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            EpochState::PublicKeySubmission { resharing } => {
-                write!(f, "PublicKeySubmission (resharing: {resharing})")
-            }
-            EpochState::DealingExchange { resharing } => {
-                write!(f, "DealingExchange (resharing: {resharing})")
+                write!(f, "PublicKeySubmission with resharing {resharing}")
            }
+            EpochState::DealingExchange { resharing } => write!(f, "DealingExchange {resharing}"),
            EpochState::VerificationKeySubmission { resharing } => {
-                write!(f, "VerificationKeySubmission (resharing: {resharing})")
+                write!(f, "VerificationKeySubmission with resharing {resharing}")
            }
            EpochState::VerificationKeyValidation { resharing } => {
-                write!(f, "VerificationKeyValidation (resharing: {resharing})")
+                write!(f, "VerificationKeyValidation with resharing {resharing}")
            }
            EpochState::VerificationKeyFinalization { resharing } => {
-                write!(f, "VerificationKeyFinalization (resharing: {resharing})")
+                write!(f, "VerificationKeyFinalization with resharing {resharing}")
            }
            EpochState::InProgress => write!(f, "InProgress"),
        }
@@ -2,7 +2,6 @@
 name = "nym-ephemera-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

@@ -14,4 +13,4 @@ cw-utils = { workspace = true }
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }

 [features]
-schema = []
+schema = []
@@ -2,7 +2,6 @@
 name = "nym-group-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

@@ -2,7 +2,6 @@
 name = "nym-multisig-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

@@ -2,7 +2,6 @@
 name = "nym-name-service-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

@@ -17,4 +16,4 @@ serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }

 [features]
-schema = ["cw2"]
+schema = ["cw2"]
@@ -2,7 +2,6 @@
 name = "nym-service-provider-directory-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

@@ -16,4 +15,4 @@ nym-contracts-common = { path = "../contracts-common", version = "0.5.0" }
 thiserror = { workspace = true }

 [features]
-schema = ["cw2"]
+schema = ["cw2"]
@@ -2,7 +2,6 @@
 name = "nym-credential-storage"
 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

@@ -14,14 +13,14 @@ thiserror = { workspace = true }
 tokio = { version = "1.24.1", features = ["sync"]}

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
-workspace = true
+version = "0.5"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-workspace = true
+version = "1.24.1"
 features = [ "rt-multi-thread", "net", "signal", "fs" ]


 [build-dependencies]
-sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
+sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }
@@ -0,0 +1,14 @@
+/*
+ * Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+CREATE TABLE ecash_wallets
+(
+    id                  INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    voucher_info        TEXT    NOT NULL,
+    wallet              TEXT    NOT NULL UNIQUE,
+    value               TEXT    NOT NULL,
+    epoch_id            TEXT    NOT NULL,
+    consumed            BOOLEAN NOT NULL
+);
@@ -1,13 +1,14 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::models::CoconutCredential;
+use crate::models::{CoconutCredential, EcashWallet};
 use std::sync::Arc;
 use tokio::sync::RwLock;

 #[derive(Clone)]
 pub struct CoconutCredentialManager {
    inner: Arc<RwLock<Vec<CoconutCredential>>>,
+    ecash: Arc<RwLock<Vec<EcashWallet>>>,
 }

 impl CoconutCredentialManager {
@@ -15,6 +16,7 @@ impl CoconutCredentialManager {
    pub fn new() -> Self {
        CoconutCredentialManager {
            inner: Arc::new(RwLock::new(Vec::new())),
+            ecash: Arc::new(RwLock::new(Vec::new())),
        }
    }

@@ -50,6 +52,39 @@ impl CoconutCredentialManager {
        });
    }

+    /// Inserts provided signature into the database.
+    ///
+    /// # Arguments
+    ///
+    /// * `voucher_info`: What type of credential it is.
+    /// * `signature`: Ecash wallet credential in the form of a wallet.
+    /// * `value` : The value of the ecash wallet
+    /// * `epoch_id`: The epoch when it was signed.
+    pub async fn insert_ecash_wallet(
+        &self,
+        voucher_info: String,
+        wallet: String,
+        value: String,
+        epoch_id: String,
+    ) {
+        let mut creds = self.ecash.write().await;
+        let id = creds.len() as i64;
+        creds.push(EcashWallet {
+            id,
+            voucher_info,
+            wallet,
+            value,
+            epoch_id,
+            consumed: false,
+        });
+    }
+
+    /// Tries to retrieve one of the stored, unused credentials.
+    pub async fn get_next_ecash_wallet(&self) -> Option<EcashWallet> {
+        let creds = self.ecash.read().await;
+        creds.iter().find(|c| !c.consumed).cloned()
+    }
+
    /// Tries to retrieve one of the stored, unused credentials.
    pub async fn get_next_coconut_credential(&self) -> Option<CoconutCredential> {
        let creds = self.inner.read().await;
@@ -67,4 +102,12 @@ impl CoconutCredentialManager {
            cred.consumed = true;
        }
    }
+
+    pub async fn update_ecash_wallet(&self, wallet: String, id: i64, consumed: bool) {
+        let mut creds = self.ecash.write().await;
+        if let Some(cred) = creds.get_mut(id as usize) {
+            cred.wallet = wallet;
+            cred.consumed = consumed;
+        }
+    }
 }
@@ -1,7 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::models::CoconutCredential;
+use crate::models::{CoconutCredential, EcashWallet};

 #[derive(Clone)]
 pub struct CoconutCredentialManager {
@@ -45,6 +45,41 @@ impl CoconutCredentialManager {
        Ok(())
    }

+    /// Inserts provided signature into the database.
+    ///
+    /// # Arguments
+    ///
+    /// * `voucher_info`: What type of credential it is.
+    /// * `signature`: Ecash wallet credential in the form of a wallet.
+    /// * `value` : The value of the ecash wallet
+    /// * `epoch_id`: The epoch when it was signed.
+
+    pub async fn insert_ecash_wallet(
+        &self,
+        voucher_info: String,
+        wallet: String,
+        value: String,
+        epoch_id: String,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "INSERT INTO ecash_wallets(voucher_info, wallet, value, epoch_id, consumed) VALUES (?, ?, ?, ?, ?)",
+            voucher_info, wallet, value, epoch_id, false
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    /// Tries to retrieve one of the stored, unused credentials.
+    pub async fn get_next_ecash_wallet(&self) -> Result<Option<EcashWallet>, sqlx::Error> {
+        sqlx::query_as!(
+            EcashWallet,
+            "SELECT * FROM ecash_wallets WHERE NOT consumed"
+        )
+        .fetch_optional(&self.connection_pool)
+        .await
+    }
+
    /// Tries to retrieve one of the stored, unused credentials.
    pub async fn get_next_coconut_credential(
        &self,
@@ -71,4 +106,29 @@ impl CoconutCredentialManager {
        .await?;
        Ok(())
    }
+
+    /// Consumes in the database the specified credential.
+    ///
+    /// # Arguments
+    ///
+    /// * `wallet` : New wallet string to update with
+    /// * `id`: Database id.
+    /// * `consumed` : If the wallet is entirely consumed
+    ///
+    pub async fn update_ecash_wallet(
+        &self,
+        wallet: String,
+        id: i64,
+        consumed: bool,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "UPDATE ecash_wallets SET wallet = ?, consumed = ? WHERE id = ?",
+            wallet,
+            consumed,
+            id
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
 }
@@ -3,7 +3,7 @@

 use crate::backends::memory::CoconutCredentialManager;
 use crate::error::StorageError;
-use crate::models::CoconutCredential;
+use crate::models::{CoconutCredential, EcashWallet};
 use crate::storage::Storage;
 use async_trait::async_trait;

@@ -50,6 +50,30 @@ impl Storage for EphemeralStorage {
        Ok(())
    }

+    async fn insert_ecash_wallet(
+        &self,
+        voucher_info: String,
+        wallet: String,
+        value: String,
+        epoch_id: String,
+    ) -> Result<(), StorageError> {
+        self.coconut_credential_manager
+            .insert_ecash_wallet(voucher_info, wallet, value, epoch_id)
+            .await;
+
+        Ok(())
+    }
+
+    async fn get_next_ecash_wallet(&self) -> Result<EcashWallet, StorageError> {
+        let credential = self
+            .coconut_credential_manager
+            .get_next_ecash_wallet()
+            .await
+            .ok_or(StorageError::NoCredential)?;
+
+        Ok(credential)
+    }
+
    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError> {
        let credential = self
            .coconut_credential_manager
@@ -67,4 +91,16 @@ impl Storage for EphemeralStorage {

        Ok(())
    }
+
+    async fn update_ecash_wallet(
+        &self,
+        wallet: String,
+        id: i64,
+        consumed: bool,
+    ) -> Result<(), StorageError> {
+        self.coconut_credential_manager
+            .update_ecash_wallet(wallet, id, consumed)
+            .await;
+        Ok(())
+    }
 }
@@ -13,3 +13,14 @@ pub struct CoconutCredential {
    pub epoch_id: String,
    pub consumed: bool,
 }
+
+#[derive(Clone)]
+pub struct EcashWallet {
+    #[allow(dead_code)]
+    pub id: i64,
+    pub voucher_info: String,
+    pub wallet: String,
+    pub value: String,
+    pub epoch_id: String,
+    pub consumed: bool,
+}
@@ -1,9 +1,9 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::backends::sqlite::CoconutCredentialManager;
 use crate::error::StorageError;
 use crate::storage::Storage;
+use crate::{backends::sqlite::CoconutCredentialManager, models::EcashWallet};

 use crate::models::CoconutCredential;
 use async_trait::async_trait;
@@ -81,6 +81,30 @@ impl Storage for PersistentStorage {
        Ok(())
    }

+    async fn insert_ecash_wallet(
+        &self,
+        voucher_info: String,
+        wallet: String,
+        value: String,
+        epoch_id: String,
+    ) -> Result<(), StorageError> {
+        self.coconut_credential_manager
+            .insert_ecash_wallet(voucher_info, wallet, value, epoch_id)
+            .await?;
+
+        Ok(())
+    }
+
+    async fn get_next_ecash_wallet(&self) -> Result<EcashWallet, StorageError> {
+        let credential = self
+            .coconut_credential_manager
+            .get_next_ecash_wallet()
+            .await?
+            .ok_or(StorageError::NoCredential)?;
+
+        Ok(credential)
+    }
+
    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError> {
        let credential = self
            .coconut_credential_manager
@@ -98,4 +122,16 @@ impl Storage for PersistentStorage {

        Ok(())
    }
+
+    async fn update_ecash_wallet(
+        &self,
+        wallet: String,
+        id: i64,
+        consumed: bool,
+    ) -> Result<(), StorageError> {
+        self.coconut_credential_manager
+            .update_ecash_wallet(wallet, id, consumed)
+            .await?;
+        Ok(())
+    }
 }
@@ -1,7 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::models::CoconutCredential;
+use crate::models::{CoconutCredential, EcashWallet};
 use async_trait::async_trait;
 use std::error::Error;

@@ -29,6 +29,25 @@ pub trait Storage: Send + Sync {
        epoch_id: String,
    ) -> Result<(), Self::StorageError>;

+    /// Inserts provided wallet into the database.
+    ///
+    /// # Arguments
+    ///
+    /// * `voucher_info`: What type of credential it is.
+    /// * `signature`: Ecash wallet credential in the form of a wallet.
+    /// * `value` : The value of the ecash wallet
+    /// * `epoch_id`: The epoch when it was signed.
+    async fn insert_ecash_wallet(
+        &self,
+        voucher_info: String,
+        signature: String,
+        value: String,
+        epoch_id: String,
+    ) -> Result<(), Self::StorageError>;
+
+    /// Tries to retrieve one of the stored, unused credentials.
+    async fn get_next_ecash_wallet(&self) -> Result<EcashWallet, Self::StorageError>;
+
    /// Tries to retrieve one of the stored, unused credentials.
    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, Self::StorageError>;

@@ -38,4 +57,19 @@ pub trait Storage: Send + Sync {
    ///
    /// * `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
+    ///
+    /// * `wallet` : New Ecash wallet credential
+    /// * `id`: Id of the credential to be updated.
+    /// * `consumed`: if the credential is consumed or not
+    ///
+    async fn update_ecash_wallet(
+        &self,
+        wallet: String,
+        id: i64,
+        consumed: bool,
+    ) -> Result<(), Self::StorageError>;
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
durch	ce8718ae96	Rebase, clippy, fmt	2023-12-07 10:43:03 +01:00
Simon Wicky	07a86afb54	generate ecash key on client upgrade	2023-12-07 09:49:27 +01:00
Simon Wicky	3098eb8544	add config migration for clients	2023-12-07 09:49:27 +01:00
Simon Wicky	f2ab3e0972	add small note on nym-api	2023-12-07 09:49:27 +01:00
Simon Wicky	785634b824	fix sql migrations	2023-12-07 09:49:27 +01:00
Simon Wicky	f6d00ba196	increase api timeout for ecash	2023-12-07 09:49:27 +01:00
Simon Wicky	1dd208dd4c	prevent shutdown to be dropped in online mode	2023-12-07 09:49:15 +01:00
Simon Wicky	49d22ab791	add serial number to payments	2023-12-07 09:49:15 +01:00
Simon Wicky	d97244fb27	add value to payment	2023-12-07 09:49:13 +01:00
Simon Wicky	8093932c7b	online mode on gateway	2023-12-07 09:48:29 +01:00
Simon Wicky	e0f36537db	add value to ecash wallets	2023-12-07 09:48:29 +01:00
Simon Wicky	2bb130c204	prepare new api endpoint	2023-12-07 09:48:29 +01:00
Simon Wicky	338613362d	offline/online toggle for gateway	2023-12-07 09:48:29 +01:00
Simon Wicky	770324cf95	name change in preparation for online setup	2023-12-07 09:48:29 +01:00
Simon Wicky	9c6555663a	persist pending credentials on reboot	2023-12-07 09:48:27 +01:00
Simon Wicky	9255e32d08	set ticker missed behavior	2023-12-07 09:48:12 +01:00
Simon Wicky	f35f2649ef	tweak to not try_send every time	2023-12-07 09:48:12 +01:00
Simon Wicky	7514fa3ca6	async credential sending	2023-12-07 09:48:12 +01:00
Simon Wicky	976b6d9ada	bump up the bandwidth a bit	2023-12-07 09:46:00 +01:00
Simon Wicky	9d030bef94	fix sql migration	2023-12-07 09:46:00 +01:00
Simon Wicky	ddfd503962	change parameters serialization so it's not random	2023-12-07 09:46:00 +01:00
Simon Wicky	b8803376ff	conversion to keypairauth elsewhere	2023-12-07 09:46:00 +01:00
Simon Wicky	3afb4c5041	use api ecash key for issuance	2023-12-07 09:46:00 +01:00
Simon Wicky	f8a881af59	use stored ecash keypair for the api	2023-12-07 09:46:00 +01:00
Simon Wicky	14b974d2e1	add ecash key to api	2023-12-07 09:46:00 +01:00
Simon Wicky	3bf105301a	fix route for coconut api	2023-12-07 09:46:00 +01:00
Simon Wicky	61cf4ea0c7	distribute parameters to all components	2023-12-07 09:46:00 +01:00
Simon Wicky	d559d9a113	hard code ecash parameters	2023-12-07 09:45:43 +01:00
Simon Wicky	575282fe32	add consumed update to wallet	2023-12-07 09:45:39 +01:00
Simon Wicky	3e3c8a5467	add ecash params to api	2023-12-07 09:45:15 +01:00
Simon Wicky	0603273a49	remove secret key from credential storage	2023-12-07 09:45:15 +01:00
Simon Wicky	dcfae92bab	use stored ecash key when using credentials	2023-12-07 09:45:13 +01:00
Simon Wicky	9e925fd4ce	config file template update	2023-12-07 09:45:00 +01:00
Simon Wicky	5792b89917	use ecash key for credential issuance	2023-12-07 09:45:00 +01:00
Simon Wicky	d5bfa732c6	add ecash keypair to client	2023-12-07 09:45:00 +01:00
Simon Wicky	89644e5476	use identity key as provider pk	2023-12-07 09:44:57 +01:00
aniampio	7057170381	Move generate payinfo as implementation of the struct	2023-12-07 09:43:36 +01:00
aniampio	ada02fe631	Improve function performance and readability	2023-12-07 09:43:07 +01:00
aniampio	7836f5771b	Add function generating the payinfo	2023-12-07 09:42:23 +01:00
Simon Wicky	46c53eb1a5	credentials storage on gateway and api	2023-12-07 09:41:55 +01:00
Simon Wicky	506693a8a5	wip double spending detection	2023-12-07 09:41:53 +01:00
Simon Wicky	cece0bb80e	add traits to ecashcredential	2023-12-07 09:41:14 +01:00
Simon Wicky	56d36974fa	add params in ecashcredential	2023-12-07 09:41:12 +01:00
Simon Wicky	c0713a5a13	add payinfo to credential	2023-12-07 09:40:26 +01:00
Simon Wicky	74536467b6	impl payment flow	2023-12-07 09:40:23 +01:00
Simon Wicky	c1c58a7476	update ecash credential	2023-12-07 09:40:00 +01:00
Simon Wicky	bc9d4b4682	add secret-key for ecash credential storage	2023-12-07 09:40:00 +01:00
Simon Wicky	e41796b157	WIP spending ecash	2023-12-07 09:40:00 +01:00
Simon Wicky	5a831b6482	swap VerificationKey for VerificationKeyAuth	2023-12-07 09:40:00 +01:00
Simon Wicky	4de642315d	add get_next_ecash_cred for storage	2023-12-07 09:40:00 +01:00
Simon Wicky	1091f1341c	issuance cli side	2023-12-07 09:39:58 +01:00
Simon Wicky	ea0dbfea03	ecash issuance api side	2023-12-07 09:39:45 +01:00
Simon Wicky	dd323ce493	update bls12_381 dependency	2023-12-07 09:39:45 +01:00
aniampio	954f76e241	Optimize the identification function	2023-12-07 09:39:19 +01:00
aniampio	a09dc8e462	Add byte calculation for divisible ecash	2023-12-07 09:39:19 +01:00
aniampio	f623bfed4c	Add Wallet, Partial Wallet and Payment to and from bytes converstion	2023-12-07 09:39:19 +01:00
aniampio	e6bcfb697c	Increase benchmark duration	2023-12-07 09:39:19 +01:00
aniampio	a70843b940	Update in divisible ecash benchmark	2023-12-07 09:39:19 +01:00
aniampio	8a21e4ae25	Benchmarks: change the number of public keys	2023-12-07 09:39:19 +01:00
aniampio	d7f4590239	Update compact benchmarks	2023-12-07 09:39:19 +01:00
aniampio	cd2f7a30d2	Remove spend verification from the identify function	2023-12-07 09:39:19 +01:00
aniampio	23b9e4d48a	Update benchmarks	2023-12-07 09:39:19 +01:00
aniampio	fecb67ded7	Update for compact e-cash - remove requirement for security tag	2023-12-07 09:39:19 +01:00
aniampio	3ffa367de1	Update benchmarks	2023-12-07 09:39:19 +01:00
aniampio	3691110db8	Add verification of the payments inside identify; speed up the identify checks	2023-12-07 09:39:17 +01:00
aniampio	dd527e4295	Update the spend function for compact ecash - multi spend	2023-12-07 09:39:06 +01:00
aniampio	778f5bf5e5	Add duplicate payinfo check for identify	2023-12-07 09:39:06 +01:00
aniampio	761d09534f	Update spend function in the compact ecash	2023-12-07 09:39:06 +01:00
aniampio	4a7e44b9c7	Add test for identification - case of no double spending	2023-12-07 09:39:06 +01:00
aniampio	db69158b4b	Add aggregation and e2e test	2023-12-07 09:39:06 +01:00
aniampio	40af8ebf47	Fix the eq 15 for the spend proof	2023-12-07 09:39:06 +01:00
aniampio	f8e78c7fcc	Update the verification function for structure preserving signature	2023-12-07 09:39:06 +01:00
aniampio	05ddbf2fba	Add draft of signature verification function	2023-12-07 09:39:06 +01:00
aniampio	31e9c0004a	Move the index for signature retrival	2023-12-07 09:39:06 +01:00
aniampio	e4cfdc9888	3 out of 4 pairing tests in the zk proof pass	2023-12-07 09:39:06 +01:00
aniampio	0df62df780	Fix signatures tau_l	2023-12-07 09:39:06 +01:00
aniampio	3687600587	Shifting indices in setup - eq 4 test still passing	2023-12-07 09:39:06 +01:00
aniampio	64dd6c2b8c	Add eq checks	2023-12-07 09:39:06 +01:00
aniampio	aa018769c2	Add bilinear equations into the zk proof; the last eq passes the tests	2023-12-07 09:39:04 +01:00
aniampio	2ec2613a89	Define spend instance and witness structs	2023-12-07 09:38:54 +01:00
aniampio	15d10ab027	Add spend and spend verification functions; fix breaking test for proof of withdrawal	2023-12-07 09:38:54 +01:00
aniampio	0fc5b97dfb	Add issuance and issuance verification - but one of the tests is failing	2023-12-07 09:38:54 +01:00
aniampio	7632e524c0	Add key generation functions	2023-12-07 09:38:54 +01:00
aniampio	49721177fc	Update the structure preserving signature to work in the setup function as well	2023-12-07 09:38:50 +01:00
aniampio	7f0f2b056f	Add benchmarks	2023-12-07 09:38:21 +01:00
aniampio	cec35ee4d0	Update get range proof signature function to return an error	2023-12-07 09:37:43 +01:00
aniampio	5f545675e1	Add into the zk proof the proof that l is within the range	2023-12-07 09:36:20 +01:00
aniampio	49ac369ce2	Add struct for the divisible ecash crate	2023-12-07 09:36:17 +01:00
aniampio	dfcc87167b	Add test for succesfull identification	2023-12-07 09:35:54 +01:00
aniampio	ee95596abf	Fix the issue with two gamma equations	2023-12-07 09:35:54 +01:00
aniampio	23ce9de873	Add S and T into the zk proof for spend	2023-12-07 09:35:54 +01:00
aniampio	28081bd72c	Move signature related structs and functions to utils	2023-12-07 09:35:54 +01:00
aniampio	5e146aa432	Move spend and spec vfy as functions associated with wallet and payment	2023-12-07 09:35:54 +01:00
aniampio	53a9d43c87	Add identify function	2023-12-07 09:35:54 +01:00
aniampio	f487234007	Add spendVfy function	2023-12-07 09:35:54 +01:00
aniampio	d2a7d26e5a	Add verification for the spend zkproof and first tests	2023-12-07 09:35:54 +01:00
aniampio	7fcd246089	Start the spend function and zkproof for spend	2023-12-07 09:35:54 +01:00
aniampio	f384338f0f	Add new aggregation function and struct for the aggregated wallet	2023-12-07 09:35:54 +01:00
aniampio	0114743db9	Add aggregation into e2e tests	2023-12-07 09:35:54 +01:00
aniampio	9776bfb0b0	Copy and adjust aggregation of verification keys from coconut	2023-12-07 09:35:52 +01:00
aniampio	0526b3e6b4	Fix bug in the issuance verification	2023-12-07 09:35:37 +01:00
aniampio	d00bef2ddf	Fix a bug in the commitment computation	2023-12-07 09:35:37 +01:00
aniampio	a0c81c982c	Copy polynomial and ttpcode from Coconut; add first test; add keypair structures	2023-12-07 09:35:37 +01:00
aniampio	32ba1c7c18	Add zk proof for withdrawal request	2023-12-07 09:35:35 +01:00
aniampio	bea8e4a881	Add initial functions	2023-12-07 09:34:41 +01:00
aniampio	9558c3deb2	Add template for the compact ecash crate	2023-12-07 09:33:00 +01:00