cargo fmt

add return statement
ibid
2024-02-09 16:41:01 +01:00 · 2024-02-09 16:32:53 +01:00 · 2024-02-09 14:57:49 +00:00 · 2024-02-09 15:32:35 +01:00 · 2024-02-09 14:17:20 +00:00 · 2024-02-09 13:57:35 +00:00
783 changed files with 13796 additions and 30984 deletions
@@ -1,61 +0,0 @@
-name: build-upload-binaries
-
-on:
-  workflow_dispatch:
-    inputs:
-      add_tokio_unstable:
-        description: 'True to add RUSTFLAGS="--cfg tokio_unstable"'
-        required: true
-        default: false
-        type: boolean
-
-env:
-  NETWORK: mainnet
-
-jobs:
-  publish-nym:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [ubuntu-20.04]
-
-    runs-on: ${{ matrix.platform }}
-    env:
-      CARGO_TERM_COLOR: always
-    steps:
-      - uses: actions/checkout@v3
-
-      - 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 libudev-dev squashfs-tools
-        continue-on-error: true
-
-      - name: Sets env vars for tokio if set in manual dispatch inputs
-        run: |
-          echo 'RUSTFLAGS="--cfg tokio_unstable"' >> $GITHUB_ENV
-        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: Build all binaries
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --release
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: nym-binaries-artifacts
-          path: |
-            target/release/nym-client
-            target/release/nym-gateway
-            target/release/nym-mixnode
-            target/release/nym-socks5-client
-            target/release/nym-api
-            target/release/nym-network-requester
-            target/release/nym-network-statistics
-            target/release/nym-cli
-          retention-days: 30
@@ -2,20 +2,32 @@ name: ci-build-upload-binaries

 on:
  workflow_dispatch:
+    inputs:
+      add_tokio_unstable:
+        description: 'True to add RUSTFLAGS="--cfg tokio_unstable"'
+        required: true
+        default: false
+        type: boolean
+      enable_wireguard:
+        description: 'Add --features wireguard'
+        required: true
+        default: false
+        type: boolean
  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/**"
+      - "nym-api/**"
+      - "nym-node/**"
+      - "nym-outfox/**"
+      - "nym-validator-rewarder/**"
+      - "sdk/rust/nym-sdk/**"
+      - "service-providers/**"
+      - "tools/**"

 jobs:
  publish-nym:
@@ -42,6 +54,16 @@ jobs:
      - name: Install Dependencies (Linux)
        run: sudo apt update && sudo apt install libudev-dev

+      - name: Sets env vars for tokio if set in manual dispatch inputs
+        run: |
+          echo 'RUSTFLAGS="--cfg tokio_unstable"' >> $GITHUB_ENV
+        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true
+
+      - name: Set CARGO_FEATURES
+        run: |
+          echo 'CARGO_FEATURES=--features wireguard' >> $GITHUB_ENV
+        if: github.event_name == 'workflow_dispatch' && inputs.enable_wireguard == true
+
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
@@ -51,9 +73,40 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: build
-          args: --workspace --release
+          args: --workspace --release ${{ env.CARGO_FEATURES }}
+
+      - name: Install cargo-deb
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-deb
+
+      - name: Build deb packages
+        shell: bash
+        run: make deb
+
+      # If this was a manual workflow_dispatch, publish binaries.
+
+      - name: Upload Artifact
+        if: github.event_name == 'workflow_dispatch'
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-binaries-artifacts
+          path: |
+            target/release/nym-client
+            target/release/nym-gateway
+            target/release/nym-mixnode
+            target/release/nym-socks5-client
+            target/release/nym-api
+            target/release/nym-network-requester
+            target/release/nym-network-statistics
+            target/release/nym-cli
+          retention-days: 30
+
+      # If this was a pull_request, upload to build server

      - name: Prepare build output
+        if: github.event_name == 'pull_request'
        shell: bash
        env:
          OUTPUT_DIR: ci-builds/${{ github.ref_name }}
@@ -67,8 +120,10 @@ jobs:
          cp target/release/nym-network-statistics $OUTPUT_DIR
          cp target/release/nym-cli $OUTPUT_DIR
          cp target/release/explorer-api $OUTPUT_DIR
+          cp target/debian/*.deb $OUTPUT_DIR

      - name: Deploy branch to CI www
+        if: github.event_name == 'pull_request'
        continue-on-error: true
        uses: easingthemes/ssh-deploy@main
        env:
@@ -1,5 +1,8 @@
 name: ci-cargo-deny
-on: [workflow_dispatch]
+on:
+  workflow_dispatch:
+  pull_request:
+
 jobs:
  cargo-deny:
    runs-on: ubuntu-22.04
@@ -7,10 +10,7 @@ jobs:
      matrix:
        checks:
          # - advisories
-          - licenses
-          - bans sources
-
-    continue-on-error: ${{ matrix.checks == 'licenses' }}
+          - licenses bans sources

    steps:
    - uses: actions/checkout@v3
@@ -18,7 +18,7 @@ jobs:
      - uses: actions/checkout@v2

      - name: install yarn in root
-        run: cd ../.. yarn install
+        run: cd ../.. && yarn install

      - name: Install npm
        run: npm install
@@ -1,40 +0,0 @@
-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
@@ -1,63 +0,0 @@
-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
@@ -187,6 +187,16 @@ dependencies = [
 "syn 2.0.38",
 ]

+[[package]]
+name = "addr"
+version = "0.15.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a93b8a41dbe230ad5087cc721f8d41611de654542180586b315d9f4cf6b72bef"
+dependencies = [
+ "psl",
+ "psl-types",
+]
+
 [[package]]
 name = "addr2line"
 version = "0.21.0"
@@ -1461,7 +1471,7 @@ version = "6.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7e959d788268e3bf9d35ace83e81b124190378e4c91c9067524675e33394b8ba"
 dependencies = [
- "crossterm",
+ "crossterm 0.26.1",
 "strum 0.24.1",
 "strum_macros 0.24.3",
 "unicode-width",
@@ -1559,6 +1569,12 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28c122c3980598d243d63d9a704629a2d748d101f278052ff068be5a4423ab6f"

+[[package]]
+name = "const-str"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aca749d3d3f5b87a0d6100509879f9cf486ab510803a4a4e1001da1ff61c2bd6"
+
 [[package]]
 name = "const_format"
 version = "0.2.32"
@@ -1604,9 +1620,9 @@ dependencies = [

 [[package]]
 name = "cookie"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7efb37c3e1ccb1ff97164ad95ac1606e8ccd35b3fa0a7d99a304c7f4a428cc24"
+checksum = "3cd91cf61412820176e137621345ee43b3f4423e589e7ae4e50d601d93e35ef8"
 dependencies = [
 "percent-encoding",
 "time",
@@ -1916,6 +1932,22 @@ dependencies = [
 "cfg-if",
 ]

+[[package]]
+name = "crossterm"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e64e6c0fbe2c17357405f7c758c1ef960fce08bdfb2c03d88d2a18d7e09c4b67"
+dependencies = [
+ "bitflags 1.3.2",
+ "crossterm_winapi",
+ "libc",
+ "mio",
+ "parking_lot 0.12.1",
+ "signal-hook",
+ "signal-hook-mio",
+ "winapi",
+]
+
 [[package]]
 name = "crossterm"
 version = "0.26.1"
@@ -2002,6 +2034,27 @@ dependencies = [
 "subtle 2.4.1",
 ]

+[[package]]
+name = "csv"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "ctor"
 version = "0.1.26"
@@ -3981,6 +4034,16 @@ dependencies = [
 "unicode-normalization",
 ]

+[[package]]
+name = "idna"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
 [[package]]
 name = "idna"
 version = "0.4.0"
@@ -4097,6 +4160,22 @@ dependencies = [
 "generic-array 0.14.7",
 ]

+[[package]]
+name = "inquire"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33e7c1ddeb15c9abcbfef6029d8e29f69b52b6d6c891031b88ed91b5065803b"
+dependencies = [
+ "bitflags 1.3.2",
+ "crossterm 0.25.0",
+ "dyn-clone",
+ "lazy_static",
+ "newline-converter",
+ "thiserror",
+ "unicode-segmentation",
+ "unicode-width",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -5770,6 +5849,15 @@ dependencies = [
 "tokio",
 ]

+[[package]]
+name = "newline-converter"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f71d09d5c87634207f894c6b31b6a2b2c64ea3bdcf71bd5599fdbbe1600c00f"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "nix"
 version = "0.24.3"
@@ -5957,7 +6045,6 @@ dependencies = [
 "nym-coconut",
 "nym-coconut-bandwidth-contract-common",
 "nym-coconut-dkg-common",
- "nym-coconut-interface",
 "nym-config",
 "nym-contracts-common",
 "nym-credential-storage",
@@ -6015,7 +6102,7 @@ dependencies = [
 "cosmrs 0.15.0 (git+https://github.com/jstuczyn/cosmos-rust?branch=nym-temp/all-validator-features)",
 "cosmwasm-std",
 "getset",
- "nym-coconut-interface",
+ "nym-credentials-interface",
 "nym-crypto",
 "nym-mixnet-contract-common",
 "nym-node-requests",
@@ -6030,9 +6117,11 @@ name = "nym-bandwidth-controller"
 version = "0.1.0"
 dependencies = [
 "bip39",
- "nym-coconut-interface",
+ "log",
+ "nym-coconut",
 "nym-credential-storage",
 "nym-credentials",
+ "nym-credentials-interface",
 "nym-crypto",
 "nym-network-defaults",
 "nym-validator-client",
@@ -6050,6 +6139,7 @@ dependencies = [
 "clap 4.4.7",
 "clap_complete",
 "clap_complete_fig",
+ "const-str",
 "log",
 "opentelemetry",
 "opentelemetry-jaeger",
@@ -6092,6 +6182,7 @@ dependencies = [
 "clap_complete",
 "clap_complete_fig",
 "dotenvy",
+ "inquire",
 "log",
 "nym-bin-common",
 "nym-cli-commands",
@@ -6117,9 +6208,11 @@ dependencies = [
 "comfy-table",
 "cosmrs 0.15.0 (git+https://github.com/jstuczyn/cosmos-rust?branch=nym-temp/all-validator-features)",
 "cosmwasm-std",
+ "csv",
 "cw-utils",
 "handlebars",
 "humantime-serde",
+ "inquire",
 "k256",
 "log",
 "nym-bandwidth-controller",
@@ -6166,7 +6259,6 @@ dependencies = [
 "nym-bin-common",
 "nym-client-core",
 "nym-client-websocket-requests",
- "nym-coconut-interface",
 "nym-config",
 "nym-credential-storage",
 "nym-credentials",
@@ -6222,6 +6314,7 @@ dependencies = [
 "serde",
 "serde_json",
 "sha2 0.10.8",
+ "si-scale",
 "sqlx",
 "tap",
 "tempfile",
@@ -6318,17 +6411,6 @@ dependencies = [
 "nym-multisig-contract-common",
 ]

-[[package]]
-name = "nym-coconut-interface"
-version = "0.1.0"
-dependencies = [
- "bs58 0.4.0",
- "getset",
- "nym-coconut",
- "serde",
- "thiserror",
-]
-
 [[package]]
 name = "nym-config"
 version = "0.1.0"
@@ -6364,6 +6446,7 @@ dependencies = [
 "sqlx",
 "thiserror",
 "tokio",
+ "zeroize",
 ]

 [[package]]
@@ -6373,6 +6456,7 @@ dependencies = [
 "log",
 "nym-bandwidth-controller",
 "nym-client-core",
+ "nym-coconut",
 "nym-config",
 "nym-credential-storage",
 "nym-credentials",
@@ -6385,18 +6469,31 @@ dependencies = [
 name = "nym-credentials"
 version = "0.1.0"
 dependencies = [
+ "bincode",
 "bls12_381",
 "cosmrs 0.15.0 (git+https://github.com/jstuczyn/cosmos-rust?branch=nym-temp/all-validator-features)",
 "log",
 "nym-api-requests",
- "nym-coconut-interface",
+ "nym-credentials-interface",
 "nym-crypto",
 "nym-validator-client",
 "rand 0.7.3",
+ "serde",
 "thiserror",
+ "time",
 "zeroize",
 ]

+[[package]]
+name = "nym-credentials-interface"
+version = "0.1.0"
+dependencies = [
+ "bls12_381",
+ "nym-coconut",
+ "serde",
+ "thiserror",
+]
+
 [[package]]
 name = "nym-crypto"
 version = "0.4.0"
@@ -6524,9 +6621,9 @@ dependencies = [
 "log",
 "nym-api-requests",
 "nym-bin-common",
- "nym-coconut-interface",
 "nym-config",
 "nym-credentials",
+ "nym-credentials-interface",
 "nym-crypto",
 "nym-gateway-requests",
 "nym-ip-packet-router",
@@ -6551,6 +6648,7 @@ dependencies = [
 "sqlx",
 "subtle-encoding",
 "thiserror",
+ "time",
 "tokio",
 "tokio-stream",
 "tokio-tungstenite",
@@ -6569,8 +6667,8 @@ dependencies = [
 "gloo-utils",
 "log",
 "nym-bandwidth-controller",
- "nym-coconut-interface",
 "nym-credential-storage",
+ "nym-credentials",
 "nym-crypto",
 "nym-gateway-requests",
 "nym-network-defaults",
@@ -6600,8 +6698,8 @@ dependencies = [
 "futures",
 "generic-array 0.14.7",
 "log",
- "nym-coconut-interface",
 "nym-credentials",
+ "nym-credentials-interface",
 "nym-crypto",
 "nym-pemstore",
 "nym-sphinx",
@@ -6643,6 +6741,8 @@ dependencies = [
 "rand 0.8.5",
 "serde",
 "thiserror",
+ "tokio",
+ "tokio-util",
 ]

 [[package]]
@@ -6650,21 +6750,27 @@ name = "nym-ip-packet-router"
 version = "0.1.0"
 dependencies = [
 "bincode",
+ "bs58 0.4.0",
 "bytes",
+ "clap 4.4.7",
 "etherparse",
 "futures",
+ "lazy_static",
 "log",
 "nym-bin-common",
 "nym-client-core",
 "nym-config",
+ "nym-crypto",
 "nym-exit-policy",
 "nym-ip-packet-requests",
+ "nym-network-defaults",
 "nym-network-requester",
 "nym-sdk",
 "nym-service-providers-common",
 "nym-sphinx",
 "nym-task",
 "nym-tun",
+ "nym-types",
 "nym-wireguard",
 "nym-wireguard-types",
 "rand 0.8.5",
@@ -6823,6 +6929,7 @@ dependencies = [
 "cfg-if",
 "dotenvy",
 "hex-literal",
+ "log",
 "once_cell",
 "schemars",
 "serde",
@@ -6834,6 +6941,7 @@ dependencies = [
 name = "nym-network-requester"
 version = "1.1.32"
 dependencies = [
+ "addr",
 "anyhow",
 "async-file-watcher",
 "async-trait",
@@ -7132,7 +7240,6 @@ dependencies = [
 "log",
 "nym-bin-common",
 "nym-client-core",
- "nym-coconut-interface",
 "nym-config",
 "nym-credential-storage",
 "nym-credentials",
@@ -7479,7 +7586,6 @@ dependencies = [
 "hmac 0.12.1",
 "itertools 0.11.0",
 "log",
- "nym-coconut-interface",
 "nym-config",
 "nym-crypto",
 "nym-mixnet-contract-common",
@@ -7521,9 +7627,9 @@ dependencies = [
 "itertools 0.10.5",
 "log",
 "nym-api-requests",
+ "nym-coconut",
 "nym-coconut-bandwidth-contract-common",
 "nym-coconut-dkg-common",
- "nym-coconut-interface",
 "nym-config",
 "nym-contracts-common",
 "nym-ephemera-common",
@@ -7730,9 +7836,9 @@ dependencies = [

 [[package]]
 name = "okapi"
-version = "0.7.0-rc.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce66b6366e049880a35c378123fddb630b1a1a3c37fa1ca70caaf4a09f6e2893"
+checksum = "9a64853d7ab065474e87696f7601cee817d200e86c42e04004e005cb3e20c3c5"
 dependencies = [
 "log",
 "schemars",
@@ -8061,7 +8167,7 @@ checksum = "61a386cd715229d399604b50d1361683fe687066f42d56f54be995bc6868f71c"
 dependencies = [
 "inlinable_string",
 "pear_codegen",
- "yansi 1.0.0-rc.1",
+ "yansi",
 ]

 [[package]]
@@ -8438,7 +8544,7 @@ dependencies = [
 "quote",
 "syn 2.0.38",
 "version_check",
- "yansi 1.0.0-rc.1",
+ "yansi",
 ]

 [[package]]
@@ -8563,14 +8669,28 @@ dependencies = [
 ]

 [[package]]
-name = "publicsuffix"
-version = "1.5.6"
+name = "psl"
+version = "2.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95b4ce31ff0a27d93c8de1849cf58162283752f065a90d508f1105fa6c9a213f"
+checksum = "383703acfc34f7a00724846c14dc5ea4407c59e5aedcbbb18a1c0c1a23fe5013"
 dependencies = [
- "idna 0.2.3",
- "native-tls",
- "url",
+ "psl-types",
+]
+
+[[package]]
+name = "psl-types"
+version = "2.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33cb294fe86a74cbcf50d4445b37da762029549ebeea341421c7c70370f86cac"
+
+[[package]]
+name = "publicsuffix"
+version = "2.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96a8c1bda5ae1af7f99a2962e49df150414a43d62404644d98dd5c3a93d07457"
+dependencies = [
+ "idna 0.3.0",
+ "psl-types",
 ]

 [[package]]
@@ -9173,9 +9293,9 @@ dependencies = [

 [[package]]
 name = "rocket"
-version = "0.5.0-rc.3"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58734f7401ae5cfd129685b48f61182331745b357b96f2367f01aebaf1cc9cc9"
+checksum = "9e7bb57ccb26670d73b6a47396c83139447b9e7878cab627fdfe9ea8da489150"
 dependencies = [
 "async-stream",
 "async-trait",
@@ -9185,8 +9305,7 @@ dependencies = [
 "either",
 "figment",
 "futures",
- "indexmap 1.9.3",
- "is-terminal",
+ "indexmap 2.0.2",
 "log",
 "memchr",
 "multer",
@@ -9207,30 +9326,33 @@ dependencies = [
 "tokio-util",
 "ubyte",
 "version_check",
- "yansi 0.5.1",
+ "yansi",
 ]

 [[package]]
 name = "rocket_codegen"
-version = "0.5.0-rc.3"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7093353f14228c744982e409259fb54878ba9563d08214f2d880d59ff2fc508b"
+checksum = "a2238066abf75f21be6cd7dc1a09d5414a671f4246e384e49fe3f8a4936bd04c"
 dependencies = [
 "devise",
 "glob",
- "indexmap 1.9.3",
+ "indexmap 2.0.2",
 "proc-macro2",
 "quote",
 "rocket_http",
 "syn 2.0.38",
 "unicode-xid",
+ "version_check",
 ]

 [[package]]
 name = "rocket_cors"
-version = "0.5.2"
-source = "git+https://github.com/lawliet89/rocket_cors?rev=dfd3662c49e2f6fc37df35091cb94d82f7fb5915#dfd3662c49e2f6fc37df35091cb94d82f7fb5915"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfac3a1df83f8d4fc96aa41dba3b86c786417b7fc0f52ec76295df2ba781aa69"
 dependencies = [
+ "http",
 "log",
 "regex",
 "rocket",
@@ -9243,16 +9365,16 @@ dependencies = [

 [[package]]
 name = "rocket_http"
-version = "0.5.0-rc.3"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "936012c99162a03a67f37f9836d5f938f662e26f2717809761a9ac46432090f4"
+checksum = "37a1663694d059fe5f943ea5481363e48050acedd241d46deb2e27f71110389e"
 dependencies = [
- "cookie 0.17.0",
+ "cookie 0.18.0",
 "either",
 "futures",
 "http",
 "hyper",
- "indexmap 1.9.3",
+ "indexmap 2.0.2",
 "log",
 "memchr",
 "pear",
@@ -9270,11 +9392,10 @@ dependencies = [

 [[package]]
 name = "rocket_okapi"
-version = "0.8.0-rc.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "742098674565c8f0c35c77444f90344aafedebb71cfee9cdbf0185acc6b9cdb7"
+checksum = "e059407ecef9ee2f071fc971e10444fcf942149deb028879d6d8ca61a7ce9edc"
 dependencies = [
- "either",
 "log",
 "okapi",
 "rocket",
@@ -9286,9 +9407,9 @@ dependencies = [

 [[package]]
 name = "rocket_okapi_codegen"
-version = "0.8.0-rc.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c43f8edc57d88750a220b0ec1870a36c1106204ec99cc35131b49de3b954a4a"
+checksum = "cfb96114e69e5d7f80bfa0948cbc0120016e9b460954abe9eed37e9a2ad3f999"
 dependencies = [
 "darling 0.13.4",
 "proc-macro2",
@@ -9604,9 +9725,9 @@ dependencies = [

 [[package]]
 name = "schemars"
-version = "0.8.15"
+version = "0.8.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f7b0ce13155372a76ee2e1c5ffba1fe61ede73fbea5630d61eee6fac4929c0c"
+checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29"
 dependencies = [
 "dyn-clone",
 "indexmap 1.9.3",
@@ -9617,9 +9738,9 @@ dependencies = [

 [[package]]
 name = "schemars_derive"
-version = "0.8.15"
+version = "0.8.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e85e2a16b12bdb763244c69ab79363d71db2b4b918a2def53f80b02e0574b13c"
+checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -10017,6 +10138,12 @@ dependencies = [
 "dirs 4.0.0",
 ]

+[[package]]
+name = "si-scale"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44beb68bf488343b13ddbd74d1d5d5e6559a58b6dfaee74eb8d5ed4f7ed7666f"
+
 [[package]]
 name = "signal-hook"
 version = "0.3.17"
@@ -10376,9 +10503,9 @@ dependencies = [

 [[package]]
 name = "state"
-version = "0.5.3"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbe866e1e51e8260c9eed836a042a5e7f6726bb2b411dffeaa712e19c388f23b"
+checksum = "2b8c4a4445d81357df8b1a650d0d0d6fbbbfe99d064aa5e02f3e4022061476d8"
 dependencies = [
 "loom",
 ]
@@ -12630,17 +12757,14 @@ dependencies = [
 "static_assertions",
 ]

-[[package]]
-name = "yansi"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
-
 [[package]]
 name = "yansi"
 version = "1.0.0-rc.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1367295b8f788d371ce2dbc842c7b709c73ee1364d30351dd300ec2203b12377"
+dependencies = [
+ "is-terminal",
+]

 [[package]]
 name = "yasna"
@@ -27,7 +27,6 @@ members = [
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
-    "common/coconut-interface",
    "common/commands",
    "common/config",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
@@ -43,6 +42,7 @@ members = [
    "common/credential-storage",
    "common/credentials",
    "common/credential-utils",
+    "common/credentials-interface",
    "common/crypto",
    "common/dkg",
    "common/execute",
@@ -128,7 +128,7 @@ default-members = [
    "nym-validator-rewarder",
 ]

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

 [workspace.package]
 authors = ["Nym Technologies SA"]
@@ -12,6 +12,7 @@ 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 "  deb: build debian packages

 # -----------------------------------------------------------------------------
 # Meta targets
@@ -157,6 +158,12 @@ 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
 # -----------------------------------------------------------------------------
@@ -169,6 +176,13 @@ run-api-tests:
 	cd nym-api/tests/functional_test && yarn test:qa

 # Build debian package, and update PPA
-# Requires base64 encode GPG key to be set up in environment PPA_SIGNING_KEY
-deb:
-	scripts/ppa.sh
+deb-mixnode: build-nym-mixnode
+	cargo deb -p nym-mixnode 
+
+deb-gateway: build-nym-gateway
+	cargo deb -p nym-gateway
+
+deb-cli: build-nym-cli
+	cargo deb -p nym-cli
+
+deb: deb-mixnode deb-gateway deb-cli
@@ -38,7 +38,6 @@ tokio-tungstenite = { workspace = true }
 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-config = { path = "../../common/config" }
 nym-credential-storage = { path = "../../common/credential-storage" }
 nym-credentials = { path = "../../common/credentials" }
@@ -51,7 +51,7 @@ impl InitialisableClient for NativeClientInit {
    }
 }

-#[derive(Args, Clone)]
+#[derive(Args, Clone, Debug)]
 pub(crate) struct Init {
    #[command(flatten)]
    common_args: CommonClientInitArgs,
@@ -23,7 +23,6 @@ url = { workspace = true }
 # internal
 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-config = { path = "../../common/config" }
 nym-credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
@@ -51,7 +51,7 @@ impl InitialisableClient for Socks5ClientInit {
    }
 }

-#[derive(Args, Clone)]
+#[derive(Args, Clone, Debug)]
 pub(crate) struct Init {
    #[command(flatten)]
    common_args: CommonClientInitArgs,
@@ -8,14 +8,16 @@ license.workspace = true

 [dependencies]
 bip39 = { workspace = true }
+log = { workspace = true }
 rand = "0.7.3"
 thiserror = { workspace = true }
 url = { workspace = true }
 zeroize = { workspace = true }

-nym-coconut-interface = { path = "../coconut-interface" }
+nym-coconut = { path = "../nymcoconut" }
 nym-credential-storage = { path = "../credential-storage" }
 nym-credentials = { path = "../credentials" }
+nym-credentials-interface = { path = "../credentials-interface" }
 nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
 nym-network-defaults = { path = "../network-defaults" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::BandwidthControllerError;
-use nym_coconut_interface::Base58;
+use nym_credential_storage::models::StorableIssuedCredential;
 use nym_credential_storage::storage::Storage;
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+use nym_credentials::coconut::bandwidth::{CredentialType, IssuanceBandwidthCredential};
 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_validator_client::nyxd::contract_traits::CoconutBandwidthSigningClient;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use nym_validator_client::nyxd::Coin;
 use rand::rngs::OsRng;
 use state::State;
+use zeroize::Zeroizing;

 pub mod state;

@@ -24,13 +24,11 @@ where
    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 voucher_value = amount.amount.to_string();

    let tx_hash = client
        .deposit(
-            amount,
-            String::from(VOUCHER_INFO),
+            amount.clone(),
+            CredentialType::Voucher.to_string(),
            signing_key.public_key().to_base58_string(),
            encryption_key.public_key().to_base58_string(),
            None,
@@ -38,21 +36,15 @@ where
        .await?
        .transaction_hash;

-    let voucher = BandwidthVoucher::new(
-        &params,
-        voucher_value,
-        VOUCHER_INFO.to_string(),
-        tx_hash,
-        signing_key,
-        encryption_key,
-    );
+    let voucher =
+        IssuanceBandwidthCredential::new_voucher(amount, tx_hash, signing_key, encryption_key);

-    let state = State { voucher, params };
+    let state = State { voucher };

    Ok(state)
 }

-pub async fn get_credential<C, St>(
+pub async fn get_bandwidth_voucher<C, St>(
    state: &State,
    client: &C,
    storage: &St,
@@ -62,6 +54,9 @@ where
    St: Storage,
    <St as Storage>::StorageError: Send + Sync + 'static,
 {
+    // temporary
+    assert!(state.voucher.typ().is_voucher());
+
    let epoch_id = client.get_current_epoch().await?.epoch_id;
    let threshold = client
        .get_current_epoch_threshold()
@@ -70,22 +65,23 @@ where

    let coconut_api_clients = all_coconut_api_clients(client, epoch_id).await?;

-    let signature = obtain_aggregate_signature(
-        &state.params,
-        &state.voucher,
-        &coconut_api_clients,
-        threshold,
-    )
-    .await?;
+    let signature =
+        obtain_aggregate_signature(&state.voucher, &coconut_api_clients, threshold).await?;
+    let issued = state.voucher.to_issued_credential(signature);
+
+    // make sure the data gets zeroized after persisting it
+    let credential_data = Zeroizing::new(issued.pack_v1());
+    let storable = StorableIssuedCredential {
+        serialization_revision: issued.current_serialization_revision(),
+        credential_data: credential_data.as_ref(),
+        credential_type: issued.typ().to_string(),
+        epoch_id: epoch_id
+            .try_into()
+            .expect("our epoch is has run over u32::MAX!"),
+    };
+
    storage
-        .insert_coconut_credential(
-            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(),
-        )
+        .insert_issued_credential(storable)
        .await
        .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))
 }
@@ -1,19 +1,14 @@
-// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_coconut_interface::Parameters;
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+use nym_credentials::coconut::bandwidth::IssuanceBandwidthCredential;

 pub struct State {
-    pub voucher: BandwidthVoucher,
-    pub params: Parameters,
+    pub voucher: IssuanceBandwidthCredential,
 }

 impl State {
-    pub fn new(voucher: BandwidthVoucher) -> Self {
-        State {
-            voucher,
-            params: BandwidthVoucher::default_parameters(),
-        }
+    pub fn new(voucher: IssuanceBandwidthCredential) -> Self {
+        State { voucher }
    }
 }
@@ -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_coconut::CoconutError;
 use nym_credential_storage::error::StorageError;
 use nym_credentials::error::Error as CredentialsError;
 use nym_crypto::asymmetric::encryption::KeyRecoveryError;
@@ -45,4 +45,7 @@ pub enum BandwidthControllerError {

    #[error("Threshold not set yet")]
    NoThreshold,
+
+    #[error("can't handle recovering storage with revision {stored}. {expected} was expected")]
+    UnsupportedCredentialStorageRevision { stored: u8, expected: u8 },
 }
@@ -1,28 +1,38 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::BandwidthControllerError;
-use nym_credential_storage::error::StorageError;
+use crate::utils::stored_credential_to_issued_bandwidth;
+use log::{error, warn};
 use nym_credential_storage::storage::Storage;
+use nym_credentials::coconut::bandwidth::CredentialSpendingData;
+use nym_credentials::coconut::utils::obtain_aggregate_verification_key;
+use nym_credentials_interface::VerificationKey;
 use nym_validator_client::coconut::all_coconut_api_clients;
+use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
-use 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;
+mod utils;

 pub struct BandwidthController<C, St> {
    storage: St,
    client: C,
 }

+pub struct PreparedCredential {
+    /// The cryptographic material required for spending the underlying credential.
+    pub data: CredentialSpendingData,
+
+    /// The (DKG) epoch id under which the credential has been issued so that the verifier
+    /// could use correct verification key for validation.
+    pub epoch_id: EpochId,
+
+    /// The database id of the stored credential.
+    pub credential_id: i64,
+}
+
 impl<C, St: Storage> BandwidthController<C, St> {
    pub fn new(storage: St, client: C) -> Self {
        BandwidthController { storage, client }
@@ -32,49 +42,54 @@ impl<C, St: Storage> BandwidthController<C, St> {
        &self.storage
    }

-    pub async fn prepare_coconut_credential(
+    async fn get_aggregate_verification_key(
        &self,
-    ) -> Result<(nym_coconut_interface::Credential, i64), BandwidthControllerError>
+        epoch_id: EpochId,
+    ) -> Result<VerificationKey, BandwidthControllerError>
    where
        C: DkgQueryClient + Sync + Send,
        <St as Storage>::StorageError: Send + Sync + 'static,
    {
-        let bandwidth_credential = self
+        let coconut_api_clients = all_coconut_api_clients(&self.client, epoch_id).await?;
+        Ok(obtain_aggregate_verification_key(&coconut_api_clients).await?)
+    }
+
+    pub async fn prepare_bandwidth_credential(
+        &self,
+    ) -> Result<PreparedCredential, BandwidthControllerError>
+    where
+        C: DkgQueryClient + Sync + Send,
+        <St as Storage>::StorageError: Send + Sync + 'static,
+    {
+        let retrieved_credential = self
            .storage
-            .get_next_coconut_credential()
+            .get_next_unspent_credential()
            .await
            .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))?;
-        let voucher_value = u64::from_str(&bandwidth_credential.voucher_value)
-            .map_err(|_| StorageError::InconsistentData)?;
-        let voucher_info = bandwidth_credential.voucher_info.clone();
-        let serial_number = Zeroizing::new(nym_coconut_interface::Attribute::try_from_bs58(
-            bandwidth_credential.serial_number,
-        )?);
-        let binding_number = Zeroizing::new(nym_coconut_interface::Attribute::try_from_bs58(
-            bandwidth_credential.binding_number,
-        )?);
-        let signature =
-            nym_coconut_interface::Signature::try_from_bs58(bandwidth_credential.signature)?;
-        let epoch_id = u64::from_str(&bandwidth_credential.epoch_id)
-            .map_err(|_| StorageError::InconsistentData)?;

-        let coconut_api_clients = all_coconut_api_clients(&self.client, epoch_id).await?;
+        let epoch_id = retrieved_credential.epoch_id as EpochId;
+        let credential_id = retrieved_credential.id;

-        let verification_key = obtain_aggregate_verification_key(&coconut_api_clients).await?;
+        let issued_bandwidth = stored_credential_to_issued_bandwidth(retrieved_credential)?;

-        // 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 verification_key = match self.get_aggregate_verification_key(epoch_id).await {
+            Ok(key) => key,
+            Err(err) => {
+                warn!("failed to obtain master verification key: {err}. Putting the credential back into the database");
+
+                // TODO: ERROR RECOVERY:
+                error!("unimplemented: putting the credential back into the database");
+                return Err(err);
+            }
+        };
+
+        let spend_request = issued_bandwidth.prepare_for_spending(&verification_key)?;
+
+        Ok(PreparedCredential {
+            data: spend_request,
+            epoch_id,
+            credential_id,
+        })
    }

    pub async fn consume_credential(&self, id: i64) -> Result<(), BandwidthControllerError>
@@ -93,7 +108,7 @@ impl<C, St: Storage> BandwidthController<C, St> {
 impl<C, St> Clone for BandwidthController<C, St>
 where
    C: Clone,
-    St: Storage + Clone,
+    St: Clone,
 {
    fn clone(&self) -> Self {
        BandwidthController {
@@ -0,0 +1,22 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::error::BandwidthControllerError;
+use nym_credential_storage::models::StoredIssuedCredential;
+use nym_credentials::coconut::bandwidth::issued::CURRENT_SERIALIZATION_REVISION;
+use nym_credentials::coconut::bandwidth::IssuedBandwidthCredential;
+
+pub fn stored_credential_to_issued_bandwidth(
+    cred: StoredIssuedCredential,
+) -> Result<IssuedBandwidthCredential, BandwidthControllerError> {
+    if cred.serialization_revision != CURRENT_SERIALIZATION_REVISION {
+        return Err(
+            BandwidthControllerError::UnsupportedCredentialStorageRevision {
+                stored: cred.serialization_revision,
+                expected: CURRENT_SERIALIZATION_REVISION,
+            },
+        );
+    }
+
+    Ok(IssuedBandwidthCredential::unpack_v1(&cred.credential_data)?)
+}
@@ -9,6 +9,7 @@ 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"
@@ -42,12 +42,20 @@ pub struct BinaryBuildInformation {

    // VERGEN_CARGO_DEBUG
    /// Provides the cargo debug mode that was used for the build.
-    pub cargo_debug: &'static str,
+    // NOTE: keep the old name cargo_profile instead of cargo_debug for backwards compatibility
+    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"),
@@ -57,7 +65,7 @@ impl BinaryBuildInformation {
            commit_branch: env!("VERGEN_GIT_BRANCH"),
            rustc_version: env!("VERGEN_RUSTC_SEMVER"),
            rustc_channel: env!("VERGEN_RUSTC_CHANNEL"),
-            cargo_debug: env!("VERGEN_CARGO_DEBUG"),
+            cargo_profile,
        }
    }

@@ -71,7 +79,7 @@ impl BinaryBuildInformation {
            commit_branch: self.commit_branch.to_owned(),
            rustc_version: self.rustc_version.to_owned(),
            rustc_channel: self.rustc_channel.to_owned(),
-            cargo_debug: self.cargo_debug.to_owned(),
+            cargo_profile: self.cargo_profile.to_owned(),
        }
    }

@@ -117,7 +125,8 @@ pub struct BinaryBuildInformationOwned {

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

 impl Display for BinaryBuildInformationOwned {
@@ -151,8 +160,8 @@ impl Display for BinaryBuildInformationOwned {
            self.rustc_version,
            "rustc Channel:",
            self.rustc_channel,
-            "cargo Debug:",
-            self.cargo_debug,
+            "cargo Profile:",
+            self.cargo_profile,
        )
    }
 }
@@ -46,6 +46,7 @@ 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"
@@ -109,6 +109,8 @@ 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);

@@ -140,17 +142,32 @@ 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,6 +1,7 @@
 // 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;
@@ -10,6 +11,7 @@ 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::{
@@ -254,6 +256,7 @@ where
        self_address: Recipient,
        topology_accessor: TopologyAccessor,
        mix_tx: BatchMixMessageSender,
+        stats_tx: PacketStatisticsReporter,
        shutdown: TaskClient,
    ) {
        info!("Starting loop cover traffic stream...");
@@ -266,6 +269,7 @@ where
            topology_accessor,
            debug_config.traffic,
            debug_config.cover_traffic,
+            stats_tx,
        );

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

@@ -299,6 +304,7 @@ where
            reply_controller_receiver,
            lane_queue_lengths,
            client_connection_rx,
+            stats_tx,
        )
        .start_with_shutdown(shutdown, packet_type);
    }
@@ -312,6 +318,7 @@ 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> =
@@ -321,6 +328,7 @@ where
                mixnet_receiver,
                reply_key_storage,
                reply_controller_sender,
+                packet_statistics_control,
            );
        controller.start_with_shutdown(shutdown)
    }
@@ -506,6 +514,13 @@ 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,
@@ -633,6 +648,9 @@ 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,
@@ -662,6 +680,7 @@ 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
@@ -700,6 +719,7 @@ where
            client_connection_rx,
            shutdown.fork("real_traffic_controller"),
            self.config.debug.traffic.packet_type,
+            packet_stats_reporter.clone(),
        );

        if !self
@@ -714,6 +734,7 @@ where
                self_address,
                shared_topology_accessor.clone(),
                message_sender,
+                packet_stats_reporter,
                shutdown.fork("cover_traffic_stream"),
            );
        }
@@ -2,6 +2,7 @@
 // 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};
@@ -61,6 +62,8 @@ where
    secondary_packet_size: Option<PacketSize>,

    packet_type: PacketType,
+
+    stats_tx: PacketStatisticsReporter,
 }

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

@@ -122,6 +127,7 @@ 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,
        }
    }

@@ -191,6 +197,10 @@ 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%
@@ -7,6 +7,7 @@ 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;
@@ -0,0 +1,498 @@
+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,6 +1,8 @@
 // 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::*;
@@ -17,6 +19,7 @@ pub(super) struct AcknowledgementListener {
    ack_key: Arc<AckKey>,
    ack_receiver: AcknowledgementReceiver,
    action_sender: AckActionSender,
+    stats_tx: PacketStatisticsReporter,
 }

 impl AcknowledgementListener {
@@ -24,16 +27,21 @@ 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)
        {
@@ -48,11 +56,14 @@ 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();
@@ -8,6 +8,7 @@ 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;
@@ -208,6 +209,7 @@ where
        connectors: AcknowledgementControllerConnectors,
        message_handler: MessageHandler<R>,
        reply_controller_sender: ReplyControllerSender,
+        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        let (retransmission_tx, retransmission_rx) = mpsc::unbounded();

@@ -224,6 +226,7 @@ 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,6 +35,8 @@ 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;
@@ -143,6 +145,7 @@ impl RealMessagesController<OsRng> {
        reply_controller_receiver: ReplyControllerReceiver,
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
+        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        let rng = OsRng;

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

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

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

 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;
@@ -113,6 +114,9 @@ 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)]
@@ -171,6 +175,7 @@ where
        topology_access: TopologyAccessor,
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
+        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        OutQueueControl {
            config,
@@ -184,6 +189,7 @@ where
            transmission_buffer: TransmissionBuffer::new(),
            client_connection_rx,
            lane_queue_lengths,
+            stats_tx,
        }
    }

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

-        let (next_message, fragment_id) = match next_message {
+        let (next_message, fragment_id, packet_size) = 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");
@@ -250,15 +256,28 @@ where
                        "Somehow failed to generate a loop cover message with a valid topology",
                    ),
                    None,
+                    cover_traffic_packet_size.size(),
                )
            }
            StreamMessage::Real(real_message) => {
-                (real_message.mix_packet, real_message.fragment_id)
+                let packet_size = real_message.packet_size();
+                (
+                    real_message.mix_packet,
+                    real_message.fragment_id,
+                    packet_size,
+                )
            }
        };

        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
@@ -340,6 +359,28 @@ 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)
    }

@@ -433,6 +474,13 @@ 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");
@@ -471,10 +519,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!("Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), no delay")
+            format!("Packet backlog: {backlog:.2} kiB ({packets}), {lanes} lanes, no delay")
        } else {
            format!(
-                "Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), avg delay: {delay}ms ({mult})"
+                "Packet backlog: {backlog:.2} kiB ({packets}), {lanes} lanes, avg delay: {delay}ms ({mult})"
            )
        };
        if packets > 1000 {
@@ -1,8 +1,10 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::replies::reply_controller::ReplyControllerSender;
-use crate::client::replies::reply_storage::SentReplyKeys;
+use crate::client::{
+    packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter},
+    replies::{reply_controller::ReplyControllerSender, reply_storage::SentReplyKeys},
+};
 use crate::spawn_future;
 use futures::channel::mpsc;
 use futures::lock::Mutex;
@@ -43,15 +45,33 @@ 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]) -> Option<NymMessage> {
+    fn recover_from_fragment(
+        &mut self,
+        fragment_data: &[u8],
+        fragment_data_size: usize,
+    ) -> 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!");
@@ -103,15 +123,17 @@ 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))
+        Ok(self.recover_from_fragment(fragment_data, reply_ciphertext_size))
    }

    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,
@@ -123,7 +145,7 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
            Ok(frag_data) => frag_data,
        };

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

@@ -141,6 +163,7 @@ 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 {
@@ -149,6 +172,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                message_receiver: R::new(),
                message_sender: None,
                recently_reconstructed: HashSet::new(),
+                stats_tx,
            })),
            reply_key_storage,
            reply_controller_sender,
@@ -353,7 +377,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                };

            if let Some(completed) = completed_message {
-                info!("received {completed}");
+                debug!("received {completed}");
                completed_messages.push(completed)
            }
        }
@@ -480,11 +504,13 @@ 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 {
@@ -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::trace!("Fetching list of gateways from: {nym_api}");
+    log::debug!("Fetching list of gateways from: {nym_api}");

    let gateways = client.get_cached_described_gateways().await?;
    log::debug!("Found {} gateways", gateways.len());
@@ -178,7 +178,7 @@ impl<T> From<PersistedGatewayDetails<T>> for GatewayDetails<T> {
    }
 }

-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum GatewaySelectionSpecification<T = EmptyCustomDetails> {
    /// Uniformly choose a random remote gateway.
    UniformRemote { must_use_tls: bool },
@@ -19,7 +19,7 @@ tokio = { version = "1.24.1", features = ["macros"] }

 # internal
 nym-bandwidth-controller = { path = "../../bandwidth-controller" }
-nym-coconut-interface = { path = "../../coconut-interface" }
+nym-credentials = { path = "../../credentials" }
 nym-credential-storage = { path = "../../credential-storage" }
 nym-crypto = { path = "../../crypto" }
 nym-gateway-requests = { path = "../../../gateway/gateway-requests" }
@@ -1,4 +1,4 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::GatewayClientError;
@@ -12,17 +12,20 @@ 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_credential_storage::ephemeral_storage::EphemeralStorage as EphemeralCredentialStorage;
 use nym_credential_storage::storage::Storage as CredentialStorage;
+use nym_credentials::CredentialSpendingData;
 use nym_crypto::asymmetric::identity;
 use nym_gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
 use nym_gateway_requests::iv::IV;
 use nym_gateway_requests::registration::handshake::{client_handshake, SharedKeys};
-use nym_gateway_requests::{BinaryRequest, ClientControlRequest, ServerResponse, PROTOCOL_VERSION};
+use nym_gateway_requests::{
+    BinaryRequest, ClientControlRequest, ServerResponse, CURRENT_PROTOCOL_VERSION,
+};
 use nym_network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_task::TaskClient;
+use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use rand::rngs::OsRng;
 use std::convert::TryFrom;
@@ -79,6 +82,9 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
    /// Delay between each subsequent reconnection attempt.
    reconnection_backoff: Duration,

+    // currently unused (but populated)
+    negotiated_protocol: Option<u8>,
+
    /// Listen to shutdown messages.
    shutdown: TaskClient,
 }
@@ -108,6 +114,7 @@ impl<C, St> GatewayClient<C, St> {
            should_reconnect_on_failure: true,
            reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
            reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
+            negotiated_protocol: None,
            shutdown,
        }
    }
@@ -383,17 +390,17 @@ impl<C, St> GatewayClient<C, St> {
                // note: in +1.2.0 we will have to return a hard error here
                Ok(())
            }
-            Some(v) if v != PROTOCOL_VERSION => {
+            Some(v) if v > CURRENT_PROTOCOL_VERSION => {
                let err = GatewayClientError::IncompatibleProtocol {
                    gateway: Some(v),
-                    current: PROTOCOL_VERSION,
+                    current: CURRENT_PROTOCOL_VERSION,
                };
                error!("{err}");
                Err(err)
            }

            Some(_) => {
-                info!("the gateway is using exactly the same protocol version as we are. We're good to continue!");
+                info!("the gateway is using exactly the same (or older) protocol version as we are. We're good to continue!");
                Ok(())
            }
        }
@@ -439,6 +446,10 @@ impl<C, St> GatewayClient<C, St> {
        if self.authenticated {
            self.shared_key = Some(Arc::new(shared_key));
        }
+
+        // populate the negotiated protocol for future uses
+        self.negotiated_protocol = gateway_protocol;
+
        Ok(())
    }

@@ -515,13 +526,15 @@ impl<C, St> GatewayClient<C, St> {

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

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

-        let (credential, credential_id) = self
+        let prepared_credential = self
            .bandwidth_controller
            .as_ref()
            .unwrap()
-            .prepare_coconut_credential()
+            .prepare_bandwidth_credential()
            .await?;

-        self.claim_coconut_bandwidth(credential).await?;
+        self.claim_coconut_bandwidth(prepared_credential.data, prepared_credential.epoch_id)
+            .await?;
        self.bandwidth_controller
            .as_ref()
            .unwrap()
-            .consume_credential(credential_id)
+            .consume_credential(prepared_credential.credential_id)
            .await?;

        Ok(())
@@ -817,6 +831,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
            should_reconnect_on_failure: false,
            reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
            reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
+            negotiated_protocol: None,
            shutdown,
        }
    }
@@ -848,6 +863,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
            should_reconnect_on_failure: self.should_reconnect_on_failure,
            reconnection_attempts: self.reconnection_attempts,
            reconnection_backoff: self.reconnection_backoff,
+            negotiated_protocol: self.negotiated_protocol,
            shutdown,
        }
    }
@@ -33,7 +33,7 @@ tokio = { workspace = true, features = ["sync", "time"] }
 futures = { workspace = true }
 openssl = { version = "^0.10.55", features = ["vendored"], optional = true }

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

@@ -4,9 +4,9 @@
 use crate::nyxd::contract_traits::{DkgQueryClient, PagedDkgQueryClient};
 use crate::nyxd::error::NyxdError;
 use crate::NymApiClient;
+use nym_coconut::{Base58, CoconutError, VerificationKey};
 use nym_coconut_dkg_common::types::{EpochId, NodeIndex};
 use nym_coconut_dkg_common::verification_key::ContractVKShare;
-use nym_coconut_interface::{Base58, CoconutError, VerificationKey};
 use thiserror::Error;
 use url::Url;

@@ -7,17 +7,18 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
+use nym_coconut_dkg_common::types::ChunkIndex;
 use serde::Deserialize;

 pub use nym_coconut_dkg_common::{
-    dealer::{
-        DealerDetailsResponse, DealingResponse, DealingStatusResponse, PagedDealerResponse,
-        PagedDealingsResponse,
+    dealer::{DealerDetailsResponse, PagedDealerResponse},
+    dealing::{
+        DealerDealingsStatusResponse, DealingChunkResponse, DealingChunkStatusResponse,
+        DealingMetadataResponse, DealingStatusResponse,
    },
    msg::QueryMsg as DkgQueryMsg,
    types::{
-        DealerDetails, DealingIndex, Epoch, EpochId, EpochState, InitialReplacementData,
-        PartialContractDealing, State,
+        DealerDetails, DealingIndex, Epoch, EpochId, EpochState, InitialReplacementData, State,
    },
    verification_key::{ContractVKShare, PagedVKSharesResponse, VkShareResponse},
 };
@@ -77,6 +78,31 @@ pub trait DkgQueryClient {
        self.query_dkg_contract(request).await
    }

+    async fn get_dealings_metadata(
+        &self,
+        epoch_id: EpochId,
+        dealer: String,
+        dealing_index: DealingIndex,
+    ) -> Result<DealingMetadataResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealingsMetadata {
+            epoch_id,
+            dealer,
+            dealing_index,
+        };
+
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_dealer_dealings_status(
+        &self,
+        epoch_id: EpochId,
+        dealer: String,
+    ) -> Result<DealerDealingsStatusResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealerDealingsStatus { epoch_id, dealer };
+
+        self.query_dkg_contract(request).await
+    }
+
    async fn get_dealing_status(
        &self,
        epoch_id: EpochId,
@@ -92,34 +118,37 @@ pub trait DkgQueryClient {
        self.query_dkg_contract(request).await
    }

-    async fn get_dealing(
+    async fn get_dealing_chunk_status(
        &self,
        epoch_id: EpochId,
        dealer: String,
        dealing_index: DealingIndex,
-    ) -> Result<DealingResponse, NyxdError> {
-        let request = DkgQueryMsg::GetDealing {
+        chunk_index: ChunkIndex,
+    ) -> Result<DealingChunkStatusResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealingChunkStatus {
            epoch_id,
            dealer,
            dealing_index,
+            chunk_index,
        };

        self.query_dkg_contract(request).await
    }

-    async fn get_dealer_dealings_paged(
+    async fn get_dealing_chunk(
        &self,
        epoch_id: EpochId,
-        dealer: &str,
-        start_after: Option<DealingIndex>,
-        limit: Option<u32>,
-    ) -> Result<PagedDealingsResponse, NyxdError> {
-        let request = DkgQueryMsg::GetDealings {
+        dealer: String,
+        dealing_index: DealingIndex,
+        chunk_index: ChunkIndex,
+    ) -> Result<DealingChunkResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealingChunk {
            epoch_id,
-            dealer: dealer.to_string(),
-            limit,
-            start_after,
+            dealer,
+            dealing_index,
+            chunk_index,
        };
+
        self.query_dkg_contract(request).await
    }

@@ -165,14 +194,6 @@ pub trait PagedDkgQueryClient: DkgQueryClient {
        collect_paged!(self, get_past_dealers_paged, dealers)
    }

-    async fn get_all_dealer_dealings(
-        &self,
-        epoch_id: EpochId,
-        dealer: &str,
-    ) -> Result<Vec<PartialContractDealing>, NyxdError> {
-        collect_paged!(self, get_dealer_dealings_paged, dealings, epoch_id, dealer)
-    }
-
    async fn get_all_verification_key_shares(
        &self,
        epoch_id: EpochId,
@@ -206,6 +227,7 @@ where
 mod tests {
    use super::*;
    use crate::nyxd::contract_traits::tests::IgnoreValue;
+    use nym_coconut_dkg_common::msg::QueryMsg;

    // it's enough that this compiles and clippy is happy about it
    #[allow(dead_code)]
@@ -236,18 +258,31 @@ mod tests {
            } => client
                .get_dealing_status(epoch_id, dealer, dealing_index)
                .ignore(),
-            DkgQueryMsg::GetDealing {
+            DkgQueryMsg::GetDealingsMetadata {
                epoch_id,
                dealer,
                dealing_index,
-            } => client.get_dealing(epoch_id, dealer, dealing_index).ignore(),
-            DkgQueryMsg::GetDealings {
+            } => client
+                .get_dealings_metadata(epoch_id, dealer, dealing_index)
+                .ignore(),
+            QueryMsg::GetDealerDealingsStatus { epoch_id, dealer } => {
+                client.get_dealer_dealings_status(epoch_id, dealer).ignore()
+            }
+            DkgQueryMsg::GetDealingChunkStatus {
                epoch_id,
                dealer,
-                limit,
-                start_after,
+                dealing_index,
+                chunk_index,
            } => client
-                .get_dealer_dealings_paged(epoch_id, &dealer, limit, start_after)
+                .get_dealing_chunk_status(epoch_id, dealer, dealing_index, chunk_index)
+                .ignore(),
+            DkgQueryMsg::GetDealingChunk {
+                epoch_id,
+                dealer,
+                dealing_index,
+                chunk_index,
+            } => client
+                .get_dealing_chunk(epoch_id, dealer, dealing_index, chunk_index)
                .ignore(),
            DkgQueryMsg::GetVerificationKey { epoch_id, owner } => {
                client.get_vk_share(epoch_id, owner).ignore()
@@ -8,9 +8,9 @@ use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
 use crate::signing::signer::OfflineSigner;
 use async_trait::async_trait;
 use cosmrs::AccountId;
-use cosmwasm_std::Addr;
+use nym_coconut_dkg_common::dealing::{DealingChunkInfo, PartialContractDealing};
 use nym_coconut_dkg_common::msg::ExecuteMsg as DkgExecuteMsg;
-use nym_coconut_dkg_common::types::{EncodedBTEPublicKeyWithProof, PartialContractDealing};
+use nym_coconut_dkg_common::types::{DealingIndex, EncodedBTEPublicKeyWithProof};
 use nym_coconut_dkg_common::verification_key::VerificationKeyShare;
 use nym_contracts_common::IdentityKey;

@@ -65,15 +65,32 @@ pub trait DkgSigningClient {
            .await
    }

-    async fn submit_dealing_bytes(
+    async fn submit_dealing_metadata(
        &self,
-        dealing: PartialContractDealing,
+        dealing_index: DealingIndex,
+        chunks: Vec<DealingChunkInfo>,
        resharing: bool,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NyxdError> {
-        let req = DkgExecuteMsg::CommitDealing { dealing, resharing };
+        let req = DkgExecuteMsg::CommitDealingsMetadata {
+            dealing_index,
+            chunks,
+            resharing,
+        };

-        self.execute_dkg_contract(fee, req, "dealing commitment".to_string(), vec![])
+        self.execute_dkg_contract(fee, req, "dealing metadata commitment".to_string(), vec![])
+            .await
+    }
+
+    async fn submit_dealing_chunk(
+        &self,
+        chunk: PartialContractDealing,
+        resharing: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = DkgExecuteMsg::CommitDealingsChunk { chunk, resharing };
+
+        self.execute_dkg_contract(fee, req, "dealing chunk commitment".to_string(), vec![])
            .await
    }

@@ -100,9 +117,10 @@ pub trait DkgSigningClient {
        resharing: bool,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NyxdError> {
-        // the call to unchecked is fine as we're converting from pre-validated `AccountId`
-        let owner = Addr::unchecked(owner.to_string());
-        let req = DkgExecuteMsg::VerifyVerificationKeyShare { owner, resharing };
+        let req = DkgExecuteMsg::VerifyVerificationKeyShare {
+            owner: owner.to_string(),
+            resharing,
+        };

        self.execute_dkg_contract(
            fee,
@@ -167,18 +185,21 @@ mod tests {
                    None,
                )
                .ignore(),
-            DkgExecuteMsg::CommitDealing { dealing, resharing } => client
-                .submit_dealing_bytes(dealing, resharing, None)
+            DkgExecuteMsg::CommitDealingsMetadata {
+                dealing_index,
+                chunks,
+                resharing,
+            } => client
+                .submit_dealing_metadata(dealing_index, chunks, resharing, None)
                .ignore(),
+            DkgExecuteMsg::CommitDealingsChunk { chunk, resharing } => {
+                client.submit_dealing_chunk(chunk, resharing, None).ignore()
+            }
            DkgExecuteMsg::CommitVerificationKeyShare { share, resharing } => client
                .submit_verification_key_share(share, resharing, None)
                .ignore(),
            DkgExecuteMsg::VerifyVerificationKeyShare { owner, resharing } => client
-                .verify_verification_key_share(
-                    &owner.into_string().parse().unwrap(),
-                    resharing,
-                    None,
-                )
+                .verify_verification_key_share(&owner.parse().unwrap(), resharing, None)
                .ignore(),
            DkgExecuteMsg::SurpassedThreshold {} => client.surpass_threshold(None).ignore(),
            DkgExecuteMsg::AdvanceEpochState {} => client.advance_dkg_epoch_state(None).ignore(),
@@ -140,9 +140,6 @@ pub enum NyxdError {
    #[error("Cosmwasm std error: {0}")]
    CosmwasmStdError(#[from] cosmwasm_std::StdError),

-    #[error("Coconut interface error: {0}")]
-    CoconutInterfaceError(#[from] nym_coconut_interface::error::CoconutInterfaceError),
-
    #[error("Account had an unexpected bech32 prefix. Expected: {expected}, got: {got}")]
    UnexpectedBech32Prefix { got: String, expected: String },
 }
@@ -1,14 +0,0 @@
-[package]
-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"
-getset = "0.1.1"
-serde = { workspace = true, features = ["derive"] }
-thiserror = { workspace = true }
-
-nym-coconut = {path = "../nymcoconut" }
@@ -1,17 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_coconut::CoconutError;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum CoconutInterfaceError {
-    #[error("not enough bytes: {0} received, minimum {1} required")]
-    InvalidByteLength(usize, usize),
-
-    #[error("Could not decode base 58 string - {0}")]
-    MalformedString(#[from] bs58::decode::Error),
-
-    #[error("Coconut error - {0}")]
-    CoconutError(#[from] CoconutError),
-}
@@ -1,196 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod error;
-
-use getset::{CopyGetters, Getters};
-use serde::{Deserialize, Serialize};
-
-use error::CoconutInterfaceError;
-
-// We list these explicity instead of glob export due to shadowing warnings with the pub tests
-// module.
-pub use nym_coconut::{
-    aggregate_signature_shares, aggregate_verification_keys, blind_sign, hash_to_scalar,
-    prepare_blind_sign, prove_bandwidth_credential, Attribute, Base58, BlindSignRequest,
-    BlindedSignature, Bytable, CoconutError, KeyPair, Parameters, PrivateAttribute,
-    PublicAttribute, SecretKey, Signature, SignatureShare, Theta, VerificationKey,
-};
-
-#[derive(Debug, Serialize, Deserialize, Getters, CopyGetters, Clone, PartialEq, Eq)]
-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,
-}
-impl Credential {
-    pub fn new(
-        n_params: u32,
-        theta: Theta,
-        voucher_value: u64,
-        voucher_info: String,
-        epoch_id: u64,
-    ) -> Credential {
-        Credential {
-            n_params,
-            theta,
-            voucher_value,
-            voucher_info,
-            epoch_id,
-        }
-    }
-
-    pub fn blinded_serial_number(&self) -> String {
-        self.theta.blinded_serial_number_bs58()
-    }
-
-    pub fn has_blinded_serial_number(
-        &self,
-        blinded_serial_number_bs58: &str,
-    ) -> Result<bool, CoconutInterfaceError> {
-        Ok(self
-            .theta
-            .has_blinded_serial_number(blinded_serial_number_bs58)?)
-    }
-
-    pub fn voucher_value(&self) -> u64 {
-        self.voucher_value
-    }
-
-    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)
-    }
-
-    pub fn as_bytes(&self) -> Vec<u8> {
-        let n_params_bytes = self.n_params.to_be_bytes();
-        let theta_bytes = self.theta.to_bytes();
-        let theta_bytes_len = theta_bytes.len();
-        let voucher_value_bytes = self.voucher_value.to_be_bytes();
-        let epoch_id_bytes = self.epoch_id.to_be_bytes();
-        let voucher_info_bytes = self.voucher_info.as_bytes();
-        let voucher_info_len = voucher_info_bytes.len();
-
-        let mut bytes = Vec::with_capacity(28 + theta_bytes_len + voucher_info_len);
-        bytes.extend_from_slice(&n_params_bytes);
-        bytes.extend_from_slice(&(theta_bytes_len as u64).to_be_bytes());
-        bytes.extend_from_slice(&theta_bytes);
-        bytes.extend_from_slice(&voucher_value_bytes);
-        bytes.extend_from_slice(&epoch_id_bytes);
-        bytes.extend_from_slice(voucher_info_bytes);
-
-        bytes
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<Self, CoconutError> {
-        if bytes.len() < 28 {
-            return Err(CoconutError::Deserialization(String::from(
-                "To few bytes in credential",
-            )));
-        }
-        let mut four_byte = [0u8; 4];
-        let mut eight_byte = [0u8; 8];
-
-        four_byte.copy_from_slice(&bytes[..4]);
-        let n_params = u32::from_be_bytes(four_byte);
-        eight_byte.copy_from_slice(&bytes[4..12]);
-        let theta_len = u64::from_be_bytes(eight_byte);
-        if bytes.len() < 28 + theta_len as usize {
-            return Err(CoconutError::Deserialization(String::from(
-                "To few bytes in credential",
-            )));
-        }
-        let theta = Theta::from_bytes(&bytes[12..12 + theta_len as usize])
-            .map_err(|e| CoconutError::Deserialization(e.to_string()))?;
-        eight_byte.copy_from_slice(&bytes[12 + theta_len as usize..20 + theta_len as usize]);
-        let voucher_value = u64::from_be_bytes(eight_byte);
-        eight_byte.copy_from_slice(&bytes[20 + theta_len as usize..28 + theta_len as usize]);
-        let epoch_id = u64::from_be_bytes(eight_byte);
-        let voucher_info = String::from_utf8(bytes[28 + theta_len as usize..].to_vec())
-            .map_err(|e| CoconutError::Deserialization(e.to_string()))?;
-
-        Ok(Credential {
-            n_params,
-            theta,
-            voucher_value,
-            voucher_info,
-            epoch_id,
-        })
-    }
-}
-
-impl Bytable for Credential {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.as_bytes()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self, CoconutError> {
-        Credential::from_bytes(slice)
-    }
-}
-
-impl Base58 for Credential {}
-
-#[cfg(test)]
-mod tests {
-    use nym_coconut::{prove_bandwidth_credential, Signature};
-
-    use super::*;
-
-    #[test]
-    fn serde_coconut_credential() {
-        let voucher_value = 1000000u64;
-        let voucher_info = String::from("BandwidthVoucher");
-        let serial_number =
-            Attribute::try_from_bs58("7Rp3imcuNX3w9se9wm5th8gSvc2czsnMrGsdt5HsrycA").unwrap();
-        let binding_number =
-            Attribute::try_from_bs58("Auf8yVEgyEAWNHaXUZmimS4n9g5YiYnNYqp6F9BtBe9E").unwrap();
-        let signature = Signature::try_from_bs58(
-            "ta3pM9ffj5T6YGbwjSBp2W118rcwyP9PXStc\
-        7ssb91g5GQYMQHhuTNajbdZcjxUFBFL5rhED8EHpRzE8r432ss3qbPBfpNev4CdkfMkQ3wepyM7hy7q1W6Rn9WmFoZL\
-        ZR9j",
-        )
-        .unwrap();
-        let params = Parameters::new(4).unwrap();
-        let verification_key = VerificationKey::try_from_bs58("8CFtVVXdwLy4WHMQPE4\
-        woe89q3DRHoNxBSchftrEjSBPWA4r4xZv4Y9qSvS5x5bMmFtp7BX6ikECAnuXr5EjXWSsgjirZJmpS5XDUynVfht1cD\
-        FWGDvy2XFrRCuoCMotNXi3PoF6wYqdTR9Rqcfoj3i2H5Nid422WBaLtVoC9QNobvpvaqq6vX5PbsSyPayvU8HCXFxM6\
-        JjScYpbRTxQtdwefWLrk3LmXyJQBWi7c2VAhSxu9msp7VTBycqdwQNgxHETStZuwXsozxaGQ2KssVUCaaoYPR4g2RqK\
-        UAvtWwA7pMiAQNcbkXcbsjCgVjWaCpMWC37XA31cLcFf3zbjHD9e5tXjAcqa4M89fbFhuvvSXxowSAZ5NoWrN32kd5d\
-        wxJm1JW3Tt2h6yDDBe84oMy71462dZn7N78DVk2mFNGwBCibrZWA7oUzRBMfYxiQrksoFcou7QfLLd58zoNYmPQPt84\
-        1VpQopEBfdQ7Nf9zoXxBt3zMy7g5NsFGvzh7KTbDUyeeXrdkKJPQBs6dqaizr9sS8CPPmR4uk96vDTRh8CJ5FbSsmb8\
-        nP71dRvvwRZJHGzwYirMo6SXS3ZYxFuiA3mkxYuqDHCwkTWDuRCcAaztrDYRZg7VCMo4Q446AaEso5eqpeWpHZQt53E\
-        ZRpqmNYKASGwMhTeEHPSLgSmtoAAUcaRWpGRzYfd6kzEma8tdGLwyP4rLXgvSvtDLP37dU7YgF3LEXbGAz57U9ATy46\
-        6sroLpHPdaCWB8RF11wvB6Tu196JnJd2KyQBP1iUWP3rtZs3GhAF1QVcxquh8BqDZzAcpQ6wCS1P9c5GxKgww77FVF5\
-        Kp83XtoxSrw3GaYVyKTGxNh3vcKPR31txCjTxPaN2fg7TaPLhoQJX4YaAroFSXqrqbbRsisuHhhCeUP2YwDjHedes9y")
-            .unwrap();
-        let theta = prove_bandwidth_credential(
-            &params,
-            &verification_key,
-            &signature,
-            &serial_number,
-            &binding_number,
-        )
-        .unwrap();
-        let credential = Credential::new(4, theta, voucher_value, voucher_info, 42);
-
-        let serialized_credential = credential.as_bytes();
-        let deserialized_credential = Credential::from_bytes(&serialized_credential).unwrap();
-
-        assert_eq!(credential, deserialized_credential);
-    }
-}
@@ -13,9 +13,11 @@ bs58 = "0.4"
 comfy-table = "6.0.0"
 cfg-if = "1.0.0"
 clap = { workspace = true, features = ["derive"] }
+csv = "1.3.0"
 cw-utils = { workspace = true }
 handlebars = "3.0.1"
 humantime-serde = "1.0"
+inquire = "0.6.2"
 k256 = { workspace = true, features = ["ecdsa", "sha256"] }
 log = { workspace = true }
 rand = {version = "0.6", features = ["std"] }
@@ -0,0 +1,4 @@
+n1q85lscptz860j3dx92f8phaeaw08j2l5dt7adq,50,nym
+n136ckky0n39eskewg04xhvahq9yp9f7sgtnxytt,50,unym
+n1xh7ru0zp67czxhvx0r5e8ur7rvg6n3ymmje0ju,50,nyx
+n13mpm4aj03alffnvz2x9ynjy4u3cxemxn2xw34w,50,unyx
@@ -1,4 +1,4 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 use clap::{Args, Subcommand};
@@ -7,6 +7,7 @@ pub mod balance;
 pub mod create;
 pub mod pubkey;
 pub mod send;
+pub mod send_multiple;

 #[derive(Debug, Args)]
 #[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
@@ -25,4 +26,6 @@ pub enum AccountCommands {
    PubKey(crate::validator::account::pubkey::Args),
    /// Sends tokens to another account
    Send(crate::validator::account::send::Args),
+    /// Batch multiple token sends
+    SendMultiple(crate::validator::account::send_multiple::Args),
 }
@@ -0,0 +1,216 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use crate::utils::pretty_coin;
+use clap::Parser;
+use comfy_table::Table;
+use cosmrs::rpc::endpoint::tx::Response;
+use log::{error, info};
+use nym_validator_client::nyxd::{AccountId, Coin};
+use serde_json::json;
+use std::str::FromStr;
+use std::{fs, io::Write};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub memo: Option<String>,
+
+    #[clap(
+        long,
+        help = "Input file path (CSV format) with account/amount pairs to send"
+    )]
+    pub input: String,
+
+    #[clap(
+        long,
+        help = "An output file path (CSV format) to create or append a log of results to"
+    )]
+    pub output: Option<String>,
+}
+
+pub async fn send_multiple(args: Args, client: &SigningClient) {
+    let memo = args
+        .memo
+        .unwrap_or_else(|| "Sending tokens with nym-cli".to_owned());
+
+    let rows = InputFileReader::new(&args.input);
+    if let Err(e) = rows {
+        error!("Failed to read input file: {}", e);
+        return;
+    }
+    let rows = rows.unwrap();
+
+    let mut table = Table::new();
+
+    if rows.rows.is_empty() {
+        error!("No transactions to send");
+        return;
+    }
+
+    println!(
+        "The following transfer will be made from account {} to:",
+        client.address()
+    );
+    table.set_header(vec!["Address", "Amount"]);
+
+    for row in rows.rows.iter() {
+        table.add_row(vec![row.address.to_string(), pretty_coin(&row.amount)]);
+    }
+
+    println!("{table}");
+
+    let ans = inquire::Confirm::new("Do you want to continue with the transfers?")
+        .with_default(false)
+        .with_help_message("You must confirm before the transaction will be sent")
+        .prompt();
+
+    if let Err(e) = ans {
+        info!("Aborting, {}...", e);
+        return;
+    }
+    if let Ok(false) = ans {
+        info!("Aborting!");
+        return;
+    }
+
+    info!("Transferring from {}...", client.address());
+
+    let multiple_sends: Vec<(AccountId, Vec<Coin>)> = rows
+        .rows
+        .iter()
+        .map(|row| (row.address.clone(), vec![row.amount.clone()]))
+        .collect();
+
+    let res = client
+        .send_multiple(multiple_sends, memo, None)
+        .await
+        .expect("failed to send tokens!");
+
+    info!("Sending result: {}", json!(res));
+
+    println!();
+    println!(
+        "Nodesguru: https://nym.explorers.guru/transaction/{}",
+        &res.hash
+    );
+    println!("Mintscan: https://www.mintscan.io/nyx/txs/{}", &res.hash);
+    println!("Transaction result code: {}", &res.tx_result.code.value());
+    println!("Transaction hash: {}", &res.hash);
+
+    if let Some(output_filename) = args.output {
+        println!("\nWriting output log to {}", output_filename);
+
+        if let Err(e) = write_output_file(rows, res, &output_filename) {
+            error!(
+                "Failed to write output file {} with error {}",
+                output_filename, e
+            );
+        }
+    }
+}
+
+fn write_output_file(
+    rows: InputFileReader,
+    res: Response,
+    output_filename: &String,
+) -> Result<(), anyhow::Error> {
+    let mut file = fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(output_filename)?;
+
+    let now = time::OffsetDateTime::now_utc();
+    let now = now.format(&time::format_description::well_known::Rfc3339)?;
+
+    let data = rows
+        .rows
+        .iter()
+        .map(|row| {
+            format!(
+                "{},{},{},{},{}",
+                row.address, row.amount.amount, row.amount.denom, now, res.hash
+            )
+        })
+        .collect::<Vec<String>>()
+        .join("\n");
+
+    Ok(file.write_all(format!("{}\n", data).as_bytes())?)
+}
+
+#[derive(Debug)]
+pub struct InputFileRow {
+    pub address: AccountId,
+    pub amount: Coin,
+}
+
+pub struct InputFileReader {
+    pub rows: Vec<InputFileRow>,
+}
+
+impl InputFileReader {
+    pub fn new(path: &str) -> Result<InputFileReader, anyhow::Error> {
+        let mut rows: Vec<InputFileRow> = vec![];
+        let file_contents = fs::read_to_string(path)?;
+
+        let lines: Vec<String> = file_contents.lines().map(String::from).collect();
+        for line in lines {
+            let tokens: Vec<_> = line.split(',').collect();
+            if tokens.len() < 3 {
+                return Err(anyhow::anyhow!(
+                    "'{}' does not have enough columns, expecting <address>,<amount>,<denom>",
+                    line
+                ));
+            }
+            // try parse amount to u128
+            let amount = u128::from_str(tokens[1])
+                .map_err(|_| anyhow::anyhow!("'{}' has an invalid amount", line))?;
+
+            let denom: String = tokens[2].into();
+
+            // multiply when a whole token amount, e.g. 50nym (50.123456nym is not allowed, that must be input as 50123456unym)
+            let (amount, denom) = if !denom.starts_with('u') {
+                (amount * 1_000_000u128, format!("u{}", denom))
+            } else {
+                (amount, denom)
+            };
+
+            let address = AccountId::from_str(tokens[0])
+                .map_err(|e| anyhow::anyhow!("'{}' has an invalid address: {}", line, e))?;
+
+            let amount = Coin { amount, denom };
+
+            rows.push(InputFileRow { address, amount })
+        }
+
+        Ok(InputFileReader { rows })
+    }
+}
+
+#[cfg(test)]
+mod test_multiple_send_input_csv {
+    use super::*;
+    use nym_validator_client::nyxd::AccountId;
+    use std::str::FromStr;
+    #[test]
+    fn works_on_happy_path() {
+        let input_csv = InputFileReader::new("fixtures/test_send_multiple.csv").unwrap();
+        assert_eq!(
+            AccountId::from_str("n1q85lscptz860j3dx92f8phaeaw08j2l5dt7adq").unwrap(),
+            input_csv.rows[0].address
+        );
+
+        println!("{:?}", input_csv.rows);
+
+        assert_eq!(50_000_000u128, input_csv.rows[0].amount.amount);
+        assert_eq!(50u128, input_csv.rows[1].amount.amount);
+        assert_eq!(50_000_000u128, input_csv.rows[2].amount.amount);
+        assert_eq!(50u128, input_csv.rows[3].amount.amount);
+
+        assert_eq!("unym", input_csv.rows[0].amount.denom);
+        assert_eq!("unym", input_csv.rows[1].amount.denom);
+        assert_eq!("unyx", input_csv.rows[2].amount.denom);
+        assert_eq!("unyx", input_csv.rows[3].amount.denom);
+    }
+}
@@ -3,10 +3,11 @@

 use clap::Parser;
 use log::{debug, info};
+use nym_coconut_dkg_common::dealing::DEFAULT_DEALINGS;
 use std::str::FromStr;

 use nym_coconut_dkg_common::msg::InstantiateMsg;
-use nym_coconut_dkg_common::types::{TimeConfiguration, DEFAULT_DEALINGS};
+use nym_coconut_dkg_common::types::TimeConfiguration;
 use nym_validator_client::nyxd::AccountId;

 #[derive(Debug, Parser)]
@@ -1,10 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::types::{
-    ContractDealing, DealingIndex, EncodedBTEPublicKeyWithProof, EpochId, NodeIndex,
-    PartialContractDealing,
-};
+use crate::types::{EncodedBTEPublicKeyWithProof, NodeIndex};
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::Addr;

@@ -68,53 +65,3 @@ impl PagedDealerResponse {
        }
    }
 }
-
-#[cw_serde]
-pub struct DealingResponse {
-    pub epoch_id: EpochId,
-
-    pub dealer: Addr,
-
-    pub dealing_index: DealingIndex,
-
-    pub dealing: Option<ContractDealing>,
-}
-
-#[cw_serde]
-pub struct DealingStatusResponse {
-    pub epoch_id: EpochId,
-
-    pub dealer: Addr,
-
-    pub dealing_index: DealingIndex,
-
-    pub dealing_submitted: bool,
-}
-
-#[cw_serde]
-pub struct PagedDealingsResponse {
-    pub epoch_id: EpochId,
-
-    pub dealer: Addr,
-
-    pub dealings: Vec<PartialContractDealing>,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<DealingIndex>,
-}
-
-impl PagedDealingsResponse {
-    pub fn new(
-        epoch_id: EpochId,
-        dealer: Addr,
-        dealings: Vec<PartialContractDealing>,
-        start_next_after: Option<DealingIndex>,
-    ) -> Self {
-        PagedDealingsResponse {
-            epoch_id,
-            dealer,
-            dealings,
-            start_next_after,
-        }
-    }
-}
@@ -0,0 +1,290 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::types::{ChunkIndex, DealingIndex, EpochId, PartialContractDealingData};
+use contracts_common::dealings::ContractSafeBytes;
+use cosmwasm_schema::cw_serde;
+use cosmwasm_std::Addr;
+use std::collections::{BTreeMap, HashMap};
+
+/// Defines the maximum size of a dealing chunk. Currently set to 2kB
+pub const MAX_DEALING_CHUNK_SIZE: usize = 2048;
+
+/// Defines the maximum size of a full dealing.
+/// Currently set to 100kB (which is enough for a dealing created for 100 parties)
+pub const MAX_DEALING_SIZE: usize = 102400;
+
+pub const MAX_DEALING_CHUNKS: usize = MAX_DEALING_SIZE / MAX_DEALING_CHUNK_SIZE;
+
+// 2 public attributes, 2 private attributes, 1 fixed for coconut credential
+pub const DEFAULT_DEALINGS: usize = 2 + 2 + 1;
+
+pub fn chunk_dealing(
+    dealing_index: DealingIndex,
+    dealing_bytes: Vec<u8>,
+    chunk_size: usize,
+) -> HashMap<ChunkIndex, PartialContractDealing> {
+    let mut chunks = HashMap::new();
+    for (chunk_index, chunk) in dealing_bytes.chunks(chunk_size).enumerate() {
+        let chunk = PartialContractDealing {
+            dealing_index,
+            chunk_index: chunk_index as ChunkIndex,
+            data: ContractSafeBytes(chunk.to_vec()),
+        };
+        chunks.insert(chunk_index as ChunkIndex, chunk);
+    }
+
+    chunks
+}
+
+#[cw_serde]
+#[derive(Copy)]
+pub struct DealingChunkInfo {
+    pub size: u64,
+}
+
+impl DealingChunkInfo {
+    pub fn new(size: usize) -> Self {
+        DealingChunkInfo { size: size as u64 }
+    }
+
+    pub fn construct(dealing_len: usize, chunk_size: usize) -> Vec<Self> {
+        let (full_chunks, overflow) = (dealing_len / chunk_size, dealing_len % chunk_size);
+
+        let mut chunks = Vec::new();
+        for _ in 0..full_chunks {
+            chunks.push(DealingChunkInfo::new(chunk_size));
+        }
+
+        if overflow != 0 {
+            chunks.push(DealingChunkInfo::new(overflow));
+        }
+
+        chunks
+    }
+}
+
+#[cw_serde]
+#[derive(Copy)]
+pub struct SubmittedChunk {
+    pub info: DealingChunkInfo,
+
+    pub status: ChunkSubmissionStatus,
+}
+
+#[cw_serde]
+#[derive(Default, Copy)]
+pub struct ChunkSubmissionStatus {
+    // this field is updated by the contract itself to indicate when this particular chunk has been received
+    pub submission_height: Option<u64>,
+}
+
+impl ChunkSubmissionStatus {
+    pub fn submitted(&self) -> bool {
+        self.submission_height.is_some()
+    }
+}
+
+impl From<DealingChunkInfo> for SubmittedChunk {
+    fn from(value: DealingChunkInfo) -> Self {
+        SubmittedChunk::new(value)
+    }
+}
+
+impl SubmittedChunk {
+    pub fn new(info: DealingChunkInfo) -> Self {
+        SubmittedChunk {
+            info,
+            status: Default::default(),
+        }
+    }
+
+    pub fn submitted(&self) -> bool {
+        self.status.submitted()
+    }
+}
+
+#[cw_serde]
+pub struct DealingMetadata {
+    pub dealing_index: DealingIndex,
+
+    pub submitted_chunks: BTreeMap<ChunkIndex, SubmittedChunk>,
+}
+
+impl DealingMetadata {
+    pub fn new(dealing_index: DealingIndex, chunks: Vec<DealingChunkInfo>) -> Self {
+        DealingMetadata {
+            dealing_index,
+            submitted_chunks: chunks
+                .into_iter()
+                .enumerate()
+                .map(|(id, chunk)| (id as ChunkIndex, chunk.into()))
+                .collect(),
+        }
+    }
+
+    pub fn is_complete(&self) -> bool {
+        self.submitted_chunks.values().all(|c| c.submitted())
+    }
+
+    pub fn total_size(&self) -> usize {
+        self.submitted_chunks
+            .values()
+            .map(|c| c.info.size as usize)
+            .sum()
+    }
+
+    pub fn submission_statuses(&self) -> BTreeMap<ChunkIndex, ChunkSubmissionStatus> {
+        self.submitted_chunks
+            .iter()
+            .map(|(id, c)| (*id, c.status))
+            .collect()
+    }
+}
+
+#[cw_serde]
+pub struct PartialContractDealing {
+    pub dealing_index: DealingIndex,
+    pub chunk_index: ChunkIndex,
+    pub data: PartialContractDealingData,
+}
+
+impl PartialContractDealing {
+    pub fn new(
+        dealing_index: DealingIndex,
+        chunk_index: ChunkIndex,
+        data: PartialContractDealingData,
+    ) -> Self {
+        PartialContractDealing {
+            dealing_index,
+            chunk_index,
+            data,
+        }
+    }
+}
+
+#[cw_serde]
+pub struct DealingMetadataResponse {
+    pub epoch_id: EpochId,
+
+    pub dealer: Addr,
+
+    pub dealing_index: DealingIndex,
+
+    pub metadata: Option<DealingMetadata>,
+}
+
+#[cw_serde]
+pub struct DealingChunkResponse {
+    pub epoch_id: EpochId,
+
+    pub dealer: Addr,
+
+    pub dealing_index: DealingIndex,
+
+    pub chunk_index: ChunkIndex,
+
+    pub chunk: Option<PartialContractDealingData>,
+}
+
+#[cw_serde]
+pub struct DealingChunkStatusResponse {
+    pub epoch_id: EpochId,
+
+    pub dealer: Addr,
+
+    pub dealing_index: DealingIndex,
+
+    pub chunk_index: ChunkIndex,
+
+    pub status: ChunkSubmissionStatus,
+}
+
+#[cw_serde]
+pub struct DealingStatusResponse {
+    pub epoch_id: EpochId,
+
+    pub dealer: Addr,
+
+    pub dealing_index: DealingIndex,
+
+    pub status: DealingStatus,
+}
+
+#[cw_serde]
+pub struct DealingStatus {
+    pub has_metadata: bool,
+
+    pub fully_submitted: bool,
+
+    pub chunk_submission_status: BTreeMap<ChunkIndex, ChunkSubmissionStatus>,
+}
+
+impl From<Option<DealingMetadata>> for DealingStatus {
+    fn from(metadata: Option<DealingMetadata>) -> Self {
+        DealingStatus {
+            has_metadata: metadata.is_some(),
+            fully_submitted: metadata
+                .as_ref()
+                .map(|m| m.is_complete())
+                .unwrap_or_default(),
+            chunk_submission_status: metadata
+                .map(|m| m.submission_statuses())
+                .unwrap_or_default(),
+        }
+    }
+}
+
+#[cw_serde]
+pub struct DealerDealingsStatusResponse {
+    pub epoch_id: EpochId,
+
+    pub dealer: Addr,
+
+    pub all_dealings_fully_submitted: bool,
+
+    pub dealing_submission_status: BTreeMap<DealingIndex, DealingStatus>,
+}
+
+impl DealerDealingsStatusResponse {
+    pub fn full_dealings(&self) -> usize {
+        self.dealing_submission_status
+            .values()
+            .filter(|s| s.fully_submitted)
+            .count()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn chunking_dealings() {
+        const CHUNK_SIZE: usize = 512;
+
+        let test_cases = [
+            (CHUNK_SIZE - 10, CHUNK_SIZE, 1),
+            (CHUNK_SIZE, CHUNK_SIZE, 1),
+            (CHUNK_SIZE + 10, CHUNK_SIZE, 2),
+            (CHUNK_SIZE * 2, CHUNK_SIZE, 2),
+            (CHUNK_SIZE * 2 + 1, CHUNK_SIZE, 3),
+            (CHUNK_SIZE * 10 + 42, CHUNK_SIZE, 11),
+        ];
+
+        for (dealing_len, chunk_size, expected_chunks) in test_cases {
+            let chunks = DealingChunkInfo::construct(dealing_len, chunk_size);
+            assert_eq!(expected_chunks, chunks.len());
+            assert_eq!(
+                dealing_len as u64,
+                chunks.iter().map(|c| c.size).sum::<u64>()
+            );
+
+            let mut expected_last = dealing_len % chunk_size;
+            if expected_last == 0 {
+                expected_last = chunk_size;
+            }
+            assert_eq!(chunks.last().unwrap().size, expected_last as u64);
+        }
+    }
+}
@@ -1,4 +1,8 @@
+// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
 pub mod dealer;
+pub mod dealing;
 pub mod event_attributes;
 pub mod msg;
 pub mod types;
@@ -1,23 +1,24 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::dealing::{DealingChunkInfo, PartialContractDealing};
 use crate::types::{
-    DealingIndex, EncodedBTEPublicKeyWithProof, EpochId, PartialContractDealing, TimeConfiguration,
+    ChunkIndex, DealingIndex, EncodedBTEPublicKeyWithProof, EpochId, TimeConfiguration,
 };
 use crate::verification_key::VerificationKeyShare;
+use contracts_common::IdentityKey;
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Addr;

 #[cfg(feature = "schema")]
 use crate::{
-    dealer::{
-        DealerDetailsResponse, DealingResponse, DealingStatusResponse, PagedDealerResponse,
-        PagedDealingsResponse,
+    dealer::{DealerDetailsResponse, PagedDealerResponse},
+    dealing::{
+        DealerDealingsStatusResponse, DealingChunkResponse, DealingChunkStatusResponse,
+        DealingMetadataResponse, DealingStatusResponse,
    },
    types::{Epoch, InitialReplacementData, State},
    verification_key::{PagedVKSharesResponse, VkShareResponse},
 };
-use contracts_common::IdentityKey;
 #[cfg(feature = "schema")]
 use cosmwasm_schema::QueryResponses;

@@ -44,8 +45,14 @@ pub enum ExecuteMsg {
        resharing: bool,
    },

-    CommitDealing {
-        dealing: PartialContractDealing,
+    CommitDealingsMetadata {
+        dealing_index: DealingIndex,
+        chunks: Vec<DealingChunkInfo>,
+        resharing: bool,
+    },
+
+    CommitDealingsChunk {
+        chunk: PartialContractDealing,
        resharing: bool,
    },

@@ -55,8 +62,7 @@ pub enum ExecuteMsg {
    },

    VerifyVerificationKeyShare {
-        // TODO: this should be using a String...
-        owner: Addr,
+        owner: String,
        resharing: bool,
    },

@@ -95,6 +101,16 @@ pub enum QueryMsg {
        start_after: Option<String>,
    },

+    #[cfg_attr(feature = "schema", returns(DealingMetadataResponse))]
+    GetDealingsMetadata {
+        epoch_id: EpochId,
+        dealer: String,
+        dealing_index: DealingIndex,
+    },
+
+    #[cfg_attr(feature = "schema", returns(DealerDealingsStatusResponse))]
+    GetDealerDealingsStatus { epoch_id: EpochId, dealer: String },
+
    #[cfg_attr(feature = "schema", returns(DealingStatusResponse))]
    GetDealingStatus {
        epoch_id: EpochId,
@@ -102,19 +118,20 @@ pub enum QueryMsg {
        dealing_index: DealingIndex,
    },

-    #[cfg_attr(feature = "schema", returns(DealingResponse))]
-    GetDealing {
+    #[cfg_attr(feature = "schema", returns(DealingChunkStatusResponse))]
+    GetDealingChunkStatus {
        epoch_id: EpochId,
        dealer: String,
        dealing_index: DealingIndex,
+        chunk_index: ChunkIndex,
    },

-    #[cfg_attr(feature = "schema", returns(PagedDealingsResponse))]
-    GetDealings {
+    #[cfg_attr(feature = "schema", returns(DealingChunkResponse))]
+    GetDealingChunk {
        epoch_id: EpochId,
        dealer: String,
-        limit: Option<u32>,
-        start_after: Option<DealingIndex>,
+        dealing_index: DealingIndex,
+        chunk_index: ChunkIndex,
    },

    #[cfg_attr(feature = "schema", returns(VkShareResponse))]
@@ -15,31 +15,11 @@ pub type EncodedBTEPublicKeyWithProofRef<'a> = &'a str;
 pub type NodeIndex = u64;
 pub type EpochId = u64;
 pub type DealingIndex = u32;
-pub type ContractDealing = ContractSafeBytes;
-
-// 2 public attributes, 2 private attributes, 1 fixed for coconut credential
-pub const DEFAULT_DEALINGS: usize = 2 + 2 + 1;
-
-#[cw_serde]
-pub struct PartialContractDealing {
-    pub index: DealingIndex,
-    pub data: ContractDealing,
-}
-
-impl PartialContractDealing {
-    pub fn new(index: DealingIndex, data: ContractDealing) -> Self {
-        PartialContractDealing { index, data }
-    }
-}
-
-impl From<(DealingIndex, ContractDealing)> for PartialContractDealing {
-    fn from(value: (DealingIndex, ContractDealing)) -> Self {
-        PartialContractDealing {
-            index: value.0,
-            data: value.1,
-        }
-    }
-}
+// we really don't need to hold more data than that (even u8 would have been enough),
+// but explicitly make it different type than `DealingIndex` so type system would detect any
+// accidental misuses
+pub type ChunkIndex = u16;
+pub type PartialContractDealingData = ContractSafeBytes;

 #[cw_serde]
 pub struct InitialReplacementData {
@@ -272,4 +252,8 @@ impl EpochState {
    pub fn is_final(&self) -> bool {
        *self == EpochState::InProgress
    }
+
+    pub fn is_in_progress(&self) -> bool {
+        matches!(self, EpochState::InProgress)
+    }
 }
@@ -43,7 +43,10 @@ pub fn to_cosmos_msg(
    multisig_addr: String,
    expiration_time: Timestamp,
 ) -> StdResult<CosmosMsg> {
-    let verify_vk_share_req = ExecuteMsg::VerifyVerificationKeyShare { owner, resharing };
+    let verify_vk_share_req = ExecuteMsg::VerifyVerificationKeyShare {
+        owner: owner.to_string(),
+        resharing,
+    };
    let verify_vk_share_msg = CosmosMsg::Wasm(WasmMsg::Execute {
        contract_addr: coconut_dkg_addr,
        msg: to_binary(&verify_vk_share_req)?,
@@ -67,7 +70,7 @@ pub fn to_cosmos_msg(
 // DKG SAFETY:
 // each legit verification proposal will only contain a single execute msg,
 // if they have more than one, we can safely ignore it
-pub fn owner_from_cosmos_msgs(msgs: &[CosmosMsg]) -> Option<Addr> {
+pub fn owner_from_cosmos_msgs(msgs: &[CosmosMsg]) -> Option<String> {
    if msgs.len() != 1 {
        return None;
    }
@@ -1,17 +1,17 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 use schemars::JsonSchema;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::{Display, Formatter};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};

 // some sane upper-bound size on byte sizes
 // currently set to 128 bytes
 pub const MAX_DISPLAY_SIZE: usize = 128;

-// TODO: if we are to use this for different types, it might make sense to introduce something like
-// CommitmentTypeId field on the below for distinguishing different ones. it would somehow become part of the trait
+// helps to transfer bytes between contract boundary to decrease amount of data sent accross
+// after it's put to `Binary`
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, JsonSchema)]
 pub struct ContractSafeBytes(pub Vec<u8>);

@@ -23,12 +23,24 @@ impl Deref for ContractSafeBytes {
    }
 }

+impl DerefMut for ContractSafeBytes {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 impl From<Vec<u8>> for ContractSafeBytes {
    fn from(value: Vec<u8>) -> Self {
        ContractSafeBytes(value)
    }
 }

+impl<'a> From<&'a [u8]> for ContractSafeBytes {
+    fn from(value: &'a [u8]) -> Self {
+        value.to_vec().into()
+    }
+}
+
 impl Display for ContractSafeBytes {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if !self.0.is_empty() {
@@ -11,7 +11,9 @@ async-trait = { workspace = true }

 log = { workspace = true }
 thiserror = { workspace = true }
-tokio = { version = "1.24.1", features = ["sync"]}
+tokio = { workspace = true, features = ["sync"]}
+zeroize = { workspace = true, features = ["zeroize_derive"] }
+

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
 workspace = true
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+DROP TABLE coconut_credentials;
+CREATE TABLE coconut_credentials
+(
+    id                     INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+
+--     introduce a way for us to introduce breaking changes in serialization
+    serialization_revision INTEGER NOT NULL,
+    credential_type        TEXT    NOT NULL,
+    credential_data        BLOB    NOT NULL,
+    epoch_id               INTEGER NOT NULL,
+    consumed               BOOLEAN NOT NULL
+);
@@ -1,59 +1,60 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2023-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::models::CoconutCredential;
+use crate::models::StoredIssuedCredential;
 use std::sync::Arc;
 use tokio::sync::RwLock;

 #[derive(Clone)]
 pub struct CoconutCredentialManager {
-    inner: Arc<RwLock<Vec<CoconutCredential>>>,
+    inner: Arc<RwLock<CoconutCredentialManagerInner>>,
+}
+
+#[derive(Default)]
+struct CoconutCredentialManagerInner {
+    data: Vec<StoredIssuedCredential>,
+    _next_id: i64,
+}
+
+impl CoconutCredentialManagerInner {
+    fn next_id(&mut self) -> i64 {
+        let next = self._next_id;
+        self._next_id += 1;
+        next
+    }
 }

 impl CoconutCredentialManager {
    /// Creates new empty instance of the `CoconutCredentialManager`.
    pub fn new() -> Self {
        CoconutCredentialManager {
-            inner: Arc::new(RwLock::new(Vec::new())),
+            inner: Default::default(),
        }
    }

-    /// Inserts provided signature into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `voucher_value`: Plaintext bandwidth value of the credential.
-    /// * `voucher_info`: Plaintext information of the credential.
-    /// * `serial_number`: Base58 representation of the serial number attribute.
-    /// * `binding_number`: Base58 representation of the binding number attribute.
-    /// * `signature`: Coconut credential in the form of a signature.
-    pub async fn insert_coconut_credential(
+    pub async fn insert_issued_credential(
        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-        epoch_id: String,
+        credential_type: String,
+        serialization_revision: u8,
+        credential_data: &[u8],
+        epoch_id: u32,
    ) {
-        let mut creds = self.inner.write().await;
-        let id = creds.len() as i64;
-        creds.push(CoconutCredential {
+        let mut inner = self.inner.write().await;
+        let id = inner.next_id();
+        inner.data.push(StoredIssuedCredential {
            id,
-            voucher_value,
-            voucher_info,
-            serial_number,
-            binding_number,
-            signature,
+            serialization_revision,
+            credential_data: credential_data.to_vec(),
+            credential_type,
            epoch_id,
            consumed: false,
-        });
+        })
    }

    /// Tries to retrieve one of the stored, unused credentials.
-    pub async fn get_next_coconut_credential(&self) -> Option<CoconutCredential> {
+    pub async fn get_next_unspent_credential(&self) -> Option<StoredIssuedCredential> {
        let creds = self.inner.read().await;
-        creds.iter().find(|c| !c.consumed).cloned()
+        creds.data.iter().find(|c| !c.consumed).cloned()
    }

    /// Consumes in the database the specified credential.
@@ -63,7 +64,7 @@ impl CoconutCredentialManager {
    /// * `id`: Database id.
    pub async fn consume_coconut_credential(&self, id: i64) {
        let mut creds = self.inner.write().await;
-        if let Some(cred) = creds.get_mut(id as usize) {
+        if let Some(cred) = creds.data.get_mut(id as usize) {
            cred.consumed = true;
        }
    }
@@ -1,7 +1,7 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::models::CoconutCredential;
+use crate::models::StoredIssuedCredential;

 #[derive(Clone)]
 pub struct CoconutCredentialManager {
@@ -18,43 +18,29 @@ impl CoconutCredentialManager {
        CoconutCredentialManager { connection_pool }
    }

-    /// Inserts provided signature into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `voucher_value`: Plaintext bandwidth value of the credential.
-    /// * `voucher_info`: Plaintext information of the credential.
-    /// * `serial_number`: Base58 representation of the serial number attribute.
-    /// * `binding_number`: Base58 representation of the binding number attribute.
-    /// * `signature`: Coconut credential in the form of a signature.
-    pub async fn insert_coconut_credential(
+    pub async fn insert_issued_credential(
        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-        epoch_id: String,
+        credential_type: String,
+        serialization_revision: u8,
+        credential_data: &[u8],
+        epoch_id: u32,
    ) -> Result<(), sqlx::Error> {
        sqlx::query!(
-            "INSERT INTO coconut_credentials(voucher_value, voucher_info, serial_number, binding_number, signature, epoch_id, consumed) VALUES (?, ?, ?, ?, ?, ?, ?)",
-            voucher_value, voucher_info, serial_number, binding_number, signature, epoch_id, false
-        )
-        .execute(&self.connection_pool)
-        .await?;
+            r#"
+                INSERT INTO coconut_credentials(serialization_revision, credential_type, credential_data, epoch_id, consumed)
+                VALUES (?, ?, ?, ?, false)
+            "#,
+            serialization_revision, credential_type, credential_data, epoch_id
+        ).execute(&self.connection_pool).await?;
        Ok(())
    }

-    /// Tries to retrieve one of the stored, unused credentials.
-    pub async fn get_next_coconut_credential(
+    pub async fn get_next_unspent_credential(
        &self,
-    ) -> Result<Option<CoconutCredential>, sqlx::Error> {
-        sqlx::query_as!(
-            CoconutCredential,
-            "SELECT * FROM coconut_credentials WHERE NOT consumed"
-        )
-        .fetch_optional(&self.connection_pool)
-        .await
+    ) -> Result<Option<StoredIssuedCredential>, sqlx::Error> {
+        sqlx::query_as("SELECT * FROM coconut_credentials WHERE NOT consumed LIMIT 1")
+            .fetch_optional(&self.connection_pool)
+            .await
    }

    /// Consumes in the database the specified credential.
@@ -3,7 +3,7 @@

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

@@ -27,33 +27,27 @@ impl Default for EphemeralStorage {
 impl Storage for EphemeralStorage {
    type StorageError = StorageError;

-    async fn insert_coconut_credential(
+    async fn insert_issued_credential<'a>(
        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-        epoch_id: String,
+        bandwidth_credential: StorableIssuedCredential<'a>,
    ) -> Result<(), StorageError> {
        self.coconut_credential_manager
-            .insert_coconut_credential(
-                voucher_value,
-                voucher_info,
-                serial_number,
-                binding_number,
-                signature,
-                epoch_id,
+            .insert_issued_credential(
+                bandwidth_credential.credential_type,
+                bandwidth_credential.serialization_revision,
+                bandwidth_credential.credential_data,
+                bandwidth_credential.epoch_id,
            )
            .await;
-
        Ok(())
    }

-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError> {
+    async fn get_next_unspent_credential(
+        &self,
+    ) -> Result<StoredIssuedCredential, Self::StorageError> {
        let credential = self
            .coconut_credential_manager
-            .get_next_coconut_credential()
+            .get_next_unspent_credential()
            .await
            .ok_or(StorageError::NoCredential)?;

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

-#[derive(Clone)]
-pub struct CoconutCredential {
-    #[allow(dead_code)]
+use zeroize::{Zeroize, ZeroizeOnDrop};
+
+// #[derive(Clone)]
+// pub struct CoconutCredential {
+//     #[allow(dead_code)]
+//     pub id: i64,
+//     pub voucher_value: String,
+//     pub voucher_info: String,
+//     pub serial_number: String,
+//     pub binding_number: String,
+//     pub signature: String,
+//     pub epoch_id: String,
+//     pub consumed: bool,
+// }
+
+#[cfg_attr(not(target_arch = "wasm32"), derive(sqlx::FromRow))]
+#[derive(Zeroize, ZeroizeOnDrop, Clone)]
+pub struct StoredIssuedCredential {
    pub id: i64,
-    pub voucher_value: String,
-    pub voucher_info: String,
-    pub serial_number: String,
-    pub binding_number: String,
-    pub signature: String,
-    pub epoch_id: String,
+
+    pub serialization_revision: u8,
+    pub credential_data: Vec<u8>,
+    pub credential_type: String,
+
+    pub epoch_id: u32,
    pub consumed: bool,
 }
+
+pub struct StorableIssuedCredential<'a> {
+    pub serialization_revision: u8,
+    pub credential_data: &'a [u8],
+    pub credential_type: String,
+
+    pub epoch_id: u32,
+}
@@ -5,7 +5,7 @@ use crate::backends::sqlite::CoconutCredentialManager;
 use crate::error::StorageError;
 use crate::storage::Storage;

-use crate::models::CoconutCredential;
+use crate::models::{StorableIssuedCredential, StoredIssuedCredential};
 use async_trait::async_trait;
 use log::{debug, error};
 use sqlx::ConnectOptions;
@@ -58,33 +58,28 @@ impl PersistentStorage {
 impl Storage for PersistentStorage {
    type StorageError = StorageError;

-    async fn insert_coconut_credential(
+    async fn insert_issued_credential<'a>(
        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-        epoch_id: String,
-    ) -> Result<(), StorageError> {
+        bandwidth_credential: StorableIssuedCredential<'a>,
+    ) -> Result<(), Self::StorageError> {
        self.coconut_credential_manager
-            .insert_coconut_credential(
-                voucher_value,
-                voucher_info,
-                serial_number,
-                binding_number,
-                signature,
-                epoch_id,
+            .insert_issued_credential(
+                bandwidth_credential.credential_type,
+                bandwidth_credential.serialization_revision,
+                bandwidth_credential.credential_data,
+                bandwidth_credential.epoch_id,
            )
            .await?;

        Ok(())
    }

-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError> {
+    async fn get_next_unspent_credential(
+        &self,
+    ) -> Result<StoredIssuedCredential, Self::StorageError> {
        let credential = self
            .coconut_credential_manager
-            .get_next_coconut_credential()
+            .get_next_unspent_credential()
            .await?
            .ok_or(StorageError::NoCredential)?;

@@ -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::{StorableIssuedCredential, StoredIssuedCredential};
 use async_trait::async_trait;
 use std::error::Error;

@@ -9,28 +9,15 @@ use std::error::Error;
 pub trait Storage: Send + Sync {
    type StorageError: Error;

-    /// Inserts provided signature into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `voucher_value`: How much bandwidth is in the credential.
-    /// * `voucher_info`: What type of credential it is.
-    /// * `serial_number`: Serial number of the credential.
-    /// * `binding_number`: Binding number of the credential.
-    /// * `signature`: Coconut credential in the form of a signature.
-    /// * `epoch_id`: The epoch when it was signed.
-    async fn insert_coconut_credential(
+    async fn insert_issued_credential<'a>(
        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-        epoch_id: String,
+        bandwidth_credential: StorableIssuedCredential<'a>,
    ) -> Result<(), Self::StorageError>;

    /// Tries to retrieve one of the stored, unused credentials.
-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, Self::StorageError>;
+    async fn get_next_unspent_credential(
+        &self,
+    ) -> Result<StoredIssuedCredential, Self::StorageError>;

    /// Marks as consumed in the database the specified credential.
    ///
@@ -12,6 +12,7 @@ thiserror = { workspace = true }
 tokio = { workspace = true }

 nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
+nym-coconut = { path = "../nymcoconut" }
 nym-credentials = { path = "../../common/credentials" }
 nym-credential-storage = { path = "../../common/credential-storage" }
 nym-validator-client = { path = "../../common/client-libs/validator-client" }
@@ -3,11 +3,13 @@

 use crate::errors::Result;
 use log::error;
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+use nym_credentials::coconut::bandwidth::IssuanceBandwidthCredential;
 use std::fs::{create_dir_all, read_dir, File};
 use std::io::{Read, Write};
 use std::path::PathBuf;

+pub const DUMPED_VOUCHER_EXTENSION: &str = "credentialrecovery";
+
 pub struct RecoveryStorage {
    recovery_dir: PathBuf,
 }
@@ -18,14 +20,16 @@ impl RecoveryStorage {
        Ok(Self { recovery_dir })
    }

-    pub fn unconsumed_vouchers(&self) -> Result<Vec<BandwidthVoucher>> {
+    pub fn unconsumed_vouchers(&self) -> Result<Vec<IssuanceBandwidthCredential>> {
        let entries = read_dir(&self.recovery_dir)?;

        let mut paths = vec![];
        for entry in entries.flatten() {
            let path = entry.path();
-            if path.is_file() {
-                paths.push(path)
+            if let Some(extension) = path.extension() {
+                if extension == DUMPED_VOUCHER_EXTENSION {
+                    paths.push(path)
+                }
            }
        }

@@ -34,7 +38,7 @@ impl RecoveryStorage {
            if let Ok(mut file) = File::open(&path) {
                let mut buff = Vec::new();
                if file.read_to_end(&mut buff).is_ok() {
-                    match BandwidthVoucher::try_from_bytes(&buff) {
+                    match IssuanceBandwidthCredential::try_from_recovered_bytes(&buff) {
                        Ok(voucher) => vouchers.push(voucher),
                        Err(err) => {
                            error!("failed to parse the voucher at {}: {err}", path.display())
@@ -47,11 +51,17 @@ impl RecoveryStorage {
        Ok(vouchers)
    }

-    pub fn insert_voucher(&self, voucher: &BandwidthVoucher) -> Result<PathBuf> {
-        let file_name = voucher.tx_hash().to_string();
+    pub fn voucher_filename(voucher: &IssuanceBandwidthCredential) -> String {
+        let prefix = voucher.typ().to_string();
+        let suffix = voucher.blinded_g1_serial_number_bs58();
+        format!("{prefix}-{suffix}.{DUMPED_VOUCHER_EXTENSION}")
+    }
+
+    pub fn insert_voucher(&self, voucher: &IssuanceBandwidthCredential) -> Result<PathBuf> {
+        let file_name = Self::voucher_filename(voucher);
        let file_path = self.recovery_dir.join(file_name);
        let mut file = File::create(&file_path)?;
-        let buff = voucher.to_bytes();
+        let buff = voucher.to_recovery_bytes();
        file.write_all(&buff)?;

        Ok(file_path)
@@ -5,6 +5,7 @@ use nym_bandwidth_controller::acquire::state::State;
 use nym_client_core::config::disk_persistence::CommonClientPaths;
 use nym_config::DEFAULT_DATA_DIR;
 use nym_credential_storage::persistent_storage::PersistentStorage;
+use nym_credentials::coconut::bandwidth::CredentialType;
 use nym_validator_client::nyxd::contract_traits::{
    dkg_query_client::EpochState, CoconutBandwidthSigningClient, DkgQueryClient,
 };
@@ -43,7 +44,7 @@ where

    let state = nym_bandwidth_controller::acquire::deposit(client, amount.clone()).await?;

-    if nym_bandwidth_controller::acquire::get_credential(&state, client, persistent_storage)
+    if nym_bandwidth_controller::acquire::get_bandwidth_voucher(&state, client, persistent_storage)
        .await
        .is_err()
    {
@@ -128,19 +129,29 @@ where
 {
    let mut recovered_amount: u128 = 0;
    for voucher in recovery_storage.unconsumed_vouchers()? {
-        let voucher_value = voucher.get_voucher_value();
+        let voucher_value = match voucher.typ() {
+            CredentialType::Voucher => voucher.get_bandwidth_attribute(),
+            CredentialType::FreePass => {
+                error!("unimplemented recovery of free pass credentials");
+                continue;
+            }
+        };
        recovered_amount += voucher_value.parse::<u128>()?;

+        let voucher_name = RecoveryStorage::voucher_filename(&voucher);
        let state = State::new(voucher);
-        let voucher = state.voucher.tx_hash();
+
        if let Err(e) =
-            nym_bandwidth_controller::acquire::get_credential(&state, client, shared_storage).await
+            nym_bandwidth_controller::acquire::get_bandwidth_voucher(&state, client, shared_storage)
+                .await
        {
-            error!("Could not recover deposit {voucher} due to {e}, try again later",)
+            error!("Could not recover deposit {voucher_name} due to {e}, try again later",)
        } else {
-            info!("Converted deposit {voucher} to a credential, removing recovery data for it",);
-            if let Err(e) = recovery_storage.remove_voucher(voucher.to_string()) {
-                warn!("Could not remove recovery data: {e}");
+            info!(
+                "Converted deposit {voucher_name} to a credential, removing recovery data for it",
+            );
+            if let Err(err) = recovery_storage.remove_voucher(voucher_name) {
+                warn!("Could not remove recovery data: {err}");
            }
        }
    }
@@ -0,0 +1,18 @@
+[package]
+name = "nym-credentials-interface"
+version = "0.1.0"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bls12_381 = { workspace = true, default-features = false }
+serde = { workspace = true, features = ["derive"] }
+thiserror = { workspace = true }
+
+nym-coconut = { path = "../nymcoconut" }
@@ -0,0 +1,129 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use bls12_381::Scalar;
+use serde::{Deserialize, Serialize};
+use std::fmt::{Display, Formatter};
+use std::str::FromStr;
+use thiserror::Error;
+
+pub use nym_coconut::{
+    aggregate_signature_shares, aggregate_verification_keys, blind_sign, hash_to_scalar, keygen,
+    prepare_blind_sign, prove_bandwidth_credential, verify_credential, Attribute, Base58,
+    BlindSignRequest, BlindedSignature, Bytable, CoconutError, KeyPair, Parameters,
+    PrivateAttribute, PublicAttribute, SecretKey, Signature, SignatureShare, VerificationKey,
+    VerifyCredentialRequest,
+};
+
+pub const VOUCHER_INFO_TYPE: &str = "BandwidthVoucher";
+pub const FREE_PASS_INFO_TYPE: &str = "FreeBandwidthPass";
+
+// pub trait NymCredential {
+//     fn prove_credential(&self) -> Result<(), ()>;
+// }
+
+#[derive(Debug, Error)]
+#[error("{0} is not a valid credential type")]
+pub struct UnknownCredentialType(String);
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub enum CredentialType {
+    Voucher,
+    FreePass,
+}
+
+impl FromStr for CredentialType {
+    type Err = UnknownCredentialType;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s == VOUCHER_INFO_TYPE {
+            Ok(CredentialType::Voucher)
+        } else if s == FREE_PASS_INFO_TYPE {
+            Ok(CredentialType::FreePass)
+        } else {
+            Err(UnknownCredentialType(s.to_string()))
+        }
+    }
+}
+
+impl CredentialType {
+    pub fn validate(&self, type_plain: &str) -> bool {
+        match self {
+            CredentialType::Voucher => type_plain == VOUCHER_INFO_TYPE,
+            CredentialType::FreePass => type_plain == FREE_PASS_INFO_TYPE,
+        }
+    }
+
+    pub fn is_free_pass(&self) -> bool {
+        matches!(self, CredentialType::FreePass)
+    }
+
+    pub fn is_voucher(&self) -> bool {
+        matches!(self, CredentialType::Voucher)
+    }
+}
+
+impl Display for CredentialType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CredentialType::Voucher => VOUCHER_INFO_TYPE.fmt(f),
+            CredentialType::FreePass => FREE_PASS_INFO_TYPE.fmt(f),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct CredentialSigningData {
+    pub pedersen_commitments_openings: Vec<Scalar>,
+
+    pub blind_sign_request: BlindSignRequest,
+
+    pub public_attributes_plain: Vec<String>,
+
+    pub typ: CredentialType,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
+pub struct CredentialSpendingData {
+    pub embedded_private_attributes: usize,
+
+    pub verify_credential_request: VerifyCredentialRequest,
+
+    pub public_attributes_plain: Vec<String>,
+
+    pub typ: CredentialType,
+}
+
+impl CredentialSpendingData {
+    pub fn verify(&self, params: &Parameters, verification_key: &VerificationKey) -> bool {
+        let hashed_public_attributes = self
+            .public_attributes_plain
+            .iter()
+            .map(hash_to_scalar)
+            .collect::<Vec<_>>();
+
+        // get references to the attributes
+        let public_attributes = hashed_public_attributes.iter().collect::<Vec<_>>();
+
+        verify_credential(
+            params,
+            verification_key,
+            &self.verify_credential_request,
+            &public_attributes,
+        )
+    }
+
+    pub fn validate_type_attribute(&self) -> bool {
+        // the first attribute is variant specific bandwidth encoding, the second one should be the type
+        let Some(type_plain) = self.public_attributes_plain.get(1) else {
+            return false;
+        };
+
+        self.typ.validate(type_plain)
+    }
+
+    pub fn get_bandwidth_attribute(&self) -> Option<&String> {
+        // the first attribute is variant specific bandwidth encoding, the second one should be the type
+        self.public_attributes_plain.first()
+    }
+}
@@ -8,14 +8,17 @@ license.workspace = true

 [dependencies]
 bls12_381 = { workspace = true, default-features = false, features = ["pairings", "alloc", "experimental"] }
+bincode = "1.3.3"
 cosmrs = { workspace = true }
 thiserror = { workspace = true }
 log = { workspace = true }
+time = { workspace = true, features = ["serde"] }
+serde = { workspace = true, features = ["derive"] }
 zeroize = { workspace = true }

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

@@ -1,428 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// for time being assume the bandwidth credential consists of public identity of the requester
-// and private (though known... just go along with it) infinite bandwidth value
-// right now this has no double-spending protection, spender binding, etc
-// it's the simplest possible case
-
-use cosmrs::tendermint::hash::Algorithm;
-use cosmrs::tendermint::Hash;
-use nym_coconut_interface::{
-    hash_to_scalar, prepare_blind_sign, Attribute, BlindSignRequest, Credential, Parameters,
-    PrivateAttribute, PublicAttribute, Signature, VerificationKey,
-};
-use nym_crypto::asymmetric::{encryption, identity};
-use zeroize::{Zeroize, ZeroizeOnDrop};
-
-use super::utils::prepare_credential_for_spending;
-use crate::error::Error;
-
-#[derive(Zeroize, ZeroizeOnDrop)]
-pub struct BandwidthVoucher {
-    // private attributes
-    /// a random secret value generated by the client used for double-spending detection
-    serial_number: PrivateAttribute,
-
-    /// a random secret value generated by the client used to bind multiple credentials together
-    binding_number: PrivateAttribute,
-
-    // public atttributes:
-    /// the plain text value (e.g., bandwidth) encoded in this voucher
-    // TODO: in another PR change the value from `"1000"` to `"1000unym"`
-    voucher_value_plain: String,
-
-    /// the plain text information
-    voucher_info_plain: String,
-
-    /// the precomputed value (e.g., bandwidth) encoded in this voucher
-    _voucher_value_prehashed: PublicAttribute,
-
-    /// the precomputed field with public information, e.g., type of voucher, interval etc.
-    _voucher_info_prehashed: PublicAttribute,
-
-    /// the hash of the deposit transaction
-    #[zeroize(skip)]
-    tx_hash: Hash,
-
-    /// base58 encoded private key ensuring the depositer requested these attributes
-    signing_key: identity::PrivateKey,
-
-    /// base58 encoded private key ensuring only this client receives the signature share
-    unused_ed25519: encryption::PrivateKey,
-
-    pedersen_commitments_openings: Vec<Attribute>,
-
-    #[zeroize(skip)]
-    blind_sign_request: BlindSignRequest,
-}
-
-impl BandwidthVoucher {
-    pub const PUBLIC_ATTRIBUTES: u32 = 2;
-    pub const PRIVATE_ATTRIBUTES: u32 = 2;
-    pub const ENCODED_ATTRIBUTES: u32 = 4;
-
-    pub fn default_parameters() -> Parameters {
-        // safety: the unwrap is fine here as Self::ENCODED_ATTRIBUTES is non-zero
-        Parameters::new(Self::ENCODED_ATTRIBUTES).unwrap()
-    }
-
-    pub fn new(
-        params: &Parameters,
-        voucher_value: String,
-        voucher_info: String,
-        tx_hash: Hash,
-        signing_key: identity::PrivateKey,
-        encryption_key: encryption::PrivateKey,
-    ) -> Self {
-        let serial_number = params.random_scalar();
-        let binding_number = params.random_scalar();
-        let voucher_value_plain = voucher_value.clone();
-        let voucher_info_plain = voucher_info.clone();
-
-        let _voucher_value_prehashed = hash_to_scalar(voucher_value);
-        let _voucher_info_prehashed = hash_to_scalar(voucher_info);
-
-        let (pedersen_commitments_openings, blind_sign_request) = prepare_blind_sign(
-            params,
-            &[&serial_number, &binding_number],
-            &[&_voucher_value_prehashed, &_voucher_info_prehashed],
-        )
-        .unwrap();
-        BandwidthVoucher {
-            serial_number,
-            binding_number,
-            _voucher_value_prehashed,
-            voucher_value_plain,
-            _voucher_info_prehashed,
-            voucher_info_plain,
-            tx_hash,
-            signing_key,
-            unused_ed25519: encryption_key,
-            pedersen_commitments_openings,
-            blind_sign_request,
-        }
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let serial_number_b = self.serial_number.to_bytes();
-        let binding_number_b = self.binding_number.to_bytes();
-        let voucher_value_plain_b = self.voucher_value_plain.as_bytes();
-        let voucher_info_plain_b = self.voucher_info_plain.as_bytes();
-        let tx_hash_b = self.tx_hash.as_bytes();
-        let signing_key_b = self.signing_key.to_bytes();
-        let encryption_key_b = self.unused_ed25519.to_bytes();
-        let blind_sign_request_b = self.blind_sign_request.to_bytes();
-
-        let mut ret = Vec::new();
-
-        ret.extend_from_slice(&serial_number_b);
-        ret.extend_from_slice(&binding_number_b);
-        ret.extend_from_slice(tx_hash_b);
-        ret.extend_from_slice(&signing_key_b);
-        ret.extend_from_slice(&encryption_key_b);
-        ret.extend_from_slice(&(voucher_value_plain_b.len() as u64).to_be_bytes());
-        ret.extend_from_slice(&(voucher_info_plain_b.len() as u64).to_be_bytes());
-        ret.extend_from_slice(&(blind_sign_request_b.len() as u64).to_be_bytes());
-        ret.extend_from_slice(&(self.pedersen_commitments_openings.len() as u64).to_be_bytes());
-        ret.extend_from_slice(voucher_value_plain_b);
-        ret.extend_from_slice(voucher_info_plain_b);
-        ret.extend_from_slice(&blind_sign_request_b);
-        for commitment in self.pedersen_commitments_openings.iter() {
-            ret.extend_from_slice(&commitment.to_bytes());
-        }
-
-        ret
-    }
-
-    pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, Error> {
-        if bytes.len() < 32 * 5 + 4 * 8 {
-            return Err(Error::BandwidthVoucherDeserializationError(format!(
-                "Less then {} bytes needed",
-                32 * 5 + 4 * 8
-            )));
-        }
-        let mut buff = [0u8; 32];
-        let mut small_buff = [0u8; 8];
-        let scalar_err =
-            || Error::BandwidthVoucherDeserializationError(String::from("Invalid Scalar"));
-        buff.copy_from_slice(&bytes[..32]);
-        let serial_number = Option::<PrivateAttribute>::from(PrivateAttribute::from_bytes(&buff))
-            .ok_or_else(scalar_err)?;
-        buff.copy_from_slice(&bytes[32..2 * 32]);
-        let binding_number = Option::<PrivateAttribute>::from(PrivateAttribute::from_bytes(&buff))
-            .ok_or_else(scalar_err)?;
-        buff.copy_from_slice(&bytes[2 * 32..3 * 32]);
-        let tx_hash = Hash::from_bytes(Algorithm::Sha256, &buff).map_err(|_| {
-            Error::BandwidthVoucherDeserializationError(String::from("Invalid transaction Hash"))
-        })?;
-        buff.copy_from_slice(&bytes[3 * 32..4 * 32]);
-        let signing_key = identity::PrivateKey::from_bytes(&buff).map_err(|_| {
-            Error::BandwidthVoucherDeserializationError(String::from("Invalid key"))
-        })?;
-        buff.copy_from_slice(&bytes[4 * 32..5 * 32]);
-        let encryption_key = encryption::PrivateKey::from_bytes(&buff).map_err(|_| {
-            Error::BandwidthVoucherDeserializationError(String::from("Invalid key"))
-        })?;
-        small_buff.copy_from_slice(&bytes[5 * 32..5 * 32 + 8]);
-        let voucher_value_plain_no = u64::from_be_bytes(small_buff) as usize;
-        small_buff.copy_from_slice(&bytes[5 * 32 + 8..5 * 32 + 2 * 8]);
-        let voucher_info_plain_no = u64::from_be_bytes(small_buff) as usize;
-        small_buff.copy_from_slice(&bytes[5 * 32 + 2 * 8..5 * 32 + 3 * 8]);
-        let blind_sign_request_no = u64::from_be_bytes(small_buff) as usize;
-        small_buff.copy_from_slice(&bytes[5 * 32 + 3 * 8..5 * 32 + 4 * 8]);
-        let pedersen_commitments_openings_no = u64::from_be_bytes(small_buff) as usize;
-
-        let total_length = 32 * 5
-            + 4 * 8
-            + voucher_value_plain_no
-            + voucher_info_plain_no
-            + blind_sign_request_no
-            + pedersen_commitments_openings_no * 32;
-        if bytes.len() != total_length {
-            return Err(Error::BandwidthVoucherDeserializationError(format!(
-                "Expected {total_length} bytes",
-            )));
-        }
-
-        let utf_err = |_| {
-            Err(Error::BandwidthVoucherDeserializationError(String::from(
-                "Invalid UTF8 string",
-            )))
-        };
-        let mut var_length_pointer = 5 * 32 + 4 * 8;
-        let voucher_value_plain = String::from_utf8(
-            bytes[var_length_pointer..var_length_pointer + voucher_value_plain_no].to_vec(),
-        )
-        .or_else(utf_err)?;
-        let _voucher_value_prehashed = hash_to_scalar(&voucher_value_plain);
-        var_length_pointer += voucher_value_plain_no;
-        let voucher_info_plain = String::from_utf8(
-            bytes[var_length_pointer..var_length_pointer + voucher_info_plain_no].to_vec(),
-        )
-        .or_else(utf_err)?;
-        let _voucher_info_prehashed = hash_to_scalar(&voucher_info_plain);
-        var_length_pointer += voucher_info_plain_no;
-        let blind_sign_request = BlindSignRequest::from_bytes(
-            &bytes[var_length_pointer..var_length_pointer + blind_sign_request_no],
-        )?;
-        var_length_pointer += blind_sign_request_no;
-
-        let mut pedersen_commitments_openings = Vec::new();
-        for _ in 0..pedersen_commitments_openings_no {
-            buff.copy_from_slice(&bytes[var_length_pointer..var_length_pointer + 32]);
-            let commitment =
-                Option::<Attribute>::from(Attribute::from_bytes(&buff)).ok_or_else(scalar_err)?;
-            var_length_pointer += 32;
-            pedersen_commitments_openings.push(commitment);
-        }
-
-        Ok(Self {
-            serial_number,
-            binding_number,
-            _voucher_value_prehashed,
-            voucher_value_plain,
-            _voucher_info_prehashed,
-            voucher_info_plain,
-            tx_hash,
-            signing_key,
-            unused_ed25519: encryption_key,
-            pedersen_commitments_openings,
-            blind_sign_request,
-        })
-    }
-
-    /// Check if the plain values correspond to the PublicAttributes
-    pub fn verify_against_plain(values: &[&PublicAttribute], plain_values: &[String]) -> bool {
-        values.len() == 2
-            && plain_values.len() == 2
-            && values[0] == &hash_to_scalar(&plain_values[0])
-            && values[1] == &hash_to_scalar(&plain_values[1])
-    }
-
-    pub fn tx_hash(&self) -> Hash {
-        self.tx_hash
-    }
-
-    pub fn get_public_attributes(&self) -> Vec<&PublicAttribute> {
-        vec![
-            &self._voucher_value_prehashed,
-            &self._voucher_info_prehashed,
-        ]
-    }
-
-    pub fn identity_key(&self) -> &identity::PrivateKey {
-        &self.signing_key
-    }
-
-    pub fn encryption_key(&self) -> &encryption::PrivateKey {
-        &self.unused_ed25519
-    }
-
-    pub fn pedersen_commitments_openings(&self) -> &Vec<Attribute> {
-        &self.pedersen_commitments_openings
-    }
-
-    pub fn blind_sign_request(&self) -> &BlindSignRequest {
-        &self.blind_sign_request
-    }
-
-    pub fn get_voucher_value(&self) -> String {
-        self.voucher_value_plain.clone()
-    }
-
-    pub fn get_public_attributes_plain(&self) -> Vec<String> {
-        vec![
-            self.voucher_value_plain.clone(),
-            self.voucher_info_plain.clone(),
-        ]
-    }
-
-    pub fn get_private_attributes(&self) -> Vec<&PrivateAttribute> {
-        vec![&self.serial_number, &self.binding_number]
-    }
-
-    pub fn signable_plaintext(request: &BlindSignRequest, tx_hash: Hash) -> Vec<u8> {
-        let mut message = request.to_bytes();
-        message.extend_from_slice(tx_hash.as_bytes());
-        message
-    }
-
-    pub fn sign(&self) -> identity::Signature {
-        let message = Self::signable_plaintext(&self.blind_sign_request, self.tx_hash);
-        self.signing_key.sign(message)
-    }
-}
-
-pub fn prepare_for_spending(
-    voucher_value: u64,
-    voucher_info: String,
-    serial_number: &PrivateAttribute,
-    binding_number: &PrivateAttribute,
-    epoch_id: u64,
-    signature: &Signature,
-    verification_key: &VerificationKey,
-) -> Result<Credential, Error> {
-    let params = Parameters::new(BandwidthVoucher::ENCODED_ATTRIBUTES)?;
-
-    prepare_credential_for_spending(
-        &params,
-        voucher_value,
-        voucher_info,
-        serial_number,
-        binding_number,
-        epoch_id,
-        signature,
-        verification_key,
-    )
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use cosmrs::tendermint::hash::Algorithm;
-    use nym_coconut_interface::Base58;
-    use rand::rngs::OsRng;
-
-    fn voucher_fixture() -> BandwidthVoucher {
-        let params = Parameters::new(4).unwrap();
-        let mut rng = OsRng;
-        BandwidthVoucher::new(
-            &params,
-            "1234".to_string(),
-            "voucher info".to_string(),
-            Hash::from_bytes(Algorithm::Sha256, &[0; 32]).unwrap(),
-            identity::PrivateKey::from_base58_string(
-                identity::KeyPair::new(&mut rng)
-                    .private_key()
-                    .to_base58_string(),
-            )
-            .unwrap(),
-            encryption::PrivateKey::from_bytes(
-                &encryption::KeyPair::new(&mut rng).private_key().to_bytes(),
-            )
-            .unwrap(),
-        )
-    }
-
-    #[test]
-    fn serde_voucher() {
-        let voucher = voucher_fixture();
-        let bytes = voucher.to_bytes();
-        let deserialized_voucher = BandwidthVoucher::try_from_bytes(&bytes).unwrap();
-        assert_eq!(voucher.serial_number, deserialized_voucher.serial_number);
-        assert_eq!(voucher.binding_number, deserialized_voucher.binding_number);
-        assert_eq!(
-            voucher.voucher_value_plain,
-            deserialized_voucher.voucher_value_plain
-        );
-        assert_eq!(
-            voucher.voucher_info_plain,
-            deserialized_voucher.voucher_info_plain
-        );
-        assert_eq!(
-            voucher._voucher_value_prehashed,
-            deserialized_voucher._voucher_value_prehashed
-        );
-        assert_eq!(
-            voucher._voucher_info_prehashed,
-            deserialized_voucher._voucher_info_prehashed
-        );
-        assert_eq!(voucher.tx_hash, deserialized_voucher.tx_hash);
-        assert_eq!(
-            voucher.signing_key.to_string(),
-            deserialized_voucher.signing_key.to_string()
-        );
-        assert_eq!(
-            voucher.unused_ed25519.to_string(),
-            deserialized_voucher.unused_ed25519.to_string()
-        );
-        assert_eq!(
-            voucher.pedersen_commitments_openings,
-            deserialized_voucher.pedersen_commitments_openings
-        );
-        assert_eq!(
-            voucher.blind_sign_request.to_bs58(),
-            deserialized_voucher.blind_sign_request.to_bs58()
-        );
-    }
-
-    #[test]
-    fn voucher_consistency() {
-        let voucher = voucher_fixture();
-        assert!(!BandwidthVoucher::verify_against_plain(
-            &[],
-            &voucher.get_public_attributes_plain()
-        ));
-        assert!(!BandwidthVoucher::verify_against_plain(
-            &voucher.get_public_attributes(),
-            &[],
-        ));
-        assert!(!BandwidthVoucher::verify_against_plain(
-            &voucher.get_public_attributes(),
-            &[
-                voucher.get_public_attributes_plain()[0].clone(),
-                String::new()
-            ]
-        ));
-        assert!(!BandwidthVoucher::verify_against_plain(
-            &voucher.get_public_attributes(),
-            &[
-                String::new(),
-                voucher.get_public_attributes_plain()[1].clone()
-            ]
-        ));
-        assert!(!BandwidthVoucher::verify_against_plain(
-            &[voucher.get_public_attributes()[0], &Attribute::one()],
-            &voucher.get_public_attributes_plain()
-        ));
-        assert!(!BandwidthVoucher::verify_against_plain(
-            &[&Attribute::one(), voucher.get_public_attributes()[1]],
-            &voucher.get_public_attributes_plain()
-        ));
-        assert!(BandwidthVoucher::verify_against_plain(
-            &voucher.get_public_attributes(),
-            &voucher.get_public_attributes_plain()
-        ));
-    }
-}
@@ -0,0 +1,79 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::coconut::utils::scalar_serde_helper;
+use nym_credentials_interface::{hash_to_scalar, Attribute, PublicAttribute};
+use serde::{Deserialize, Serialize};
+use time::{Duration, OffsetDateTime, Time};
+use zeroize::{Zeroize, ZeroizeOnDrop};
+
+pub const MAX_FREE_PASS_VALIDITY: Duration = Duration::WEEK; // 1 week
+
+#[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
+pub struct FreePassIssuedData {
+    /// the plain validity value of this credential expressed as unix timestamp
+    #[zeroize(skip)]
+    expiry_date: OffsetDateTime,
+}
+
+impl<'a> From<&'a FreePassIssuanceData> for FreePassIssuedData {
+    fn from(value: &'a FreePassIssuanceData) -> Self {
+        FreePassIssuedData {
+            expiry_date: value.expiry_date,
+        }
+    }
+}
+
+impl FreePassIssuedData {
+    pub fn expiry_date_plain(&self) -> String {
+        self.expiry_date.unix_timestamp().to_string()
+    }
+}
+
+#[derive(Zeroize, Serialize, Deserialize)]
+pub struct FreePassIssuanceData {
+    /// the plain validity value of this credential expressed as unix timestamp
+    #[zeroize(skip)]
+    expiry_date: OffsetDateTime,
+
+    // the expiry date, as unix timestamp, hashed into a scalar
+    #[serde(with = "scalar_serde_helper")]
+    expiry_date_prehashed: PublicAttribute,
+}
+
+impl FreePassIssuanceData {
+    pub fn new(expiry_date: Option<OffsetDateTime>) -> Self {
+        // ideally we should have implemented a proper error handling here, sure.
+        // but given it's meant to only be used by nym, imo it's fine to just panic here in case of invalid arguments
+        let expiry_date = if let Some(provided) = expiry_date {
+            if provided - OffsetDateTime::now_utc() > MAX_FREE_PASS_VALIDITY {
+                panic!("the provided expiry date is bigger than the maximum value of {MAX_FREE_PASS_VALIDITY}");
+            }
+
+            provided
+        } else {
+            Self::default_expiry_date()
+        };
+
+        let expiry_date_prehashed = hash_to_scalar(expiry_date.unix_timestamp().to_string());
+
+        FreePassIssuanceData {
+            expiry_date,
+            expiry_date_prehashed,
+        }
+    }
+
+    pub fn default_expiry_date() -> OffsetDateTime {
+        // set it to furthest midnight in the future such as it's no more than a week away,
+        // i.e. if it's currently for example 9:43 on 2nd March 2024, it will set it to 0:00 on 9th March 2024
+        (OffsetDateTime::now_utc() + MAX_FREE_PASS_VALIDITY).replace_time(Time::MIDNIGHT)
+    }
+
+    pub fn expiry_date_attribute(&self) -> &Attribute {
+        &self.expiry_date_prehashed
+    }
+
+    pub fn expiry_date_plain(&self) -> String {
+        self.expiry_date.unix_timestamp().to_string()
+    }
+}
@@ -0,0 +1,293 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::coconut::bandwidth::freepass::FreePassIssuanceData;
+use crate::coconut::bandwidth::issued::IssuedBandwidthCredential;
+use crate::coconut::bandwidth::voucher::BandwidthVoucherIssuanceData;
+use crate::coconut::bandwidth::{
+    bandwidth_credential_params, CredentialSigningData, CredentialType,
+};
+use crate::coconut::utils::scalar_serde_helper;
+use crate::error::Error;
+use bls12_381::G1Projective;
+use nym_credentials_interface::{
+    aggregate_signature_shares, hash_to_scalar, prepare_blind_sign, Attribute, Parameters,
+    PrivateAttribute, PublicAttribute, Signature, SignatureShare, VerificationKey,
+};
+use nym_crypto::asymmetric::{encryption, identity};
+use nym_validator_client::nyxd::{Coin, Hash};
+use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
+use zeroize::{Zeroize, ZeroizeOnDrop};
+
+#[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
+pub enum BandwidthCredentialIssuanceDataVariant {
+    Voucher(BandwidthVoucherIssuanceData),
+    FreePass(FreePassIssuanceData),
+}
+
+impl From<FreePassIssuanceData> for BandwidthCredentialIssuanceDataVariant {
+    fn from(value: FreePassIssuanceData) -> Self {
+        BandwidthCredentialIssuanceDataVariant::FreePass(value)
+    }
+}
+
+impl From<BandwidthVoucherIssuanceData> for BandwidthCredentialIssuanceDataVariant {
+    fn from(value: BandwidthVoucherIssuanceData) -> Self {
+        BandwidthCredentialIssuanceDataVariant::Voucher(value)
+    }
+}
+
+impl BandwidthCredentialIssuanceDataVariant {
+    pub fn info(&self) -> CredentialType {
+        match self {
+            BandwidthCredentialIssuanceDataVariant::Voucher(..) => CredentialType::Voucher,
+            BandwidthCredentialIssuanceDataVariant::FreePass(..) => CredentialType::FreePass,
+        }
+    }
+
+    // currently this works under the assumption of there being a single unique public attribute for given variant
+    pub fn public_value(&self) -> &Attribute {
+        match self {
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => voucher.value_attribute(),
+            BandwidthCredentialIssuanceDataVariant::FreePass(freepass) => {
+                freepass.expiry_date_attribute()
+            }
+        }
+    }
+
+    // currently this works under the assumption of there being a single unique public attribute for given variant
+    pub fn public_value_plain(&self) -> String {
+        match self {
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => voucher.value_plain(),
+            BandwidthCredentialIssuanceDataVariant::FreePass(freepass) => {
+                freepass.expiry_date_plain()
+            }
+        }
+    }
+
+    pub fn voucher_data(&self) -> Option<&BandwidthVoucherIssuanceData> {
+        match self {
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => Some(voucher),
+            _ => None,
+        }
+    }
+}
+
+// all types of bandwidth credentials contain serial number and binding number
+#[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
+pub struct IssuanceBandwidthCredential {
+    // private attributes
+    /// a random secret value generated by the client used for double-spending detection
+    #[serde(with = "scalar_serde_helper")]
+    serial_number: PrivateAttribute,
+
+    /// a random secret value generated by the client used to bind multiple credentials together
+    #[serde(with = "scalar_serde_helper")]
+    binding_number: PrivateAttribute,
+
+    /// data specific to given bandwidth credential, for example a value for bandwidth voucher and expiry date for the free pass
+    variant_data: BandwidthCredentialIssuanceDataVariant,
+
+    /// type of the bandwdith credential hashed onto a scalar
+    #[serde(with = "scalar_serde_helper")]
+    type_prehashed: PublicAttribute,
+}
+
+impl IssuanceBandwidthCredential {
+    pub const PUBLIC_ATTRIBUTES: u32 = 2;
+    pub const PRIVATE_ATTRIBUTES: u32 = 2;
+    pub const ENCODED_ATTRIBUTES: u32 = Self::PUBLIC_ATTRIBUTES + Self::PRIVATE_ATTRIBUTES;
+
+    pub fn default_parameters() -> Parameters {
+        // safety: the unwrap is fine here as Self::ENCODED_ATTRIBUTES is non-zero
+        Parameters::new(Self::ENCODED_ATTRIBUTES).unwrap()
+    }
+
+    pub fn new<B: Into<BandwidthCredentialIssuanceDataVariant>>(variant_data: B) -> Self {
+        let variant_data = variant_data.into();
+        let type_prehashed = hash_to_scalar(variant_data.info().to_string());
+
+        let params = bandwidth_credential_params();
+        let serial_number = params.random_scalar();
+        let binding_number = params.random_scalar();
+
+        IssuanceBandwidthCredential {
+            serial_number,
+            binding_number,
+            variant_data,
+            type_prehashed,
+        }
+    }
+
+    pub fn new_voucher(
+        value: impl Into<Coin>,
+        deposit_tx_hash: Hash,
+        signing_key: identity::PrivateKey,
+        unused_ed25519: encryption::PrivateKey,
+    ) -> Self {
+        Self::new(BandwidthVoucherIssuanceData::new(
+            value,
+            deposit_tx_hash,
+            signing_key,
+            unused_ed25519,
+        ))
+    }
+
+    pub fn new_freepass(expiry_date: Option<OffsetDateTime>) -> Self {
+        Self::new(FreePassIssuanceData::new(expiry_date))
+    }
+
+    pub fn blind_serial_number_in_g1subgroup(&self) -> G1Projective {
+        bandwidth_credential_params().gen1() * self.serial_number
+    }
+
+    // NOT TO BE CONFUSED WITH BLINDED SERIAL NUMBER IN CREDENTIAL ITSELF
+    pub fn blinded_g1_serial_number_bs58(&self) -> String {
+        use nym_credentials_interface::Base58;
+
+        self.blind_serial_number_in_g1subgroup().to_bs58()
+    }
+
+    pub fn typ(&self) -> CredentialType {
+        self.variant_data.info()
+    }
+
+    pub fn get_private_attributes(&self) -> Vec<&PrivateAttribute> {
+        vec![&self.serial_number, &self.binding_number]
+    }
+
+    pub fn get_public_attributes(&self) -> Vec<&PublicAttribute> {
+        vec![self.variant_data.public_value(), &self.type_prehashed]
+    }
+
+    pub fn get_plain_public_attributes(&self) -> Vec<String> {
+        vec![
+            self.variant_data.public_value_plain(),
+            self.typ().to_string(),
+        ]
+    }
+
+    pub fn get_variant_data(&self) -> &BandwidthCredentialIssuanceDataVariant {
+        &self.variant_data
+    }
+
+    pub fn get_bandwidth_attribute(&self) -> String {
+        self.variant_data.public_value_plain()
+    }
+
+    pub fn prepare_for_signing(&self) -> CredentialSigningData {
+        let params = bandwidth_credential_params();
+
+        // safety: the creation of the request can only fail if one provided invalid parameters
+        // and we created then specific to this type of the credential so the unwrap is fine
+        let (pedersen_commitments_openings, blind_sign_request) = prepare_blind_sign(
+            params,
+            &[&self.serial_number, &self.binding_number],
+            &self.get_public_attributes(),
+        )
+        .unwrap();
+
+        CredentialSigningData {
+            pedersen_commitments_openings,
+            blind_sign_request,
+            public_attributes_plain: self.get_plain_public_attributes(),
+            typ: self.typ(),
+        }
+    }
+
+    pub async fn obtain_partial_credential(
+        &self,
+        client: &nym_validator_client::client::NymApiClient,
+        validator_vk: &VerificationKey,
+        signing_data: impl Into<Option<CredentialSigningData>>,
+    ) -> Result<Signature, Error> {
+        // if we provided signing data, do use them, otherwise generate fresh data
+        let signing_data = signing_data
+            .into()
+            .unwrap_or_else(|| self.prepare_for_signing());
+
+        let blinded_signature = match &self.variant_data {
+            BandwidthCredentialIssuanceDataVariant::FreePass(_freepass) => unimplemented!(),
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => {
+                // TODO: the request can be re-used between different apis
+                let request = voucher.create_blind_sign_request_body(&signing_data);
+                voucher.obtain_blinded_credential(client, &request).await?
+            }
+        };
+
+        let public_attributes = self.get_public_attributes();
+        let private_attributes = self.get_private_attributes();
+
+        let params = bandwidth_credential_params();
+        let unblinded_signature = blinded_signature.unblind_and_verify(
+            params,
+            validator_vk,
+            &private_attributes,
+            &public_attributes,
+            &signing_data.blind_sign_request.get_commitment_hash(),
+            &signing_data.pedersen_commitments_openings,
+        )?;
+
+        Ok(unblinded_signature)
+    }
+
+    pub fn aggregate_signature_shares(
+        &self,
+        verification_key: &VerificationKey,
+        shares: &[SignatureShare],
+    ) -> Result<Signature, Error> {
+        let public_attributes = self.get_public_attributes();
+        let private_attributes = self.get_private_attributes();
+
+        let params = bandwidth_credential_params();
+
+        let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
+        attributes.extend_from_slice(&private_attributes);
+        attributes.extend_from_slice(&public_attributes);
+
+        aggregate_signature_shares(params, verification_key, &attributes, shares)
+            .map_err(Error::SignatureAggregationError)
+    }
+
+    // also drops self after the conversion
+    pub fn into_issued_credential(
+        self,
+        aggregate_signature: Signature,
+    ) -> IssuedBandwidthCredential {
+        self.to_issued_credential(aggregate_signature)
+    }
+
+    pub fn to_issued_credential(
+        &self,
+        aggregate_signature: Signature,
+    ) -> IssuedBandwidthCredential {
+        IssuedBandwidthCredential::new(
+            self.serial_number,
+            self.binding_number,
+            aggregate_signature,
+            (&self.variant_data).into(),
+            self.type_prehashed,
+        )
+    }
+
+    // TODO: is that actually needed?
+    pub fn to_recovery_bytes(&self) -> Vec<u8> {
+        use bincode::Options;
+        // safety: our data format is stable and thus the serialization should not fail
+        make_recovery_bincode_serializer().serialize(self).unwrap()
+    }
+
+    // TODO: is that actually needed?
+    pub fn try_from_recovered_bytes(bytes: &[u8]) -> Result<Self, Error> {
+        use bincode::Options;
+        Ok(make_recovery_bincode_serializer().deserialize(bytes)?)
+    }
+}
+
+fn make_recovery_bincode_serializer() -> impl bincode::Options {
+    use bincode::Options;
+    bincode::DefaultOptions::new()
+        .with_big_endian()
+        .with_varint_encoding()
+}
@@ -0,0 +1,178 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::coconut::bandwidth::bandwidth_credential_params;
+use crate::coconut::bandwidth::freepass::FreePassIssuedData;
+use crate::coconut::bandwidth::issuance::{
+    BandwidthCredentialIssuanceDataVariant, IssuanceBandwidthCredential,
+};
+use crate::coconut::bandwidth::voucher::BandwidthVoucherIssuedData;
+use crate::coconut::bandwidth::{CredentialSpendingData, CredentialType};
+use crate::coconut::utils::scalar_serde_helper;
+use crate::error::Error;
+use nym_credentials_interface::prove_bandwidth_credential;
+use nym_credentials_interface::{
+    Parameters, PrivateAttribute, PublicAttribute, Signature, VerificationKey,
+};
+use serde::{Deserialize, Serialize};
+use zeroize::{Zeroize, ZeroizeOnDrop};
+
+pub const CURRENT_SERIALIZATION_REVISION: u8 = 1;
+
+#[derive(Zeroize, Serialize, Deserialize)]
+pub enum BandwidthCredentialIssuedDataVariant {
+    Voucher(BandwidthVoucherIssuedData),
+    FreePass(FreePassIssuedData),
+}
+
+impl<'a> From<&'a BandwidthCredentialIssuanceDataVariant> for BandwidthCredentialIssuedDataVariant {
+    fn from(value: &'a BandwidthCredentialIssuanceDataVariant) -> Self {
+        match value {
+            BandwidthCredentialIssuanceDataVariant::Voucher(voucher) => {
+                BandwidthCredentialIssuedDataVariant::Voucher(voucher.into())
+            }
+            BandwidthCredentialIssuanceDataVariant::FreePass(freepass) => {
+                BandwidthCredentialIssuedDataVariant::FreePass(freepass.into())
+            }
+        }
+    }
+}
+
+impl From<FreePassIssuedData> for BandwidthCredentialIssuedDataVariant {
+    fn from(value: FreePassIssuedData) -> Self {
+        BandwidthCredentialIssuedDataVariant::FreePass(value)
+    }
+}
+
+impl From<BandwidthVoucherIssuedData> for BandwidthCredentialIssuedDataVariant {
+    fn from(value: BandwidthVoucherIssuedData) -> Self {
+        BandwidthCredentialIssuedDataVariant::Voucher(value)
+    }
+}
+
+impl BandwidthCredentialIssuedDataVariant {
+    pub fn info(&self) -> CredentialType {
+        match self {
+            BandwidthCredentialIssuedDataVariant::Voucher(..) => CredentialType::Voucher,
+            BandwidthCredentialIssuedDataVariant::FreePass(..) => CredentialType::FreePass,
+        }
+    }
+
+    // currently this works under the assumption of there being a single unique public attribute for given variant
+    pub fn public_value_plain(&self) -> String {
+        match self {
+            BandwidthCredentialIssuedDataVariant::Voucher(voucher) => voucher.value_plain(),
+            BandwidthCredentialIssuedDataVariant::FreePass(freepass) => {
+                freepass.expiry_date_plain()
+            }
+        }
+    }
+}
+
+// the only important thing to zeroize here are the private attributes, the rest can be made fully public for what we're concerned
+#[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
+pub struct IssuedBandwidthCredential {
+    // private attributes
+    /// a random secret value generated by the client used for double-spending detection
+    #[serde(with = "scalar_serde_helper")]
+    serial_number: PrivateAttribute,
+
+    /// a random secret value generated by the client used to bind multiple credentials together
+    #[serde(with = "scalar_serde_helper")]
+    binding_number: PrivateAttribute,
+
+    /// the underlying aggregated signature on the attributes
+    #[zeroize(skip)]
+    signature: Signature,
+
+    /// data specific to given bandwidth credential, for example a value for bandwidth voucher and expiry date for the free pass
+    variant_data: BandwidthCredentialIssuedDataVariant,
+
+    /// type of the bandwdith credential hashed onto a scalar
+    #[serde(with = "scalar_serde_helper")]
+    type_prehashed: PublicAttribute,
+}
+
+impl IssuedBandwidthCredential {
+    pub fn new(
+        serial_number: PrivateAttribute,
+        binding_number: PrivateAttribute,
+        signature: Signature,
+        variant_data: BandwidthCredentialIssuedDataVariant,
+        type_prehashed: PublicAttribute,
+    ) -> Self {
+        IssuedBandwidthCredential {
+            serial_number,
+            binding_number,
+            signature,
+            variant_data,
+            type_prehashed,
+        }
+    }
+
+    pub fn current_serialization_revision(&self) -> u8 {
+        CURRENT_SERIALIZATION_REVISION
+    }
+
+    /// Pack (serialize) this credential data into a stream of bytes using v1 serializer.
+    pub fn pack_v1(&self) -> Vec<u8> {
+        use bincode::Options;
+        // safety: our data format is stable and thus the serialization should not fail
+        make_storable_bincode_serializer().serialize(self).unwrap()
+    }
+
+    /// Unpack (deserialize) the credential data from the given bytes using v1 serializer.
+    pub fn unpack_v1(bytes: &[u8]) -> Result<Self, Error> {
+        use bincode::Options;
+        Ok(make_storable_bincode_serializer().deserialize(bytes)?)
+    }
+
+    pub fn randomise_signature(&mut self) {
+        let signature_prime = self.signature.randomise(bandwidth_credential_params());
+        self.signature = signature_prime.0
+    }
+
+    pub fn default_parameters() -> Parameters {
+        IssuanceBandwidthCredential::default_parameters()
+    }
+
+    pub fn typ(&self) -> CredentialType {
+        self.variant_data.info()
+    }
+
+    pub fn get_plain_public_attributes(&self) -> Vec<String> {
+        vec![
+            self.variant_data.public_value_plain(),
+            self.typ().to_string(),
+        ]
+    }
+
+    pub fn prepare_for_spending(
+        &self,
+        verification_key: &VerificationKey,
+    ) -> Result<CredentialSpendingData, Error> {
+        let params = bandwidth_credential_params();
+
+        let verify_credential_request = prove_bandwidth_credential(
+            params,
+            verification_key,
+            &self.signature,
+            &self.serial_number,
+            &self.binding_number,
+        )?;
+
+        Ok(CredentialSpendingData {
+            embedded_private_attributes: IssuanceBandwidthCredential::PRIVATE_ATTRIBUTES as usize,
+            verify_credential_request,
+            public_attributes_plain: self.get_plain_public_attributes(),
+            typ: self.typ(),
+        })
+    }
+}
+
+fn make_storable_bincode_serializer() -> impl bincode::Options {
+    use bincode::Options;
+    bincode::DefaultOptions::new()
+        .with_big_endian()
+        .with_varint_encoding()
+}
@@ -0,0 +1,21 @@
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::sync::OnceLock;
+
+pub use issuance::IssuanceBandwidthCredential;
+pub use issued::IssuedBandwidthCredential;
+pub use nym_credentials_interface::{
+    CredentialSigningData, CredentialSpendingData, CredentialType, Parameters,
+};
+
+pub mod freepass;
+pub mod issuance;
+pub mod issued;
+pub mod voucher;
+
+// works under the assumption of having 4 attributes in the underlying credential(s)
+pub fn bandwidth_credential_params() -> &'static Parameters {
+    static BANDWIDTH_CREDENTIAL_PARAMS: OnceLock<Parameters> = OnceLock::new();
+    BANDWIDTH_CREDENTIAL_PARAMS.get_or_init(IssuanceBandwidthCredential::default_parameters)
+}
@@ -0,0 +1,133 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::coconut::bandwidth::CredentialSigningData;
+use crate::coconut::utils::scalar_serde_helper;
+use crate::error::Error;
+use nym_api_requests::coconut::BlindSignRequestBody;
+use nym_credentials_interface::{
+    hash_to_scalar, Attribute, BlindSignRequest, BlindedSignature, PublicAttribute,
+};
+use nym_crypto::asymmetric::{encryption, identity};
+use nym_validator_client::nyxd::{Coin, Hash};
+use serde::{Deserialize, Serialize};
+use zeroize::{Zeroize, ZeroizeOnDrop};
+
+#[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
+pub struct BandwidthVoucherIssuedData {
+    /// the plain value (e.g., bandwidth) encoded in this voucher
+    // note: for legacy reasons we're only using the value of the coin and ignoring the denom
+    #[zeroize(skip)]
+    value: Coin,
+}
+
+impl<'a> From<&'a BandwidthVoucherIssuanceData> for BandwidthVoucherIssuedData {
+    fn from(value: &'a BandwidthVoucherIssuanceData) -> Self {
+        BandwidthVoucherIssuedData {
+            value: value.value.clone(),
+        }
+    }
+}
+
+impl BandwidthVoucherIssuedData {
+    pub fn value_plain(&self) -> String {
+        self.value.amount.to_string()
+    }
+}
+
+#[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
+pub struct BandwidthVoucherIssuanceData {
+    /// the plain value (e.g., bandwidth) encoded in this voucher
+    // note: for legacy reasons we're only using the value of the coin and ignoring the denom
+    #[zeroize(skip)]
+    value: Coin,
+
+    // note: as mentioned above, we're only hashing the value of the coin!
+    #[serde(with = "scalar_serde_helper")]
+    value_prehashed: PublicAttribute,
+
+    /// the hash of the deposit transaction
+    #[zeroize(skip)]
+    deposit_tx_hash: Hash,
+
+    /// base58 encoded private key ensuring the depositer requested these attributes
+    signing_key: identity::PrivateKey,
+
+    /// base58 encoded private key ensuring only this client receives the signature share
+    unused_ed25519: encryption::PrivateKey,
+}
+
+impl BandwidthVoucherIssuanceData {
+    pub fn new(
+        value: impl Into<Coin>,
+        deposit_tx_hash: Hash,
+        signing_key: identity::PrivateKey,
+        unused_ed25519: encryption::PrivateKey,
+    ) -> Self {
+        let value = value.into();
+        let value_prehashed = hash_to_scalar(value.amount.to_string());
+
+        BandwidthVoucherIssuanceData {
+            value,
+            value_prehashed,
+            deposit_tx_hash,
+            signing_key,
+            unused_ed25519,
+        }
+    }
+
+    pub fn request_plaintext(request: &BlindSignRequest, tx_hash: Hash) -> Vec<u8> {
+        let mut message = request.to_bytes();
+        message.extend_from_slice(tx_hash.as_bytes());
+        message
+    }
+
+    fn request_signature(&self, signing_request: &CredentialSigningData) -> identity::Signature {
+        let message =
+            Self::request_plaintext(&signing_request.blind_sign_request, self.deposit_tx_hash);
+        self.signing_key.sign(message)
+    }
+
+    pub fn create_blind_sign_request_body(
+        &self,
+        signing_request: &CredentialSigningData,
+    ) -> BlindSignRequestBody {
+        let request_signature = self.request_signature(signing_request);
+
+        BlindSignRequestBody::new(
+            signing_request.blind_sign_request.clone(),
+            self.deposit_tx_hash,
+            request_signature,
+            signing_request.public_attributes_plain.clone(),
+        )
+    }
+
+    pub async fn obtain_blinded_credential(
+        &self,
+        client: &nym_validator_client::client::NymApiClient,
+        request_body: &BlindSignRequestBody,
+    ) -> Result<BlindedSignature, Error> {
+        let server_response = client.blind_sign(request_body).await?;
+        Ok(server_response.blinded_signature)
+    }
+
+    pub fn value_plain(&self) -> String {
+        self.value.amount.to_string()
+    }
+
+    pub fn value_attribute(&self) -> &Attribute {
+        &self.value_prehashed
+    }
+
+    pub fn tx_hash(&self) -> Hash {
+        self.deposit_tx_hash
+    }
+
+    pub fn identity_key(&self) -> &identity::PrivateKey {
+        &self.signing_key
+    }
+
+    pub fn encryption_key(&self) -> &encryption::PrivateKey {
+        &self.unused_ed25519
+    }
+}
@@ -1,4 +1,4 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 pub mod bandwidth;
@@ -1,13 +1,11 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::coconut::bandwidth::BandwidthVoucher;
+use crate::coconut::bandwidth::IssuanceBandwidthCredential;
 use crate::error::Error;
 use log::{debug, warn};
-use nym_api_requests::coconut::BlindSignRequestBody;
-use nym_coconut_interface::{
-    aggregate_signature_shares, aggregate_verification_keys, prove_bandwidth_credential, Attribute,
-    Credential, Parameters, Signature, SignatureShare, VerificationKey,
+use nym_credentials_interface::{
+    aggregate_verification_keys, Signature, SignatureShare, VerificationKey,
 };
 use nym_validator_client::client::CoconutApiClient;

@@ -30,44 +28,8 @@ pub async fn obtain_aggregate_verification_key(
    Ok(aggregate_verification_keys(&shares, Some(&indices))?)
 }

-async fn obtain_partial_credential(
-    params: &Parameters,
-    voucher: &BandwidthVoucher,
-    client: &nym_validator_client::client::NymApiClient,
-    validator_vk: &VerificationKey,
-) -> Result<Signature, Error> {
-    let public_attributes_plain = voucher.get_public_attributes_plain();
-    let blind_sign_request = voucher.blind_sign_request();
-    let request_signature = voucher.sign();
-
-    let blind_sign_request_body = BlindSignRequestBody::new(
-        blind_sign_request.clone(),
-        voucher.tx_hash(),
-        request_signature,
-        public_attributes_plain,
-    );
-    let response = client.blind_sign(&blind_sign_request_body).await?;
-
-    let blinded_signature = response.blinded_signature;
-
-    let public_attributes = voucher.get_public_attributes();
-    let private_attributes = voucher.get_private_attributes();
-
-    let unblinded_signature = blinded_signature.unblind_and_verify(
-        params,
-        validator_vk,
-        &private_attributes,
-        &public_attributes,
-        &blind_sign_request.get_commitment_hash(),
-        voucher.pedersen_commitments_openings(),
-    )?;
-
-    Ok(unblinded_signature)
-}
-
 pub async fn obtain_aggregate_signature(
-    params: &Parameters,
-    voucher: &BandwidthVoucher,
+    voucher: &IssuanceBandwidthCredential,
    coconut_api_clients: &[CoconutApiClient],
    threshold: u64,
 ) -> Result<Signature, Error> {
@@ -75,16 +37,9 @@ pub async fn obtain_aggregate_signature(
        return Err(Error::NoValidatorsAvailable);
    }
    let mut shares = Vec::with_capacity(coconut_api_clients.len());
-    let validators_partial_vks: Vec<_> = coconut_api_clients
-        .iter()
-        .map(|api_client| api_client.verification_key.clone())
-        .collect();
-    let indices: Vec<_> = coconut_api_clients
-        .iter()
-        .map(|api_client| api_client.node_id)
-        .collect();
-    let verification_key =
-        aggregate_verification_keys(&validators_partial_vks, Some(indices.as_ref()))?;
+    let verification_key = obtain_aggregate_verification_key(coconut_api_clients).await?;
+
+    let request = voucher.prepare_for_signing();

    for coconut_api_client in coconut_api_clients.iter() {
        debug!(
@@ -92,13 +47,13 @@ pub async fn obtain_aggregate_signature(
            coconut_api_client.api_client.api_url()
        );

-        match obtain_partial_credential(
-            params,
-            voucher,
-            &coconut_api_client.api_client,
-            &coconut_api_client.verification_key,
-        )
-        .await
+        match voucher
+            .obtain_partial_credential(
+                &coconut_api_client.api_client,
+                &coconut_api_client.verification_key,
+                Some(request.clone()),
+            )
+            .await
        {
            Ok(signature) => {
                let share = SignatureShare::new(signature, coconut_api_client.node_id);
@@ -116,42 +71,27 @@ pub async fn obtain_aggregate_signature(
        return Err(Error::NotEnoughShares);
    }

-    let public_attributes = voucher.get_public_attributes();
-    let private_attributes = voucher.get_private_attributes();
-
-    let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
-    attributes.extend_from_slice(&private_attributes);
-    attributes.extend_from_slice(&public_attributes);
-
-    aggregate_signature_shares(params, &verification_key, &attributes, &shares)
-        .map_err(Error::SignatureAggregationError)
+    voucher.aggregate_signature_shares(&verification_key, &shares)
 }

-// TODO: better type flow
-#[allow(clippy::too_many_arguments)]
-pub fn prepare_credential_for_spending(
-    params: &Parameters,
-    voucher_value: u64,
-    voucher_info: String,
-    serial_number: &Attribute,
-    binding_number: &Attribute,
-    epoch_id: u64,
-    signature: &Signature,
-    verification_key: &VerificationKey,
-) -> Result<Credential, Error> {
-    let theta = prove_bandwidth_credential(
-        params,
-        verification_key,
-        signature,
-        serial_number,
-        binding_number,
-    )?;
+pub(crate) mod scalar_serde_helper {
+    use bls12_381::Scalar;
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+    use zeroize::Zeroizing;

-    Ok(Credential::new(
-        BandwidthVoucher::ENCODED_ATTRIBUTES,
-        theta,
-        voucher_value,
-        voucher_info,
-        epoch_id,
-    ))
+    pub fn serialize<S: Serializer>(scalar: &Scalar, serializer: S) -> Result<S::Ok, S::Error> {
+        scalar.to_bytes().serialize(serializer)
+    }
+
+    pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Scalar, D::Error> {
+        let b = <[u8; 32]>::deserialize(deserializer)?;
+
+        // make sure the bytes get zeroed
+        let bytes = Zeroizing::new(b);
+
+        let maybe_scalar: Option<Scalar> = Scalar::from_bytes(&bytes).into();
+        maybe_scalar.ok_or(serde::de::Error::custom(
+            "did not construct a valid bls12-381 scalar out of the provided bytes",
+        ))
+    }
 }
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

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

@@ -12,6 +12,9 @@ pub enum Error {
    #[error("IO error")]
    IOError(#[from] std::io::Error),

+    #[error("failed to (de)serialize credential structure: {0}")]
+    SerializationFailure(#[from] bincode::Error),
+
    #[error("The detailed description is yet to be determined")]
    BandwidthCredentialError,

@@ -4,4 +4,8 @@
 pub mod coconut;
 pub mod error;

+pub use coconut::bandwidth::{
+    CredentialSigningData, CredentialSpendingData, IssuanceBandwidthCredential,
+    IssuedBandwidthCredential,
+};
 pub use coconut::utils::{obtain_aggregate_signature, obtain_aggregate_verification_key};
@@ -8,8 +8,6 @@ documentation.workspace = true
 edition.workspace = true
 license.workspace = true

-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 bincode = "1.3.3"
 bytes = "1.5.0"
@@ -17,3 +15,5 @@ nym-sphinx = { path = "../nymsphinx" }
 rand = "0.8.5"
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
+tokio = { workspace = true, features = ["time"] }
+tokio-util = { workspace = true, features = ["codec"] }
@@ -0,0 +1,123 @@
+use std::time::Duration;
+
+use bytes::{Buf, Bytes, BytesMut};
+use tokio_util::codec::{Decoder, Encoder};
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("{0}")]
+    IO(#[from] std::io::Error),
+}
+
+pub const BUFFER_TIMEOUT: Duration = Duration::from_millis(20);
+
+// TODO: increase this to make max out effective sphinx payload size. Sphinx packets also carry the
+// MixAck so that's why we can't just use 2kb.
+pub const MAX_PACKET_SIZE: usize = 1500;
+
+// Each IP packet is prefixed by a 2 byte length prefix
+const LENGTH_PREFIX_SIZE: usize = 2;
+
+// Tokio codec for bundling multiple IP packets into one buffer that is at most 1500 bytes long.
+// These packets are separated by a 2 byte length prefix. We need a timer so that we don't wait too
+// long for the buffer to fill up, since this kills latency.
+pub struct MultiIpPacketCodec {
+    buffer: BytesMut,
+    buffer_timeout: tokio::time::Interval,
+}
+
+impl MultiIpPacketCodec {
+    pub fn new(buffer_timeout: Duration) -> Self {
+        MultiIpPacketCodec {
+            buffer: BytesMut::new(),
+            buffer_timeout: tokio::time::interval(buffer_timeout),
+        }
+    }
+
+    // Append a packet to the buffer and return the buffer if it's full
+    pub fn append_packet(&mut self, packet: Bytes) -> Option<Bytes> {
+        let mut bundled_packets = BytesMut::new();
+        self.encode(packet, &mut bundled_packets).unwrap();
+        if bundled_packets.is_empty() {
+            None
+        } else {
+            // log::info!("Sphinx packet utilization: {:.2}", self.buffer.len() as f64 / MAX_PACKET_SIZE as f64);
+            Some(bundled_packets.freeze())
+        }
+    }
+
+    // Flush the current buffer and return it.
+    fn flush_current_buffer(&mut self) -> Bytes {
+        let mut output_buffer = BytesMut::new();
+        std::mem::swap(&mut output_buffer, &mut self.buffer);
+        output_buffer.freeze()
+    }
+
+    // Wait for the buffer_timeout to tick and then flush the buffer.
+    // This is useful when we want to send the buffer even if it's not full.
+    pub async fn buffer_timeout(&mut self) -> Option<Bytes> {
+        // Wait for buffer_timeout to tick
+        let _ = self.buffer_timeout.tick().await;
+
+        // Flush the buffer and return it
+        let packets = self.flush_current_buffer();
+        if packets.is_empty() {
+            None
+        } else {
+            Some(packets)
+        }
+    }
+}
+
+impl Encoder<Bytes> for MultiIpPacketCodec {
+    type Error = Error;
+
+    fn encode(&mut self, packet: Bytes, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        if self.buffer.is_empty() {
+            self.buffer_timeout.reset();
+        }
+        let packet_size = packet.len();
+
+        if self.buffer.len() + packet_size + LENGTH_PREFIX_SIZE > MAX_PACKET_SIZE {
+            // If the packet doesn't fit in the buffer, send the buffer and then add it to the buffer
+            dst.extend_from_slice(&self.buffer);
+            self.buffer = BytesMut::new();
+            self.buffer_timeout.reset();
+        }
+
+        // Add the packet size
+        self.buffer
+            .extend_from_slice(&(packet_size as u16).to_be_bytes());
+        // Add the packet to the buffer
+        self.buffer.extend_from_slice(&packet);
+
+        Ok(())
+    }
+}
+
+impl Decoder for MultiIpPacketCodec {
+    type Item = Bytes;
+    type Error = Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if src.len() < LENGTH_PREFIX_SIZE {
+            // Not enough bytes to read the length prefix
+            return Ok(None);
+        }
+
+        let packet_size = u16::from_be_bytes([src[0], src[1]]) as usize;
+
+        if src.len() < packet_size + LENGTH_PREFIX_SIZE {
+            // Not enough bytes to read the packet
+            return Ok(None);
+        }
+
+        // Remove the length prefix
+        src.advance(LENGTH_PREFIX_SIZE);
+
+        // Read the packet
+        let packet = src.split_to(packet_size);
+
+        Ok(Some(packet.freeze()))
+    }
+}
@@ -1,319 +1,8 @@
-use std::net::IpAddr;
+pub mod codec;
+pub mod request;
+pub mod response;

-use nym_sphinx::addressing::clients::Recipient;
-use serde::{Deserialize, Serialize};
-
-pub const CURRENT_VERSION: u8 = 1;
-
-fn generate_random() -> u64 {
-    use rand::RngCore;
-    let mut rng = rand::rngs::OsRng;
-    rng.next_u64()
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct IpPacketRequest {
-    pub version: u8,
-    pub data: IpPacketRequestData,
-}
-
-impl IpPacketRequest {
-    pub fn new_static_connect_request(
-        ip: IpAddr,
-        reply_to: Recipient,
-        reply_to_hops: Option<u8>,
-        reply_to_avg_mix_delays: Option<f64>,
-    ) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                version: CURRENT_VERSION,
-                data: IpPacketRequestData::StaticConnect(StaticConnectRequest {
-                    request_id,
-                    ip,
-                    reply_to,
-                    reply_to_hops,
-                    reply_to_avg_mix_delays,
-                }),
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_dynamic_connect_request(
-        reply_to: Recipient,
-        reply_to_hops: Option<u8>,
-        reply_to_avg_mix_delays: Option<f64>,
-    ) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                version: CURRENT_VERSION,
-                data: IpPacketRequestData::DynamicConnect(DynamicConnectRequest {
-                    request_id,
-                    reply_to,
-                    reply_to_hops,
-                    reply_to_avg_mix_delays,
-                }),
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketRequestData::Data(DataRequest { ip_packet }),
-        }
-    }
-
-    pub fn id(&self) -> Option<u64> {
-        match &self.data {
-            IpPacketRequestData::StaticConnect(request) => Some(request.request_id),
-            IpPacketRequestData::DynamicConnect(request) => Some(request.request_id),
-            IpPacketRequestData::Data(_) => None,
-        }
-    }
-
-    pub fn recipient(&self) -> Option<&Recipient> {
-        match &self.data {
-            IpPacketRequestData::StaticConnect(request) => Some(&request.reply_to),
-            IpPacketRequestData::DynamicConnect(request) => Some(&request.reply_to),
-            IpPacketRequestData::Data(_) => None,
-        }
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-
-    pub fn from_reconstructed_message(
-        message: &nym_sphinx::receiver::ReconstructedMessage,
-    ) -> Result<Self, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().deserialize(&message.message)
-    }
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub enum IpPacketRequestData {
-    StaticConnect(StaticConnectRequest),
-    DynamicConnect(DynamicConnectRequest),
-    Data(DataRequest),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct StaticConnectRequest {
-    pub request_id: u64,
-    pub ip: IpAddr,
-    // The nym-address the response should be sent back to
-    pub reply_to: Recipient,
-    // The number of mix node hops that responses should take, in addition to the entry and exit
-    // node. Zero means only client -> entry -> exit -> client.
-    pub reply_to_hops: Option<u8>,
-    // The average delay at each mix node, in milliseconds. Currently this is not supported by the
-    // ip packet router.
-    pub reply_to_avg_mix_delays: Option<f64>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct DynamicConnectRequest {
-    pub request_id: u64,
-    // The nym-address the response should be sent back to
-    pub reply_to: Recipient,
-    // The number of mix node hops that responses should take, in addition to the entry and exit
-    // node. Zero means only client -> entry -> exit -> client.
-    pub reply_to_hops: Option<u8>,
-    // The average delay at each mix node, in milliseconds. Currently this is not supported by the
-    // ip packet router.
-    pub reply_to_avg_mix_delays: Option<f64>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct DataRequest {
-    pub ip_packet: bytes::Bytes,
-}
-
-// ---
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct IpPacketResponse {
-    pub version: u8,
-    pub data: IpPacketResponseData,
-}
-
-impl IpPacketResponse {
-    pub fn new_static_connect_success(request_id: u64, reply_to: Recipient) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
-                request_id,
-                reply_to,
-                reply: StaticConnectResponseReply::Success,
-            }),
-        }
-    }
-
-    pub fn new_static_connect_failure(
-        request_id: u64,
-        reply_to: Recipient,
-        reason: StaticConnectFailureReason,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
-                request_id,
-                reply_to,
-                reply: StaticConnectResponseReply::Failure(reason),
-            }),
-        }
-    }
-
-    pub fn new_dynamic_connect_success(request_id: u64, reply_to: Recipient, ip: IpAddr) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
-                request_id,
-                reply_to,
-                reply: DynamicConnectResponseReply::Success(DynamicConnectSuccess { ip }),
-            }),
-        }
-    }
-
-    pub fn new_dynamic_connect_failure(
-        request_id: u64,
-        reply_to: Recipient,
-        reason: DynamicConnectFailureReason,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
-                request_id,
-                reply_to,
-                reply: DynamicConnectResponseReply::Failure(reason),
-            }),
-        }
-    }
-
-    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::Data(DataResponse { ip_packet }),
-        }
-    }
-
-    pub fn id(&self) -> Option<u64> {
-        match &self.data {
-            IpPacketResponseData::StaticConnect(response) => Some(response.request_id),
-            IpPacketResponseData::DynamicConnect(response) => Some(response.request_id),
-            IpPacketResponseData::Data(_) => None,
-        }
-    }
-
-    pub fn recipient(&self) -> Option<&Recipient> {
-        match &self.data {
-            IpPacketResponseData::StaticConnect(response) => Some(&response.reply_to),
-            IpPacketResponseData::DynamicConnect(response) => Some(&response.reply_to),
-            IpPacketResponseData::Data(_) => None,
-        }
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-
-    pub fn from_reconstructed_message(
-        message: &nym_sphinx::receiver::ReconstructedMessage,
-    ) -> Result<Self, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().deserialize(&message.message)
-    }
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum IpPacketResponseData {
-    StaticConnect(StaticConnectResponse),
-    DynamicConnect(DynamicConnectResponse),
-    Data(DataResponse),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct StaticConnectResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: StaticConnectResponseReply,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum StaticConnectResponseReply {
-    Success,
-    Failure(StaticConnectFailureReason),
-}
-
-impl StaticConnectResponseReply {
-    pub fn is_success(&self) -> bool {
-        match self {
-            StaticConnectResponseReply::Success => true,
-            StaticConnectResponseReply::Failure(_) => false,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
-pub enum StaticConnectFailureReason {
-    #[error("requested ip address is already in use")]
-    RequestedIpAlreadyInUse,
-    #[error("requested nym-address is already in use")]
-    RequestedNymAddressAlreadyInUse,
-    #[error("{0}")]
-    Other(String),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct DynamicConnectResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: DynamicConnectResponseReply,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum DynamicConnectResponseReply {
-    Success(DynamicConnectSuccess),
-    Failure(DynamicConnectFailureReason),
-}
-
-impl DynamicConnectResponseReply {
-    pub fn is_success(&self) -> bool {
-        match self {
-            DynamicConnectResponseReply::Success(_) => true,
-            DynamicConnectResponseReply::Failure(_) => false,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct DynamicConnectSuccess {
-    pub ip: IpAddr,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
-pub enum DynamicConnectFailureReason {
-    #[error("requested nym-address is already in use")]
-    RequestedNymAddressAlreadyInUse,
-    #[error("no available ip address")]
-    NoAvailableIp,
-    #[error("{0}")]
-    Other(String),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct DataResponse {
-    pub ip_packet: bytes::Bytes,
-}
+pub const CURRENT_VERSION: u8 = 2;

 fn make_bincode_serializer() -> impl bincode::Options {
    use bincode::Options;
@@ -321,63 +10,3 @@ fn make_bincode_serializer() -> impl bincode::Options {
        .with_big_endian()
        .with_varint_encoding()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn check_size_of_request() {
-        let connect = IpPacketRequest {
-            version: 4,
-            data: IpPacketRequestData::StaticConnect(
-                StaticConnectRequest {
-                    request_id: 123,
-                    ip: IpAddr::from([10, 0, 0, 1]),
-                    reply_to: Recipient::try_from_base58_string("D1rrpsysCGCYXy9saP8y3kmNpGtJZUXN9SvFoUcqAsM9.9Ssso1ea5NfkbMASdiseDSjTN1fSWda5SgEVjdSN4CvV@GJqd3ZxpXWSNxTfx7B1pPtswpetH4LnJdFeLeuY5KUuN").unwrap(),
-                    reply_to_hops: None,
-                    reply_to_avg_mix_delays: None,
-                },
-            )
-        };
-        assert_eq!(connect.to_bytes().unwrap().len(), 107);
-    }
-
-    #[test]
-    fn check_size_of_data() {
-        let data = IpPacketRequest {
-            version: 4,
-            data: IpPacketRequestData::Data(DataRequest {
-                ip_packet: bytes::Bytes::from(vec![1u8; 32]),
-            }),
-        };
-        assert_eq!(data.to_bytes().unwrap().len(), 35);
-    }
-
-    #[test]
-    fn serialize_and_deserialize_data_request() {
-        let data = IpPacketRequest {
-            version: 4,
-            data: IpPacketRequestData::Data(DataRequest {
-                ip_packet: bytes::Bytes::from(vec![1, 2, 4, 2, 5]),
-            }),
-        };
-
-        let serialized = data.to_bytes().unwrap();
-        let deserialized = IpPacketRequest::from_reconstructed_message(
-            &nym_sphinx::receiver::ReconstructedMessage {
-                message: serialized,
-                sender_tag: None,
-            },
-        )
-        .unwrap();
-
-        assert_eq!(deserialized.version, 4);
-        assert_eq!(
-            deserialized.data,
-            IpPacketRequestData::Data(DataRequest {
-                ip_packet: bytes::Bytes::from(vec![1, 2, 4, 2, 5]),
-            })
-        );
-    }
-}
@@ -0,0 +1,221 @@
+use std::net::IpAddr;
+
+use nym_sphinx::addressing::clients::Recipient;
+use serde::{Deserialize, Serialize};
+
+use crate::{make_bincode_serializer, CURRENT_VERSION};
+
+fn generate_random() -> u64 {
+    use rand::RngCore;
+    let mut rng = rand::rngs::OsRng;
+    rng.next_u64()
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct IpPacketRequest {
+    pub version: u8,
+    pub data: IpPacketRequestData,
+}
+
+impl IpPacketRequest {
+    pub fn new_static_connect_request(
+        ip: IpAddr,
+        reply_to: Recipient,
+        reply_to_hops: Option<u8>,
+        reply_to_avg_mix_delays: Option<f64>,
+    ) -> (Self, u64) {
+        let request_id = generate_random();
+        (
+            Self {
+                version: CURRENT_VERSION,
+                data: IpPacketRequestData::StaticConnect(StaticConnectRequest {
+                    request_id,
+                    ip,
+                    reply_to,
+                    reply_to_hops,
+                    reply_to_avg_mix_delays,
+                }),
+            },
+            request_id,
+        )
+    }
+
+    pub fn new_dynamic_connect_request(
+        reply_to: Recipient,
+        reply_to_hops: Option<u8>,
+        reply_to_avg_mix_delays: Option<f64>,
+    ) -> (Self, u64) {
+        let request_id = generate_random();
+        (
+            Self {
+                version: CURRENT_VERSION,
+                data: IpPacketRequestData::DynamicConnect(DynamicConnectRequest {
+                    request_id,
+                    reply_to,
+                    reply_to_hops,
+                    reply_to_avg_mix_delays,
+                }),
+            },
+            request_id,
+        )
+    }
+
+    pub fn new_disconnect_request(reply_to: Recipient) -> (Self, u64) {
+        let request_id = generate_random();
+        (
+            Self {
+                version: CURRENT_VERSION,
+                data: IpPacketRequestData::Disconnect(DisconnectRequest {
+                    request_id,
+                    reply_to,
+                }),
+            },
+            request_id,
+        )
+    }
+
+    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketRequestData::Data(DataRequest { ip_packet }),
+        }
+    }
+
+    pub fn id(&self) -> Option<u64> {
+        match &self.data {
+            IpPacketRequestData::StaticConnect(request) => Some(request.request_id),
+            IpPacketRequestData::DynamicConnect(request) => Some(request.request_id),
+            IpPacketRequestData::Disconnect(request) => Some(request.request_id),
+            IpPacketRequestData::Data(_) => None,
+        }
+    }
+
+    pub fn recipient(&self) -> Option<&Recipient> {
+        match &self.data {
+            IpPacketRequestData::StaticConnect(request) => Some(&request.reply_to),
+            IpPacketRequestData::DynamicConnect(request) => Some(&request.reply_to),
+            IpPacketRequestData::Disconnect(request) => Some(&request.reply_to),
+            IpPacketRequestData::Data(_) => None,
+        }
+    }
+
+    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
+        use bincode::Options;
+        make_bincode_serializer().serialize(self)
+    }
+
+    pub fn from_reconstructed_message(
+        message: &nym_sphinx::receiver::ReconstructedMessage,
+    ) -> Result<Self, bincode::Error> {
+        use bincode::Options;
+        make_bincode_serializer().deserialize(&message.message)
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub enum IpPacketRequestData {
+    StaticConnect(StaticConnectRequest),
+    DynamicConnect(DynamicConnectRequest),
+    Disconnect(DisconnectRequest),
+    Data(DataRequest),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct StaticConnectRequest {
+    pub request_id: u64,
+    pub ip: IpAddr,
+    // The nym-address the response should be sent back to
+    pub reply_to: Recipient,
+    // The number of mix node hops that responses should take, in addition to the entry and exit
+    // node. Zero means only client -> entry -> exit -> client.
+    pub reply_to_hops: Option<u8>,
+    // The average delay at each mix node, in milliseconds. Currently this is not supported by the
+    // ip packet router.
+    pub reply_to_avg_mix_delays: Option<f64>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct DynamicConnectRequest {
+    pub request_id: u64,
+    // The nym-address the response should be sent back to
+    pub reply_to: Recipient,
+    // The number of mix node hops that responses should take, in addition to the entry and exit
+    // node. Zero means only client -> entry -> exit -> client.
+    pub reply_to_hops: Option<u8>,
+    // The average delay at each mix node, in milliseconds. Currently this is not supported by the
+    // ip packet router.
+    pub reply_to_avg_mix_delays: Option<f64>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct DisconnectRequest {
+    pub request_id: u64,
+    // The nym-address the response should be sent back to
+    pub reply_to: Recipient,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct DataRequest {
+    pub ip_packet: bytes::Bytes,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn check_size_of_request() {
+        let connect = IpPacketRequest {
+            version: 4,
+            data: IpPacketRequestData::StaticConnect(
+                StaticConnectRequest {
+                    request_id: 123,
+                    ip: IpAddr::from([10, 0, 0, 1]),
+                    reply_to: Recipient::try_from_base58_string("D1rrpsysCGCYXy9saP8y3kmNpGtJZUXN9SvFoUcqAsM9.9Ssso1ea5NfkbMASdiseDSjTN1fSWda5SgEVjdSN4CvV@GJqd3ZxpXWSNxTfx7B1pPtswpetH4LnJdFeLeuY5KUuN").unwrap(),
+                    reply_to_hops: None,
+                    reply_to_avg_mix_delays: None,
+                },
+            )
+        };
+        assert_eq!(connect.to_bytes().unwrap().len(), 107);
+    }
+
+    #[test]
+    fn check_size_of_data() {
+        let data = IpPacketRequest {
+            version: 4,
+            data: IpPacketRequestData::Data(DataRequest {
+                ip_packet: bytes::Bytes::from(vec![1u8; 32]),
+            }),
+        };
+        assert_eq!(data.to_bytes().unwrap().len(), 35);
+    }
+
+    #[test]
+    fn serialize_and_deserialize_data_request() {
+        let data = IpPacketRequest {
+            version: 4,
+            data: IpPacketRequestData::Data(DataRequest {
+                ip_packet: bytes::Bytes::from(vec![1, 2, 4, 2, 5]),
+            }),
+        };
+
+        let serialized = data.to_bytes().unwrap();
+        let deserialized = IpPacketRequest::from_reconstructed_message(
+            &nym_sphinx::receiver::ReconstructedMessage {
+                message: serialized,
+                sender_tag: None,
+            },
+        )
+        .unwrap();
+
+        assert_eq!(deserialized.version, 4);
+        assert_eq!(
+            deserialized.data,
+            IpPacketRequestData::Data(DataRequest {
+                ip_packet: bytes::Bytes::from(vec![1, 2, 4, 2, 5]),
+            })
+        );
+    }
+}
@@ -0,0 +1,262 @@
+use std::net::IpAddr;
+
+use nym_sphinx::addressing::clients::Recipient;
+use serde::{Deserialize, Serialize};
+
+use crate::{make_bincode_serializer, CURRENT_VERSION};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct IpPacketResponse {
+    pub version: u8,
+    pub data: IpPacketResponseData,
+}
+
+impl IpPacketResponse {
+    pub fn new_static_connect_success(request_id: u64, reply_to: Recipient) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
+                request_id,
+                reply_to,
+                reply: StaticConnectResponseReply::Success,
+            }),
+        }
+    }
+
+    pub fn new_static_connect_failure(
+        request_id: u64,
+        reply_to: Recipient,
+        reason: StaticConnectFailureReason,
+    ) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
+                request_id,
+                reply_to,
+                reply: StaticConnectResponseReply::Failure(reason),
+            }),
+        }
+    }
+
+    pub fn new_dynamic_connect_success(request_id: u64, reply_to: Recipient, ip: IpAddr) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
+                request_id,
+                reply_to,
+                reply: DynamicConnectResponseReply::Success(DynamicConnectSuccess { ip }),
+            }),
+        }
+    }
+
+    pub fn new_dynamic_connect_failure(
+        request_id: u64,
+        reply_to: Recipient,
+        reason: DynamicConnectFailureReason,
+    ) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
+                request_id,
+                reply_to,
+                reply: DynamicConnectResponseReply::Failure(reason),
+            }),
+        }
+    }
+
+    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::Data(DataResponse { ip_packet }),
+        }
+    }
+
+    pub fn new_version_mismatch(
+        request_id: u64,
+        reply_to: Recipient,
+        request_version: u8,
+        our_version: u8,
+    ) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::Error(ErrorResponse {
+                request_id,
+                reply_to,
+                reply: ErrorResponseReply::VersionMismatch {
+                    request_version,
+                    response_version: our_version,
+                },
+            }),
+        }
+    }
+
+    pub fn new_data_error_response(reply_to: Recipient, reply: ErrorResponseReply) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::Error(ErrorResponse {
+                request_id: 0,
+                reply_to,
+                reply,
+            }),
+        }
+    }
+
+    pub fn id(&self) -> Option<u64> {
+        match &self.data {
+            IpPacketResponseData::StaticConnect(response) => Some(response.request_id),
+            IpPacketResponseData::DynamicConnect(response) => Some(response.request_id),
+            IpPacketResponseData::Disconnect(response) => Some(response.request_id),
+            IpPacketResponseData::Data(_) => None,
+            IpPacketResponseData::Error(response) => Some(response.request_id),
+        }
+    }
+
+    pub fn recipient(&self) -> Option<&Recipient> {
+        match &self.data {
+            IpPacketResponseData::StaticConnect(response) => Some(&response.reply_to),
+            IpPacketResponseData::DynamicConnect(response) => Some(&response.reply_to),
+            IpPacketResponseData::Disconnect(response) => Some(&response.reply_to),
+            IpPacketResponseData::Data(_) => None,
+            IpPacketResponseData::Error(response) => Some(&response.reply_to),
+        }
+    }
+
+    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
+        use bincode::Options;
+        make_bincode_serializer().serialize(self)
+    }
+
+    pub fn from_reconstructed_message(
+        message: &nym_sphinx::receiver::ReconstructedMessage,
+    ) -> Result<Self, bincode::Error> {
+        use bincode::Options;
+        make_bincode_serializer().deserialize(&message.message)
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum IpPacketResponseData {
+    StaticConnect(StaticConnectResponse),
+    DynamicConnect(DynamicConnectResponse),
+    Disconnect(DisconnectResponse),
+    Data(DataResponse),
+    Error(ErrorResponse),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct StaticConnectResponse {
+    pub request_id: u64,
+    pub reply_to: Recipient,
+    pub reply: StaticConnectResponseReply,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum StaticConnectResponseReply {
+    Success,
+    Failure(StaticConnectFailureReason),
+}
+
+impl StaticConnectResponseReply {
+    pub fn is_success(&self) -> bool {
+        match self {
+            StaticConnectResponseReply::Success => true,
+            StaticConnectResponseReply::Failure(_) => false,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
+pub enum StaticConnectFailureReason {
+    #[error("requested ip address is already in use")]
+    RequestedIpAlreadyInUse,
+    #[error("requested nym-address is already in use")]
+    RequestedNymAddressAlreadyInUse,
+    #[error("{0}")]
+    Other(String),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct DynamicConnectResponse {
+    pub request_id: u64,
+    pub reply_to: Recipient,
+    pub reply: DynamicConnectResponseReply,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum DynamicConnectResponseReply {
+    Success(DynamicConnectSuccess),
+    Failure(DynamicConnectFailureReason),
+}
+
+impl DynamicConnectResponseReply {
+    pub fn is_success(&self) -> bool {
+        match self {
+            DynamicConnectResponseReply::Success(_) => true,
+            DynamicConnectResponseReply::Failure(_) => false,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct DynamicConnectSuccess {
+    pub ip: IpAddr,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
+pub enum DynamicConnectFailureReason {
+    #[error("requested nym-address is already in use")]
+    RequestedNymAddressAlreadyInUse,
+    #[error("no available ip address")]
+    NoAvailableIp,
+    #[error("{0}")]
+    Other(String),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct DisconnectResponse {
+    pub request_id: u64,
+    pub reply_to: Recipient,
+    pub reply: DisconnectResponseReply,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum DisconnectResponseReply {
+    Success,
+    Failure(DisconnectFailureReason),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
+pub enum DisconnectFailureReason {
+    #[error("requested nym-address is not currently connected")]
+    RequestedNymAddressNotConnected,
+    #[error("{0}")]
+    Other(String),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct DataResponse {
+    pub ip_packet: bytes::Bytes,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    pub request_id: u64,
+    pub reply_to: Recipient,
+    pub reply: ErrorResponseReply,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
+pub enum ErrorResponseReply {
+    #[error("{msg}")]
+    Generic { msg: String },
+    #[error(
+        "version mismatch: response is v{request_version} and response is v{response_version}"
+    )]
+    VersionMismatch {
+        request_version: u8,
+        response_version: u8,
+    },
+    #[error("destination failed exit policy filter check: {dst}")]
+    ExitPolicyFilterCheckFailed { dst: String },
+}
@@ -11,6 +11,7 @@ repository.workspace = true
 cfg-if = { workspace = true }
 dotenvy = { workspace = true }
 hex-literal = "0.3.3"
+log = { workspace = true }
 once_cell = { workspace = true }
 schemars = { workspace = true, features = ["preserve_order"] }
 serde = { workspace = true, features = ["derive"]}
@@ -400,11 +400,25 @@ fn fix_deprecated_environmental_variables() {
    }
 }

+// Read the variables from the file and log what the corresponding values in the environment are.
+fn print_env_vars_with_keys_in_file<P: AsRef<Path> + Copy>(config_env_file: P) {
+    let items = dotenvy::from_path_iter(config_env_file)
+        .expect("Invalid path to environment configuration file");
+    for item in items {
+        let (key, val) = item.expect("Invalid item in environment configuration file");
+        log::debug!("{}: {}", key, val);
+    }
+}
+
 pub fn setup_env<P: AsRef<Path>>(config_env_file: Option<P>) {
    match std::env::var(var_names::CONFIGURED) {
        // if the configuration is not already set in the env vars
        Err(std::env::VarError::NotPresent) => {
-            if let Some(config_env_file) = config_env_file {
+            if let Some(config_env_file) = &config_env_file {
+                log::debug!(
+                    "Loading environment variables from {:?}",
+                    config_env_file.as_ref()
+                );
                dotenvy::from_path(config_env_file)
                    .expect("Invalid path to environment configuration file");
                fix_deprecated_environmental_variables();
@@ -412,17 +426,25 @@ pub fn setup_env<P: AsRef<Path>>(config_env_file: Option<P>) {
                // if nothing is set, the use mainnet defaults
                // if the user has not set `CONFIGURED`, then even if they set any of the env variables,
                // overwrite them
+                log::debug!("Loading mainnet defaults");
                crate::mainnet::export_to_env();
            }
        }
-        Err(_) => crate::mainnet::export_to_env(),
+        Err(_) => {
+            log::debug!("Environment variables already set. Using them");
+            crate::mainnet::export_to_env()
+        }
        _ => {
            fix_deprecated_environmental_variables();
        }
    }

    // if we haven't explicitly defined any of the constants, fallback to defaults
-    crate::mainnet::export_to_env_if_not_set()
+    crate::mainnet::export_to_env_if_not_set();
+
+    if let Some(config_env_file) = &config_env_file {
+        print_env_vars_with_keys_in_file(config_env_file);
+    }
 }

 // Name of the event triggered by the eth contract. If the event name is changed,
@@ -435,6 +457,9 @@ pub const ETH_ERC20_APPROVE_FUNCTION_NAME: &str = "approve";
 /// How much bandwidth (in bytes) one token can buy
 pub const BYTES_PER_UTOKEN: u64 = 1024;

+/// How much bandwidth (in bytes) one freepass provides
+pub const BYTES_PER_FREEPASS: u64 = 1024 * 1024 * 1024; // 1GB
+
 /// Threshold for claiming more bandwidth: 1 MB
 pub const REMAINING_BANDWIDTH_THRESHOLD: i64 = 1024 * 1024;
 /// How many ERC20 tokens should be burned to buy bandwidth
@@ -444,10 +469,6 @@ pub const UTOKENS_TO_BURN: u64 = TOKENS_TO_BURN * 1000000;
 /// Default bandwidth (in bytes) that we try to buy
 pub const BANDWIDTH_VALUE: u64 = UTOKENS_TO_BURN * BYTES_PER_UTOKEN;

-pub const VOUCHER_INFO: &str = "BandwidthVoucher";
-
-pub const ETH_MIN_BLOCK_DEPTH: usize = 7;
-
 /// Defaults Cosmos Hub/ATOM path
 pub const COSMOS_DERIVATION_PATH: &str = "m/44'/118'/0'/0/0";
 // as set by validators in their configs
@@ -1,4 +1,4 @@
-use crate::{BlindSignRequest, BlindedSignature, Bytable, Theta};
+use crate::{BlindSignRequest, BlindedSignature, Bytable, VerifyCredentialRequest};

 macro_rules! impl_clone {
    ($struct:ident) => {
@@ -12,4 +12,4 @@ macro_rules! impl_clone {

 impl_clone!(BlindSignRequest);
 impl_clone!(BlindedSignature);
-impl_clone!(Theta);
+impl_clone!(VerifyCredentialRequest);
@@ -1,7 +1,8 @@
 use crate::elgamal::PrivateKey;
 use crate::scheme::SecretKey;
 use crate::{
-    Base58, BlindSignRequest, BlindedSignature, PublicKey, Signature, Theta, VerificationKey,
+    Base58, BlindSignRequest, BlindedSignature, PublicKey, Signature, VerificationKey,
+    VerifyCredentialRequest,
 };
 use serde::de::Unexpected;
 use serde::{de::Error, de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
@@ -53,4 +54,4 @@ impl_serde!(PrivateKey, V4);
 impl_serde!(BlindSignRequest, V5);
 impl_serde!(BlindedSignature, V6);
 impl_serde!(Signature, V7);
-impl_serde!(Theta, V8);
+impl_serde!(VerifyCredentialRequest, V8);
@@ -14,6 +14,7 @@ pub use scheme::issuance::blind_sign;
 pub use scheme::issuance::prepare_blind_sign;
 pub use scheme::issuance::verify_partial_blind_signature;
 pub use scheme::issuance::BlindSignRequest;
+pub use scheme::keygen::keygen;
 pub use scheme::keygen::ttp_keygen;
 pub use scheme::keygen::KeyPair;
 pub use scheme::keygen::SecretKey;
@@ -23,7 +24,7 @@ pub use scheme::setup::Parameters;
 pub use scheme::verification::check_vk_pairing;
 pub use scheme::verification::prove_bandwidth_credential;
 pub use scheme::verification::verify_credential;
-pub use scheme::verification::Theta;
+pub use scheme::verification::VerifyCredentialRequest;
 pub use scheme::BlindedSignature;
 pub use scheme::Signature;
 pub use scheme::SignatureShare;
@@ -565,7 +565,6 @@ impl TryFrom<&[u8]> for KeyPair {
 /// Generate a single Coconut keypair ((x, y0, y1...), (g2^x, g2^y0, ...)).
 /// It is not suitable for threshold credentials as all subsequent calls to `keygen` generate keys
 /// that are independent of each other.
-#[cfg(test)]
 pub fn keygen(params: &Parameters) -> KeyPair {
    let attributes = params.gen_hs().len();

@@ -44,11 +44,11 @@ impl Parameters {
        })
    }

-    pub(crate) fn gen1(&self) -> &G1Affine {
+    pub fn gen1(&self) -> &G1Affine {
        &self.g1
    }

-    pub(crate) fn gen2(&self) -> &G2Affine {
+    pub fn gen2(&self) -> &G2Affine {
        &self.g2
    }

@@ -56,7 +56,7 @@ impl Parameters {
        &self._g2_prepared_miller
    }

-    pub(crate) fn gen_hs(&self) -> &[G1Affine] {
+    pub fn gen_hs(&self) -> &[G1Affine] {
        &self.hs
    }

@@ -21,7 +21,7 @@ use crate::Attribute;
 // TODO NAMING: this whole thing
 // Theta
 #[derive(Debug, PartialEq, Eq)]
-pub struct Theta {
+pub struct VerifyCredentialRequest {
    // blinded_message (kappa)
    pub blinded_message: G2Projective,
    // blinded serial number (zeta)
@@ -32,10 +32,10 @@ pub struct Theta {
    pub pi_v: ProofKappaZeta,
 }

-impl TryFrom<&[u8]> for Theta {
+impl TryFrom<&[u8]> for VerifyCredentialRequest {
    type Error = CoconutError;

-    fn try_from(bytes: &[u8]) -> Result<Theta> {
+    fn try_from(bytes: &[u8]) -> Result<VerifyCredentialRequest> {
        if bytes.len() < 288 {
            return Err(
                CoconutError::Deserialization(
@@ -66,7 +66,7 @@ impl TryFrom<&[u8]> for Theta {

        let pi_v = ProofKappaZeta::from_bytes(&bytes[288..])?;

-        Ok(Theta {
+        Ok(VerifyCredentialRequest {
            blinded_message,
            blinded_serial_number,
            credential,
@@ -75,7 +75,7 @@ impl TryFrom<&[u8]> for Theta {
    }
 }

-impl Theta {
+impl VerifyCredentialRequest {
    fn verify_proof(&self, params: &Parameters, verification_key: &VerificationKey) -> bool {
        self.pi_v.verify(
            params,
@@ -107,8 +107,8 @@ impl Theta {
        bytes
    }

-    pub fn from_bytes(bytes: &[u8]) -> Result<Theta> {
-        Theta::try_from(bytes)
+    pub fn from_bytes(bytes: &[u8]) -> Result<VerifyCredentialRequest> {
+        VerifyCredentialRequest::try_from(bytes)
    }

    pub fn blinded_serial_number_bs58(&self) -> String {
@@ -119,17 +119,17 @@ impl Theta {
    }
 }

-impl Bytable for Theta {
+impl Bytable for VerifyCredentialRequest {
    fn to_byte_vec(&self) -> Vec<u8> {
        self.to_bytes()
    }

    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        Theta::try_from(slice)
+        VerifyCredentialRequest::try_from(slice)
    }
 }

-impl Base58 for Theta {}
+impl Base58 for VerifyCredentialRequest {}

 pub fn compute_kappa(
    params: &Parameters,
@@ -156,7 +156,7 @@ pub fn prove_bandwidth_credential(
    signature: &Signature,
    serial_number: &Attribute,
    binding_number: &Attribute,
-) -> Result<Theta> {
+) -> Result<VerifyCredentialRequest> {
    if verification_key.beta_g2.len() < 2 {
        return Err(
            CoconutError::Verification(
@@ -196,7 +196,7 @@ pub fn prove_bandwidth_credential(
        &blinded_serial_number,
    );

-    Ok(Theta {
+    Ok(VerifyCredentialRequest {
        blinded_message,
        blinded_serial_number,
        credential: signature_prime,
@@ -256,7 +256,7 @@ pub fn check_vk_pairing(
 pub fn verify_credential(
    params: &Parameters,
    verification_key: &VerificationKey,
-    theta: &Theta,
+    theta: &VerifyCredentialRequest,
    public_attributes: &[&Attribute],
 ) -> bool {
    if public_attributes.len() + theta.pi_v.private_attributes_len()
@@ -358,6 +358,9 @@ mod tests {
        .unwrap();

        let bytes = theta.to_bytes();
-        assert_eq!(Theta::try_from(bytes.as_slice()).unwrap(), theta);
+        assert_eq!(
+            VerifyCredentialRequest::try_from(bytes.as_slice()).unwrap(),
+            theta
+        );
    }
 }
@@ -12,7 +12,7 @@ pub fn theta_from_keys_and_attributes(
    coconut_keypairs: &Vec<KeyPair>,
    indices: &[scheme::SignerIndex],
    public_attributes: &[&PublicAttribute],
-) -> Result<Theta, CoconutError> {
+) -> Result<VerifyCredentialRequest, CoconutError> {
    let serial_number = params.random_scalar();
    let binding_number = params.random_scalar();
    let private_attributes = vec![&serial_number, &binding_number];
@@ -239,8 +239,15 @@ impl NymMessage {
        let (packets_used, space_left) =
            chunking::number_of_required_fragments(total_required_bytes, plaintext_per_packet);

-        let wasted_space = space_left as f32 / (bytes.len() + 1 + space_left) as f32;
-        log::trace!("Padding {self_display}: {} of raw plaintext bytes are required. They're going to be put into {packets_used} sphinx packets with {space_left} bytes of leftover space. {wasted_space}% of packet capacity is going to be wasted.", bytes.len() + 1);
+        let wasted_space_percentage =
+            (space_left as f32 / (bytes.len() + 1 + space_left) as f32) * 100.0;
+        log::trace!(
+            "Padding {self_display}: {} of raw plaintext bytes are required. \
+            They're going to be put into {packets_used} sphinx packets with {space_left} bytes \
+            of leftover space. {wasted_space_percentage:.1}% of packet capacity is going to \
+            be wasted.",
+            bytes.len() + 1
+        );

        bytes
            .into_iter()
@@ -31,7 +31,6 @@ nym-validator-client = { path = "../../common/client-libs/validator-client" }
 nym-mixnet-contract-common = { path = "../../common/cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../../common/cosmwasm-smart-contracts/vesting-contract" }
 nym-config = { path = "../../common/config" }
-nym-coconut-interface = { path = "../../common/coconut-interface" }
 nym-crypto = { path = "../../common/crypto", features = ["asymmetric"] }

 [dev-dependencies]
@@ -140,17 +140,51 @@
      {
        "type": "object",
        "required": [
-          "commit_dealing"
+          "commit_dealings_metadata"
        ],
        "properties": {
-          "commit_dealing": {
+          "commit_dealings_metadata": {
            "type": "object",
            "required": [
-              "dealing",
+              "chunks",
+              "dealing_index",
              "resharing"
            ],
            "properties": {
-              "dealing": {
+              "chunks": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/definitions/DealingChunkInfo"
+                }
+              },
+              "dealing_index": {
+                "type": "integer",
+                "format": "uint32",
+                "minimum": 0.0
+              },
+              "resharing": {
+                "type": "boolean"
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        "additionalProperties": false
+      },
+      {
+        "type": "object",
+        "required": [
+          "commit_dealings_chunk"
+        ],
+        "properties": {
+          "commit_dealings_chunk": {
+            "type": "object",
+            "required": [
+              "chunk",
+              "resharing"
+            ],
+            "properties": {
+              "chunk": {
                "$ref": "#/definitions/PartialContractDealing"
              },
              "resharing": {
@@ -201,7 +235,7 @@
            ],
            "properties": {
              "owner": {
-                "$ref": "#/definitions/Addr"
+                "type": "string"
              },
              "resharing": {
                "type": "boolean"
@@ -240,10 +274,6 @@
      }
    ],
    "definitions": {
-      "Addr": {
-        "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
-        "type": "string"
-      },
      "ContractSafeBytes": {
        "type": "array",
        "items": {
@@ -252,17 +282,37 @@
          "minimum": 0.0
        }
      },
+      "DealingChunkInfo": {
+        "type": "object",
+        "required": [
+          "size"
+        ],
+        "properties": {
+          "size": {
+            "type": "integer",
+            "format": "uint64",
+            "minimum": 0.0
+          }
+        },
+        "additionalProperties": false
+      },
      "PartialContractDealing": {
        "type": "object",
        "required": [
+          "chunk_index",
          "data",
-          "index"
+          "dealing_index"
        ],
        "properties": {
+          "chunk_index": {
+            "type": "integer",
+            "format": "uint16",
+            "minimum": 0.0
+          },
          "data": {
            "$ref": "#/definitions/ContractSafeBytes"
          },
-          "index": {
+          "dealing_index": {
            "type": "integer",
            "format": "uint32",
            "minimum": 0.0
@@ -407,6 +457,66 @@
        },
        "additionalProperties": false
      },
+      {
+        "type": "object",
+        "required": [
+          "get_dealings_metadata"
+        ],
+        "properties": {
+          "get_dealings_metadata": {
+            "type": "object",
+            "required": [
+              "dealer",
+              "dealing_index",
+              "epoch_id"
+            ],
+            "properties": {
+              "dealer": {
+                "type": "string"
+              },
+              "dealing_index": {
+                "type": "integer",
+                "format": "uint32",
+                "minimum": 0.0
+              },
+              "epoch_id": {
+                "type": "integer",
+                "format": "uint64",
+                "minimum": 0.0
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        "additionalProperties": false
+      },
+      {
+        "type": "object",
+        "required": [
+          "get_dealer_dealings_status"
+        ],
+        "properties": {
+          "get_dealer_dealings_status": {
+            "type": "object",
+            "required": [
+              "dealer",
+              "epoch_id"
+            ],
+            "properties": {
+              "dealer": {
+                "type": "string"
+              },
+              "epoch_id": {
+                "type": "integer",
+                "format": "uint64",
+                "minimum": 0.0
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        "additionalProperties": false
+      },
      {
        "type": "object",
        "required": [
@@ -443,17 +553,23 @@
      {
        "type": "object",
        "required": [
-          "get_dealing"
+          "get_dealing_chunk_status"
        ],
        "properties": {
-          "get_dealing": {
+          "get_dealing_chunk_status": {
            "type": "object",
            "required": [
+              "chunk_index",
              "dealer",
              "dealing_index",
              "epoch_id"
            ],
            "properties": {
+              "chunk_index": {
+                "type": "integer",
+                "format": "uint16",
+                "minimum": 0.0
+              },
              "dealer": {
                "type": "string"
              },
@@ -476,39 +592,35 @@
      {
        "type": "object",
        "required": [
-          "get_dealings"
+          "get_dealing_chunk"
        ],
        "properties": {
-          "get_dealings": {
+          "get_dealing_chunk": {
            "type": "object",
            "required": [
+              "chunk_index",
              "dealer",
+              "dealing_index",
              "epoch_id"
            ],
            "properties": {
+              "chunk_index": {
+                "type": "integer",
+                "format": "uint16",
+                "minimum": 0.0
+              },
              "dealer": {
                "type": "string"
              },
+              "dealing_index": {
+                "type": "integer",
+                "format": "uint32",
+                "minimum": 0.0
+              },
              "epoch_id": {
                "type": "integer",
                "format": "uint64",
                "minimum": 0.0
-              },
-              "limit": {
-                "type": [
-                  "integer",
-                  "null"
-                ],
-                "format": "uint32",
-                "minimum": 0.0
-              },
-              "start_after": {
-                "type": [
-                  "integer",
-                  "null"
-                ],
-                "format": "uint32",
-                "minimum": 0.0
              }
            },
            "additionalProperties": false
@@ -909,6 +1021,80 @@
      "format": "uint64",
      "minimum": 0.0
    },
+    "get_dealer_dealings_status": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "DealerDealingsStatusResponse",
+      "type": "object",
+      "required": [
+        "all_dealings_fully_submitted",
+        "dealer",
+        "dealing_submission_status",
+        "epoch_id"
+      ],
+      "properties": {
+        "all_dealings_fully_submitted": {
+          "type": "boolean"
+        },
+        "dealer": {
+          "$ref": "#/definitions/Addr"
+        },
+        "dealing_submission_status": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/DealingStatus"
+          }
+        },
+        "epoch_id": {
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        }
+      },
+      "additionalProperties": false,
+      "definitions": {
+        "Addr": {
+          "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
+          "type": "string"
+        },
+        "ChunkSubmissionStatus": {
+          "type": "object",
+          "properties": {
+            "submission_height": {
+              "type": [
+                "integer",
+                "null"
+              ],
+              "format": "uint64",
+              "minimum": 0.0
+            }
+          },
+          "additionalProperties": false
+        },
+        "DealingStatus": {
+          "type": "object",
+          "required": [
+            "chunk_submission_status",
+            "fully_submitted",
+            "has_metadata"
+          ],
+          "properties": {
+            "chunk_submission_status": {
+              "type": "object",
+              "additionalProperties": {
+                "$ref": "#/definitions/ChunkSubmissionStatus"
+              }
+            },
+            "fully_submitted": {
+              "type": "boolean"
+            },
+            "has_metadata": {
+              "type": "boolean"
+            }
+          },
+          "additionalProperties": false
+        }
+      }
+    },
    "get_dealer_details": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "DealerDetailsResponse",
@@ -977,20 +1163,18 @@
        }
      }
    },
-    "get_dealing": {
+    "get_dealing_chunk": {
      "$schema": "http://json-schema.org/draft-07/schema#",
-      "title": "DealingResponse",
+      "title": "DealingChunkResponse",
      "type": "object",
      "required": [
+        "chunk_index",
        "dealer",
        "dealing_index",
        "epoch_id"
      ],
      "properties": {
-        "dealer": {
-          "$ref": "#/definitions/Addr"
-        },
-        "dealing": {
+        "chunk": {
          "anyOf": [
            {
              "$ref": "#/definitions/ContractSafeBytes"
@@ -1000,6 +1184,14 @@
            }
          ]
        },
+        "chunk_index": {
+          "type": "integer",
+          "format": "uint16",
+          "minimum": 0.0
+        },
+        "dealer": {
+          "$ref": "#/definitions/Addr"
+        },
        "dealing_index": {
          "type": "integer",
          "format": "uint32",
@@ -1027,6 +1219,62 @@
        }
      }
    },
+    "get_dealing_chunk_status": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "DealingChunkStatusResponse",
+      "type": "object",
+      "required": [
+        "chunk_index",
+        "dealer",
+        "dealing_index",
+        "epoch_id",
+        "status"
+      ],
+      "properties": {
+        "chunk_index": {
+          "type": "integer",
+          "format": "uint16",
+          "minimum": 0.0
+        },
+        "dealer": {
+          "$ref": "#/definitions/Addr"
+        },
+        "dealing_index": {
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        },
+        "epoch_id": {
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        },
+        "status": {
+          "$ref": "#/definitions/ChunkSubmissionStatus"
+        }
+      },
+      "additionalProperties": false,
+      "definitions": {
+        "Addr": {
+          "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
+          "type": "string"
+        },
+        "ChunkSubmissionStatus": {
+          "type": "object",
+          "properties": {
+            "submission_height": {
+              "type": [
+                "integer",
+                "null"
+              ],
+              "format": "uint64",
+              "minimum": 0.0
+            }
+          },
+          "additionalProperties": false
+        }
+      }
+    },
    "get_dealing_status": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "DealingStatusResponse",
@@ -1034,7 +1282,79 @@
      "required": [
        "dealer",
        "dealing_index",
-        "dealing_submitted",
+        "epoch_id",
+        "status"
+      ],
+      "properties": {
+        "dealer": {
+          "$ref": "#/definitions/Addr"
+        },
+        "dealing_index": {
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        },
+        "epoch_id": {
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        },
+        "status": {
+          "$ref": "#/definitions/DealingStatus"
+        }
+      },
+      "additionalProperties": false,
+      "definitions": {
+        "Addr": {
+          "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
+          "type": "string"
+        },
+        "ChunkSubmissionStatus": {
+          "type": "object",
+          "properties": {
+            "submission_height": {
+              "type": [
+                "integer",
+                "null"
+              ],
+              "format": "uint64",
+              "minimum": 0.0
+            }
+          },
+          "additionalProperties": false
+        },
+        "DealingStatus": {
+          "type": "object",
+          "required": [
+            "chunk_submission_status",
+            "fully_submitted",
+            "has_metadata"
+          ],
+          "properties": {
+            "chunk_submission_status": {
+              "type": "object",
+              "additionalProperties": {
+                "$ref": "#/definitions/ChunkSubmissionStatus"
+              }
+            },
+            "fully_submitted": {
+              "type": "boolean"
+            },
+            "has_metadata": {
+              "type": "boolean"
+            }
+          },
+          "additionalProperties": false
+        }
+      }
+    },
+    "get_dealings_metadata": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "DealingMetadataResponse",
+      "type": "object",
+      "required": [
+        "dealer",
+        "dealing_index",
        "epoch_id"
      ],
      "properties": {
@@ -1046,55 +1366,20 @@
          "format": "uint32",
          "minimum": 0.0
        },
-        "dealing_submitted": {
-          "type": "boolean"
-        },
-        "epoch_id": {
-          "type": "integer",
-          "format": "uint64",
-          "minimum": 0.0
-        }
-      },
-      "additionalProperties": false,
-      "definitions": {
-        "Addr": {
-          "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
-          "type": "string"
-        }
-      }
-    },
-    "get_dealings": {
-      "$schema": "http://json-schema.org/draft-07/schema#",
-      "title": "PagedDealingsResponse",
-      "type": "object",
-      "required": [
-        "dealer",
-        "dealings",
-        "epoch_id"
-      ],
-      "properties": {
-        "dealer": {
-          "$ref": "#/definitions/Addr"
-        },
-        "dealings": {
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/PartialContractDealing"
-          }
-        },
        "epoch_id": {
          "type": "integer",
          "format": "uint64",
          "minimum": 0.0
        },
-        "start_next_after": {
-          "description": "Field indicating paging information for the following queries if the caller wishes to get further entries.",
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint32",
-          "minimum": 0.0
+        "metadata": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/DealingMetadata"
+            },
+            {
+              "type": "null"
+            }
+          ]
        }
      },
      "additionalProperties": false,
@@ -1103,28 +1388,67 @@
          "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
          "type": "string"
        },
-        "ContractSafeBytes": {
-          "type": "array",
-          "items": {
-            "type": "integer",
-            "format": "uint8",
-            "minimum": 0.0
-          }
+        "ChunkSubmissionStatus": {
+          "type": "object",
+          "properties": {
+            "submission_height": {
+              "type": [
+                "integer",
+                "null"
+              ],
+              "format": "uint64",
+              "minimum": 0.0
+            }
+          },
+          "additionalProperties": false
        },
-        "PartialContractDealing": {
+        "DealingChunkInfo": {
          "type": "object",
          "required": [
-            "data",
-            "index"
+            "size"
          ],
          "properties": {
-            "data": {
-              "$ref": "#/definitions/ContractSafeBytes"
-            },
-            "index": {
+            "size": {
+              "type": "integer",
+              "format": "uint64",
+              "minimum": 0.0
+            }
+          },
+          "additionalProperties": false
+        },
+        "DealingMetadata": {
+          "type": "object",
+          "required": [
+            "dealing_index",
+            "submitted_chunks"
+          ],
+          "properties": {
+            "dealing_index": {
              "type": "integer",
              "format": "uint32",
              "minimum": 0.0
+            },
+            "submitted_chunks": {
+              "type": "object",
+              "additionalProperties": {
+                "$ref": "#/definitions/SubmittedChunk"
+              }
+            }
+          },
+          "additionalProperties": false
+        },
+        "SubmittedChunk": {
+          "type": "object",
+          "required": [
+            "info",
+            "status"
+          ],
+          "properties": {
+            "info": {
+              "$ref": "#/definitions/DealingChunkInfo"
+            },
+            "status": {
+              "$ref": "#/definitions/ChunkSubmissionStatus"
            }
          },
          "additionalProperties": false
@@ -51,17 +51,51 @@
    {
      "type": "object",
      "required": [
-        "commit_dealing"
+        "commit_dealings_metadata"
      ],
      "properties": {
-        "commit_dealing": {
+        "commit_dealings_metadata": {
          "type": "object",
          "required": [
-            "dealing",
+            "chunks",
+            "dealing_index",
            "resharing"
          ],
          "properties": {
-            "dealing": {
+            "chunks": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/DealingChunkInfo"
+              }
+            },
+            "dealing_index": {
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
+            },
+            "resharing": {
+              "type": "boolean"
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    {
+      "type": "object",
+      "required": [
+        "commit_dealings_chunk"
+      ],
+      "properties": {
+        "commit_dealings_chunk": {
+          "type": "object",
+          "required": [
+            "chunk",
+            "resharing"
+          ],
+          "properties": {
+            "chunk": {
              "$ref": "#/definitions/PartialContractDealing"
            },
            "resharing": {
@@ -112,7 +146,7 @@
          ],
          "properties": {
            "owner": {
-              "$ref": "#/definitions/Addr"
+              "type": "string"
            },
            "resharing": {
              "type": "boolean"
@@ -151,10 +185,6 @@
    }
  ],
  "definitions": {
-    "Addr": {
-      "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
-      "type": "string"
-    },
    "ContractSafeBytes": {
      "type": "array",
      "items": {
@@ -163,17 +193,37 @@
        "minimum": 0.0
      }
    },
+    "DealingChunkInfo": {
+      "type": "object",
+      "required": [
+        "size"
+      ],
+      "properties": {
+        "size": {
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        }
+      },
+      "additionalProperties": false
+    },
    "PartialContractDealing": {
      "type": "object",
      "required": [
+        "chunk_index",
        "data",
-        "index"
+        "dealing_index"
      ],
      "properties": {
+        "chunk_index": {
+          "type": "integer",
+          "format": "uint16",
+          "minimum": 0.0
+        },
        "data": {
          "$ref": "#/definitions/ContractSafeBytes"
        },
-        "index": {
+        "dealing_index": {
          "type": "integer",
          "format": "uint32",
          "minimum": 0.0
@@ -133,6 +133,66 @@
      },
      "additionalProperties": false
    },
+    {
+      "type": "object",
+      "required": [
+        "get_dealings_metadata"
+      ],
+      "properties": {
+        "get_dealings_metadata": {
+          "type": "object",
+          "required": [
+            "dealer",
+            "dealing_index",
+            "epoch_id"
+          ],
+          "properties": {
+            "dealer": {
+              "type": "string"
+            },
+            "dealing_index": {
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
+            },
+            "epoch_id": {
+              "type": "integer",
+              "format": "uint64",
+              "minimum": 0.0
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    {
+      "type": "object",
+      "required": [
+        "get_dealer_dealings_status"
+      ],
+      "properties": {
+        "get_dealer_dealings_status": {
+          "type": "object",
+          "required": [
+            "dealer",
+            "epoch_id"
+          ],
+          "properties": {
+            "dealer": {
+              "type": "string"
+            },
+            "epoch_id": {
+              "type": "integer",
+              "format": "uint64",
+              "minimum": 0.0
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
    {
      "type": "object",
      "required": [
@@ -169,17 +229,23 @@
    {
      "type": "object",
      "required": [
-        "get_dealing"
+        "get_dealing_chunk_status"
      ],
      "properties": {
-        "get_dealing": {
+        "get_dealing_chunk_status": {
          "type": "object",
          "required": [
+            "chunk_index",
            "dealer",
            "dealing_index",
            "epoch_id"
          ],
          "properties": {
+            "chunk_index": {
+              "type": "integer",
+              "format": "uint16",
+              "minimum": 0.0
+            },
            "dealer": {
              "type": "string"
            },
@@ -202,39 +268,35 @@
    {
      "type": "object",
      "required": [
-        "get_dealings"
+        "get_dealing_chunk"
      ],
      "properties": {
-        "get_dealings": {
+        "get_dealing_chunk": {
          "type": "object",
          "required": [
+            "chunk_index",
            "dealer",
+            "dealing_index",
            "epoch_id"
          ],
          "properties": {
+            "chunk_index": {
+              "type": "integer",
+              "format": "uint16",
+              "minimum": 0.0
+            },
            "dealer": {
              "type": "string"
            },
+            "dealing_index": {
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
+            },
            "epoch_id": {
              "type": "integer",
              "format": "uint64",
              "minimum": 0.0
-            },
-            "limit": {
-              "type": [
-                "integer",
-                "null"
-              ],
-              "format": "uint32",
-              "minimum": 0.0
-            },
-            "start_after": {
-              "type": [
-                "integer",
-                "null"
-              ],
-              "format": "uint32",
-              "minimum": 0.0
            }
          },
          "additionalProperties": false
@@ -0,0 +1,74 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "DealerDealingsStatusResponse",
+  "type": "object",
+  "required": [
+    "all_dealings_fully_submitted",
+    "dealer",
+    "dealing_submission_status",
+    "epoch_id"
+  ],
+  "properties": {
+    "all_dealings_fully_submitted": {
+      "type": "boolean"
+    },
+    "dealer": {
+      "$ref": "#/definitions/Addr"
+    },
+    "dealing_submission_status": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/DealingStatus"
+      }
+    },
+    "epoch_id": {
+      "type": "integer",
+      "format": "uint64",
+      "minimum": 0.0
+    }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "Addr": {
+      "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
+      "type": "string"
+    },
+    "ChunkSubmissionStatus": {
+      "type": "object",
+      "properties": {
+        "submission_height": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 0.0
+        }
+      },
+      "additionalProperties": false
+    },
+    "DealingStatus": {
+      "type": "object",
+      "required": [
+        "chunk_submission_status",
+        "fully_submitted",
+        "has_metadata"
+      ],
+      "properties": {
+        "chunk_submission_status": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/ChunkSubmissionStatus"
+          }
+        },
+        "fully_submitted": {
+          "type": "boolean"
+        },
+        "has_metadata": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}
--- a/Show More
+++ b/Show More